@tensorflow/tfjs-core
Version:
Hardware-accelerated JavaScript library for machine intelligence
1,083 lines • 47.5 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.
* =============================================================================
*/
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
var engine_1 = require("../engine");
var tensor_1 = require("../tensor");
var tensor_util_env_1 = require("../tensor_util_env");
var util = require("../util");
var axis_util_1 = require("./axis_util");
var concat_split_1 = require("./concat_split");
var operation_1 = require("./operation");
var rand_1 = require("./rand");
var tensor_ops_1 = require("./tensor_ops");
/**
* Broadcast an array to a compatible shape NumPy-style.
*
* The tensor's shape is compared to the broadcast shape from end to beginning.
* Ones are prepended to the tensor's shape until is has the same length as
* the broadcast shape. If input.shape[i]==shape[i], the (i+1)-th axis is
* already broadcast-compatible. If input.shape[i]==1 and shape[i]==N, then
* the input tensor is tiled N times along that axis (using tf.tile).
*
* @param input The tensor that is to be broadcasted.
* @param shape The input is to be broadcast to this shape.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function broadcastTo_(x, shape) {
var input = tensor_util_env_1.convertToTensor(x, 'broadcastTo', 'x');
var xShape = input.shape;
if (shape.some(function (d) { return !(d > 0) || d % 1 !== 0; })) {
throw new Error("broadcastTo(): Invalid broadcast shape [" + shape + "].");
}
if (shape.length < input.rank) {
throw new Error("broadcastTo(): shape.length=" + shape.length + " < input.rank=" + input.rank + ".");
}
if (shape.length > input.rank) {
var newShape = input.shape.slice();
while (newShape.length < shape.length) {
newShape.unshift(1);
}
input = input.reshape(newShape);
}
var reps = Array.from(shape);
for (var i = shape.length - 1; i >= 0; i--) {
if (input.shape[i] === shape[i]) {
reps[i] = 1;
}
else if (input.shape[i] !== 1) {
throw new Error("broadcastTo(): [" + xShape + "] cannot be broadcast to [" + shape + "].");
}
}
var axes = reps.map(function (n, i) { return n > 1 ? i : -1; }).filter(function (i) { return i >= 0; });
if (axes.length === 0) {
return input.clone();
}
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.tile(input, reps); }, { input: input }, function (dy) {
return ({ input: function () { return dy.sum(axes, /*keepDims=*/ true); } });
});
}
/**
* Creates a new tensor with the same values and shape as the specified
* tensor.
*
* ```js
* const x = tf.tensor([1, 2]);
*
* x.clone().print();
* ```
*
* @param x The tensor to clone.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function clone_(x) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'clone', null);
var der = function (dy) {
return { $x: function () { return dy.toFloat(); } };
};
return engine_1.ENGINE.runKernelFunc(function () { return engine_1.ENGINE.makeTensorFromDataId($x.dataId, $x.shape, $x.dtype); }, { $x: $x }, der);
}
/**
* Create an identity matrix.
*
* @param numRows Number of rows.
* @param numColumns Number of columns. Defaults to `numRows`.
* @param batchShape If provided, will add the batch shape to the beginning
* of the shape of the returned `tf.Tensor` by repeating the identity
* matrix.
* @param dtype Data type.
* @returns Identity matrix of the specified size and data type, possibly
* with batch repetition if `batchShape` is specified.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function eye_(numRows, numColumns, batchShape, dtype) {
if (dtype === void 0) { dtype = 'float32'; }
if (numColumns == null) {
numColumns = numRows;
}
var buff = buffer([numRows, numColumns], dtype);
var n = numRows <= numColumns ? numRows : numColumns;
for (var i = 0; i < n; ++i) {
buff.set(1, i, i);
}
var out = buff.toTensor().as2D(numRows, numColumns);
if (batchShape == null) {
return out;
}
else {
if (batchShape.length === 1) {
return exports.tile(exports.expandDims(out, 0), [batchShape[0], 1, 1]);
}
else if (batchShape.length === 2) {
return exports.tile(exports.expandDims(exports.expandDims(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
}
else if (batchShape.length === 3) {
return exports.tile(exports.expandDims(exports.expandDims(exports.expandDims(out, 0), 0), 0), [batchShape[0], batchShape[1], batchShape[2], 1, 1]);
}
else {
throw new Error("eye() currently supports only 1D and 2D " +
(
// tslint:disable-next-line:no-any
"batchShapes, but received " + batchShape.length + "D."));
}
}
}
/**
* Creates a `tf.Tensor` with values sampled from a normal distribution.
*
* ```js
* tf.randomNormal([2, 2]).print();
* ```
*
* @param shape An array of integers defining the output tensor shape.
* @param mean The mean of the normal distribution.
* @param stdDev The standard deviation of the normal distribution.
* @param dtype The data type of the output.
* @param seed The seed for the random number generator.
*/
/** @doc {heading: 'Tensors', subheading: 'Random'} */
function randomNormal_(shape, mean, stdDev, dtype, seed) {
if (mean === void 0) { mean = 0; }
if (stdDev === void 0) { stdDev = 1; }
if (dtype != null && dtype === 'bool') {
throw new Error("Unsupported data type " + dtype);
}
var randGauss = new rand_1.MPRandGauss(mean, stdDev, dtype, false /* truncated */, seed);
var res = buffer(shape, dtype);
for (var i = 0; i < res.values.length; i++) {
res.values[i] = randGauss.nextValue();
}
return res.toTensor();
}
/**
* Creates a `tf.Tensor` with values sampled from a truncated normal
* distribution.
*
* ```js
* tf.truncatedNormal([2, 2]).print();
* ```
*
* The generated values follow a normal distribution with specified mean and
* standard deviation, except that values whose magnitude is more than 2
* standard deviations from the mean are dropped and re-picked.
*
* @param shape An array of integers defining the output tensor shape.
* @param mean The mean of the normal distribution.
* @param stdDev The standard deviation of the normal distribution.
* @param dtype The data type of the output tensor.
* @param seed The seed for the random number generator.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function truncatedNormal_(shape, mean, stdDev, dtype, seed) {
if (mean === void 0) { mean = 0; }
if (stdDev === void 0) { stdDev = 1; }
if (dtype != null && dtype === 'bool') {
throw new Error("Unsupported data type " + dtype);
}
var randGauss = new rand_1.MPRandGauss(mean, stdDev, dtype, true /* truncated */, seed);
var res = buffer(shape, dtype);
for (var i = 0; i < res.values.length; i++) {
res.values[i] = randGauss.nextValue();
}
return res.toTensor();
}
/**
* Creates a `tf.Tensor` with values sampled from a gamma distribution.
*
* ```js
* tf.randomGamma([2, 2], 1).print();
* ```
*
* @param shape An array of integers defining the output tensor shape.
* @param alpha The shape parameter of the gamma distribution.
* @param beta The inverse scale parameter of the gamma distribution. Defaults
* to 1.
* @param dtype The data type of the output. Defaults to float32.
* @param seed The seed for the random number generator.
*/
/** @doc {heading: 'Tensors', subheading: 'Random'} */
function randomGamma_(shape, alpha, beta, dtype, seed) {
if (beta === void 0) { beta = 1; }
if (dtype === void 0) { dtype = 'float32'; }
if (beta == null) {
beta = 1;
}
if (dtype == null) {
dtype = 'float32';
}
if (dtype !== 'float32' && dtype !== 'int32') {
throw new Error("Unsupported data type " + dtype);
}
var rgamma = new rand_1.RandGamma(alpha, beta, dtype, seed);
var res = buffer(shape, dtype);
for (var i = 0; i < res.values.length; i++) {
res.values[i] = rgamma.nextValue();
}
return res.toTensor();
}
/**
* Creates a `tf.Tensor` with values sampled from a uniform distribution.
*
* The generated values follow a uniform distribution in the range [minval,
* maxval). The lower bound minval is included in the range, while the upper
* bound maxval is excluded.
*
* ```js
* tf.randomUniform([2, 2]).print();
* ```
*
* @param shape An array of integers defining the output tensor shape.
* @param minval The lower bound on the range of random values to generate.
* Defaults to 0.
* @param maxval The upper bound on the range of random values to generate.
* Defaults to 1.
* @param dtype The data type of the output tensor. Defaults to 'float32'.
*/
/** @doc {heading: 'Tensors', subheading: 'Random'} */
function randomUniform_(shape, minval, maxval, dtype, seed) {
if (minval === void 0) { minval = 0; }
if (maxval === void 0) { maxval = 1; }
if (dtype === void 0) { dtype = 'float32'; }
var res = buffer(shape, dtype);
var random = new rand_1.UniformRandom(minval, maxval, null, seed);
for (var i = 0; i < res.values.length; i++) {
res.values[i] = random.nextValue();
}
return res.toTensor();
}
/**
* Creates a `tf.Tensor` with values sampled from a random number generator
* function defined by the user.
*
* @param shape An array of integers defining the output tensor shape.
* @param randFunction A random number generator function which is called
* for each element in the output tensor.
* @param dtype The data type of the output tensor. Defaults to 'float32'.
*/
function rand_(shape, randFunction, dtype) {
var size = util.sizeFromShape(shape);
var values = null;
if (dtype == null || dtype === 'float32') {
values = new Float32Array(size);
}
else if (dtype === 'int32') {
values = new Int32Array(size);
}
else if (dtype === 'bool') {
values = new Uint8Array(size);
}
else {
throw new Error("Unknown data type " + dtype);
}
for (var i = 0; i < size; i++) {
values[i] = randFunction();
}
return engine_1.ENGINE.makeTensor(values, shape, dtype);
}
/**
* Creates a `tf.Tensor` with values drawn from a multinomial distribution.
*
* ```js
* const probs = tf.tensor([.75, .25]);
* tf.multinomial(probs, 3).print();
* ```
*
* @param logits 1D array with unnormalized log-probabilities, or
* 2D array of shape `[batchSize, numOutcomes]`. See the `normalized`
* parameter.
* @param numSamples Number of samples to draw for each row slice.
* @param seed The seed number.
* @param normalized Whether the provided `logits` are normalized true
* probabilities (sum to 1). Defaults to false.
* @return 1D array of shape `[numSamples]`, or 2D array of shape
* `[batchSize, numSamples]`, depending on the rank of the input.
*/
/** @doc {heading: 'Tensors', subheading: 'Random'} */
function multinomial_(logits, numSamples, seed, normalized) {
if (normalized === void 0) { normalized = false; }
var $logits = tensor_util_env_1.convertToTensor(logits, 'logits', 'multinomial');
var numOutcomes = $logits.size;
var origRank = $logits.rank;
if (numOutcomes < 2) {
throw new Error("Error in multinomial: you need at least 2 outcomes, but got " +
(numOutcomes + "."));
}
if (origRank > 2) {
throw new Error("Rank of probabilities must be 1 or 2, but is " + origRank);
}
seed = seed || Math.random();
var logits2D = origRank === 1 ? $logits.as2D(1, -1) : $logits;
var res = engine_1.ENGINE.runKernelFunc(function (backend) { return backend.multinomial(logits2D, normalized, numSamples, seed); }, { logits2D: logits2D });
return origRank === 1 ? res.as1D() : res;
}
/**
* Creates a one-hot `tf.Tensor`. The locations represented by `indices` take
* value `onValue` (defaults to 1), while all other locations take value
* `offValue` (defaults to 0). If `indices` is rank `R`, the output has rank
* `R+1` with the last axis of size `depth`.
*
* ```js
* tf.oneHot(tf.tensor1d([0, 1], 'int32'), 3).print();
* ```
*
* @param indices `tf.Tensor` of indices with dtype `int32`.
* @param depth The depth of the one hot dimension.
* @param onValue A number used to fill in the output when the index matches
* the location.
* @param offValue A number used to fill in the output when the index does
* not match the location.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function oneHot_(indices, depth, onValue, offValue) {
if (onValue === void 0) { onValue = 1; }
if (offValue === void 0) { offValue = 0; }
if (depth < 2) {
throw new Error("Error in oneHot: depth must be >=2, but it is " + depth);
}
var $indices = tensor_util_env_1.convertToTensor(indices, 'indices', 'oneHot', 'int32');
var outShape = $indices.shape.concat([depth]);
$indices = $indices.flatten();
var grad = function (dy) {
return { $indices: function () { return tensor_ops_1.zeros($indices.shape, 'float32'); } };
};
var result = engine_1.ENGINE.runKernelFunc(function (backend) { return backend.oneHot($indices, depth, onValue, offValue); }, { $indices: $indices }, grad);
return result.reshape(outShape);
}
/**
* Reshapes a `tf.Tensor` to a given shape.
*
* Given an input tensor, returns a new tensor with the same values as the
* input tensor with shape `shape`.
*
* If one component of shape is the special value -1, the size of that
* dimension is computed so that the total size remains constant. In
* particular, a shape of [-1] flattens into 1-D. At most one component of
* shape can be -1.
*
* If shape is 1-D or higher, then the operation returns a tensor with shape
* shape filled with the values of tensor. In this case, the number of
* elements implied by shape must be the same as the number of elements in
* tensor.
*
* ```js
* const x = tf.tensor1d([1, 2, 3, 4]);
* x.reshape([2, 2]).print();
* ```
*
* @param x The input tensor to be reshaped.
* @param shape An array of integers defining the output tensor shape.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function reshape_(x, shape) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'reshape', null);
shape = util.inferFromImplicitShape(shape, $x.size);
util.assert($x.size === util.sizeFromShape(shape), function () { return 'new shape and old shape must have the same number of elements.'; });
var grad = function (dy) {
return { x: function () { return dy.reshape($x.shape); } };
};
var attrs = { shape: shape };
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.reshape($x, shape); }, { x: $x }, grad, 'Reshape', attrs);
}
/**
* Removes dimensions of size 1 from the shape of a `tf.Tensor`.
*
* ```js
* const x = tf.tensor([1, 2, 3, 4], [1, 1, 4]);
* x.squeeze().print();
* ```
*
* @param x The input tensor to be squeezed.
* @param axis An optional list of numbers. If specified, only
* squeezes the dimensions listed. The dimension index starts at 0. It
* is an error to squeeze a dimension that is not 1.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function squeeze_(x, axis) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'squeeze');
return exports.reshape($x, util.squeezeShape($x.shape, axis).newShape);
}
/**
* Casts a `tf.Tensor` to a new dtype.
*
* ```js
* const x = tf.tensor1d([1.5, 2.5, 3]);
* tf.cast(x, 'int32').print();
* ```
* @param x The input tensor to be casted.
* @param dtype The dtype to cast the input tensor to.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function cast_(x, dtype) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'cast');
// Sanity checks.
if (!util.isValidDtype(dtype)) {
throw new Error("Failed to cast to unknown dtype " + dtype);
}
if (dtype === 'string' && $x.dtype !== 'string' ||
dtype !== 'string' && $x.dtype === 'string') {
throw new Error('Only strings can be casted to strings');
}
var grad = function (dy) {
return { x: function () { return dy.clone(); } };
};
var attrs = { dtype: dtype };
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.cast($x, dtype); }, { x: $x }, grad, 'Cast', attrs);
}
/**
* Construct a tensor by repeating it the number of times given by reps.
*
* This operation creates a new tensor by replicating `input` `reps`
* times. The output tensor's i'th dimension has `input.shape[i] *
* reps[i]` elements, and the values of `input` are replicated
* `reps[i]` times along the i'th dimension. For example, tiling
* `[a, b, c, d]` by `[2]` produces `[a, b, c, d, a, b, c, d]`.
*
* ```js
* const a = tf.tensor1d([1, 2]);
*
* a.tile([2]).print(); // or a.tile([2])
* ```
*
* ```js
* const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);
*
* a.tile([1, 2]).print(); // or a.tile([1, 2])
* ```
* @param x The tensor to tile.
* @param reps Determines the number of replications per dimension.
*/
/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
function tile_(x, reps) {
var parseAs = null;
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'tile', parseAs);
util.assert($x.rank === reps.length, function () { return "Error in transpose: rank of input " + $x.rank + " " +
("must match length of reps " + reps + "."); });
var grad = function (dy, saved) {
var $x = saved[0];
var derX = function () {
var xGrad = tensor_ops_1.zerosLike($x);
// TODO(cais): Maybe reduce memory footprint by avoiding repeated
// slicing.
if ($x.rank === 1) {
for (var i = 0; i < reps[0]; ++i) {
xGrad = xGrad.add(dy.slice([i * $x.shape[0]], [$x.shape[0]]));
}
}
else if ($x.rank === 2) {
for (var i = 0; i < reps[0]; ++i) {
for (var j = 0; j < reps[1]; ++j) {
xGrad = xGrad.add(dy.slice([i * $x.shape[0], j * $x.shape[1]], [$x.shape[0], $x.shape[1]]));
}
}
}
else if ($x.rank === 3) {
for (var i = 0; i < reps[0]; ++i) {
for (var j = 0; j < reps[1]; ++j) {
for (var k = 0; k < reps[2]; ++k) {
xGrad = xGrad.add(dy.slice([i * $x.shape[0], j * $x.shape[1], k * $x.shape[2]], [$x.shape[0], $x.shape[1], $x.shape[2]]));
}
}
}
}
else if ($x.rank === 4) {
for (var i = 0; i < reps[0]; ++i) {
for (var j = 0; j < reps[1]; ++j) {
for (var k = 0; k < reps[2]; ++k) {
for (var l = 0; l < reps[3]; ++l) {
xGrad = xGrad.add(dy.slice([
i * $x.shape[0], j * $x.shape[1], k * $x.shape[2],
l * $x.shape[3]
], [$x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]));
}
}
}
}
}
else {
throw new Error("Gradient for tile operation is not implemented for rank-" +
($x.rank + " tensors yet."));
}
return xGrad;
};
return { x: derX };
};
var inputsToSave = [$x];
var attrs = { reps: reps };
return engine_1.ENGINE.runKernelFunc(function (backend, save) {
var res = backend.tile($x, reps);
save([$x]);
return res;
}, { x: $x }, grad, 'Tile', attrs, inputsToSave);
}
/**
* Pads a `tf.Tensor1D` with a given value and paddings. See `pad` for details.
*/
function pad1d_(x, paddings, constantValue) {
if (constantValue === void 0) { constantValue = 0; }
util.assert(paddings.length === 2, function () { return 'Invalid number of paddings. Must be length of 2.'; });
return exports.pad(x, [paddings], constantValue);
}
/**
* Pads a `tf.Tensor2D` with a given value and paddings. See `pad` for details.
*/
function pad2d_(x, paddings, constantValue) {
if (constantValue === void 0) { constantValue = 0; }
util.assert(paddings.length === 2 && paddings[0].length === 2 &&
paddings[1].length === 2, function () { return 'Invalid number of paddings. Must be length of 2 each.'; });
return exports.pad(x, paddings, constantValue);
}
/**
* Pads a `tf.Tensor3D` with a given value and paddings. See `pad` for details.
*/
function pad3d_(x, paddings, constantValue) {
if (constantValue === void 0) { constantValue = 0; }
util.assert(paddings.length === 3 && paddings[0].length === 2 &&
paddings[1].length === 2 && paddings[2].length === 2, function () { return 'Invalid number of paddings. Must be length of 2 each.'; });
return exports.pad(x, paddings, constantValue);
}
/**
* Pads a `tf.Tensor4D` with a given value and paddings. See `pad` for details.
*/
function pad4d_(x, paddings, constantValue) {
if (constantValue === void 0) { constantValue = 0; }
util.assert(paddings.length === 4 && paddings[0].length === 2 &&
paddings[1].length === 2 && paddings[2].length === 2 &&
paddings[3].length === 2, function () { return 'Invalid number of paddings. Must be length of 2 each.'; });
return exports.pad(x, paddings, constantValue);
}
/**
* Pads a `tf.Tensor` with a given value and paddings.
*
* This operation currently only implements the `CONSTANT` mode.
*
* Also available are stricter rank-specific methods with the same signature
* as this method that assert that `paddings` is of given length.
* - `tf.pad1d`
* - `tf.pad2d`
* - `tf.pad3d`
* - `tf.pad4d`
*
* ```js
* const x = tf.tensor1d([1, 2, 3, 4]);
* x.pad([[1, 2]]).print();
* ```
* @param x The tensor to pad.
* @param paddings An array of length `R` (the rank of the tensor), where
* each element is a length-2 tuple of ints `[padBefore, padAfter]`,
* specifying how much to pad along each dimension of the tensor.
* @param constantValue The pad value to use. Defaults to 0.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function pad_(x, paddings, constantValue) {
if (constantValue === void 0) { constantValue = 0; }
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'pad');
if ($x.rank === 0) {
throw new Error('pad(scalar) is not defined. Pass non-scalar to pad');
}
var grad = function (dy) {
// Pad introduces values around the original tensor, so the gradient
// slices the original shape out of the gradient.
var begin = paddings.map(function (p) { return p[0]; });
return { x: function () { return dy.slice(begin, $x.shape); } };
};
var attrs = { paddings: paddings, constantValue: constantValue };
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.pad($x, paddings, constantValue); }, { x: $x }, grad, 'PadV2', attrs);
}
/**
* Stacks a list of rank-`R` `tf.Tensor`s into one rank-`(R+1)` `tf.Tensor`.
*
* ```js
* const a = tf.tensor1d([1, 2]);
* const b = tf.tensor1d([3, 4]);
* const c = tf.tensor1d([5, 6]);
* tf.stack([a, b, c]).print();
* ```
*
* @param tensors A list of tensor objects with the same shape and dtype.
* @param axis The axis to stack along. Defaults to 0 (the first dim).
*/
/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
function stack_(tensors, axis) {
if (axis === void 0) { axis = 0; }
var $tensors = tensor_util_env_1.convertToTensorArray(tensors, 'tensors', 'stack');
util.assert($tensors.length >= 1, function () { return 'Pass at least one tensor to tf.stack'; });
if ($tensors.length === 1) {
return $tensors[0].expandDims(axis);
}
var rank = $tensors[0].rank;
var shape = $tensors[0].shape;
var dtype = $tensors[0].dtype;
util.assert(axis <= rank, function () { return 'Axis must be <= rank of the tensor'; });
$tensors.forEach(function (t) {
util.assertShapesMatch(shape, t.shape, 'All tensors passed to stack must have matching shapes');
});
$tensors.forEach(function (t) {
util.assert(dtype === t.dtype, function () { return 'All tensors passed to stack must have matching dtypes'; });
});
var expandedTensors = $tensors.map(function (t) { return t.expandDims(axis); });
return concat_split_1.concat(expandedTensors, axis);
}
/**
* This operation reshapes the "batch" dimension 0 into `M + 1` dimensions of
* shape `blockShape + [batch]`, interleaves these blocks back into the grid
* defined by the spatial dimensions `[1, ..., M]`, to obtain a result with
* the same rank as the input. The spatial dimensions of this intermediate
* result are then optionally cropped according to `crops` to produce the
* output. This is the reverse of `tf.spaceToBatchND`. See below for a precise
* description.
*
* ```js
* const x = tf.tensor4d([1, 2, 3, 4], [4, 1, 1, 1]);
* const blockShape = [2, 2];
* const crops = [[0, 0], [0, 0]];
*
* x.batchToSpaceND(blockShape, crops).print();
* ```
*
* @param x A `tf.Tensor`. N-D with `x.shape` = `[batch] + spatialShape +
* remainingShape`, where spatialShape has `M` dimensions.
* @param blockShape A 1-D array. Must have shape `[M]`, all values must
* be >= 1.
* @param crops A 2-D array. Must have shape `[M, 2]`, all values must be >= 0.
* `crops[i] = [cropStart, cropEnd]` specifies the amount to crop from input
* dimension `i + 1`, which corresponds to spatial dimension `i`. It is required
* that `cropStart[i] + cropEnd[i] <= blockShape[i] * inputShape[i + 1]`
*
* This operation is equivalent to the following steps:
*
* 1. Reshape `x` to `reshaped` of shape: `[blockShape[0], ...,
* blockShape[M-1], batch / prod(blockShape), x.shape[1], ...,
* x.shape[N-1]]`
*
* 2. Permute dimensions of `reshaped`to produce `permuted` of shape `[batch /
* prod(blockShape),x.shape[1], blockShape[0], ..., x.shape[M],
* blockShape[M-1],x.shape[M+1], ..., x.shape[N-1]]`
*
* 3. Reshape `permuted` to produce `reshapedPermuted` of shape `[batch /
* prod(blockShape),x.shape[1] * blockShape[0], ..., x.shape[M] *
* blockShape[M-1],x.shape[M+1], ..., x.shape[N-1]]`
*
* 4. Crop the start and end of dimensions `[1, ..., M]` of `reshapedPermuted`
* according to `crops` to produce the output of shape: `[batch /
* prod(blockShape),x.shape[1] * blockShape[0] - crops[0,0] - crops[0,1],
* ..., x.shape[M] * blockShape[M-1] - crops[M-1,0] -
* crops[M-1,1],x.shape[M+1], ..., x.shape[N-1]]`
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function batchToSpaceND_(x, blockShape, crops) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'batchToSpaceND');
var prod = blockShape.reduce(function (a, b) { return a * b; });
util.assert($x.rank >= 1 + blockShape.length, function () { return "input rank is " + $x.rank + " but should be > than blockShape.length " + blockShape.length; });
util.assert(crops.length === blockShape.length, function () { return "crops.length is " + crops.length + " but should be equal to blockShape.length " + blockShape.length; });
util.assert($x.shape[0] % prod === 0, function () { return "input tensor batch is " + $x.shape[0] + " but is not divisible by the product of " +
("the elements of blockShape " + blockShape.join(' * ') + " === " + prod); });
var grad = function (dy) {
return { $x: function () { return dy.spaceToBatchND(blockShape, crops); } };
};
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.batchToSpaceND($x, blockShape, crops); }, { $x: $x }, grad);
}
/**
* This operation divides "spatial" dimensions `[1, ..., M]` of the input into
* a grid of blocks of shape `blockShape`, and interleaves these blocks with
* the "batch" dimension (0) such that in the output, the spatial
* dimensions `[1, ..., M]` correspond to the position within the grid,
* and the batch dimension combines both the position within a spatial block
* and the original batch position. Prior to division into blocks,
* the spatial dimensions of the input are optionally zero padded
* according to `paddings`. See below for a precise description.
*
* ```js
* const x = tf.tensor4d([1, 2, 3, 4], [1, 2, 2, 1]);
* const blockShape = [2, 2];
* const paddings = [[0, 0], [0, 0]];
*
* x.spaceToBatchND(blockShape, paddings).print();
* ```
*
* @param x A `tf.Tensor`. N-D with `x.shape` = `[batch] + spatialShape +
* remainingShape`, where spatialShape has `M` dimensions.
* @param blockShape A 1-D array. Must have shape `[M]`, all values must
* be >= 1.
* @param paddings A 2-D array. Must have shape `[M, 2]`, all values must be >=
* 0. `paddings[i] = [padStart, padEnd]` specifies the amount to zero-pad
* from input dimension `i + 1`, which corresponds to spatial dimension `i`. It
* is required that
* `(inputShape[i + 1] + padStart + padEnd) % blockShape[i] === 0`
*
* This operation is equivalent to the following steps:
*
* 1. Zero-pad the start and end of dimensions `[1, ..., M]` of the input
* according to `paddings` to produce `padded` of shape paddedShape.
*
* 2. Reshape `padded` to `reshapedPadded` of shape:
* `[batch] + [paddedShape[1] / blockShape[0], blockShape[0], ...,
* paddedShape[M] / blockShape[M-1], blockShape[M-1]] + remainingShape`
*
* 3. Permute dimensions of `reshapedPadded` to produce `permutedReshapedPadded`
* of shape: `blockShape + [batch] + [paddedShape[1] / blockShape[0], ...,
* paddedShape[M] / blockShape[M-1]] + remainingShape`
*
* 4. Reshape `permutedReshapedPadded` to flatten `blockShape` into the
* batch dimension, producing an output tensor of shape:
* `[batch * prod(blockShape)] + [paddedShape[1] / blockShape[0], ...,
* paddedShape[M] / blockShape[M-1]] + remainingShape`
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function spaceToBatchND_(x, blockShape, paddings) {
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'spaceToBatchND');
util.assert($x.rank >= 1 + blockShape.length, function () { return "input rank " + $x.rank + " should be > than [blockShape] " + blockShape.length; });
util.assert(paddings.length === blockShape.length, function () { return "paddings.shape[0] " + paddings.length + " must be equal to [blockShape] " + blockShape.length; });
util.assert($x.shape.reduce(function (a, b, i) {
if (i > 0 && i <= blockShape.length) {
return a &&
((b + paddings[i - 1][0] + paddings[i - 1][1]) %
blockShape[i - 1] ===
0);
}
return a;
}, true), function () { return "input spatial dimensions " + $x.shape.slice(1) + " with paddings " + paddings.toString() + " must be divisible by blockShapes " + blockShape.toString(); });
var grad = function (dy) {
return { $x: function () { return dy.batchToSpaceND(blockShape, paddings); } };
};
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.spaceToBatchND($x, blockShape, paddings); }, { $x: $x }, grad);
}
/**
* Unstacks a `tf.Tensor` of rank-`R` into a list of rank-`(R-1)` `tf.Tensor`s.
*
* ```js
* const a = tf.tensor2d([1, 2, 3, 4], [2, 2]);
*
* tf.unstack(a).forEach(tensor => tensor.print());
* ```
*
* @param x A tensor object.
* @param axis The axis to unstack along. Defaults to 0 (the first dim).
*/
/** @doc {heading: 'Tensors', subheading: 'Slicing and Joining'} */
function unstack_(x, axis) {
if (axis === void 0) { axis = 0; }
axis = axis || 0;
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'unstack');
util.assert(axis >= -$x.shape.length && axis < $x.shape.length, function () {
return "Axis = " + axis + " is not in [-" + $x.shape.length + ", " + $x.shape.length + ")";
});
if (axis < 0) {
axis += $x.shape.length;
}
var grad = function (dy) {
return { x: function () { return exports.stack(dy, axis); } };
};
var attrs = { axis: axis };
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.unstack($x, axis); }, { x: $x }, grad, 'Unpack', attrs);
}
/**
* Computes the cumulative sum of a `tf.Tensor` along `axis`.
*
* ```js
* const x = tf.tensor([1, 2, 3, 4]);
* x.cumsum().print();
* ```
* ```js
* const x = tf.tensor([[1, 2], [3, 4]]);
* x.cumsum().print();
* ```
*
* @param x The input tensor to be summed.
* @param axis The axis along which to sum. Optional. Defaults to 0.
* @param exclusive Whether to perform exclusive cumulative sum. Optional.
* Defaults to false. If set to true then the sum of each tensor entry
* does not include its own value, but only the values previous to it
* along the specified axis.
* @param reverse Whether to sum in the opposite direction. Optional.
* Defaults to false.
*/
/** @doc {heading: 'Operations', subheading: 'Scan'} */
function cumsum_(x, axis, exclusive, reverse) {
if (axis === void 0) { axis = 0; }
if (exclusive === void 0) { exclusive = false; }
if (reverse === void 0) { reverse = false; }
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'cumsum');
axis = axis | 0;
var permutation = axis_util_1.getAxesPermutation([axis], $x.rank);
var permutedX = $x;
if (permutation != null) {
permutedX = $x.transpose(permutation);
}
var permutedAxis = axis_util_1.getInnerMostAxes(1, $x.rank)[0];
var grad = function (dy) {
return { permutedX: function () { return dy.cumsum(axis, exclusive, !reverse); } };
};
var value = engine_1.ENGINE.runKernelFunc(function (backend) { return backend.cumsum(permutedX, permutedAxis, exclusive, reverse); }, { permutedX: permutedX }, grad);
if (permutation != null) {
value = value.transpose(permutation);
}
return value;
}
/**
* Returns a `tf.Tensor` that has expanded rank, by inserting a dimension
* into the tensor's shape.
*
* ```js
* const x = tf.tensor1d([1, 2, 3, 4]);
* const axis = 1;
* x.expandDims(axis).print();
* ```
*
* @param x The input tensor whose dimensions to be expanded.
* @param axis The dimension index at which to insert shape of `1`. Defaults
* to 0 (the first dimension).
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function expandDims_(x, axis) {
if (axis === void 0) { axis = 0; }
var parseAs = null;
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'expandDims', parseAs);
util.assert(axis <= $x.rank, function () { return 'Axis must be <= rank of the tensor'; });
var newShape = $x.shape.slice();
if (axis < 0) {
// Negative value is counted from the tail of rank.
util.assert(-($x.rank + 1) <= axis, function () { return "Axis must be in the interval [" + -($x.rank + 1) + ", " + $x.rank + "]"; });
axis = $x.rank + axis + 1;
}
newShape.splice(axis, 0, 1);
return exports.reshape($x, newShape);
}
/**
* Rearranges data from depth into blocks of spatial data. More specifically,
* this op outputs a copy of the input tensor where values from the `depth`
* dimension are moved in spatial blocks to the `height` and `width` dimensions.
* The attr `blockSize` indicates the input block size and how the data is
* moved.
*
* - Chunks of data of size `blockSize * blockSize` from depth are rearranged
* into non-overlapping blocks of size `blockSize x blockSize`
*
* - The width the output tensor is `inputWidth * blockSize`, whereas the
* height is `inputHeight * blockSize`
*
* - The Y, X coordinates within each block of the output image are determined
* by the high order component of the input channel index
*
* - The depth of the input tensor must be divisible by `blockSize *
* blockSize`
*
* The `dataFormat` attr specifies the layout of the input and output tensors
* with the following options: "NHWC": [ `batch, height, width, channels` ]
* "NCHW": [ `batch, channels, height, width` ]
*
* ```js
* const x = tf.tensor4d([1, 2, 3, 4], [1, 1, 1, 4]);
* const blockSize = 2;
* const dataFormat = "NHWC";
*
* tf.depthToSpace(x, blockSize, dataFormat).print();
* ```
*
* @param x The input tensor of rank 4
* @param blockSIze An `int` that is `>= 2`. The size of the spatial block
* @param dataFormat An optional string from: "NHWC", "NCHW". Defaults to "NHWC"
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function depthToSpace_(x, blockSize, dataFormat) {
if (dataFormat === void 0) { dataFormat = 'NHWC'; }
var $x = tensor_util_env_1.convertToTensor(x, 'x', 'depthToSpace');
var inputHeight = (dataFormat === 'NHWC') ? $x.shape[1] : $x.shape[2];
var inputWidth = (dataFormat === 'NHWC') ? $x.shape[2] : $x.shape[3];
var inputDepth = (dataFormat === 'NHWC') ? $x.shape[3] : $x.shape[1];
util.assert(inputHeight * blockSize >= 0, function () { return "Negative dimension size caused by overflow when multiplying\n " + inputHeight + " and " + blockSize + " for depthToSpace with input shape\n " + $x.shape; });
util.assert(inputWidth * blockSize >= 0, function () { return "Negative dimension size caused by overflow when multiplying\n " + inputWidth + " and " + blockSize + " for depthToSpace with input shape\n " + $x.shape; });
util.assert((inputDepth % (blockSize * blockSize) === 0), function () { return "Dimension size must be evenly divisible by " + blockSize * blockSize + " but is " + inputDepth + " for depthToSpace with input shape " + $x.shape; });
return engine_1.ENGINE.runKernelFunc(function (backend) { return backend.depthToSpace($x, blockSize, dataFormat); }, { $x: $x });
}
/**
* Computes the difference between two lists of numbers.
*
* Given a Tensor `x` and a Tensor `y`, this operation returns a Tensor `out`
* that represents all values that are in `x` but not in `y`. The returned
* Tensor `out` is sorted in the same order that the numbers appear in `x`
* (duplicates are preserved). This operation also returns a Tensor indices that
* represents the position of each out element in `x`. In other words:
*
* `out[i] = x[idx[i]] for i in [0, 1, ..., out.length - 1]`
*
* ```js
* const x = [1, 2, 3, 4, 5, 6];
* const y = [1, 3, 5];
*
* const [out, indices] = await tf.setdiff1dAsync(x, y);
* out.print(); // [2, 4, 6]
* indices.print(); // [1, 3, 5]
* ```
*
* @param x 1-D Tensor. Values to keep.
* @param y 1-D Tensor. Must have the same type as x. Values to exclude in the
* output.
* @returns Promise of Tensor tuple [out, indices].
* out: Tensor with the same type as x.
* indices: A Tensor of type int32.
*/
/** @doc {heading: 'Tensors', subheading: 'Transformations'} */
function setdiff1dAsync_(x, y) {
return __awaiter(this, void 0, void 0, function () {
var $x, $y, xVals, yVals, ySet, outputSize, i, buffer, indices, i, p;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
$x = tensor_util_env_1.convertToTensor(x, 'x', 'setdiff1d');
$y = tensor_util_env_1.convertToTensor(y, 'y', 'setdiff1d');
util.assert($x.dtype === $y.dtype, function () { return "x and y should have the same dtype, but got x (" + $x.dtype + ") and y (" + $y.dtype + ")."; });
util.assert($x.rank === 1, function () { return "x should be 1D tensor, but got x (" + $x.shape + ")."; });
util.assert($y.rank === 1, function () { return "y should be 1D tensor, but got y (" + $y.shape + ")."; });
return [4 /*yield*/, $x.data()];
case 1:
xVals = _a.sent();
return [4 /*yield*/, $y.data()];
case 2:
yVals = _a.sent();
ySet = new Set(yVals);
outputSize = 0;
for (i = 0; i < xVals.length; i++) {
if (!ySet.has(xVals[i])) {
outputSize++;
}
}
buffer = new tensor_1.TensorBuffer([outputSize], $x.dtype);
indices = new tensor_1.TensorBuffer([outputSize], 'int32');
for (i = 0, p = 0; i < xVals.length; i++) {
if (!ySet.has(xVals[i])) {
buffer.values[p] = xVals[i];
indices.values[p] = i;
p++;
}
}
return [2 /*return*/, [buffer.toTensor(), indices.toTensor()]];
}
});
});
}
/**
* Creates an empty `tf.TensorBuffer` with the specified `shape` and `dtype`.
*
* The values are stored in CPU as `TypedArray`. Fill the buffer using
* `buffer.set()`, or by modifying directly `buffer.values`.
*
* When done, call `buffer.toTensor()` to get an immutable `tf.Tensor` with
* those values.
*
* ```js
* // Create a buffer and set values at particular indices.
* const buffer = tf.buffer([2, 2]);
* buffer.set(3, 0, 0);
* buffer.set(5, 1, 0);
*
* // Convert the buffer back to a tensor.
* buffer.toTensor().print();
* ```
*
* @param shape An array of integers defining the output tensor shape.
* @param dtype The dtype of the buffer. Defaults to 'float32'.
* @param values The values of the buffer as `TypedArray`. Defaults to
* zeros.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function buffer(shape, dtype, values) {
if (dtype === void 0) { dtype = 'float32'; }
dtype = dtype || 'float32';
util.assertNonNegativeIntegerDimensions(shape);
return new tensor_1.TensorBuffer(shape, dtype, values);
}
exports.buffer = buffer;
/**
* Prints information about the `tf.Tensor` including its data.
*
* ```js
* const verbose = true;
* tf.tensor2d([1, 2, 3, 4], [2, 2]).print(verbose);
* ```
* @param x The tensor to be printed.
* @param verbose Whether to print verbose information about the ` Tensor`,
* including dtype and size.
*/
/** @doc {heading: 'Tensors', subheading: 'Creation'} */
function print(x, verbose) {
if (verbose === void 0) { verbose = false; }
console.log(x.toString(verbose));
}
exports.print = print;
exports.batchToSpaceND = operation_1.op({ batchToSpaceND_: batchToSpaceND_ });
exports.broadcastTo = operation_1.op({ broadcastTo_: broadcastTo_ });
exports.cast = operation_1.op({ cast_: cast_ });
exports.clone = operation_1.op({ clone_: clone_ });
exports.cumsum = operation_1.op({ cumsum_: cumsum_ });
exports.depthToSpace = operation_1.op({ depthToSpace_: depthToSpace_ });
exports.expandDims = operation_1.op({ expandDims_: expandDims_ });
exports.eye = operation_1.op({ eye_: eye_ });
exports.multinomial = operation_1.op({ multinomial_: multinomial_ });
exports.oneHot = operation_1.op({ oneHot_: oneHot_ });
exports.pad = operation_1.op({ pad_: pad_ });
exports.pad1d = operation_1.op({ pad1d_: pad1d_ });
exports.pad2d = operation_1.op({ pad2d_: pad2d_ });
exports.pad3d = operation_1.op({ pad3d_: pad3d_ });
exports.pad4d = operation_1.op({ pad4d_: pad4d_ });
exports.rand = operation_1.op({ rand_: rand_ });
exports.randomNormal = operation_1.op({ randomNormal_: randomNormal_ });
exports.randomGamma = operation_1.op({ randomGamma_: randomGamma_ });
exports.randomUniform = operation_1.op({ randomUniform_: randomUniform_ });
exports.reshape = operation_1.op({ reshape_: reshape_ });
exports.spaceToBatchND = operation_1.op({ spaceToBatchND_: spaceToBatchND_ });
exports.squeeze = operation_1.op({ squeeze_: squeeze_ });
exports.stack = operation_1.op({ stack_: stack_ });
exports.tile = operation_1.op({ tile_: tile_ });
exports.truncatedNormal = operation_1.op({ truncatedNormal_: truncatedNormal_ });
exports.unstack = operation_1.op({ unstack_: unstack_ });
exports.setdiff1dAsync = setdiff1dAsync_;
//# sourceMappingURL=array_ops.js.map