@tensorflow/tfjs-core
Version:
Hardware-accelerated JavaScript library for machine intelligence
345 lines • 12.4 kB
JavaScript
"use strict";
/**
* @license
* Copyright 2018 Google Inc. 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.
* =============================================================================
*/
Object.defineProperty(exports, "__esModule", { value: true });
var engine_1 = require("./engine");
var environment_1 = require("./environment");
var tensor_1 = require("./tensor");
var tensor_util_1 = require("./tensor_util");
/**
* Enables production mode which disables correctness checks in favor of
* performance.
*/
/** @doc {heading: 'Environment'} */
function enableProdMode() {
environment_1.ENV.set('PROD', true);
}
exports.enableProdMode = enableProdMode;
/**
* 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'} */
function enableDebugMode() {
environment_1.ENV.set('DEBUG', true);
}
exports.enableDebugMode = enableDebugMode;
/** Globally disables deprecation warnings */
function disableDeprecationWarnings() {
environment_1.ENV.set('DEPRECATION_WARNINGS_ENABLED', false);
console.warn("TensorFlow.js deprecation warnings have been disabled.");
}
exports.disableDeprecationWarnings = disableDeprecationWarnings;
/** Warn users about deprecated functionality. */
function deprecationWarn(msg) {
if (environment_1.ENV.getBool('DEPRECATION_WARNINGS_ENABLED')) {
console.warn(msg + ' You can disable deprecation warnings with ' +
'tf.disableDeprecationWarnings().');
}
}
exports.deprecationWarn = deprecationWarn;
tensor_1.setDeprecationWarningFn(deprecationWarn);
/**
* Dispose all variables kept in backend engine.
*/
/** @doc {heading: 'Environment'} */
function disposeVariables() {
engine_1.ENGINE.disposeVariables();
}
exports.disposeVariables = disposeVariables;
/**
* 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
* `unrealible` is true.
* - `reasons`: `string[]`, reasons why the memory is unreliable, present if
* `unreliable` is true.
*/
/** @doc {heading: 'Performance', subheading: 'Memory'} */
function memory() {
return engine_1.ENGINE.memory();
}
exports.memory = memory;
/**
* Executes the provided function `f()` and returns a promise that resolves
* with information about the function's memory use:
* - `newBytes`: tne 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.
*
* ```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'} */
function profile(f) {
return engine_1.ENGINE.profile(f);
}
exports.profile = profile;
/**
* 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 one = tf.scalar(1);
* const a = tf.scalar(2);
* const b = a.square();
*
* console.log('numTensors (in tidy): ' + tf.memory().numTensors);
*
* // The value returned inside the tidy function will return
* // through the tidy, in this case to the variable y.
* return b.add(one);
* });
*
* console.log('numTensors (outside tidy): ' + tf.memory().numTensors);
* y.print();
* ```
*
* @param nameOrFn The name of the closure, or the function to execute.
* If a name is provided, the 2nd argument should be the function.
* If debug mode is on, the timing and the memory usage of the function
* will be tracked and displayed on the console using the provided name.
* @param fn The function to execute.
*/
/** @doc {heading: 'Performance', subheading: 'Memory'} */
function tidy(nameOrFn, fn) {
return engine_1.ENGINE.tidy(nameOrFn, fn);
}
exports.tidy = tidy;
/**
* Disposes any `tf.Tensor`s found within the provided object.
*
* @param container an object that may be a `tf.Tensor` or may directly
* contain `tf.Tensor`s, such as a `Tensor[]` or `{key: Tensor, ...}`. If
* the object is not a `tf.Tensor` or does not contain `Tensors`, nothing
* happens. In general it is safe to pass any object here, except that
* `Promise`s are not supported.
*/
/** @doc {heading: 'Performance', subheading: 'Memory'} */
function dispose(container) {
var tensors = tensor_util_1.getTensorsInContainer(container);
tensors.forEach(function (tensor) { return tensor.dispose(); });
}
exports.dispose = dispose;
/**
* Keeps a `tf.Tensor` generated inside a `tf.tidy` from being disposed
* automatically.
*
* ```js
* let b;
* const y = tf.tidy(() => {
* const one = tf.scalar(1);
* const a = tf.scalar(2);
*
* // b will not be cleaned up by the tidy. a and one will be cleaned up
* // when the tidy ends.
* b = tf.keep(a.square());
*
* console.log('numTensors (in tidy): ' + tf.memory().numTensors);
*
* // The value returned inside the tidy function will return
* // through the tidy, in this case to the variable y.
* return b.add(one);
* });
*
* console.log('numTensors (outside tidy): ' + tf.memory().numTensors);
* console.log('y:');
* y.print();
* console.log('b:');
* b.print();
* ```
*
* @param result The tensor to keep from being disposed.
*/
/** @doc {heading: 'Performance', subheading: 'Memory'} */
function keep(result) {
return engine_1.ENGINE.keep(result);
}
exports.keep = keep;
/**
* Executes `f()` and returns a promise that resolves with timing
* information.
*
* The result is an object with the following properties:
*
* - `wallMs`: Wall execution time.
* - `kernelMs`: Kernel execution time, ignoring data transfer.
* - On `WebGL` The following additional properties exist:
* - `uploadWaitMs`: CPU blocking time on texture uploads.
* - `downloadWaitMs`: CPU blocking time on texture downloads (readPixels).
*
* ```js
* const x = tf.randomNormal([20, 20]);
* const time = await tf.time(() => x.matMul(x));
*
* console.log(`kernelMs: ${time.kernelMs}, wallTimeMs: ${time.wallMs}`);
* ```
*
* @param f The function to execute and time.
*/
/** @doc {heading: 'Performance', subheading: 'Timing'} */
function time(f) {
return engine_1.ENGINE.time(f);
}
exports.time = time;
/**
* Sets the backend (cpu, webgl, etc) responsible for creating tensors and
* executing operations on those tensors. Returns a promise that resolves
* to a boolean if the backend initialization was successful.
*
* Note this disposes the current backend, if any, as well as any tensors
* associated with it. A new backend is initialized, even if it is of the
* same type as the previous one.
*
* @param backendName The name of the backend. Currently supports
* `'webgl'|'cpu'` in the browser, and `'tensorflow'` under node.js
* (requires tfjs-node).
*/
/** @doc {heading: 'Backends'} */
function setBackend(backendName) {
return engine_1.ENGINE.setBackend(backendName);
}
exports.setBackend = setBackend;
/**
* Returns a promise that resolves when the currently selected backend (or the
* highest priority one) has initialized. Await this promise when you are using
* a backend that has async initialization.
*/
/** @doc {heading: 'Backends'} */
function ready() {
return engine_1.ENGINE.ready();
}
exports.ready = ready;
/**
* Returns the current backend name (cpu, webgl, etc). The backend is
* responsible for creating tensors and executing operations on those tensors.
*/
/** @doc {heading: 'Backends'} */
function getBackend() {
return engine_1.ENGINE.backendName;
}
exports.getBackend = getBackend;
/**
* Removes a backend and the registered factory.
*/
/** @doc {heading: 'Backends'} */
function removeBackend(name) {
engine_1.ENGINE.removeBackend(name);
}
exports.removeBackend = removeBackend;
/**
* Finds the backend registered under the provided name. Returns null if the
* name is not in the registry, or the registration hasn't finished yet.
*/
function findBackend(name) {
return engine_1.ENGINE.findBackend(name);
}
exports.findBackend = findBackend;
/**
* Finds the backend factory registered under the provided name. Returns a
* function that produces a new backend when called. Returns null if the name
* is not in the registry.
*/
function findBackendFactory(name) {
return engine_1.ENGINE.findBackendFactory(name);
}
exports.findBackendFactory = findBackendFactory;
/**
* Registers a global backend. The registration should happen when importing
* a module file (e.g. when importing `backend_webgl.ts`), and is used for
* modular builds (e.g. custom tfjs bundle with only webgl support).
*
* @param factory The backend factory function. When called, it should
* return a backend instance, or a promise of an instance.
* @param priority The priority of the backend (higher = more important).
* In case multiple backends are registered, the priority is used to find
* the best backend. Defaults to 1.
* @return False if there is already a registered backend under this name, true
* if not.
*/
/** @doc {heading: 'Backends'} */
function registerBackend(name, factory, priority) {
if (priority === void 0) { priority = 1; }
return engine_1.ENGINE.registerBackend(name, factory, priority);
}
exports.registerBackend = registerBackend;
/**
* Gets the current backend. If no backends have been initialized, this will
* attempt to initialize the best backend. Will throw an error if the highest
* priority backend has async initialization, in which case, you should call
* 'await tf.ready()' before running other code.
*/
/** @doc {heading: 'Backends'} */
function backend() {
return engine_1.ENGINE.backend;
}
exports.backend = backend;
/**
* Sets the global platform.
*
* @param platformName The name of this platform.
* @param platform A platform implementation.
*/
function setPlatform(platformName, platform) {
environment_1.ENV.setPlatform(platformName, platform);
}
exports.setPlatform = setPlatform;
//# sourceMappingURL=globals.js.map