/**

* @license

* Copyright 2018 Google LLC. All Rights Reserved.

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

* =============================================================================

*/

import {KernelBackend} from './backends/backend';

import {ENGINE, Engine, MemoryInfo, ProfileInfo, ScopeFn, TimingInfo} from './engine';

import {env} from './environment';

import {Platform} from './platforms/platform';

import {setDeprecationWarningFn, Tensor} from './tensor';

import {TensorContainer} from './tensor_types';

import {getTensorsInContainer} from './tensor_util';

/**

* Enables production mode which disables correctness checks in favor of

* performance.

*

* @doc {heading: 'Environment'}

*/

export function enableProdMode(): void {

env().set('PROD', true);

}

/**

* Enables debug mode which will log information about all executed kernels:

* the elapsed time of the kernel execution, as well as the rank, shape, and

* size of the output tensor.

*

* Debug mode will significantly slow down your application as it will

* download the result of every operation to the CPU. This should not be used in

* production. Debug mode does not affect the timing information of the kernel

* execution as we do not measure download time in the kernel execution time.

*

* See also: `tf.profile`, `tf.memory`.

*

* @doc {heading: 'Environment'}

*/

export function enableDebugMode(): void {

env().set('DEBUG', true);

}

/** Globally disables deprecation warnings */

export function disableDeprecationWarnings(): void {

env().set('DEPRECATION_WARNINGS_ENABLED', false);

console.warn(`TensorFlow.js deprecation warnings have been disabled.`);

}

/** Warn users about deprecated functionality. */

export function deprecationWarn(msg: string) {

}

setDeprecationWarningFn(deprecationWarn);

/**

* Dispose all variables kept in backend engine.

*

* @doc {heading: 'Environment'}

*/

export function disposeVariables(): void {

ENGINE.disposeVariables();

}

/**

* It returns the global engine that keeps track of all tensors and backends.

*

* @doc {heading: 'Environment'}

*/

export function engine(): Engine {

return ENGINE;

}

/**

* Returns memory info at the current time in the program. The result is an

* object with the following properties:

*

* - `numBytes`: Number of bytes allocated (undisposed) at this time.

* - `numTensors`: Number of unique tensors allocated.

* - `numDataBuffers`: Number of unique data buffers allocated

* (undisposed) at this time, which is ≤ the number of tensors

* (e.g. `a.reshape(newShape)` makes a new Tensor that shares the same

* data buffer with `a`).

* - `unreliable`: True if the memory usage is unreliable. See `reasons` when

* `unreliable` is true.

* - `reasons`: `string[]`, reasons why the memory is unreliable, present if

* `unreliable` is true.

*

* WebGL Properties:

* - `numBytesInGPU`: Number of bytes allocated (undisposed) in the GPU only at

* this time.

*

* @doc {heading: 'Performance', subheading: 'Memory'}

*/

export function memory(): MemoryInfo {

return ENGINE.memory();

}

/**

* Executes the provided function `f()` and returns a promise that resolves

* with information about the function's memory use:

* - `newBytes`: the number of new bytes allocated

* - `newTensors`: the number of new tensors created

* - `peakBytes`: the peak number of bytes allocated

* - `kernels`: an array of objects for each kernel involved that reports

* their input and output shapes, number of bytes used, and number of new

* tensors created.

* - `kernelNames`: an array of unique strings with just the names of the

* kernels in the `kernels` array.

*

* ```js

* const profile = await tf.profile(() => {

* const x = tf.tensor1d([1, 2, 3]);

* let x2 = x.square();

* x2.dispose();

* x2 = x.square();

* x2.dispose();

* return x;

* });

*

* console.log(`newBytes: ${profile.newBytes}`);

* console.log(`newTensors: ${profile.newTensors}`);

* console.log(`byte usage over all kernels: ${profile.kernels.map(k =>

* k.totalBytesSnapshot)}`);

* ```

*

*

* @doc {heading: 'Performance', subheading: 'Profile'}

*/

export function profile(f: () => (TensorContainer | Promise<TensorContainer>)):

Promise<ProfileInfo> {

return ENGINE.profile(f);

}

/**

* Executes the provided function `fn` and after it is executed, cleans up all

* intermediate tensors allocated by `fn` except those returned by `fn`.

* `fn` must not return a Promise (async functions not allowed). The returned

* result can be a complex object.

*

* Using this method helps avoid memory leaks. In general, wrap calls to

* operations in `tf.tidy` for automatic memory cleanup.

*

* NOTE: Variables do *not* get cleaned up when inside a tidy(). If you want to

* dispose variables, please use `tf.disposeVariables` or call dispose()

* directly on variables.

*

* ```js

* // y = 2 ^ 2 + 1

* const y = tf.tidy(() => {

* // a, b, and one will be cleaned up when the tidy ends.

* const >