/**
|
* @license
|
* Copyright 2023 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.
|
* =============================================================================
|
*/
|
'use strict';
|
|
var tfjsCore = require('@tensorflow/tfjs-core');
|
var seedrandom = require('seedrandom');
|
|
function _interopNamespaceDefault(e) {
|
var n = Object.create(null);
|
if (e) {
|
Object.keys(e).forEach(function (k) {
|
if (k !== 'default') {
|
var d = Object.getOwnPropertyDescriptor(e, k);
|
Object.defineProperty(n, k, d.get ? d : {
|
enumerable: true,
|
get: function () { return e[k]; }
|
});
|
}
|
});
|
}
|
n.default = e;
|
return n;
|
}
|
|
var seedrandom__namespace = /*#__PURE__*/_interopNamespaceDefault(seedrandom);
|
|
/******************************************************************************
|
Copyright (c) Microsoft Corporation.
|
|
Permission to use, copy, modify, and/or distribute this software for any
|
purpose with or without fee is hereby granted.
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
PERFORMANCE OF THIS SOFTWARE.
|
***************************************************************************** */
|
/* global Reflect, Promise */
|
var extendStatics = function (d, b) {
|
extendStatics = Object.setPrototypeOf ||
|
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
function (d, b) { for (var p in b)
|
if (Object.prototype.hasOwnProperty.call(b, p))
|
d[p] = b[p]; };
|
return extendStatics(d, b);
|
};
|
function __extends(d, b) {
|
if (typeof b !== "function" && b !== null)
|
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
|
extendStatics(d, b);
|
function __() { this.constructor = d; }
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
}
|
function __awaiter(thisArg, _arguments, P, generator) {
|
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
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) : adopt(result.value).then(fulfilled, rejected); }
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
});
|
}
|
function __generator(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 };
|
}
|
}
|
function __values(o) {
|
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
if (m)
|
return m.call(o);
|
if (o && typeof o.length === "number")
|
return {
|
next: function () {
|
if (o && i >= o.length)
|
o = void 0;
|
return { value: o && o[i++], done: !o };
|
}
|
};
|
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
}
|
function __read(o, n) {
|
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
if (!m)
|
return o;
|
var i = m.call(o), r, ar = [], e;
|
try {
|
while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
|
ar.push(r.value);
|
}
|
catch (error) {
|
e = { error: error };
|
}
|
finally {
|
try {
|
if (r && !r.done && (m = i["return"]))
|
m.call(i);
|
}
|
finally {
|
if (e)
|
throw e.error;
|
}
|
}
|
return ar;
|
}
|
function __spreadArray(to, from, pack) {
|
if (pack || arguments.length === 2)
|
for (var i = 0, l = from.length, ar; i < l; i++) {
|
if (ar || !(i in from)) {
|
if (!ar)
|
ar = Array.prototype.slice.call(from, 0, i);
|
ar[i] = from[i];
|
}
|
}
|
return to.concat(ar || Array.prototype.slice.call(from));
|
}
|
|
/**
|
* @license
|
* Copyright 2019 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.
|
* =============================================================================
|
*/
|
function assertNotComplex(tensor, opName) {
|
if (!Array.isArray(tensor)) {
|
tensor = [tensor];
|
}
|
tensor.forEach(function (t) {
|
if (t != null) {
|
tfjsCore.util.assert(t.dtype !== 'complex64', function () { return "".concat(opName, " does not support complex64 tensors in the CPU backend."); });
|
}
|
});
|
}
|
|
var whereImpl = tfjsCore.kernel_impls.whereImpl;
|
var MathBackendCPU = /** @class */ (function (_super) {
|
__extends(MathBackendCPU, _super);
|
function MathBackendCPU() {
|
var _this = _super.call(this) || this;
|
_this.blockSize = 48;
|
_this.firstUse = true;
|
_this.data = new tfjsCore.DataStorage(_this, tfjsCore.engine());
|
return _this;
|
}
|
MathBackendCPU.prototype.nextDataId = function () {
|
return MathBackendCPU.nextDataId++;
|
};
|
MathBackendCPU.prototype.write = function (values, shape, dtype) {
|
if (this.firstUse) {
|
this.firstUse = false;
|
if (tfjsCore.env().get('IS_NODE')) {
|
tfjsCore.backend_util.warn('\n============================\n' +
|
'Hi, looks like you are running TensorFlow.js in ' +
|
'Node.js. To speed things up dramatically, install our node ' +
|
'backend, visit https://github.com/tensorflow/tfjs-node for more details. ' +
|
'\n============================');
|
}
|
}
|
var dataId = { id: this.nextDataId() };
|
this.data.set(dataId, { values: values, dtype: dtype, refCount: 1 });
|
return dataId;
|
};
|
/**
|
* Create a data bucket in cpu backend.
|
* @param shape Shape of the `TensorInfo`.
|
* @param dtype DType of the `TensorInfo`.
|
* @param values The value of the `TensorInfo` stored as a flattened array.
|
*/
|
MathBackendCPU.prototype.makeTensorInfo = function (shape, dtype, values) {
|
var outId;
|
if (dtype === 'string' && values != null && values.length > 0 &&
|
tfjsCore.util.isString(values[0])) {
|
var encodedValues = values.map(function (d) { return tfjsCore.util.encodeString(d); });
|
outId = this.write(encodedValues, shape, dtype);
|
}
|
else {
|
outId = this.write(values, shape, dtype);
|
}
|
return { dataId: outId, shape: shape, dtype: dtype };
|
};
|
/** Return refCount of a `TensorData`. */
|
MathBackendCPU.prototype.refCount = function (dataId) {
|
if (this.data.has(dataId)) {
|
var tensorData = this.data.get(dataId);
|
return tensorData.refCount;
|
}
|
return 0;
|
};
|
/** Increase refCount of a `TensorData`. */
|
MathBackendCPU.prototype.incRef = function (dataId) {
|
var tensorData = this.data.get(dataId);
|
tensorData.refCount++;
|
};
|
/** Decrease refCount of a `TensorData`. */
|
MathBackendCPU.prototype.decRef = function (dataId) {
|
if (this.data.has(dataId)) {
|
var tensorData = this.data.get(dataId);
|
tensorData.refCount--;
|
}
|
};
|
MathBackendCPU.prototype.move = function (dataId, values, shape, dtype, refCount) {
|
this.data.set(dataId, { values: values, dtype: dtype, refCount: refCount });
|
};
|
MathBackendCPU.prototype.numDataIds = function () {
|
return this.data.numDataIds();
|
};
|
MathBackendCPU.prototype.read = function (dataId) {
|
return __awaiter(this, void 0, void 0, function () {
|
return __generator(this, function (_b) {
|
return [2 /*return*/, this.readSync(dataId)];
|
});
|
});
|
};
|
MathBackendCPU.prototype.readSync = function (dataId) {
|
var _b = this.data.get(dataId), dtype = _b.dtype, complexTensorInfos = _b.complexTensorInfos;
|
if (dtype === 'complex64') {
|
var realValues = this.readSync(complexTensorInfos.real.dataId);
|
var imagValues = this.readSync(complexTensorInfos.imag.dataId);
|
return tfjsCore.backend_util.mergeRealAndImagArrays(realValues, imagValues);
|
}
|
return tfjsCore.util.convertBackendValuesAndArrayBuffer(this.data.get(dataId).values, dtype);
|
};
|
MathBackendCPU.prototype.bufferSync = function (t) {
|
var data = this.readSync(t.dataId);
|
if (t.dtype === 'string') {
|
try {
|
// Decode the bytes into string.
|
var strings = data.map(function (d) { return tfjsCore.util.decodeString(d); });
|
return tfjsCore.buffer(t.shape, t.dtype, strings);
|
}
|
catch (_a) {
|
throw new Error('Failed to decode encoded string bytes into utf-8');
|
}
|
}
|
return tfjsCore.buffer(t.shape, t.dtype, data);
|
};
|
MathBackendCPU.prototype.makeOutput = function (values, shape, dtype) {
|
return tfjsCore.engine().makeTensorFromTensorInfo(this.makeTensorInfo(shape, dtype, values), this);
|
};
|
/**
|
* Dispose the memory if the dataId has 0 refCount. Return true if the memory
|
* is released or memory is not managed in this backend, false if memory is
|
* not cleared.
|
* @param dataId
|
* @oaram force Optional, remove the data regardless of refCount
|
*/
|
MathBackendCPU.prototype.disposeData = function (dataId, force) {
|
if (force === void 0) { force = false; }
|
if (this.data.has(dataId)) {
|
this.data.get(dataId).refCount--;
|
if (!force && this.data.get(dataId).refCount > 0) {
|
return false;
|
}
|
var complexTensorInfos = this.data.get(dataId).complexTensorInfos;
|
if (complexTensorInfos != null) {
|
this.disposeData(complexTensorInfos.real.dataId, true);
|
this.disposeData(complexTensorInfos.imag.dataId, true);
|
}
|
this.data.delete(dataId);
|
}
|
return true;
|
};
|
MathBackendCPU.prototype.disposeIntermediateTensorInfo = function (tensorInfo) {
|
this.disposeData(tensorInfo.dataId);
|
};
|
MathBackendCPU.prototype.time = function (f) {
|
return __awaiter(this, void 0, void 0, function () {
|
var start, kernelMs;
|
return __generator(this, function (_b) {
|
start = tfjsCore.util.now();
|
f();
|
kernelMs = tfjsCore.util.now() - start;
|
return [2 /*return*/, { kernelMs: kernelMs }];
|
});
|
});
|
};
|
MathBackendCPU.prototype.memory = function () {
|
return {
|
// Unreliable due to automatic gc. The numbers above are cumulative.
|
unreliable: true,
|
reasons: ['The reported memory is an upper bound. Due to automatic garbage ' +
|
'collection, the true allocated memory may be less.']
|
};
|
};
|
MathBackendCPU.prototype.where = function (condition) {
|
assertNotComplex([condition], 'where');
|
var condVals = this.readSync(condition.dataId);
|
return whereImpl(condition.shape, condVals);
|
};
|
MathBackendCPU.prototype.dispose = function () { };
|
MathBackendCPU.prototype.floatPrecision = function () {
|
return 32;
|
};
|
/** Returns the smallest representable number. */
|
MathBackendCPU.prototype.epsilon = function () {
|
return _super.prototype.epsilon.call(this);
|
};
|
return MathBackendCPU;
|
}(tfjsCore.KernelBackend));
|
MathBackendCPU.nextDataId = 0;
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function simpleAbsImpl(vals) {
|
var resultValues = new Float32Array(vals.length);
|
for (var i = 0; i < vals.length; ++i) {
|
resultValues[i] = Math.abs(vals[i]);
|
}
|
return resultValues;
|
}
|
var abs = function (args) {
|
var x = args.inputs.x;
|
var cpuBackend = args.backend;
|
assertNotComplex(x, 'abs');
|
var resultValues = new Float32Array(tfjsCore.util.sizeFromShape(x.shape));
|
var values = cpuBackend.data.get(x.dataId).values;
|
resultValues = simpleAbsImpl(values);
|
return cpuBackend.makeOutput(resultValues, x.shape, x.dtype);
|
};
|
var absConfig = {
|
kernelName: tfjsCore.Abs,
|
backendName: 'cpu',
|
kernelFunc: abs,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
/**
|
* Template that creates implementation for binary ops. Supports broadcast.
|
*/
|
function createSimpleBinaryKernelImpl(op) {
|
return function (aShape, bShape, aVals, bVals, dtype) {
|
var newShape = tfjsCore.backend_util.assertAndGetBroadcastShape(aShape, bShape);
|
var resultRank = newShape.length;
|
var resultStrides = tfjsCore.util.computeStrides(newShape);
|
var resultSize = tfjsCore.util.sizeFromShape(newShape);
|
var result = tfjsCore.util.getTypedArrayFromDType(dtype, resultSize);
|
var aRank = aShape.length;
|
var bRank = bShape.length;
|
var aStrides = tfjsCore.util.computeStrides(aShape);
|
var bStrides = tfjsCore.util.computeStrides(bShape);
|
var aBroadcastDims = tfjsCore.backend_util.getBroadcastDims(aShape, newShape);
|
var bBroadcastDims = tfjsCore.backend_util.getBroadcastDims(bShape, newShape);
|
if (aBroadcastDims.length + bBroadcastDims.length === 0) {
|
for (var i = 0; i < result.length; ++i) {
|
result[i] = op(aVals[i % aVals.length], bVals[i % bVals.length]);
|
}
|
}
|
else {
|
var _loop_1 = function (i) {
|
var loc = tfjsCore.util.indexToLoc(i, resultRank, resultStrides);
|
var aLoc = loc.slice(-aRank);
|
aBroadcastDims.forEach(function (d) { return aLoc[d] = 0; });
|
var aIndex = tfjsCore.util.locToIndex(aLoc, aRank, aStrides);
|
var bLoc = loc.slice(-bRank);
|
bBroadcastDims.forEach(function (d) { return bLoc[d] = 0; });
|
var bIndex = tfjsCore.util.locToIndex(bLoc, bRank, bStrides);
|
result[i] = op(aVals[aIndex], bVals[bIndex]);
|
};
|
for (var i = 0; i < result.length; ++i) {
|
_loop_1(i);
|
}
|
}
|
return [result, newShape];
|
};
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function complex(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var real = inputs.real, imag = inputs.imag;
|
var realVals = backend.data.get(real.dataId).values;
|
var imagVals = backend.data.get(imag.dataId).values;
|
var complexInfo = backend.makeTensorInfo(real.shape, 'complex64');
|
var complex = backend.data.get(complexInfo.dataId);
|
// The complex tensor owns the underlying real and imag tensorInfos, only the
|
// complex tensor tracks refCount, when complexData is disposed the
|
// underlying tensorData will be disposed.
|
complex.complexTensorInfos = {
|
real: backend.makeTensorInfo(real.shape, 'float32', realVals),
|
imag: backend.makeTensorInfo(imag.shape, 'float32', imagVals)
|
};
|
return complexInfo;
|
}
|
var complexConfig = {
|
kernelName: tfjsCore.Complex,
|
backendName: 'cpu',
|
kernelFunc: complex
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
/**
|
* Generates a tensorInfo with all zeros value.
|
* @param backend cpu backend.
|
* @param shape Shape for the zeros tensor.
|
* @param dtype Optional. If set, the result has this dtype.
|
*/
|
function zeros(backend, shape, dtype) {
|
if (dtype === void 0) { dtype = 'float32'; }
|
if (dtype === 'complex64') {
|
var real = zeros(backend, shape, 'float32');
|
var imag = zeros(backend, shape, 'float32');
|
return complex({ inputs: { real: real, imag: imag }, backend: backend });
|
}
|
var values = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(shape), dtype);
|
return backend.makeTensorInfo(shape, dtype, values);
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function identity(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x;
|
backend.incRef(x.dataId);
|
return { dataId: x.dataId, shape: x.shape, dtype: x.dtype };
|
}
|
var identityConfig = {
|
kernelName: tfjsCore.Identity,
|
backendName: 'cpu',
|
kernelFunc: identity
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function real(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var input = inputs.input;
|
var real = backend.data.get(input.dataId).complexTensorInfos.real;
|
var realVal = backend.data.get(real.dataId).values;
|
// When complex tensor is disposed, its underlying parts will be disposed too.
|
// Make new tensor out of the real value of the complex. This makes sure the
|
// value is still accessible even if complex tensor is disposed.
|
return backend.makeTensorInfo(real.shape, real.dtype, realVal);
|
}
|
var realConfig = {
|
kernelName: tfjsCore.Real,
|
backendName: 'cpu',
|
kernelFunc: real
|
};
|
|
function castImpl(values, shape, inputType, dtype) {
|
if (dtype === 'int32') {
|
var resultValues = Int32Array.from(values);
|
return [shape, 'int32', resultValues];
|
}
|
if (dtype === 'bool') {
|
// This is essentially the result of notEqual(x, 0). We avoid using
|
// kernel notEqual to avoid circular dependency, i.e. binary_utils ->
|
// cast -> notEqual -> binary_utils.
|
var zero = tfjsCore.util.toTypedArray([0], inputType);
|
var _a = __read(createSimpleBinaryKernelImpl(function (a, b) { return (a !== b) ? 1 : 0; })(shape, [], values, zero, 'bool'), 2), resultData = _a[0], resultShape = _a[1];
|
return [resultShape, 'bool', resultData];
|
}
|
throw new Error("Error in Cast: failed to cast ".concat(inputType, " to ").concat(dtype));
|
}
|
function cast(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var dtype = attrs.dtype;
|
// Casting to complex64.
|
if (dtype === 'complex64') {
|
if (x.dtype === 'complex64') {
|
return identity({ inputs: { x: x }, backend: backend });
|
}
|
var zerosTensorInfo = zeros(backend, x.shape, x.dtype);
|
var floatX = cast({ inputs: { x: x }, backend: backend, attrs: { dtype: 'float32' } });
|
var result = complex({ inputs: { real: floatX, imag: zerosTensorInfo }, backend: backend });
|
backend.disposeIntermediateTensorInfo(zerosTensorInfo);
|
backend.disposeIntermediateTensorInfo(floatX);
|
return result;
|
}
|
// Casting from complex64
|
if (x.dtype === 'complex64') {
|
var realPart = real({ inputs: { input: x }, backend: backend });
|
var result = cast({ inputs: { x: realPart }, backend: backend, attrs: { dtype: dtype } });
|
backend.disposeIntermediateTensorInfo(realPart);
|
return result;
|
}
|
if (!tfjsCore.util.hasEncodingLoss(x.dtype, dtype)) {
|
// We don't change the underlying data, since we cast to higher
|
// precision.
|
var result = identity({ inputs: { x: x }, backend: backend });
|
return { dataId: result.dataId, shape: result.shape, dtype: dtype };
|
}
|
var values = backend.data.get(x.dataId).values;
|
var _a = __read(castImpl(values, x.shape, x.dtype, dtype), 3), resultShape = _a[0], resultType = _a[1], resultData = _a[2];
|
return backend.makeTensorInfo(resultShape, resultType, resultData);
|
}
|
var castConfig = {
|
kernelName: tfjsCore.Cast,
|
backendName: 'cpu',
|
kernelFunc: cast
|
};
|
|
/**
|
* Template that creates a `KernelFunc` for binary ops.
|
* @param name Kernel name.
|
* @param binaryKernelImpl A `SimpleBinaryKernelImpl` for the kernel.
|
* @param binaryKernelComplexImpl Optional. If exists, represents a
|
* `ComplexBinaryKernelImpl` for the kernel, will be used when input dtype
|
* is `complex64`.
|
* @param dtype Optional. If set, the result has this dtype. Otherwise, the
|
* result has the same dtype as the first input. This is mainly used in
|
* comparison kernels, such as Equal, Less, Greater, etc.
|
*/
|
function binaryKernelFunc(name, simpleImpl, complexImpl, dtype) {
|
if (complexImpl == null) {
|
return function (_a) {
|
var inputs = _a.inputs, backend = _a.backend;
|
var a = inputs.a, b = inputs.b;
|
var cpuBackend = backend;
|
assertNotComplex([a, b], name);
|
var aVals = cpuBackend.data.get(a.dataId).values;
|
var bVals = cpuBackend.data.get(b.dataId).values;
|
var decodedAVals = a.dtype === 'string' ?
|
// tslint:disable-next-line: no-any
|
tfjsCore.backend_util.fromUint8ToStringArray(aVals) :
|
aVals;
|
var decodedBVals = a.dtype === 'string' ?
|
// tslint:disable-next-line: no-any
|
tfjsCore.backend_util.fromUint8ToStringArray(bVals) :
|
bVals;
|
var $dtype = dtype || a.dtype;
|
var _b = __read(simpleImpl(a.shape, b.shape, decodedAVals, decodedBVals, $dtype), 2), resultData = _b[0], resultShape = _b[1];
|
return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
|
};
|
}
|
return function (_a) {
|
var inputs = _a.inputs, backend = _a.backend;
|
var a = inputs.a, b = inputs.b;
|
var cpuBackend = backend;
|
if (a.dtype === 'complex64' || b.dtype === 'complex64') {
|
var $aComplex = cast({ inputs: { x: a }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
|
var $aComplexVals = cpuBackend.data.get($aComplex.dataId);
|
var aReal = $aComplexVals.complexTensorInfos.real;
|
var aImag = $aComplexVals.complexTensorInfos.imag;
|
var aRealVals = cpuBackend.data.get(aReal.dataId).values;
|
var aImagVals = cpuBackend.data.get(aImag.dataId).values;
|
var $bComplex = cast({ inputs: { x: b }, backend: cpuBackend, attrs: { dtype: 'complex64' } });
|
var $bComplexVals = cpuBackend.data.get($bComplex.dataId);
|
var bReal = $bComplexVals.complexTensorInfos.real;
|
var bImag = $bComplexVals.complexTensorInfos.imag;
|
var bRealVals = cpuBackend.data.get(bReal.dataId).values;
|
var bImagVals = cpuBackend.data.get(bImag.dataId).values;
|
var _b = __read(complexImpl(a.shape, b.shape, aRealVals, aImagVals, bRealVals, bImagVals), 3), resultRealData = _b[0], resultImagData = _b[1], resultShape = _b[2];
|
var resultReal = cpuBackend.makeTensorInfo(resultShape, 'float32', resultRealData);
|
var resultImag = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImagData);
|
var result = complex({ inputs: { real: resultReal, imag: resultImag }, backend: cpuBackend });
|
cpuBackend.disposeIntermediateTensorInfo($aComplex);
|
cpuBackend.disposeIntermediateTensorInfo($bComplex);
|
cpuBackend.disposeIntermediateTensorInfo(resultReal);
|
cpuBackend.disposeIntermediateTensorInfo(resultImag);
|
return result;
|
}
|
else {
|
var aVals = cpuBackend.data.get(a.dataId).values;
|
var bVals = cpuBackend.data.get(b.dataId).values;
|
var $dtype = dtype || a.dtype;
|
var _c = __read(simpleImpl(a.shape, b.shape, aVals, bVals, $dtype), 2), resultData = _c[0], resultShape = _c[1];
|
return cpuBackend.makeTensorInfo(resultShape, $dtype, resultData);
|
}
|
};
|
}
|
/**
|
* Template that creates the complex type implementation for binary ops.
|
* Supports broadcast.
|
*/
|
function createComplexBinaryKernelImpl(op) {
|
return function (aShape, bShape, aRealVals, aImagVals, bRealVals, bImagVals) {
|
var resultShape = tfjsCore.backend_util.assertAndGetBroadcastShape(aShape, bShape);
|
var resultSize = tfjsCore.util.sizeFromShape(resultShape);
|
var resultRank = resultShape.length;
|
var resultStrides = tfjsCore.util.computeStrides(resultShape);
|
var resultRealVals = tfjsCore.util.getTypedArrayFromDType('float32', resultSize);
|
var resultImagVals = tfjsCore.util.getTypedArrayFromDType('float32', resultSize);
|
var aBroadcastDims = tfjsCore.backend_util.getBroadcastDims(aShape, resultShape);
|
var bBroadcastDims = tfjsCore.backend_util.getBroadcastDims(bShape, resultShape);
|
var aVals = tfjsCore.backend_util.mergeRealAndImagArrays(aRealVals, aImagVals);
|
var bVals = tfjsCore.backend_util.mergeRealAndImagArrays(bRealVals, bImagVals);
|
var aRank = aShape.length;
|
var aStrides = tfjsCore.util.computeStrides(aShape);
|
var bRank = bShape.length;
|
var bStrides = tfjsCore.util.computeStrides(bShape);
|
if (aBroadcastDims.length + bBroadcastDims.length === 0) {
|
for (var i = 0; i < resultRealVals.length; i++) {
|
var aIdx = i % aVals.length;
|
var bIdx = i % bVals.length;
|
var result = op(aVals[aIdx * 2], aVals[aIdx * 2 + 1], bVals[bIdx * 2], bVals[bIdx * 2 + 1]);
|
resultRealVals[i] = result.real;
|
resultImagVals[i] = result.imag;
|
}
|
}
|
else {
|
var _loop_1 = function (i) {
|
var loc = tfjsCore.util.indexToLoc(i, resultRank, resultStrides);
|
var aLoc = loc.slice(-aRank);
|
aBroadcastDims.forEach(function (d) { return aLoc[d] = 0; });
|
var aIndex = tfjsCore.util.locToIndex(aLoc, aRank, aStrides);
|
var bLoc = loc.slice(-bRank);
|
bBroadcastDims.forEach(function (d) { return bLoc[d] = 0; });
|
var bIndex = tfjsCore.util.locToIndex(bLoc, bRank, bStrides);
|
var opResult = op(aVals[aIndex * 2], aVals[aIndex * 2 + 1], bVals[bIndex * 2], bVals[bIndex * 2 + 1]);
|
resultRealVals[i] = opResult.real;
|
resultImagVals[i] = opResult.imag;
|
};
|
for (var i = 0; i < resultRealVals.length; i++) {
|
_loop_1(i);
|
}
|
}
|
return [resultRealVals, resultImagVals, resultShape];
|
};
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var addImpl = createSimpleBinaryKernelImpl((function (a, b) { return a + b; }));
|
var addComplexImpl = createComplexBinaryKernelImpl((function (aReal, aImag, bReal, bImag) {
|
return { real: aReal + bReal, imag: aImag + bImag };
|
}));
|
var add = binaryKernelFunc(tfjsCore.Add, addImpl, addComplexImpl);
|
var addConfig = {
|
kernelName: tfjsCore.Add,
|
backendName: 'cpu',
|
kernelFunc: add
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function bincountImpl(xVals, weightsVals, weightsDtype, weightsShape, size) {
|
var weightsSize = tfjsCore.util.sizeFromShape(weightsShape);
|
var outVals = tfjsCore.util.makeZerosTypedArray(size, weightsDtype);
|
for (var i = 0; i < xVals.length; i++) {
|
var value = xVals[i];
|
if (value < 0) {
|
throw new Error('Input x must be non-negative!');
|
}
|
if (value >= size) {
|
continue;
|
}
|
if (weightsSize > 0) {
|
outVals[value] += weightsVals[i];
|
}
|
else {
|
outVals[value] += 1;
|
}
|
}
|
return outVals;
|
}
|
function bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput) {
|
if (binaryOutput === void 0) { binaryOutput = false; }
|
var numRows = xBuf.shape[0];
|
var numCols = xBuf.shape[1];
|
var outBuf = tfjsCore.buffer([numRows, size], weightsBuf.dtype);
|
for (var i = 0; i < numRows; i++) {
|
for (var j = 0; j < numCols; j++) {
|
var value = xBuf.get(i, j);
|
if (value < 0) {
|
throw new Error('Input x must be non-negative!');
|
}
|
if (value >= size) {
|
continue;
|
}
|
if (binaryOutput) {
|
outBuf.set(1, i, value);
|
}
|
else {
|
if (weightsBuf.size > 0) {
|
outBuf.set(outBuf.get(i, value) + weightsBuf.get(i, j), i, value);
|
}
|
else {
|
outBuf.set(outBuf.get(i, value) + 1, i, value);
|
}
|
}
|
}
|
}
|
return outBuf;
|
}
|
|
/**
|
* @license
|
* Copyright 2023 Google LLC.
|
* 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 bitwiseAndImpl = createSimpleBinaryKernelImpl((function (a, b) { return a & b; }));
|
var bitwiseAnd = binaryKernelFunc(tfjsCore.BitwiseAnd, bitwiseAndImpl);
|
var bitwiseAndConfig = {
|
kernelName: tfjsCore.BitwiseAnd,
|
backendName: 'cpu',
|
kernelFunc: bitwiseAnd
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
/**
|
* Template that creates implementation for unary op.
|
*/
|
function createSimpleUnaryImpl(op) {
|
return function (values, dtype, attrs) {
|
var newValues = tfjsCore.util.getArrayFromDType(dtype, values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = op(values[i], attrs);
|
}
|
return newValues;
|
};
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
/**
|
* Template that creates a `KernelFunc` for unary ops.
|
* @param name Kernel name.
|
* @param op A `SimpleUnaryOperation` for the kernel.
|
* @param dtype Optional. If set, the result has this dtype. Otherwise, the
|
* result has the same dtype as the input. This is mainly used in certain
|
* kernels that return bool type, such as isFinite, isInf, etc.
|
*/
|
function unaryKernelFunc(name, op, dtype) {
|
var impl = createSimpleUnaryImpl(op);
|
return unaryKernelFuncFromImpl(name, impl, dtype);
|
}
|
/**
|
* Template that creates a `KernelFunc` for unary ops from the given
|
* `SimpleUnaryImpl`..
|
* @param name Kernel name.
|
* @param unaryImpl A `SimpleUnaryImpl` that implements the op.
|
* @param dtype Optional. If set, the result has this dtype. Otherwise, the
|
* result has the same dtype as the input. This is mainly used in certain
|
* kernels that return bool type, such as isFinite, isInf, etc.
|
*/
|
function unaryKernelFuncFromImpl(name, unaryImpl, dtype) {
|
return function (_a) {
|
var inputs = _a.inputs, attrs = _a.attrs, backend = _a.backend;
|
var x = inputs.x;
|
assertNotComplex(x, name);
|
var cpuBackend = backend;
|
var values = cpuBackend.data.get(x.dataId).values;
|
var decoded;
|
if (x.dtype === 'string') {
|
if (!Array.isArray(values)) {
|
throw new Error('String tensor\'s value was not an instance of Array');
|
}
|
decoded = tfjsCore.backend_util.fromUint8ToStringArray(values);
|
}
|
else {
|
decoded = values;
|
}
|
var $dtype = dtype || x.dtype;
|
var newValues = unaryImpl(decoded, $dtype, attrs);
|
return cpuBackend.makeTensorInfo(x.shape, $dtype, newValues);
|
};
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var ceilImpl = createSimpleUnaryImpl(function (xi) { return Math.ceil(xi); });
|
var ceil = unaryKernelFuncFromImpl(tfjsCore.Ceil, ceilImpl);
|
var ceilConfig = {
|
kernelName: tfjsCore.Ceil,
|
backendName: 'cpu',
|
kernelFunc: ceil,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function concatImpl(inputs, outShape, dtype, simplyConcat) {
|
var outVals = tfjsCore.util.getArrayFromDType(dtype, tfjsCore.util.sizeFromShape(outShape));
|
if (simplyConcat && dtype !== 'string') {
|
// Use built-in TypedArray.set() method for speed.
|
var offset_1 = 0;
|
inputs.forEach(function (input) {
|
var size = tfjsCore.util.sizeFromShape(input.shape);
|
outVals.set(input.vals, offset_1);
|
offset_1 += size;
|
});
|
}
|
else {
|
var colOffset_1 = 0;
|
inputs.forEach(function (input) {
|
var decodedData = dtype === 'string' ?
|
tfjsCore.backend_util.fromUint8ToStringArray(input.vals) :
|
input.vals;
|
var tIdx = 0;
|
for (var row = 0; row < input.shape[0]; ++row) {
|
var resIdx = row * outShape[1] + colOffset_1;
|
for (var col = 0; col < input.shape[1]; ++col) {
|
outVals[resIdx + col] = decodedData[tIdx++];
|
}
|
}
|
colOffset_1 += input.shape[1];
|
});
|
}
|
return outVals;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var equalImpl = createSimpleBinaryKernelImpl(function (a, b) { return (a === b) ? 1 : 0; });
|
var equal = binaryKernelFunc(tfjsCore.Equal, equalImpl, null /* complexImpl */, 'bool');
|
var equalConfig = {
|
kernelName: tfjsCore.Equal,
|
backendName: 'cpu',
|
kernelFunc: equal
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var expImpl = createSimpleUnaryImpl(function (xi) { return Math.exp(xi); });
|
var exp = unaryKernelFuncFromImpl(tfjsCore.Exp, expImpl, 'float32');
|
var expConfig = {
|
kernelName: tfjsCore.Exp,
|
backendName: 'cpu',
|
kernelFunc: exp,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var expm1Impl = createSimpleUnaryImpl(function (xi) { return Math.expm1(xi); });
|
var expm1 = unaryKernelFuncFromImpl(tfjsCore.Expm1, expm1Impl);
|
var expm1Config = {
|
kernelName: tfjsCore.Expm1,
|
backendName: 'cpu',
|
kernelFunc: expm1,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var floorImpl = createSimpleUnaryImpl(function (xi) { return Math.floor(xi); });
|
var floor = unaryKernelFuncFromImpl(tfjsCore.Floor, floorImpl);
|
var floorConfig = {
|
kernelName: tfjsCore.Floor,
|
backendName: 'cpu',
|
kernelFunc: floor,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var floorDivImpl = createSimpleBinaryKernelImpl(function (a, b) { return Math.floor(a / b); });
|
var floorDiv = binaryKernelFunc(tfjsCore.FloorDiv, floorDivImpl, null /* complexImpl */, 'int32');
|
var floorDivConfig = {
|
kernelName: tfjsCore.FloorDiv,
|
backendName: 'cpu',
|
kernelFunc: floorDiv
|
};
|
|
function gatherNdImpl(indicesData, paramsBuf, dtype, numSlices, sliceRank, sliceSize, strides, paramsShape, paramsSize) {
|
var outBuf = tfjsCore.buffer([numSlices, sliceSize], dtype);
|
for (var i = 0; i < numSlices; i++) {
|
var index = [];
|
var flattenIndex = 0;
|
for (var j = 0; j < sliceRank; j++) {
|
var dim = indicesData[i * sliceRank + j];
|
flattenIndex += dim * strides[j];
|
index.push(dim);
|
}
|
if (flattenIndex < 0 || flattenIndex >= paramsSize / sliceSize) {
|
throw new Error("Invalid indices: ".concat(index, " does not index into ").concat(paramsShape));
|
}
|
for (var k = 0; k < sliceSize; k++) {
|
outBuf.values[i * sliceSize + k] = paramsBuf.get.apply(paramsBuf, __spreadArray([], __read(paramsBuf.indexToLoc(flattenIndex * sliceSize + k)), false));
|
}
|
}
|
return outBuf;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function gatherV2Impl(xBuf, indicesBuf, flattenOutputShape) {
|
var outBuf = tfjsCore.buffer(flattenOutputShape, xBuf.dtype);
|
for (var i = 0; i < outBuf.size; ++i) {
|
var newLoc = outBuf.indexToLoc(i);
|
var originalLoc = newLoc.slice();
|
var batchIdx = originalLoc[0];
|
var indicesIdx = originalLoc[2];
|
var indicesIndex = indicesBuf.locToIndex([batchIdx, indicesIdx]);
|
originalLoc[2] = indicesBuf.values[indicesIndex];
|
var originalIndex = xBuf.locToIndex(originalLoc);
|
if (0 <= originalIndex && originalIndex < xBuf.values.length) {
|
outBuf.values[i] = xBuf.values[originalIndex];
|
} // Else, index is out of bounds, so leave the default zero val in outBuf.
|
}
|
return outBuf;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var greaterImpl = createSimpleBinaryKernelImpl(function (a, b) { return (a > b) ? 1 : 0; });
|
var greater = binaryKernelFunc(tfjsCore.Greater, greaterImpl, null /* complexImpl */, 'bool');
|
var greaterConfig = {
|
kernelName: tfjsCore.Greater,
|
backendName: 'cpu',
|
kernelFunc: greater
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var greaterEqualImpl = createSimpleBinaryKernelImpl(function (a, b) { return (a >= b) ? 1 : 0; });
|
var greaterEqual = binaryKernelFunc(tfjsCore.GreaterEqual, greaterEqualImpl, null /* complexImpl */, 'bool');
|
var greaterEqualConfig = {
|
kernelName: tfjsCore.GreaterEqual,
|
backendName: 'cpu',
|
kernelFunc: greaterEqual
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var lessImpl = createSimpleBinaryKernelImpl(function (a, b) { return (a < b) ? 1 : 0; });
|
var less = binaryKernelFunc(tfjsCore.Less, lessImpl, null /* complexImpl */, 'bool');
|
var lessConfig = {
|
kernelName: tfjsCore.Less,
|
backendName: 'cpu',
|
kernelFunc: less
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var lessEqualImpl = createSimpleBinaryKernelImpl(function (a, b) { return (a <= b) ? 1 : 0; });
|
var lessEqual = binaryKernelFunc(tfjsCore.LessEqual, lessEqualImpl, null /* complexImpl */, 'bool');
|
var lessEqualConfig = {
|
kernelName: tfjsCore.LessEqual,
|
backendName: 'cpu',
|
kernelFunc: lessEqual
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function linSpaceImpl(start, stop, num) {
|
var step = (stop - start) / (num - 1);
|
var values = tfjsCore.util.makeZerosTypedArray(num, 'float32');
|
values[0] = start;
|
for (var i = 1; i < values.length; i++) {
|
values[i] = values[i - 1] + step;
|
}
|
return values;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var logImpl = createSimpleUnaryImpl(function (xi) { return Math.log(xi); });
|
var log = unaryKernelFuncFromImpl(tfjsCore.Log, logImpl);
|
var logConfig = {
|
kernelName: tfjsCore.Log,
|
backendName: 'cpu',
|
kernelFunc: log,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxImpl(aVals, reduceSize, outShape, dtype) {
|
var vals = tfjsCore.util.getTypedArrayFromDType(dtype, tfjsCore.util.sizeFromShape(outShape));
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var max = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
if (Number.isNaN(value) ||
|
value > max) { // comparison with NaN always return false
|
max = value;
|
}
|
}
|
vals[i] = max;
|
}
|
return vals;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var maximumImpl = createSimpleBinaryKernelImpl((function (aValue, bValue) { return Math.max(aValue, bValue); }));
|
var maximum = binaryKernelFunc(tfjsCore.Maximum, maximumImpl);
|
var maximumConfig = {
|
kernelName: tfjsCore.Maximum,
|
backendName: 'cpu',
|
kernelFunc: maximum
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var minimumImpl = createSimpleBinaryKernelImpl((function (aValue, bValue) { return Math.min(aValue, bValue); }));
|
var minimum = binaryKernelFunc(tfjsCore.Minimum, minimumImpl);
|
var minimumConfig = {
|
kernelName: tfjsCore.Minimum,
|
backendName: 'cpu',
|
kernelFunc: minimum
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var multiplyImpl = createSimpleBinaryKernelImpl((function (aValue, bValue) { return aValue * bValue; }));
|
var multiplyComplexImpl = createComplexBinaryKernelImpl((function (aReal, aImag, bReal, bImag) {
|
return {
|
real: aReal * bReal - aImag * bImag,
|
imag: aReal * bImag + aImag * bReal
|
};
|
}));
|
var multiply = binaryKernelFunc(tfjsCore.Multiply, multiplyImpl, multiplyComplexImpl);
|
var multiplyConfig = {
|
kernelName: tfjsCore.Multiply,
|
backendName: 'cpu',
|
kernelFunc: multiply
|
};
|
|
function negImpl(xVals, xShape, xDtype) {
|
var minusOne = tfjsCore.util.createScalarValue(-1, xDtype);
|
return multiplyImpl([], xShape, minusOne, xVals, xDtype);
|
}
|
function neg(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x;
|
assertNotComplex(x, 'neg');
|
var xVals = backend.data.get(x.dataId).values;
|
var _a = __read(negImpl(xVals, x.shape, x.dtype), 2), res = _a[0], newShape = _a[1];
|
return backend.makeTensorInfo(newShape, x.dtype, res);
|
}
|
var negConfig = {
|
kernelName: tfjsCore.Neg,
|
backendName: 'cpu',
|
kernelFunc: neg
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var notEqualImpl = createSimpleBinaryKernelImpl((function (a, b) { return (a !== b) ? 1 : 0; }));
|
var notEqual = binaryKernelFunc(tfjsCore.NotEqual, notEqualImpl, null /* complexOp */, 'bool');
|
var notEqualConfig = {
|
kernelName: tfjsCore.NotEqual,
|
backendName: 'cpu',
|
kernelFunc: notEqual
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function transposeImpl(xVals, xShape, dtype, perm, newShape) {
|
var xRank = xShape.length;
|
var xSize = tfjsCore.util.sizeFromShape(xShape);
|
var xStrides = tfjsCore.util.computeStrides(xShape);
|
var newStrides = tfjsCore.util.computeStrides(newShape);
|
var result = tfjsCore.util.getTypedArrayFromDType(dtype, tfjsCore.util.sizeFromShape(newShape));
|
for (var i = 0; i < xSize; ++i) {
|
var loc = tfjsCore.util.indexToLoc(i, xRank, xStrides);
|
// Permute location.
|
var newLoc = new Array(loc.length);
|
for (var i_1 = 0; i_1 < newLoc.length; i_1++) {
|
newLoc[i_1] = loc[perm[i_1]];
|
}
|
var newIndex = tfjsCore.util.locToIndex(newLoc, xRank, newStrides);
|
result[newIndex] = xVals[i];
|
}
|
return result;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function transpose(args) {
|
var inputs = args.inputs, attrs = args.attrs, backend = args.backend;
|
var x = inputs.x;
|
var perm = attrs.perm;
|
assertNotComplex(x, 'transpose');
|
var xRank = x.shape.length;
|
var newShape = new Array(xRank);
|
for (var i = 0; i < newShape.length; i++) {
|
newShape[i] = x.shape[perm[i]];
|
}
|
var values = backend.data.get(x.dataId).values;
|
var result = transposeImpl(values, x.shape, x.dtype, perm, newShape);
|
var dataId = backend.write(result, newShape, x.dtype);
|
return { dataId: dataId, shape: newShape, dtype: x.dtype };
|
}
|
var transposeConfig = {
|
kernelName: tfjsCore.Transpose,
|
backendName: 'cpu',
|
kernelFunc: transpose
|
};
|
|
function prodImpl(xShape, xDtype, xVals, reductionAxes) {
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes(xShape, reductionAxes), 2), outShape = _a[0], reduceShape = _a[1];
|
var outDtype = tfjsCore.upcastType(xDtype, 'int32');
|
var outVals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(outShape), outDtype);
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
for (var i = 0; i < outVals.length; ++i) {
|
var offset = i * reduceSize;
|
var prod_1 = 1;
|
for (var j = 0; j < reduceSize; ++j) {
|
prod_1 *= xVals[offset + j];
|
}
|
outVals[i] = prod_1;
|
}
|
return { outVals: outVals, outShape: outShape, outDtype: outDtype };
|
}
|
function prod(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
assertNotComplex(x, 'prod');
|
var xRank = x.shape.length;
|
var axes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var permutation = tfjsCore.backend_util.getAxesPermutation(axes, xRank);
|
var reductionAxes = axes;
|
var permutedX = x;
|
var intermediateTensorInfos = [];
|
if (permutation != null) {
|
permutedX = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutation } });
|
intermediateTensorInfos.push(permutedX);
|
reductionAxes = tfjsCore.backend_util.getInnerMostAxes(reductionAxes.length, xRank);
|
}
|
var xVals = backend.data.get(permutedX.dataId).values;
|
var _a = prodImpl(permutedX.shape, permutedX.dtype, xVals, reductionAxes), outVals = _a.outVals, outShape = _a.outShape, outDtype = _a.outDtype;
|
var resultShape = outShape;
|
if (keepDims) {
|
resultShape = tfjsCore.backend_util.expandShapeToKeepDim(outShape, axes);
|
}
|
intermediateTensorInfos.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return backend.makeTensorInfo(resultShape, outDtype, outVals);
|
}
|
var prodConfig = {
|
kernelName: tfjsCore.Prod,
|
backendName: 'cpu',
|
kernelFunc: prod
|
};
|
|
function validateIndices(indices, indicesShape, numParams) {
|
indices.forEach(function (index, i) {
|
if (index < 0 || index >= numParams) {
|
var locString = tfjsCore.util.indexToLoc(i, indicesShape.length, tfjsCore.util.computeStrides(indicesShape))
|
.join(',');
|
throw new Error("indices[".concat(locString, "] = ").concat(index, " is not in [0, ").concat(numParams, ")"));
|
}
|
});
|
}
|
function validateSplits(paramsNestedSplits, numParamsDenseValues) {
|
// Validate
|
for (var dim = 0; dim < paramsNestedSplits.length; ++dim) {
|
var splits = paramsNestedSplits[dim];
|
var lastSplit = (dim === paramsNestedSplits.length - 1) ?
|
numParamsDenseValues :
|
paramsNestedSplits[dim + 1].length;
|
if (splits.length === 0) {
|
throw new Error('Ragged splits may not be empty');
|
}
|
if (splits[0] < 0) {
|
throw new Error('Ragged splits must be non-negative');
|
}
|
if (splits[splits.length - 1] > lastSplit) {
|
throw new Error('Ragged splits must not point past values');
|
}
|
for (var i = 1; i < splits.length; ++i) {
|
if (splits[i - 1] > splits[i]) {
|
throw new Error('Ragged splits must be sorted in ascending order');
|
}
|
}
|
}
|
}
|
// Construct the `splits` output tensors, encoded using a nested vector.
|
// Also find the slices of values that need to be copied, and store them
|
// in `valueSlices`. The total number of values that will be copied (which
|
// we need for allocating the output values tensor) is stored in `numValues`.
|
function makeSplits(indices, indicesShape, paramsNestedSplits, numParamsDenseValues) {
|
var valueSlices = [];
|
var numValues = 0;
|
var numSplits = indicesShape.length - 1 + paramsNestedSplits.length;
|
var outSplits = new Array(numSplits).fill(null).map(function () { return [0]; });
|
validateSplits(paramsNestedSplits, numParamsDenseValues);
|
// Add `splits` that come from all but the last dimension of the dense
|
// Tensor `indices`. In particular, for each dimension D, we add a
|
// splits tensor whose values are:
|
// range(reduceProd(splits.shape[:D]) + 1) * splits.shape[D+1]
|
// E.g., if indices.shape=[2, 3, 4] then we will add splits tensors:
|
// [0, 3, 6] # length=2+1, stride=3
|
// [0, 4, 8, 12, 16, 20, 24] # length=2*3+1, stride=4
|
var nrows = 1;
|
for (var dim = 0; dim < indicesShape.length - 1; ++dim) {
|
nrows *= indicesShape[dim];
|
var rowLength = indicesShape[dim + 1];
|
for (var i = 1; i < nrows + 1; ++i) {
|
outSplits[dim].push(i * rowLength);
|
}
|
}
|
// Add `splits` that come from `paramsNestedSplits`. Starting with the
|
// outermost ragged dimension (i.e., the first `splits` tensor), we work
|
// our way in, finding the range of values that should be copied. As we
|
// go, we update the output `splits` for each dimension with the appropriate
|
// values. In particular, the *lengths* of the slices from `param_splits`
|
// should be copied to generate corresponding slice lengths in the output
|
// splits. E.g., if we are copying a ragged row with length 4, then we
|
// should add a new split point to outSplits that is 4 greater than the
|
// previous split point in outSplits.
|
for (var i = 0; i < indices.length; ++i) {
|
var start = indices[i];
|
var limit = indices[i] + 1;
|
// Copy splits.
|
for (var dim = 0; dim < paramsNestedSplits.length; ++dim) {
|
var splits = paramsNestedSplits[dim];
|
var outDim = dim + indicesShape.length - 1;
|
if (outDim >= 0) {
|
var outSplitsOutDim = outSplits[outDim];
|
var delta = outSplitsOutDim[outSplitsOutDim.length - 1] - splits[start];
|
for (var j = start; j < limit; ++j) {
|
outSplits[outDim].push(splits[j + 1] + delta);
|
}
|
}
|
start = splits[start];
|
limit = splits[limit];
|
}
|
if (limit !== start) {
|
valueSlices.push([start, limit]);
|
numValues += limit - start;
|
}
|
}
|
return { outSplits: outSplits, valueSlices: valueSlices, numValues: numValues };
|
}
|
function getSplits(outSplits) {
|
var splitsOut = [];
|
var _loop_1 = function (i) {
|
var numSplits = outSplits[i].length;
|
var splits = tfjsCore.util.getArrayFromDType('int32', numSplits);
|
splitsOut.push(splits);
|
outSplits[i].forEach(function (value, j) { return splits[j] = value; });
|
};
|
for (var i = 0; i < outSplits.length; ++i) {
|
_loop_1(i);
|
}
|
return splitsOut;
|
}
|
function computeFlatOuterDims(orig, numOutDims) {
|
var outDims = orig.slice(0, numOutDims);
|
while (outDims.length < numOutDims) {
|
outDims.push(1);
|
}
|
for (var inDim = numOutDims; inDim < orig.length; inDim++) {
|
outDims[numOutDims - 1] *= orig[inDim];
|
}
|
return outDims;
|
}
|
// For each slice in `(start, limit)` in `valueSlices`, append
|
// `paramsDenseValues[start,...,limit] to `values`. `valueSize` indicates
|
// the number of scalars contained in each value paramsDenseValues[i].
|
function writeValueSlices(paramsDenseValues, paramsDenseValuesShape, valueSlices, valueSize, values, valuesShape) {
|
var e_1, _a;
|
var denseM = computeFlatOuterDims(paramsDenseValuesShape, 2)[1];
|
var valuesM = computeFlatOuterDims(valuesShape, 2)[1];
|
var outPos = 0;
|
try {
|
for (var valueSlices_1 = __values(valueSlices), valueSlices_1_1 = valueSlices_1.next(); !valueSlices_1_1.done; valueSlices_1_1 = valueSlices_1.next()) {
|
var slice = valueSlices_1_1.value;
|
for (var i = slice[0]; i < slice[1]; ++i) {
|
for (var j = 0; j < valueSize; ++j) {
|
values[outPos * valuesM + j] = paramsDenseValues[i * denseM + j];
|
}
|
++outPos;
|
}
|
}
|
}
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
finally {
|
try {
|
if (valueSlices_1_1 && !valueSlices_1_1.done && (_a = valueSlices_1.return)) _a.call(valueSlices_1);
|
}
|
finally { if (e_1) throw e_1.error; }
|
}
|
}
|
function getValues(paramsDenseValues, paramsDenseValuesShape, paramsDenseValuesDType, valueSlices, numValues) {
|
var valuesShape = paramsDenseValuesShape.slice();
|
valuesShape[0] = numValues;
|
var valuesOut = tfjsCore.util.getArrayFromDType(paramsDenseValuesDType, tfjsCore.util.sizeFromShape(valuesShape));
|
var numElements = paramsDenseValues.length;
|
var valueSize = numElements === 0 ? 0 : (numElements / paramsDenseValuesShape[0]);
|
writeValueSlices(paramsDenseValues, paramsDenseValuesShape, valueSlices, valueSize, valuesOut, valuesShape);
|
return [valuesOut, valuesShape];
|
}
|
function raggedGatherImpl(paramsNestedSplits, paramsNestedSplitsShapes, paramsDenseValues, paramsDenseValuesShape, paramsDenseValuesDType, indices, indicesShape, outputRaggedRank) {
|
if (paramsNestedSplits.length === 0) {
|
throw new Error('paramsNestedSplits must be non empty');
|
}
|
if (paramsNestedSplitsShapes[0].length === 0) {
|
throw new Error('Split tensors must not be scalars');
|
}
|
var numParams = paramsNestedSplitsShapes[0][0] - 1;
|
validateIndices(indices, indicesShape, numParams);
|
if (paramsDenseValuesShape.length === 0) {
|
throw new Error('params.rank must be nonzero');
|
}
|
var numParamsDenseValues = paramsDenseValuesShape[0];
|
// Calculate the `splits`, and store the value slices that we need to
|
// copy in `valueSlices`.
|
var _a = makeSplits(indices, indicesShape, paramsNestedSplits, numParamsDenseValues), outSplits = _a.outSplits, valueSlices = _a.valueSlices, numValues = _a.numValues;
|
// Write the output tensors.
|
var outputNestedSplits = getSplits(outSplits);
|
var outputDenseValues = getValues(paramsDenseValues, paramsDenseValuesShape, paramsDenseValuesDType, valueSlices, numValues);
|
return [outputNestedSplits, outputDenseValues[0], outputDenseValues[1]];
|
}
|
|
/**
|
* @license
|
* Copyright 2022 Google LLC.
|
* 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 INT32_MAX = 2147483647;
|
function raggedRangeImpl(starts, startsShape, startsDType, limits, limitsShape, deltas, deltasShape) {
|
// Check input tensor shapes.
|
if (startsShape.length > 1) {
|
throw new Error('starts must be a scalar or vector');
|
}
|
if (limitsShape.length > 1) {
|
throw new Error('limits must be a scalar or vector');
|
}
|
if (deltasShape.length > 1) {
|
throw new Error('deltas must be a scalar or vector');
|
}
|
// Determine which tensors we need to broadcast.
|
var broadcastStarts = startsShape.length === 0;
|
var broadcastLimits = limitsShape.length === 0;
|
var broadcastDeltas = deltasShape.length === 0;
|
// nRows (number of output rows) is the size of the non-broadcast inputs,
|
// or 1 if all inputs are scalars.
|
var inSizes = [];
|
if (!broadcastStarts) {
|
inSizes.push(startsShape[0]);
|
}
|
if (!broadcastLimits) {
|
inSizes.push(limitsShape[0]);
|
}
|
if (!broadcastDeltas) {
|
inSizes.push(deltasShape[0]);
|
}
|
for (var i = 1; i < inSizes.length; ++i) {
|
if (inSizes[i] !== inSizes[i - 1]) {
|
throw new Error('starts, limits, and deltas must have the same shape');
|
}
|
}
|
var nRows = inSizes.length === 0 ? 1 : inSizes[0];
|
// Construct the rtNestedSplits tensor.
|
var rtNestedSplits = tfjsCore.util.getArrayFromDType('int32', nRows + 1);
|
rtNestedSplits[0] = 0;
|
for (var row = 0; row < nRows; ++row) {
|
var start = broadcastStarts ? starts[0] : starts[row];
|
var limit = broadcastLimits ? limits[0] : limits[row];
|
var delta = broadcastDeltas ? deltas[0] : deltas[row];
|
if (delta === 0) {
|
throw new Error('Requires delta != 0');
|
}
|
var size = // The number of elements in the specified range.
|
void 0; // The number of elements in the specified range.
|
if (((delta > 0) && (limit < start)) || ((delta < 0) && (limit > start))) {
|
size = 0;
|
}
|
else {
|
size = Math.ceil(Math.abs((limit - start) / delta));
|
if (size > INT32_MAX) {
|
throw new Error("Requires ((limit - start) / delta) <= ".concat(INT32_MAX));
|
}
|
}
|
rtNestedSplits[row + 1] = rtNestedSplits[row] + size;
|
}
|
var nVals = rtNestedSplits[nRows];
|
// Construct the rtDenseValues tensor.
|
var rtDenseValues = tfjsCore.util.getArrayFromDType(startsDType, nVals);
|
var valueIndex = 0;
|
for (var row = 0; row < nRows; ++row) {
|
var rowSize = rtNestedSplits[row + 1] - rtNestedSplits[row];
|
var value = broadcastStarts ? starts[0] : starts[row];
|
var delta = broadcastDeltas ? deltas[0] : deltas[row];
|
for (var i = 0; i < rowSize; ++i) {
|
rtDenseValues[valueIndex++] = value;
|
value += delta;
|
}
|
}
|
return [rtNestedSplits, rtDenseValues];
|
}
|
|
var RowPartitionType = tfjsCore.backend_util.RowPartitionType;
|
// Based on
|
// https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/ragged_tensor_to_tensor_op.cc
|
var RaggedTensorToTensorOp = /** @class */ (function () {
|
function RaggedTensorToTensorOp(shape, shapeShape, values, valuesShape, valuesDType, defaultValue, defaultValueShape, rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypeStrings) {
|
this.shape = shape;
|
this.shapeShape = shapeShape;
|
this.values = values;
|
this.valuesShape = valuesShape;
|
this.valuesDType = valuesDType;
|
this.defaultValue = defaultValue;
|
this.defaultValueShape = defaultValueShape;
|
this.rowPartitionValues = rowPartitionValues;
|
this.rowPartitionValuesShapes = rowPartitionValuesShapes;
|
this.rowPartitionTypes =
|
tfjsCore.backend_util.getRowPartitionTypesHelper(rowPartitionTypeStrings);
|
this.raggedRank = tfjsCore.backend_util.getRaggedRank(this.rowPartitionTypes);
|
}
|
RaggedTensorToTensorOp.prototype.getRowPartitionTypeByDimension = function (dimension) {
|
if (this.rowPartitionTypes[0] === RowPartitionType.FIRST_DIM_SIZE) {
|
return this.rowPartitionTypes[dimension + 1];
|
}
|
else {
|
return this.rowPartitionTypes[dimension];
|
}
|
};
|
// Returns the relationship between dimension and dimension + 1.
|
RaggedTensorToTensorOp.prototype.getRowPartitionTensor = function (dimension) {
|
if (this.rowPartitionTypes[0] === RowPartitionType.FIRST_DIM_SIZE) {
|
return this.rowPartitionValues[dimension + 1];
|
}
|
else {
|
return this.rowPartitionValues[dimension];
|
}
|
};
|
RaggedTensorToTensorOp.prototype.getMaxWidth = function (dimension) {
|
var rowPartitionTensor = this.getRowPartitionTensor(dimension - 1);
|
switch (this.getRowPartitionTypeByDimension(dimension - 1)) {
|
case RowPartitionType.VALUE_ROWIDS:
|
return RaggedTensorToTensorOp.getMaxWidthValueRowID(rowPartitionTensor);
|
case RowPartitionType.ROW_SPLITS:
|
return RaggedTensorToTensorOp.getMaxWidthRowSplit(rowPartitionTensor);
|
default:
|
throw new Error("Cannot handle partition type ".concat(RowPartitionType[this.getRowPartitionTypeByDimension(dimension - 1)]));
|
}
|
};
|
RaggedTensorToTensorOp.getMaxWidthRowSplit = function (rowSplit) {
|
var tensorLength = rowSplit.length;
|
if (tensorLength === 0 || tensorLength === 1) {
|
return 0;
|
}
|
var maxWidth = 0;
|
for (var i = 0; i < tensorLength - 1; ++i) {
|
var currentWidth = rowSplit[i + 1] - rowSplit[i];
|
if (currentWidth > maxWidth) {
|
maxWidth = currentWidth;
|
}
|
}
|
return maxWidth;
|
};
|
RaggedTensorToTensorOp.getMaxWidthValueRowID = function (valueRowIds) {
|
var indexLength = valueRowIds.length;
|
if (indexLength === 0) {
|
return 0;
|
}
|
var firstEqualIndex = 0;
|
var firstEqualIndexValue = valueRowIds[0];
|
var maxWidth = 0;
|
for (var i = 1; i < indexLength; ++i) {
|
var value = valueRowIds[i];
|
if (value !== firstEqualIndexValue) {
|
firstEqualIndexValue = value;
|
maxWidth = Math.max(i - firstEqualIndex, maxWidth);
|
firstEqualIndex = i;
|
}
|
}
|
return Math.max(indexLength - firstEqualIndex, maxWidth);
|
};
|
RaggedTensorToTensorOp.prototype.tensorShapeFromTensor = function (t, tShape, isPartial) {
|
if (isPartial === void 0) { isPartial = true; }
|
if (tShape.length === 0) {
|
if (t[0] === -1) {
|
return [];
|
}
|
throw new Error("The only valid scalar shape tensor is the fully unknown shape specified as -1.");
|
}
|
// MakePartialShape/MakeShapeHelper.
|
return makeShape(t, isPartial);
|
};
|
RaggedTensorToTensorOp.prototype.calculateOutputSize = function (firstDim) {
|
var valueShape = this.valuesShape;
|
var defaultValueShape = this.defaultValueShape;
|
tfjsCore.backend_util.validateDefaultValueShape(defaultValueShape, valueShape);
|
var shape = this.tensorShapeFromTensor(this.shape, this.shapeShape);
|
var outputShape = tfjsCore.backend_util.combineRaggedTensorToTensorShapes(this.raggedRank, shape, valueShape);
|
var result = outputShape;
|
if (result[0] < 0) {
|
result[0] = firstDim;
|
}
|
for (var i = 1; i <= this.raggedRank; ++i) {
|
if (result[i] < 0) {
|
result[i] = this.getMaxWidth(i);
|
}
|
}
|
return result;
|
};
|
/**
|
* The outputIndex represents the index in the output tensor
|
* where the first element of a particular dimension would be written.
|
* If it is -1, it indicates that the index is out of scope.
|
* Example, given firstDimension = 10, firstDimensionOutput = 6,
|
* and outputIndexMultiplier = 100:
|
* result = [0 100 200 300 400 500 -1 -1 -1 -1]
|
* If firstDimensionOutput = 11 instead, then:
|
* result = [0 100 200 300 400 500 600 700 800 900]
|
*/
|
RaggedTensorToTensorOp.prototype.calculateFirstParentOutputIndex = function (firstDimension, outputIndexMultiplier, firstDimensionOutput) {
|
var minDimension = Math.min(firstDimension, firstDimensionOutput);
|
var result = [];
|
var currentOutputIndex = 0;
|
for (var i = 0; i < minDimension; ++i, currentOutputIndex += outputIndexMultiplier) {
|
result.push(currentOutputIndex);
|
}
|
for (var i = minDimension; i < firstDimension; ++i) {
|
result.push(-1);
|
}
|
tfjsCore.util.assert(result.length === firstDimension, function () { return 'Final length of result must be equal to firstDimension.'; });
|
return result;
|
};
|
RaggedTensorToTensorOp.prototype.calculateOutputIndexRowSplit = function (rowSplit, parentOutputIndex, outputIndexMultiplier, outputSize) {
|
var rowSplitSize = rowSplit.length;
|
var result = [];
|
for (var i = 0; i < rowSplitSize - 1; ++i) {
|
var rowLength = rowSplit[i + 1] - rowSplit[i];
|
var realLength = Math.min(outputSize, rowLength);
|
var parentOutputIndexCurrent = parentOutputIndex[i];
|
if (parentOutputIndexCurrent === -1) {
|
realLength = 0;
|
}
|
for (var j = 0; j < realLength; ++j) {
|
result.push(parentOutputIndexCurrent);
|
parentOutputIndexCurrent += outputIndexMultiplier;
|
}
|
for (var j = 0; j < rowLength - realLength; ++j) {
|
result.push(-1);
|
}
|
}
|
if (rowSplitSize > 0 && result.length !== rowSplit[rowSplitSize - 1]) {
|
throw new Error('Invalid row split size.');
|
}
|
return result;
|
};
|
// Calculate the output index of the first element of a list.
|
// The parentOutputIndex is the same computation for the previous list.
|
// -1 indicates an element or list that is out of range.
|
// The outputIndexMultiplier is the number of output indices one moves
|
// forward for each column.
|
// E.g., given:
|
// valueRowIds:[0 1 2 2 2 3 5 5 6]
|
// parentOutputIndex:[1000 1100 2000 2100 -1 3000 4000]
|
// outputIndexMultiplier: 10
|
// outputSize: 2
|
// You get:
|
// result = [1000 1100 2000 2010 -1 2100 -1 -1 3000]
|
// result[0] = parentOutputIndex[valueRowIds[0]]
|
// result[1] = parentOutputIndex[valueRowIds[1]]
|
// result[2] = parentOutputIndex[valueRowIds[2]]
|
// result[3] = parentOutputIndex[valueRowIds[2] + 10]
|
// result[4] = -1 because it is the third element the size is 2.
|
// result[5] = parentOutputIndex[valueRowIds[3]]
|
// result[6] = -1 because parentOutputIndex[valueRowIds[6]] == -1
|
// result[7] = -1 because parentOutputIndex[valueRowIds[6]] == -1
|
// result[8] = parentOutputIndex[valueRowIds[7]]
|
RaggedTensorToTensorOp.prototype.calculateOutputIndexValueRowID = function (valueRowIds, parentOutputIndex, outputIndexMultiplier, outputSize) {
|
var indexSize = valueRowIds.length;
|
var result = [];
|
if (indexSize === 0) {
|
return [];
|
}
|
var currentOutputColumn = 0;
|
var currentValueRowId = valueRowIds[0];
|
if (currentValueRowId >= parentOutputIndex.length) {
|
throw new Error("Got currentValueRowId=".concat(currentValueRowId, ", which is not less than ").concat(parentOutputIndex.length));
|
}
|
var currentOutputIndex = parentOutputIndex[currentValueRowId];
|
result.push(currentOutputIndex);
|
for (var i = 1; i < indexSize; ++i) {
|
var nextValueRowId = valueRowIds[i];
|
if (nextValueRowId === currentValueRowId) {
|
if (currentOutputIndex >= 0) {
|
++currentOutputColumn;
|
if (currentOutputColumn < outputSize) {
|
currentOutputIndex += outputIndexMultiplier;
|
}
|
else {
|
currentOutputIndex = -1;
|
}
|
}
|
}
|
else {
|
currentOutputColumn = 0;
|
currentValueRowId = nextValueRowId;
|
if (nextValueRowId >= parentOutputIndex.length) {
|
throw new Error("Got nextValueRowId=".concat(nextValueRowId, " which is not less than ").concat(parentOutputIndex.length));
|
}
|
currentOutputIndex = parentOutputIndex[nextValueRowId];
|
}
|
result.push(currentOutputIndex);
|
}
|
if (result.length !== valueRowIds.length) {
|
throw new Error('Invalid row ids.');
|
}
|
return result;
|
};
|
RaggedTensorToTensorOp.prototype.calculateOutputIndex = function (dimension, parentOutputIndex, outputIndexMultiplier, outputSize) {
|
var rowPartitionTensor = this.getRowPartitionTensor(dimension);
|
var partitionType = this.getRowPartitionTypeByDimension(dimension);
|
switch (partitionType) {
|
case RowPartitionType.VALUE_ROWIDS:
|
return this.calculateOutputIndexValueRowID(rowPartitionTensor, parentOutputIndex, outputIndexMultiplier, outputSize);
|
case RowPartitionType.ROW_SPLITS:
|
if (rowPartitionTensor.length - 1 > parentOutputIndex.length) {
|
throw new Error("Row partition size is greater than output size: ".concat(rowPartitionTensor.length - 1, " > ").concat(parentOutputIndex.length));
|
}
|
return this.calculateOutputIndexRowSplit(rowPartitionTensor, parentOutputIndex, outputIndexMultiplier, outputSize);
|
default:
|
throw new Error("Unsupported partition type: ".concat(RowPartitionType[partitionType]));
|
}
|
};
|
RaggedTensorToTensorOp.prototype.getFirstDimensionSize = function () {
|
var firstPartitionTensor = this.rowPartitionValues[0];
|
if (this.rowPartitionTypes.length === 0) {
|
throw new Error('No row_partition_types given.');
|
}
|
var firstPartitionType = this.rowPartitionTypes[0];
|
switch (firstPartitionType) {
|
case RowPartitionType.FIRST_DIM_SIZE:
|
return firstPartitionTensor[0];
|
case RowPartitionType.VALUE_ROWIDS:
|
throw new Error('Cannot handle VALUE_ROWIDS in first dimension.');
|
case RowPartitionType.ROW_SPLITS:
|
return this.rowPartitionValuesShapes[0][0] - 1;
|
default:
|
throw new Error("Cannot handle type ".concat(RowPartitionType[firstPartitionType]));
|
}
|
};
|
RaggedTensorToTensorOp.prototype.compute = function () {
|
var firstPartitionTensor = this.rowPartitionValues[0];
|
if (firstPartitionTensor.length <= 0) {
|
throw new Error('Invalid first partition input. ' +
|
'Tensor requires at least one element.');
|
}
|
var firstDimension = this.getFirstDimensionSize();
|
var outputSize = this.calculateOutputSize(firstDimension);
|
var multiplier = new Array(this.raggedRank + 1);
|
multiplier[multiplier.length - 1] = 1;
|
for (var i = multiplier.length - 2; i >= 0; --i) {
|
multiplier[i] = multiplier[i + 1] * outputSize[i + 1];
|
}
|
// Full size of the tensor.
|
var outputShape = makeShape(outputSize, false);
|
var outputTensor = tfjsCore.util.getArrayFromDType(this.valuesDType, tfjsCore.util.sizeFromShape(outputShape));
|
var fullSize = multiplier[0] * outputSize[0];
|
if (fullSize > 0) {
|
var outputIndex = this.calculateFirstParentOutputIndex(firstDimension, multiplier[0], outputSize[0]);
|
for (var i = 1; i <= this.raggedRank; ++i) {
|
var newOutputIndex = this.calculateOutputIndex(i - 1, outputIndex, multiplier[i], outputSize[i]);
|
outputIndex = newOutputIndex;
|
}
|
this.setOutput(this.raggedRank, outputIndex, outputTensor, outputShape);
|
}
|
return [outputShape, outputTensor];
|
};
|
RaggedTensorToTensorOp.prototype.setOutput = function (raggedRank, outputIndex, outputTensor, outputShape) {
|
if (outputTensor.length === 0) {
|
return;
|
}
|
var valuesBase = this.values;
|
var outputBase = outputTensor;
|
var elementShape = outputShape.slice();
|
elementShape = elementShape.slice(raggedRank + 1);
|
var valueElementSize = tfjsCore.util.sizeFromShape(elementShape);
|
var outputIndexSize = outputIndex.length;
|
// Broadcast the default value to value_element_size. (We can skip this
|
// if defaultValueTensor.size == 1, since we use fill when that's true.)
|
var defaultValue = this.defaultValue;
|
if (defaultValue.length !== valueElementSize && defaultValue.length !== 1) {
|
var srcShape_1 = this.defaultValueShape;
|
tfjsCore.tidy(function () {
|
var defaultValueTensor = tfjsCore.reshape(defaultValue, srcShape_1);
|
var bCastDefault = tfjsCore.broadcastTo(defaultValueTensor, elementShape);
|
defaultValue = bCastDefault.dataSync();
|
});
|
}
|
// Loop through the outputIndex array, finding contiguous regions that
|
// should be copied. Once we find the end of a contiguous region, copy it
|
// and add any necessary padding (with defaultValue).
|
var srcStart = 0; // Start of contiguous region (in values)
|
var dstStart = 0; // Destination for contiguous region (in output)
|
var dstEnd = 0; // Destination for contiguous region (in output)
|
for (var srcI = 0; srcI <= outputIndexSize; ++srcI) {
|
// dstI is the destination where the value at srcI should be copied.
|
var dstI = srcI < outputIndexSize ? outputIndex[srcI] : -1;
|
// If we're still in a contiguous region, then update dstEnd go to the
|
// next srcI.
|
if (dstI === dstEnd) {
|
++dstEnd;
|
continue;
|
}
|
// We found the end of contiguous region. This can be because we found
|
// a gap (dstI > dstEnd), or a source value that shouldn't be copied
|
// because it's out-of-bounds (dstI == -1), or the end of the tensor
|
// (dstI === -1).
|
if (dstStart < dstEnd) {
|
// Copy the contiguous region.
|
var src = valuesBase.subarray(srcStart * valueElementSize);
|
var dst = outputBase.subarray(dstStart * valueElementSize);
|
var nVals = (dstEnd - dstStart) * valueElementSize;
|
copyArray(dst, src, nVals);
|
}
|
// Add any necessary padding (w/ defaultValue).
|
if (srcI >= outputIndexSize) {
|
// We reached the end of values: pad to the end of output.
|
var outputSize = outputTensor.length;
|
dstI = Math.floor(outputSize / valueElementSize);
|
}
|
if (dstI > dstEnd) {
|
if (this.defaultValue.length === 1) {
|
outputBase
|
.subarray(dstEnd * valueElementSize, dstI * valueElementSize)
|
.fill(this.defaultValue[0]);
|
dstEnd = dstI;
|
}
|
else {
|
while (dstI > dstEnd) {
|
var dst = outputBase.slice(dstEnd * valueElementSize);
|
copyArray(dst, defaultValue, valueElementSize);
|
++dstEnd;
|
}
|
}
|
}
|
// Update indices.
|
if (dstI < 0) {
|
// srcI should be skipped -- leave it out of the contiguous region.
|
srcStart = srcI + 1;
|
dstStart = dstEnd;
|
}
|
else {
|
// srcI should be copied -- include it in the contiguous region.
|
srcStart = srcI;
|
dstStart = dstEnd;
|
dstEnd = dstStart + 1;
|
}
|
}
|
};
|
return RaggedTensorToTensorOp;
|
}());
|
function copyArray(dst, src, size) {
|
for (var i = 0; i < size; i++) {
|
dst[i] = src[i];
|
}
|
}
|
function makeShape(shape, isPartial) {
|
var e_1, _a;
|
var out = [];
|
try {
|
for (var shape_1 = __values(shape), shape_1_1 = shape_1.next(); !shape_1_1.done; shape_1_1 = shape_1.next()) {
|
var dim = shape_1_1.value;
|
if (dim < 0) {
|
if (!isPartial) {
|
throw new Error("Dimension ".concat(dim, " must be >= 0"));
|
}
|
if (dim < -1) {
|
throw new Error("Dimension ".concat(dim, " must be >= -1"));
|
}
|
dim = -1;
|
}
|
out.push(dim);
|
}
|
}
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
finally {
|
try {
|
if (shape_1_1 && !shape_1_1.done && (_a = shape_1.return)) _a.call(shape_1);
|
}
|
finally { if (e_1) throw e_1.error; }
|
}
|
return out;
|
}
|
function raggedTensorToTensorImpl(shape, shapesShape, values, valuesShape, valuesDType, defaultValue, defaultValueShape, rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes) {
|
return new RaggedTensorToTensorOp(shape, shapesShape, values, valuesShape, valuesDType, defaultValue, defaultValueShape, rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes)
|
.compute();
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function rangeImpl(start, stop, step, dtype) {
|
var sameStartStop = start === stop;
|
var increasingRangeNegativeStep = start < stop && step < 0;
|
var decreasingRangePositiveStep = stop < start && step > 1;
|
if (sameStartStop || increasingRangeNegativeStep ||
|
decreasingRangePositiveStep) {
|
return tfjsCore.util.makeZerosTypedArray(0, dtype);
|
}
|
var numElements = Math.abs(Math.ceil((stop - start) / step));
|
var values = tfjsCore.util.makeZerosTypedArray(numElements, dtype);
|
if (stop < start && step === 1) {
|
// Auto adjust the step's sign if it hasn't been set
|
// (or was set to 1)
|
step = -1;
|
}
|
values[0] = start;
|
for (var i = 1; i < values.length; i++) {
|
values[i] = values[i - 1] + step;
|
}
|
return values;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var rsqrtImpl = createSimpleUnaryImpl(function (xi) { return 1 / Math.sqrt(xi); });
|
var rsqrt = unaryKernelFuncFromImpl(tfjsCore.Rsqrt, rsqrtImpl);
|
var rsqrtConfig = {
|
kernelName: tfjsCore.Rsqrt,
|
backendName: 'cpu',
|
kernelFunc: rsqrt,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function scatterImpl(indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices) {
|
var flattenShape = [outputSize / sliceSize, sliceSize];
|
var indicesData = indices.values;
|
var updatesData = updates.values;
|
if (outputSize === 0) {
|
return tfjsCore.buffer(shape, updates.dtype);
|
}
|
var outBuf = (defaultValue instanceof tfjsCore.TensorBuffer) ?
|
defaultValue :
|
tfjsCore.buffer(flattenShape, updates.dtype);
|
if (typeof defaultValue === 'string') {
|
outBuf.values.fill(defaultValue);
|
}
|
else if (typeof defaultValue === 'number') {
|
outBuf.values.fill(defaultValue);
|
}
|
else if (typeof defaultValue === 'boolean') {
|
outBuf.values.fill(+defaultValue);
|
}
|
for (var i = 0; i < numUpdates; i++) {
|
var index = [];
|
var flattenIndex = 0;
|
for (var j = 0; j < sliceRank; j++) {
|
var dim = indicesData[i * sliceRank + j];
|
index.push(dim);
|
flattenIndex += dim * strides[j];
|
}
|
if (flattenIndex < 0 || flattenIndex >= outputSize / sliceSize) {
|
throw new Error("Invalid indices: ".concat(index, " does not index into ").concat(shape));
|
}
|
for (var k = 0; k < sliceSize; k++) {
|
if (sumDupeIndices) {
|
outBuf.values[flattenIndex * sliceSize + k] +=
|
updatesData[i * sliceSize + k];
|
}
|
else {
|
outBuf.values[flattenIndex * sliceSize + k] = updates.rank === 0 ?
|
updatesData[0] :
|
updatesData[i * sliceSize + k];
|
}
|
}
|
}
|
return outBuf;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var sigmoidImpl = createSimpleUnaryImpl(function (xi) { return 1 / (1 + Math.exp(-xi)); });
|
var sigmoid = unaryKernelFunc(tfjsCore.Sigmoid, function (xi) { return 1 / (1 + Math.exp(-xi)); });
|
var sigmoidConfig = {
|
kernelName: tfjsCore.Sigmoid,
|
backendName: 'cpu',
|
kernelFunc: sigmoid,
|
};
|
|
function sliceImpl(vals, begin, size, shape, dtype) {
|
var isContinous = tfjsCore.slice_util.isSliceContinous(shape, begin, size);
|
var length = tfjsCore.util.sizeFromShape(size);
|
var xStrides = tfjsCore.util.computeStrides(shape);
|
if (isContinous) {
|
var flatOffset = tfjsCore.slice_util.computeFlatOffset(begin, xStrides);
|
if (dtype === 'string') {
|
return vals.slice(flatOffset, flatOffset + length);
|
}
|
return vals.subarray(flatOffset, flatOffset + length);
|
}
|
var decodedData = dtype === 'string' ?
|
tfjsCore.backend_util.fromUint8ToStringArray(vals) :
|
vals;
|
var inBuf = tfjsCore.buffer(shape, dtype, decodedData);
|
var outBuf = tfjsCore.buffer(size, dtype);
|
for (var i = 0; i < outBuf.size; ++i) {
|
var outLoc = outBuf.indexToLoc(i);
|
var inLoc = outLoc.map(function (idx, j) { return idx + begin[j]; });
|
outBuf.set.apply(outBuf, __spreadArray([inBuf.get.apply(inBuf, __spreadArray([], __read(inLoc), false))], __read(outLoc), false));
|
}
|
if (dtype === 'string') {
|
return tfjsCore.backend_util.fromStringArrayToUint8(outBuf.values);
|
}
|
return outBuf.values;
|
}
|
function slice(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var begin = attrs.begin, size = attrs.size;
|
assertNotComplex(x, 'slice');
|
var _a = __read(tfjsCore.slice_util.parseSliceParams(x, begin, size), 2), $begin = _a[0], $size = _a[1];
|
tfjsCore.slice_util.assertParamsValid(x, $begin, $size);
|
var vals = backend.data.get(x.dataId).values;
|
var outVals = sliceImpl(vals, $begin, $size, x.shape, x.dtype);
|
return backend.makeTensorInfo($size, x.dtype, outVals);
|
}
|
var sliceConfig = {
|
kernelName: tfjsCore.Slice,
|
backendName: 'cpu',
|
kernelFunc: slice
|
};
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function sparseFillEmptyRowsImpl(indices, indicesShape, indicesDType, values, valuesDType, denseShape, defaultValue) {
|
var indicesCount = indicesShape[0];
|
var denseRows = denseShape[0];
|
var emptyRowIndicator = new Array(denseRows);
|
var reverseIndexMap = new Array(indicesCount);
|
var rank = indicesShape[1];
|
if (denseRows === 0) {
|
if (indicesCount !== 0) {
|
throw new Error(tfjsCore.backend_util.getSparseFillEmptyRowsIndicesDenseShapeMismatch(indicesCount));
|
}
|
var outputIndices = tfjsCore.util.getArrayFromDType(indicesDType, 0);
|
var outputValues = tfjsCore.util.getArrayFromDType(valuesDType, 0);
|
return [
|
outputIndices, [0, rank], outputValues, emptyRowIndicator, reverseIndexMap
|
];
|
}
|
var rowsAreOrdered = true;
|
var lastIndicesRow = 0;
|
var csrOffset = new Array(denseRows).fill(0);
|
for (var i = 0; i < indicesCount; ++i) {
|
// indices is a 2d tensor with shape of [N, rank]
|
var row = indices[i * rank];
|
if (row < 0) {
|
throw new Error(tfjsCore.backend_util.getSparseFillEmptyRowsNegativeIndexErrorMessage(i, row));
|
}
|
if (row >= denseRows) {
|
throw new Error(tfjsCore.backend_util.getSparseFillEmptyRowsOutOfRangeIndexErrorMessage(i, row, denseRows));
|
}
|
++csrOffset[row];
|
rowsAreOrdered = rowsAreOrdered && (row >= lastIndicesRow);
|
lastIndicesRow = row;
|
}
|
var allRowsFull = true;
|
for (var row = 0; row < denseRows; ++row) {
|
// csrOffset here describes the number of elements in this dense row
|
var rowEmpty = (csrOffset[row] === 0);
|
emptyRowIndicator[row] = rowEmpty;
|
allRowsFull = allRowsFull && !rowEmpty;
|
// In filled version, each row has at least one element.
|
csrOffset[row] = Math.max(csrOffset[row], 1);
|
// Update csrOffset to represent the number of elements up to and
|
// including denseRows + 1:
|
// csrOffset[0] == #{elements of row 0}
|
// csrOffset[1] == #{elements of row 1} + #{elements of row 0}
|
// ..
|
// csrOffset[i] == starting index for elements in row i + 1.
|
if (row > 0) {
|
csrOffset[row] += csrOffset[row - 1];
|
}
|
}
|
if (allRowsFull && rowsAreOrdered) {
|
var outputIndices = indices;
|
var outputValues = values;
|
for (var i = 0; i < indicesCount; ++i) {
|
reverseIndexMap[i] = i;
|
}
|
return [
|
outputIndices, [indicesCount, rank], outputValues, emptyRowIndicator,
|
reverseIndexMap
|
];
|
}
|
else {
|
var fullIndicesCount = csrOffset[denseRows - 1];
|
var outputIndices = tfjsCore.util.getArrayFromDType(indicesDType, fullIndicesCount * rank);
|
var outputValues = tfjsCore.util.getArrayFromDType(valuesDType, fullIndicesCount);
|
var filledCount = new Array(denseRows).fill(0);
|
// Fill in values for rows that are not missing
|
for (var i = 0; i < indicesCount; ++i) {
|
// indices is a 2d tensor with shape of [N, rank]
|
var row = indices[i * rank];
|
var offset = filledCount[row];
|
var outputI = ((row === 0) ? 0 : csrOffset[row - 1]) + offset;
|
filledCount[row]++; // Increment the filled count for this row.
|
for (var j = 0; j < rank; ++j) {
|
// indices and outputIndices are 2d tensors with shape of [N, rank]
|
outputIndices[outputI * rank + j] = indices[i * rank + j];
|
}
|
outputValues[outputI] = values[i];
|
// We'll need this reverse index map to backprop correctly.
|
reverseIndexMap[i] = outputI;
|
}
|
// Fill in values for rows that are missing
|
for (var row = 0; row < denseRows; ++row) {
|
var rowCount = filledCount[row];
|
if (rowCount === 0) { // We haven't filled this row
|
var startingIndex = (row === 0) ? 0 : csrOffset[row - 1];
|
// Remaining index values were set to zero already.
|
// Just need to set the row index in the right location.
|
// outputIndices is a 2d tensor with shape of [N, rank]
|
outputIndices[startingIndex * rank + 0] = row;
|
for (var col = 1; col < rank; ++col) {
|
outputIndices[startingIndex * rank + col] = 0;
|
}
|
outputValues[startingIndex] = defaultValue;
|
}
|
}
|
return [
|
outputIndices, [fullIndicesCount, rank], outputValues, emptyRowIndicator,
|
reverseIndexMap
|
];
|
}
|
}
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function sparseReshapeImpl(inputIndices, inputIndicesShape, inputDType, inputShape, targetShape) {
|
var denseSize = tfjsCore.util.sizeFromShape(inputShape);
|
var nnz = inputIndicesShape[0];
|
var outputRank = targetShape.length;
|
// Compute the output shape. Determine product of specified dimensions, and
|
// find the index of the unspecified one.
|
var outputShape = [];
|
var product = 1;
|
var unknownIndex = -1;
|
for (var d = 0; d < outputRank; ++d) {
|
var size = targetShape[d];
|
if (size === -1) {
|
if (unknownIndex !== -1) {
|
throw new Error(tfjsCore.backend_util
|
.getSparseReshapeMultipleNegativeOneOutputDimErrorMessage(unknownIndex, d));
|
}
|
unknownIndex = d;
|
outputShape.push(1);
|
}
|
else {
|
if (size < 0) {
|
throw new Error(tfjsCore.backend_util.getSparseReshapeNegativeOutputDimErrorMessage(d, size));
|
}
|
product *= size;
|
outputShape.push(size);
|
}
|
}
|
if (unknownIndex !== -1) {
|
if (product <= 0) {
|
throw new Error(tfjsCore.backend_util.getSparseReshapeEmptyTensorZeroOutputDimErrorMessage());
|
}
|
var missing = Math.trunc(denseSize / product);
|
if (product * missing !== denseSize) {
|
throw new Error(tfjsCore.backend_util.getSparseReshapeInputOutputMultipleErrorMessage(inputShape, outputShape));
|
}
|
outputShape[unknownIndex] = missing;
|
}
|
var outputSize = tfjsCore.util.sizeFromShape(outputShape);
|
if (outputSize !== denseSize) {
|
throw new Error(tfjsCore.backend_util.getSparseReshapeInputOutputMismatchErrorMessage(inputShape, outputShape));
|
}
|
var inputRank = inputShape.length;
|
var inputStrides = [];
|
if (inputRank > 0) {
|
inputStrides[inputRank - 1] = 1;
|
for (var d = inputRank - 2; d >= 0; --d) {
|
inputStrides[d] = inputStrides[d + 1] * inputShape[d + 1];
|
}
|
}
|
var outputStrides = [];
|
if (outputRank > 0) {
|
outputStrides[outputRank - 1] = 1;
|
for (var d = outputRank - 2; d >= 0; --d) {
|
outputStrides[d] = outputStrides[d + 1] * outputShape[d + 1];
|
}
|
}
|
var newIndices = tfjsCore.util.getArrayFromDType(inputDType, nnz * outputRank);
|
for (var i = 0; i < nnz; ++i) {
|
var id = 0;
|
for (var j = 0; j < inputRank; ++j) {
|
// inputIndices is a 2d tensor with shape of [nnz, inputRank]
|
id += inputIndices[i * inputRank + j] * inputStrides[j];
|
}
|
for (var j = 0; j < outputRank; ++j) {
|
// newIndices is a 2d tensor with shape of [nnz, outputRank]
|
newIndices[i * outputRank + j] = Math.trunc(id / outputStrides[j]);
|
id %= outputStrides[j];
|
}
|
}
|
return [newIndices, [nnz, outputRank], outputShape];
|
}
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function sparseSegmentReductionImpl(input, inputShape, inputDType, indices, segmentIds, isMean, defaultValue) {
|
if (isMean === void 0) { isMean = false; }
|
if (defaultValue === void 0) { defaultValue = 0; }
|
var numIndices = indices.length;
|
// Flatten the array to two dimensions
|
var inputFlat = [inputShape[0], input.length / inputShape[0]];
|
var numCol = inputFlat[1];
|
// Note that the current implementation assumes that segmentIds values are
|
// sorted.
|
var lastSegmentIdPlusOne = numIndices > 0 ? segmentIds[numIndices - 1] + 1 : 0;
|
var outputRows = lastSegmentIdPlusOne;
|
if (outputRows < 0) {
|
throw new Error(tfjsCore.backend_util.getSparseSegmentReductionNegativeSegmentIdsErrorMessage());
|
}
|
var outputShape = inputShape.slice();
|
outputShape[0] = outputRows;
|
var outputLength = outputShape.reduce(function (product, value) { return product * value; }, 1);
|
// Output array is initialized with the value 0 by default.
|
var output = tfjsCore.util.getArrayFromDType(inputDType, outputLength);
|
// Note that we do not initialize the output buffer with a default value, so
|
// we need to explicitly set missing indices to the default value.
|
if (numIndices === 0) {
|
if (outputRows > 0) {
|
output.fill(defaultValue);
|
}
|
return [output, outputShape];
|
}
|
if (outputRows <= 0) {
|
throw new Error(tfjsCore.backend_util.getSparseSegmentReductionNegativeSegmentIdsErrorMessage());
|
}
|
var start = 0, end = 1;
|
// Index from which the output is not initialized.
|
var uninitializedIndex = 0;
|
var outIndex = segmentIds[start];
|
while (true) {
|
// We initialize nextIndex to 0 to avoid may be uninitialized warning
|
var nextIndex = 0;
|
if (end < numIndices) {
|
nextIndex = segmentIds[end];
|
if (outIndex === nextIndex) {
|
++end;
|
continue;
|
}
|
// We have a new segment here. Verify that the segment ids are growing.
|
if (outIndex >= nextIndex) {
|
throw new Error(tfjsCore.backend_util
|
.getSparseSegmentReductionNonIncreasingSegmentIdsErrorMessage());
|
}
|
}
|
if (outIndex < 0 || outIndex >= outputRows) {
|
throw new Error(tfjsCore.backend_util.getSparseSegmentReductionSegmentIdOutOfRangeErrorMessage(outIndex, outputRows));
|
}
|
// If there is a gap between two indices, we need to set that gap to the
|
// default value.
|
if (outIndex > uninitializedIndex) {
|
output.fill(defaultValue, uninitializedIndex * numCol, outIndex * numCol);
|
}
|
for (var i = start; i < end; ++i) {
|
var index = indices[i];
|
if (index < 0 || index >= inputFlat[0]) {
|
throw new Error(tfjsCore.backend_util.getSparseSegmentReductionIndicesOutOfRangeErrorMessage(i, indices[i], inputFlat[0]));
|
}
|
for (var j = 0; j < numCol; j++) {
|
output[outIndex * numCol + j] += input[index * numCol + j];
|
}
|
}
|
if (isMean) {
|
for (var j = 0; j < numCol; j++) {
|
output[outIndex * numCol + j] /= end - start;
|
}
|
}
|
start = end;
|
++end;
|
uninitializedIndex = outIndex + 1;
|
outIndex = nextIndex;
|
if (end > numIndices) {
|
break;
|
}
|
}
|
// Fill the gap at the end with the default value.
|
if (uninitializedIndex < outputRows) {
|
output.fill(defaultValue, uninitializedIndex * numCol, outputRows * numCol);
|
}
|
return [output, outputShape];
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var sqrtImpl = createSimpleUnaryImpl(function (xi) { return Math.sqrt(xi); });
|
var sqrt = unaryKernelFunc(tfjsCore.Sqrt, function (xi) { return Math.sqrt(xi); });
|
var sqrtConfig = {
|
kernelName: tfjsCore.Sqrt,
|
backendName: 'cpu',
|
kernelFunc: sqrt,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var squaredDifferenceImpl = createSimpleBinaryKernelImpl((function (a, b) {
|
var diff = a - b;
|
return diff * diff;
|
}));
|
var squaredDifference = binaryKernelFunc(tfjsCore.SquaredDifference, squaredDifferenceImpl);
|
var squaredDifferenceConfig = {
|
kernelName: tfjsCore.SquaredDifference,
|
backendName: 'cpu',
|
kernelFunc: squaredDifference
|
};
|
|
/**
|
* @license
|
* Copyright 2023 Google LLC.
|
* 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 staticRegexReplaceImpl = createSimpleUnaryImpl(function (x, attrs) {
|
var pattern = attrs.pattern, replaceGlobal = attrs.replaceGlobal, rewrite = attrs.rewrite;
|
// TODO(mattSoulanille): Don't create a regex each time.
|
return x.replace(new RegExp(pattern, replaceGlobal ? 'g' : ''), rewrite);
|
});
|
var staticRegexReplace = unaryKernelFuncFromImpl(tfjsCore.StaticRegexReplace, staticRegexReplaceImpl);
|
var staticRegexReplaceConfig = {
|
kernelName: tfjsCore.StaticRegexReplace,
|
backendName: 'cpu',
|
kernelFunc: staticRegexReplace,
|
};
|
|
function stridedSliceImpl(outShape, xBuf, strides, begin) {
|
var outBuf = tfjsCore.buffer(outShape, xBuf.dtype);
|
for (var i = 0; i < outBuf.size; i++) {
|
var loc = outBuf.indexToLoc(i);
|
var newLoc = new Array(loc.length);
|
for (var j = 0; j < newLoc.length; j++) {
|
newLoc[j] = loc[j] * strides[j] + begin[j];
|
}
|
outBuf.set.apply(outBuf, __spreadArray([xBuf.get.apply(xBuf, __spreadArray([], __read(newLoc), false))], __read(loc), false));
|
}
|
return outBuf;
|
}
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
/**
|
* The StringNGramsOp class creates ngrams from ragged string data.
|
* The constructor contains all attributes related to the operation such as
|
* padding widths and strings, and the compute function can be used to
|
* compute the ngrams for different ragged tensor inputs.
|
*/
|
var StringNGramsOp = /** @class */ (function () {
|
function StringNGramsOp(separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences) {
|
this.separator = tfjsCore.util.encodeString(separator);
|
this.nGramWidths = nGramWidths;
|
this.leftPad = tfjsCore.util.encodeString(leftPad);
|
this.rightPad = tfjsCore.util.encodeString(rightPad);
|
this.padWidth = padWidth;
|
this.preserveShort = preserveShortSequences;
|
}
|
StringNGramsOp.prototype.getPadWidth = function (nGramWidth) {
|
// Ngrams can be padded with either a fixed pad width or a dynamic pad
|
// width depending on the 'padWidth' arg, but in no case should the padding
|
// ever be wider than 'nGramWidth' - 1.
|
return Math.min(this.padWidth < 0 ? nGramWidth - 1 : this.padWidth, nGramWidth - 1);
|
};
|
StringNGramsOp.prototype.getNumNGrams = function (length, nGramWidth) {
|
var padWidth = this.getPadWidth(nGramWidth);
|
return Math.max(0, ((length + 2 * padWidth) - nGramWidth) + 1);
|
};
|
StringNGramsOp.prototype.createNGrams = function (data, splitIndex, output, outputStartIndex, numNGrams, nGramWidth) {
|
var _loop_1 = function (nGramIndex) {
|
var padWidth = this_1.getPadWidth(nGramWidth);
|
var leftPadding = Math.max(0, padWidth - nGramIndex);
|
var rightPadding = Math.max(0, padWidth - (numNGrams - (nGramIndex + 1)));
|
var numTokens = nGramWidth - (leftPadding + rightPadding);
|
var dataStartIndex = splitIndex + (leftPadding > 0 ? 0 : nGramIndex - padWidth);
|
// Calculate the total expected size of the nGram so we can reserve the
|
// correct amount of space in the string.
|
var nGramSize = 0;
|
// Size of the left padding.
|
nGramSize += leftPadding * this_1.leftPad.length;
|
// Size of the tokens.
|
for (var n = 0; n < numTokens; ++n) {
|
nGramSize += data[dataStartIndex + n].length;
|
}
|
// Size of the right padding.
|
nGramSize += rightPadding * this_1.rightPad.length;
|
// Size of the separators.
|
var numSeparators = leftPadding + rightPadding + numTokens - 1;
|
nGramSize += numSeparators * this_1.separator.length;
|
// Build the nGram.
|
output[outputStartIndex + nGramIndex] = new Uint8Array(nGramSize);
|
var nGram = output[outputStartIndex + nGramIndex];
|
var nextNGramIndex = 0;
|
var appendToNGram = function (str) { return str.forEach(function (value) { return nGram[nextNGramIndex++] = value; }); };
|
for (var n = 0; n < leftPadding; ++n) {
|
appendToNGram(this_1.leftPad);
|
appendToNGram(this_1.separator);
|
}
|
// Only output first numTokens - 1 pairs of data and separator
|
for (var n = 0; n < numTokens - 1; ++n) {
|
appendToNGram(data[dataStartIndex + n]);
|
appendToNGram(this_1.separator);
|
}
|
// Handle case when there are no tokens or no right padding as these
|
// can result in consecutive separators.
|
if (numTokens > 0) {
|
// If we have tokens, then output last and then pair each separator
|
// with the right padding that follows, to ensure nGram ends either with
|
// the token or with the right pad.
|
appendToNGram(data[dataStartIndex + numTokens - 1]);
|
for (var n = 0; n < rightPadding; ++n) {
|
appendToNGram(this_1.separator);
|
appendToNGram(this_1.rightPad);
|
}
|
}
|
else {
|
// If we don't have tokens, then the last item inserted into the nGram
|
// has been the separator from the left padding loop above. Hence,
|
// output right pad and separator and make sure to finish with a
|
// padding, not a separator.
|
for (var n = 0; n < rightPadding - 1; ++n) {
|
appendToNGram(this_1.rightPad);
|
appendToNGram(this_1.separator);
|
}
|
appendToNGram(this_1.rightPad);
|
}
|
};
|
var this_1 = this;
|
for (var nGramIndex = 0; nGramIndex < numNGrams; ++nGramIndex) {
|
_loop_1(nGramIndex);
|
}
|
};
|
// Data and splits together form the definition of the ragged tensor,
|
// where data is 1 dimensional and contains the values of the tensor
|
// and splits denotes the indices at which each row starts.
|
StringNGramsOp.prototype.compute = function (data, splits) {
|
var _this = this;
|
// Validate that the splits are valid indices into data, only if there are
|
// splits specified.
|
var inputDataSize = data.length;
|
var splitsSize = splits.length;
|
if (splitsSize > 0) {
|
var prevSplit = splits[0];
|
if (prevSplit !== 0) {
|
throw new Error("First split value must be 0, got ".concat(prevSplit));
|
}
|
for (var i = 1; i < splitsSize; ++i) {
|
var validSplits = splits[i] >= prevSplit;
|
validSplits = validSplits && (splits[i] <= inputDataSize);
|
if (!validSplits) {
|
throw new Error("Invalid split value ".concat(splits[i], ", must be in [").concat(prevSplit, ", ").concat(inputDataSize, "]"));
|
}
|
prevSplit = splits[i];
|
}
|
if (prevSplit !== inputDataSize) {
|
throw new Error("Last split value must be data size. Expected ".concat(inputDataSize, ", got ").concat(prevSplit));
|
}
|
}
|
var numBatchItems = splitsSize - 1;
|
var nGramsSplits = tfjsCore.util.getArrayFromDType('int32', splitsSize);
|
// If there is no data or size, return an empty ragged tensor.
|
if (inputDataSize === 0 || splitsSize === 0) {
|
var empty = new Array(inputDataSize);
|
for (var i = 0; i <= numBatchItems; ++i) {
|
nGramsSplits[i] = 0;
|
}
|
return [empty, nGramsSplits];
|
}
|
nGramsSplits[0] = 0;
|
var _loop_2 = function (i) {
|
var length = splits[i] - splits[i - 1];
|
var numNGrams = 0;
|
this_2.nGramWidths.forEach(function (nGramWidth) {
|
numNGrams += _this.getNumNGrams(length, nGramWidth);
|
});
|
if (this_2.preserveShort && length > 0 && numNGrams === 0) {
|
numNGrams = 1;
|
}
|
nGramsSplits[i] = nGramsSplits[i - 1] + numNGrams;
|
};
|
var this_2 = this;
|
for (var i = 1; i <= numBatchItems; ++i) {
|
_loop_2(i);
|
}
|
var nGrams = new Array(nGramsSplits[numBatchItems]);
|
var _loop_3 = function (i) {
|
var splitIndex = splits[i];
|
var outputStartIdx = nGramsSplits[i];
|
this_3.nGramWidths.forEach(function (nGramWidth) {
|
var length = splits[i + 1] - splits[i];
|
var numNGrams = _this.getNumNGrams(length, nGramWidth);
|
_this.createNGrams(data, splitIndex, nGrams, outputStartIdx, numNGrams, nGramWidth);
|
outputStartIdx += numNGrams;
|
});
|
// If we're preserving short sequences, check to see if no sequence was
|
// generated by comparing the current output start idx to the original
|
// one (nGramSplitsdata). If no ngrams were generated, then they will
|
// be equal (since we increment outputStartIdx by numNGrams every
|
// time we create a set of ngrams.)
|
if (this_3.preserveShort && outputStartIdx === nGramsSplits[i]) {
|
var dataLength = splits[i + 1] - splits[i];
|
// One legitimate reason to not have any ngrams when this.preserveShort
|
// is true is if the sequence itself is empty. In that case, move on.
|
if (dataLength === 0) {
|
return "continue";
|
}
|
// We don't have to worry about dynamic padding sizes here: if padding
|
// was dynamic, every sequence would have had sufficient padding to
|
// generate at least one nGram.
|
var nGramWidth = dataLength + 2 * this_3.padWidth;
|
var numNGrams = 1;
|
this_3.createNGrams(data, splitIndex, nGrams, outputStartIdx, numNGrams, nGramWidth);
|
}
|
};
|
var this_3 = this;
|
for (var i = 0; i < numBatchItems; ++i) {
|
_loop_3(i);
|
}
|
return [nGrams, nGramsSplits];
|
};
|
return StringNGramsOp;
|
}());
|
function stringNGramsImpl(data, dataSplits, separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences) {
|
return new StringNGramsOp(separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences)
|
.compute(data, dataSplits);
|
}
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function split(str, delimiters, skipEmpty, result) {
|
if (!str.length) {
|
return;
|
}
|
// When the delimiter is empty, the input is split into individual characters.
|
if (delimiters.length === 0) {
|
for (var i = 0; i < str.length; ++i) {
|
result.push(str.subarray(i, i + 1));
|
}
|
return;
|
}
|
// When there is one delimiter, the input is split only at that delimiter.
|
if (delimiters.length === 1) {
|
var delimiter = delimiters[0];
|
var f = str.indexOf(delimiter);
|
while (f !== -1) {
|
var token = str.subarray(0, f);
|
if (!skipEmpty || token.length !== 0) {
|
result.push(token);
|
}
|
str = str.subarray(f + 1);
|
f = str.indexOf(delimiter);
|
}
|
if (!skipEmpty || str.length !== 0) {
|
result.push(str);
|
}
|
return;
|
}
|
// When there are multiple delimiters, the input is split at every instance
|
// one of the delimiters appears.
|
var tokenStart = 0;
|
for (var i = 0; i < str.length + 1; i++) {
|
if ((i === str.length) || (delimiters.indexOf(str[i]) !== -1)) {
|
var token = str.subarray(tokenStart, i);
|
if (!skipEmpty || token.length !== 0) {
|
result.push(token);
|
}
|
tokenStart = i + 1;
|
}
|
}
|
}
|
function stringSplitImpl(input, delimiter, skipEmpty) {
|
var batchSize = input.length;
|
// Empty delimiter means split the input character by character.
|
var tokens = [];
|
var outputSize = 0;
|
var maxNumEntries = 0;
|
var numIndices = new Array(batchSize);
|
for (var i = 0; i < batchSize; ++i) {
|
var prevTokensLength = tokens.length;
|
split(input[i], delimiter, skipEmpty, tokens);
|
var nEntries = tokens.length - prevTokensLength;
|
numIndices[i] = nEntries;
|
outputSize += nEntries;
|
maxNumEntries = Math.max(maxNumEntries, nEntries);
|
}
|
var indices = tfjsCore.util.getArrayFromDType('int32', outputSize * 2);
|
var values = new Array(outputSize);
|
var shape = [batchSize, maxNumEntries];
|
var c = 0;
|
for (var i = 0; i < batchSize; ++i) {
|
for (var j = 0; j < numIndices[i]; ++j) {
|
// indices is a 2d tensor with shape of [outputSize, 2]
|
indices[c * 2] = i;
|
indices[c * 2 + 1] = j;
|
values[c] = tokens[c];
|
++c;
|
}
|
}
|
return [indices, values, shape];
|
}
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function stringToHashBucketFastImpl(input, numBuckets) {
|
var output = tfjsCore.util.getArrayFromDType('int32', input.length);
|
for (var i = 0; i < input.length; ++i) {
|
output[i] =
|
tfjsCore.util.fingerPrint64(input[i]).modulo(numBuckets).getLowBitsUnsigned();
|
}
|
return output;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var subImpl = createSimpleBinaryKernelImpl((function (aValue, bValue) { return aValue - bValue; }));
|
var subComplexImpl = createComplexBinaryKernelImpl((function (aReal, aImag, bReal, bImag) {
|
return { real: aReal - bReal, imag: aImag - bImag };
|
}));
|
var sub = binaryKernelFunc(tfjsCore.Sub, subImpl, subComplexImpl);
|
var subConfig = {
|
kernelName: tfjsCore.Sub,
|
backendName: 'cpu',
|
kernelFunc: sub
|
};
|
|
/**
|
* @license
|
* Copyright 2019 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.
|
* =============================================================================
|
*/
|
/**
|
* An implementation of the tile kernel shared between webgl and cpu for string
|
* tensors only.
|
*/
|
function tileImpl(xBuf, reps) {
|
var newShape = new Array(xBuf.rank);
|
for (var i = 0; i < newShape.length; i++) {
|
newShape[i] = xBuf.shape[i] * reps[i];
|
}
|
var result = tfjsCore.buffer(newShape, xBuf.dtype);
|
for (var i = 0; i < result.values.length; ++i) {
|
var newLoc = result.indexToLoc(i);
|
var originalLoc = new Array(xBuf.rank);
|
for (var j = 0; j < originalLoc.length; j++) {
|
originalLoc[j] = newLoc[j] % xBuf.shape[j];
|
}
|
var originalIndex = xBuf.locToIndex(originalLoc);
|
result.values[i] = xBuf.values[originalIndex];
|
}
|
return result;
|
}
|
|
var comparePair = function (a, b) {
|
var valueDiff = b.value - a.value;
|
return valueDiff === 0 ? a.index - b.index : valueDiff;
|
};
|
/**
|
* Partitions array where all elements smaller than the (k+1) smallest element
|
* are found to the left of it, and all larger to the right of it.
|
* Based on the Floyd-Rivest Algorithm, ref:
|
* https://en.wikipedia.org/wiki/Floyd%E2%80%93Rivest_algorithm
|
* @param array: Array to partition
|
* @param left: Left index for the interval
|
* @param right: Right index for the interval
|
* @param k: Desired index value, where array[k] is the (k+1)th smallest element
|
* when left = 0
|
*/
|
function select$1(array, k, left, right) {
|
if (left === void 0) { left = 0; }
|
if (right === void 0) { right = array.length - 1; }
|
while (right > left) {
|
// Use select recursively to sample a smaller set of size s
|
// the arbitrary constants 600 and 0.5 are used in the original
|
// version to minimize execution time.
|
if (right - left > 600) {
|
var n = right - left + 1;
|
var i_1 = k - left + 1;
|
var z = Math.log(n);
|
var s = 0.5 * Math.exp(2 * z / 3);
|
var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * Math.sign(i_1 - n / 2);
|
var newLeft = Math.max(left, Math.floor(k - i_1 * s / n + sd));
|
var newRight = Math.min(right, Math.floor(k + (n - i_1) * s / n + sd));
|
select$1(array, k, newLeft, newRight);
|
}
|
// partition the elements between left and right around t
|
var t = array[k];
|
var i = left;
|
var j = right;
|
tfjsCore.util.swap(array, left, k);
|
if (comparePair(array[right], t) > 0) {
|
tfjsCore.util.swap(array, left, right);
|
}
|
while (i < j) {
|
tfjsCore.util.swap(array, i, j);
|
i++;
|
j--;
|
while (comparePair(array[i], t) < 0) {
|
i = i + 1;
|
}
|
while (comparePair(array[j], t) > 0) {
|
j = j - 1;
|
}
|
}
|
if (comparePair(array[left], t) === 0) {
|
tfjsCore.util.swap(array, left, j);
|
}
|
else {
|
j = j + 1;
|
tfjsCore.util.swap(array, j, right);
|
}
|
// Adjust left and right towards the boundaries of the subset
|
// containing the (k - left + 1)th smallest element.
|
if (j <= k) {
|
left = j + 1;
|
}
|
if (k <= j) {
|
right = j - 1;
|
}
|
}
|
}
|
function topKImpl(x, xShape, xDtype, k, sorted) {
|
// Reshape into a 2d tensor [batch, lastDim] and compute topk along lastDim.
|
var lastDim = xShape[xShape.length - 1];
|
var _a = __read([x.length / lastDim, lastDim], 2), batch = _a[0], size = _a[1];
|
var allTopKVals = tfjsCore.util.getTypedArrayFromDType(xDtype, batch * k);
|
var allTopKIndices = tfjsCore.util.getTypedArrayFromDType('int32', batch * k);
|
var _loop_1 = function (b) {
|
var offset = b * size;
|
var vals = x.subarray(offset, offset + size);
|
var valAndInd = new Array(vals.length);
|
vals.forEach(function (value, index) { return valAndInd[index] = { value: value, index: index }; });
|
if (k < valAndInd.length) {
|
select$1(valAndInd, k);
|
valAndInd = valAndInd.slice(0, k);
|
}
|
if (sorted) {
|
valAndInd.sort(comparePair);
|
}
|
var outOffset = b * k;
|
var topKVals = allTopKVals.subarray(outOffset, outOffset + k);
|
var topKIndices = allTopKIndices.subarray(outOffset, outOffset + k);
|
for (var i = 0; i < k; i++) {
|
topKVals[i] = valAndInd[i].value;
|
topKIndices[i] = valAndInd[i].index;
|
}
|
};
|
for (var b = 0; b < batch; b++) {
|
_loop_1(b);
|
}
|
// Reshape back to the original input shape, except that the last
|
// dimension is k.
|
var outputShape = xShape.slice();
|
outputShape[outputShape.length - 1] = k;
|
return [
|
tfjsCore.buffer(outputShape, xDtype, allTopKVals),
|
tfjsCore.buffer(outputShape, 'int32', allTopKIndices)
|
];
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function uniqueImpl(values, axis, shape, dtype) {
|
// Normalize and validate axis.
|
var $axis = tfjsCore.util.parseAxisParam(axis, shape)[0];
|
// Calculate the new shape that is suitable for extracting data along the
|
// given axis.
|
//
|
// The rank is 3.
|
// The size of the 1st dimension is the size of all the axes < the given axis.
|
// The size of the 2nd dimension is the same as the size of the given axis.
|
// The size of the 3rd dimension is the size of all the axes > the given axis.
|
//
|
// For example, for a 4D tensor with shape=[2, 3, 5, 4] and axis=2, the
|
// newShape would be: [2*3, 5, 4].
|
//
|
// Note that this is not the final output shape. This will be the shape for an
|
// intermediate TensorBuffer (see inputBuffer below) to allow us to extract
|
// values along the given axis. To demonstrate how it works, consider the
|
// following example:
|
//
|
// Input: a 3D tensor, with shape [1, 2, 3]
|
// [
|
// [
|
// [1,2,3],
|
// [4,5,6]
|
// ]
|
// ]
|
// Axis: 2 (the last axis).
|
// Along axis 2, we expect to extract 3 tensors: [1,4], [2,5], [3,6].
|
//
|
// For this example, newShape would be: [2, 3, 1], where 2 is calculated from
|
// 1*2. The re-shaped data would look like:
|
//
|
// [
|
// [
|
// [1], [2], [3]
|
// ],
|
// [
|
// [4], [5], [6]
|
// ]
|
// ]
|
//
|
// Then, we can construct a 3-level nested loop by the following dimension
|
// order to extract the values along the axis (dimension1):
|
// i: dimension1 // 0,1,2 (newShape[1])
|
// m: dimension0 // 0,1 (newShape[0])
|
// n: dimension2 // 0 (newShape[2])
|
//
|
// m, i, n
|
// ---------
|
// Iteration 0: data at [0, 0, 0] => "1"
|
// Iteration 1: data at [1, 0, 0] => "4"
|
// We got [1,4].
|
// Iteration 2: data at [0, 1, 0] => "2"
|
// Iteration 3: data at [1, 1, 0] => "5"
|
// We got [2,5].
|
// Iteration 4: data at [0, 2, 0] => "3"
|
// Iteration 5: data at [1, 2, 0] => "6"
|
// We got [3,6].
|
var newShape = [1, shape[0], 1];
|
for (var i = 0; i < $axis; i++) {
|
newShape[0] *= shape[i];
|
}
|
newShape[1] = shape[$axis];
|
for (var i = $axis + 1; i < shape.length; i++) {
|
newShape[2] *= shape[i];
|
}
|
// A map from unique elements (their string representations) to their values
|
// in "indices" (below).
|
var uniqueElements = new Map();
|
// The indices of each unique element in the original tensor along the given
|
// axis. It is 1D and has the same size as the given axis.
|
var indices = new Int32Array(shape[$axis]);
|
// Create a buffer so we can easily extract value at a given location.
|
var inputBuffer = new tfjsCore.TensorBuffer(newShape, dtype, values);
|
// The indices along the given axis that have unique elements. This is a
|
// de-duped version of "indices" above.
|
var uniqueIndices = [];
|
var is1DTensor = newShape[0] === 1 && newShape[2] === 1;
|
for (var i = 0; i < shape[$axis]; i++) {
|
// Extract values along the axis.
|
var element = void 0;
|
if (is1DTensor) {
|
// Fast path for 1D tensor input.
|
element = values[i].toString();
|
}
|
else {
|
var axisValues = [];
|
for (var m = 0; m < newShape[0]; m++) {
|
for (var n = 0; n < newShape[2]; n++) {
|
axisValues.push(inputBuffer.get(m, i, n));
|
}
|
}
|
element = axisValues.join(',');
|
}
|
// Dedup and update various indices.
|
var existingIndex = uniqueElements.get(element);
|
if (existingIndex != null) {
|
indices[i] = existingIndex;
|
}
|
else {
|
var uniqueIndex = uniqueElements.size;
|
uniqueElements.set(element, uniqueIndex);
|
indices[i] = uniqueIndex;
|
uniqueIndices.push(i);
|
}
|
}
|
// Now we know where each of the unique elements are located along the axis
|
// (uniqueIndices). Extract them from input buffer and store them in the
|
// output buffer.
|
var outputTmpShape = newShape.slice();
|
outputTmpShape[1] = uniqueElements.size;
|
var outputBuffer = new tfjsCore.TensorBuffer(outputTmpShape, dtype);
|
uniqueIndices.forEach(function (uniqueElementIndex, i) {
|
for (var m = 0; m < newShape[0]; m++) {
|
for (var n = 0; n < newShape[2]; n++) {
|
outputBuffer.set(inputBuffer.get(m, uniqueElementIndex, n), m, i, n);
|
}
|
}
|
});
|
// The output shape can be calculated from the input shape with the size of
|
// the given axis replaced by the number of unique elements along that axis.
|
var outputShape = shape.slice();
|
outputShape[$axis] = outputTmpShape[1];
|
return {
|
outputValues: outputBuffer.values,
|
outputShape: outputShape,
|
indices: indices,
|
};
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
|
var shared = {
|
__proto__: null,
|
addImpl: addImpl,
|
bincountImpl: bincountImpl,
|
bincountReduceImpl: bincountReduceImpl,
|
bitwiseAndImpl: bitwiseAndImpl,
|
castImpl: castImpl,
|
ceilImpl: ceilImpl,
|
concatImpl: concatImpl,
|
equalImpl: equalImpl,
|
expImpl: expImpl,
|
expm1Impl: expm1Impl,
|
floorDivImpl: floorDivImpl,
|
floorImpl: floorImpl,
|
gatherNdImpl: gatherNdImpl,
|
gatherV2Impl: gatherV2Impl,
|
greaterEqualImpl: greaterEqualImpl,
|
greaterImpl: greaterImpl,
|
lessEqualImpl: lessEqualImpl,
|
lessImpl: lessImpl,
|
linSpaceImpl: linSpaceImpl,
|
logImpl: logImpl,
|
maxImpl: maxImpl,
|
maximumImpl: maximumImpl,
|
minimumImpl: minimumImpl,
|
multiplyImpl: multiplyImpl,
|
negImpl: negImpl,
|
notEqualImpl: notEqualImpl,
|
prodImpl: prodImpl,
|
raggedGatherImpl: raggedGatherImpl,
|
raggedRangeImpl: raggedRangeImpl,
|
raggedTensorToTensorImpl: raggedTensorToTensorImpl,
|
rangeImpl: rangeImpl,
|
rsqrtImpl: rsqrtImpl,
|
scatterImpl: scatterImpl,
|
sigmoidImpl: sigmoidImpl,
|
simpleAbsImpl: simpleAbsImpl,
|
sliceImpl: sliceImpl,
|
sparseFillEmptyRowsImpl: sparseFillEmptyRowsImpl,
|
sparseReshapeImpl: sparseReshapeImpl,
|
sparseSegmentReductionImpl: sparseSegmentReductionImpl,
|
sqrtImpl: sqrtImpl,
|
squaredDifferenceImpl: squaredDifferenceImpl,
|
staticRegexReplaceImpl: staticRegexReplaceImpl,
|
stridedSliceImpl: stridedSliceImpl,
|
stringNGramsImpl: stringNGramsImpl,
|
stringSplitImpl: stringSplitImpl,
|
stringToHashBucketFastImpl: stringToHashBucketFastImpl,
|
subImpl: subImpl,
|
tileImpl: tileImpl,
|
topKImpl: topKImpl,
|
transposeImpl: transposeImpl,
|
uniqueImpl: uniqueImpl
|
};
|
|
/** @license See the LICENSE file. */
|
// This code is auto-generated, do not modify this file!
|
var version = '4.15.0';
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
// Side effects for default initialization of MathBackendCPU
|
tfjsCore.registerBackend('cpu', function () { return new MathBackendCPU(); }, 1 /* priority */);
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var elu = unaryKernelFunc(tfjsCore.Elu, function (xi) { return xi >= 0 ? xi : (Math.exp(xi) - 1); });
|
var eluConfig = {
|
kernelName: tfjsCore.Elu,
|
backendName: 'cpu',
|
kernelFunc: elu,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function leakyRelu(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var alpha = attrs.alpha;
|
assertNotComplex([x], 'leakyRelu');
|
var xSize = tfjsCore.util.sizeFromShape(x.shape);
|
var xVals = backend.data.get(x.dataId).values;
|
var outVals = tfjsCore.util.getTypedArrayFromDType('float32', xSize);
|
for (var i = 0; i < xVals.length; i++) {
|
outVals[i] = xVals[i] < 0 ? alpha * xVals[i] : xVals[i];
|
}
|
return backend.makeTensorInfo(x.shape, 'float32', outVals);
|
}
|
var leakyReluConfig = {
|
kernelName: tfjsCore.LeakyRelu,
|
backendName: 'cpu',
|
kernelFunc: leakyRelu
|
};
|
|
var preluImpl = createSimpleBinaryKernelImpl(function (xValue, aValue) { return xValue < 0 ? aValue * xValue : xValue; });
|
function prelu(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x, alpha = inputs.alpha;
|
assertNotComplex([x, alpha], 'prelu');
|
var aVals = backend.data.get(x.dataId).values;
|
var bVals = backend.data.get(alpha.dataId).values;
|
var _a = __read(preluImpl(x.shape, alpha.shape, aVals, bVals, 'float32'), 2), resultData = _a[0], resultShape = _a[1];
|
return backend.makeTensorInfo(resultShape, 'float32', resultData);
|
}
|
var preluConfig = {
|
kernelName: tfjsCore.Prelu,
|
backendName: 'cpu',
|
kernelFunc: prelu,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var relu = unaryKernelFunc(tfjsCore.Relu, function (xi) { return Math.max(0, xi); });
|
var reluConfig = {
|
kernelName: tfjsCore.Relu,
|
backendName: 'cpu',
|
kernelFunc: relu,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var relu6 = unaryKernelFunc(tfjsCore.Relu6, function (xi) { return Math.min(Math.max(0, xi), 6); });
|
var relu6Config = {
|
kernelName: tfjsCore.Relu6,
|
backendName: 'cpu',
|
kernelFunc: relu6,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function applyActivation(backend, x, activation, preluActivationWeights, leakyreluAlpha) {
|
if (activation === 'linear') {
|
return identity({ inputs: { x: x }, backend: backend });
|
}
|
else if (activation === 'relu') {
|
return relu({ inputs: { x: x }, backend: backend });
|
}
|
else if (activation === 'elu') {
|
return elu({ inputs: { x: x }, backend: backend });
|
}
|
else if (activation === 'relu6') {
|
return relu6({ inputs: { x: x }, backend: backend });
|
}
|
else if (activation === 'prelu') {
|
return prelu({ inputs: { x: x, alpha: preluActivationWeights }, backend: backend });
|
}
|
else if (activation === 'leakyrelu') {
|
return leakyRelu({ inputs: { x: x }, backend: backend, attrs: { alpha: leakyreluAlpha } });
|
}
|
else if (activation === 'sigmoid') {
|
return sigmoid({ inputs: { x: x }, backend: backend });
|
}
|
throw new Error("Activation ".concat(activation, " has not been implemented for the CPU backend."));
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function reshape(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var shape = attrs.shape;
|
var xSize = tfjsCore.util.sizeFromShape(x.shape);
|
var $shape = tfjsCore.util.inferFromImplicitShape(shape, xSize);
|
var $xSize = tfjsCore.util.sizeFromShape($shape);
|
tfjsCore.util.assert(xSize === $xSize, function () { return "The new shape (".concat($shape, ") has ").concat($xSize, " elements and the old ") +
|
"shape (".concat(x.shape, ") has ").concat(xSize, " elements. The new shape and old ") +
|
"shape must have the same number of elements."; });
|
backend.incRef(x.dataId);
|
var xData = backend.data.get(x.dataId);
|
if (xData.complexTensorInfos != null) {
|
var real = xData.complexTensorInfos.real;
|
var imag = xData.complexTensorInfos.imag;
|
real.shape = $shape;
|
imag.shape = $shape;
|
}
|
return { dataId: x.dataId, shape: $shape, dtype: x.dtype };
|
}
|
var reshapeConfig = {
|
kernelName: tfjsCore.Reshape,
|
backendName: 'cpu',
|
kernelFunc: reshape
|
};
|
|
function batchMatMul(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var a = inputs.a, b = inputs.b;
|
var transposeA = attrs.transposeA, transposeB = attrs.transposeB;
|
assertNotComplex([a, b], 'matMul');
|
var aRank = a.shape.length;
|
var bRank = b.shape.length;
|
var innerShapeA = transposeA ? a.shape[aRank - 2] : a.shape[aRank - 1];
|
var innerShapeB = transposeB ? b.shape[bRank - 1] : b.shape[bRank - 2];
|
var outerShapeA = transposeA ? a.shape[aRank - 1] : a.shape[aRank - 2];
|
var outerShapeB = transposeB ? b.shape[bRank - 2] : b.shape[bRank - 1];
|
var outerDimsA = a.shape.slice(0, -2);
|
var outerDimsB = b.shape.slice(0, -2);
|
var batchDimA = tfjsCore.util.sizeFromShape(outerDimsA);
|
var batchDimB = tfjsCore.util.sizeFromShape(outerDimsB);
|
var outShapeOuterDims = tfjsCore.broadcast_util.assertAndGetBroadcastShape(a.shape.slice(0, -2), b.shape.slice(0, -2));
|
var outShape = outShapeOuterDims.concat([outerShapeA, outerShapeB]);
|
tfjsCore.util.assert(innerShapeA === innerShapeB, function () { return "Error in matMul: inner shapes (".concat(innerShapeA, ") and (") +
|
"".concat(innerShapeB, ") of Tensors with shapes ").concat(a.shape, " and ") +
|
"".concat(b.shape, " and transposeA=").concat(transposeA) +
|
" and transposeB=".concat(transposeB, " must match."); });
|
var a3dShape = transposeA ? [batchDimA, innerShapeA, outerShapeA] :
|
[batchDimA, outerShapeA, innerShapeA];
|
var b3dShape = transposeB ? [batchDimB, outerShapeB, innerShapeB] :
|
[batchDimB, innerShapeB, outerShapeB];
|
// The rest of the implementation is designed to operate on rank-3 tensors
|
var a3d = reshape({ inputs: { x: a }, backend: backend, attrs: { shape: a3dShape } });
|
var b3d = reshape({ inputs: { x: b }, backend: backend, attrs: { shape: b3dShape } });
|
var sharedDim = transposeA ? a3d.shape[1] : a3d.shape[2];
|
var leftDim = transposeA ? a3d.shape[2] : a3d.shape[1];
|
var rightDim = transposeB ? b3d.shape[1] : b3d.shape[2];
|
var batchDim = Math.max(batchDimA, batchDimB);
|
var a3dValues = backend.data.get(a3d.dataId).values;
|
var b3dValues = backend.data.get(b3d.dataId).values;
|
var a3dStrides = tfjsCore.util.computeStrides(a3d.shape);
|
var b3dStrides = tfjsCore.util.computeStrides(b3d.shape);
|
var _a = __read(transposeA ?
|
[a3dStrides[0], 1, a3dStrides[1]] :
|
[a3dStrides[0], a3dStrides[1], 1], 3), aBatch = _a[0], aOuterStep = _a[1], aInnerStep = _a[2];
|
var _b = __read(transposeB ?
|
[1, b3dStrides[1], b3dStrides[0]] :
|
[b3dStrides[1], 1, b3dStrides[0]], 3), bInnerStep = _b[0], bOuterStep = _b[1], bBatch = _b[2];
|
var size = leftDim * rightDim;
|
var result = tfjsCore.buffer([batchDim, leftDim, rightDim], a3d.dtype);
|
var resVals = result.values;
|
var blockSize = backend.blockSize;
|
for (var bi = 0; bi < batchDim; bi++) {
|
var batchIndexA = bi % batchDimA;
|
var batchIndexB = bi % batchDimB;
|
for (var i0 = 0; i0 < leftDim; i0 += blockSize) {
|
// for when blockSize doesn't evenly divide the input
|
var iBlock = Math.min(i0 + blockSize, leftDim);
|
for (var j0 = 0; j0 < rightDim; j0 += blockSize) {
|
var jBlock = Math.min(j0 + blockSize, rightDim);
|
for (var k0 = 0; k0 < sharedDim; k0 += blockSize) {
|
var kBlock = Math.min(k0 + blockSize, sharedDim);
|
for (var i = i0; i < iBlock; i++) {
|
for (var j = j0; j < jBlock; j++) {
|
var sum = 0.0;
|
for (var k = k0; k < kBlock; k++) {
|
var aVal =
|
// tslint:disable-next-line: max-line-length
|
a3dValues[batchIndexA * aBatch + i * aOuterStep + k * aInnerStep];
|
var bVal =
|
// tslint:disable-next-line: max-line-length
|
b3dValues[k * bInnerStep + j * bOuterStep + batchIndexB * bBatch];
|
sum += aVal * bVal;
|
}
|
resVals[bi * size + (i * rightDim + j)] += sum;
|
}
|
}
|
}
|
}
|
}
|
}
|
backend.disposeIntermediateTensorInfo(a3d);
|
backend.disposeIntermediateTensorInfo(b3d);
|
// set correct shape on output.
|
return backend.makeTensorInfo(outShape, result.dtype, result.values);
|
}
|
var batchMatMulConfig = {
|
kernelName: tfjsCore.BatchMatMul,
|
backendName: 'cpu',
|
kernelFunc: batchMatMul,
|
};
|
|
function _fusedMatMul(args) {
|
var e_1, _a;
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var a = inputs.a, b = inputs.b, bias = inputs.bias, preluActivationWeights = inputs.preluActivationWeights;
|
var transposeA = attrs.transposeA, transposeB = attrs.transposeB, activation = attrs.activation, leakyreluAlpha = attrs.leakyreluAlpha;
|
var current;
|
var addRes;
|
var activationRes;
|
var intermediates = [];
|
var matMulRes = batchMatMul({ inputs: { a: a, b: b }, attrs: { transposeA: transposeA, transposeB: transposeB }, backend: backend });
|
current = matMulRes;
|
if (bias) {
|
addRes = add({ inputs: { a: current, b: bias }, backend: backend });
|
intermediates.push(current);
|
current = addRes;
|
}
|
if (activation) {
|
activationRes = applyActivation(backend, current, activation, preluActivationWeights, leakyreluAlpha);
|
intermediates.push(current);
|
current = activationRes;
|
}
|
try {
|
for (var intermediates_1 = __values(intermediates), intermediates_1_1 = intermediates_1.next(); !intermediates_1_1.done; intermediates_1_1 = intermediates_1.next()) {
|
var i = intermediates_1_1.value;
|
backend.disposeIntermediateTensorInfo(i);
|
}
|
}
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
finally {
|
try {
|
if (intermediates_1_1 && !intermediates_1_1.done && (_a = intermediates_1.return)) _a.call(intermediates_1);
|
}
|
finally { if (e_1) throw e_1.error; }
|
}
|
return current;
|
}
|
var _fusedMatMulConfig = {
|
kernelName: tfjsCore._FusedMatMul,
|
backendName: 'cpu',
|
kernelFunc: _fusedMatMul,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var acos = unaryKernelFunc(tfjsCore.Acos, function (xi) { return Math.acos(xi); });
|
var acosConfig = {
|
kernelName: tfjsCore.Acos,
|
backendName: 'cpu',
|
kernelFunc: acos,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var acosh = unaryKernelFunc(tfjsCore.Acosh, function (xi) { return Math.acosh(xi); });
|
var acoshConfig = {
|
kernelName: tfjsCore.Acosh,
|
backendName: 'cpu',
|
kernelFunc: acosh,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function addN(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var tensors = inputs;
|
assertNotComplex(inputs, 'addN');
|
var vals = tensors.map(function (t) { return backend.data.get(t.dataId).values; });
|
var outBuf = tfjsCore.buffer(tensors[0].shape, tensors[0].dtype);
|
var outVals = outBuf.values;
|
for (var i = 0; i < tensors.length; i++) {
|
var currVals = vals[i];
|
for (var j = 0; j < outVals.length; j++) {
|
outVals[j] += currVals[j];
|
}
|
}
|
return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
|
}
|
var addNConfig = {
|
kernelName: tfjsCore.AddN,
|
backendName: 'cpu',
|
kernelFunc: addN
|
};
|
|
function all(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
assertNotComplex(x, 'all');
|
var origAxes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var axes = origAxes;
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, x.shape.length);
|
var $x = x;
|
if (permutedAxes != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutedAxes } });
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, x.shape.length);
|
}
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('all', axes, $x.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes($x.shape, axes), 2), outShape = _a[0], reduceShape = _a[1];
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var vals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(outShape), $x.dtype);
|
var aVals = backend.data.get($x.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var all_1 = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
all_1 = all_1 && value;
|
}
|
vals[i] = all_1;
|
}
|
if (permutedAxes != null) {
|
backend.disposeIntermediateTensorInfo($x);
|
}
|
var result = backend.makeTensorInfo(outShape, $x.dtype, vals);
|
if (keepDims) {
|
var expandedShape = tfjsCore.backend_util.expandShapeToKeepDim(outShape, origAxes);
|
var reshapedResult = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: expandedShape } });
|
backend.disposeIntermediateTensorInfo(result);
|
return reshapedResult;
|
}
|
return result;
|
}
|
var allConfig = {
|
kernelName: tfjsCore.All,
|
backendName: 'cpu',
|
kernelFunc: all
|
};
|
|
function any(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
assertNotComplex(x, 'any');
|
var origAxes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var axes = origAxes;
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, x.shape.length);
|
var $x = x;
|
if (permutedAxes != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutedAxes } });
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, x.shape.length);
|
}
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('any', axes, $x.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes($x.shape, axes), 2), outShape = _a[0], reduceShape = _a[1];
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var vals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(outShape), $x.dtype);
|
var aVals = backend.data.get($x.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var anyVal = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
anyVal = anyVal || value;
|
}
|
vals[i] = anyVal;
|
}
|
if (permutedAxes != null) {
|
backend.disposeIntermediateTensorInfo($x);
|
}
|
var result = backend.makeTensorInfo(outShape, $x.dtype, vals);
|
if (keepDims) {
|
var expandedShape = tfjsCore.backend_util.expandShapeToKeepDim(outShape, origAxes);
|
var reshapedResult = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: expandedShape } });
|
backend.disposeIntermediateTensorInfo(result);
|
return reshapedResult;
|
}
|
return result;
|
}
|
var anyConfig = {
|
kernelName: tfjsCore.Any,
|
backendName: 'cpu',
|
kernelFunc: any
|
};
|
|
function argMax(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis;
|
assertNotComplex(x, 'argMax');
|
var axes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, x.shape.length);
|
var $x = x;
|
var intermediateTensorInfos = [];
|
if (permutedAxes != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutedAxes } });
|
intermediateTensorInfos.push($x);
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, $x.shape.length);
|
}
|
axes = [axes[0]];
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('argMax', axes, $x.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes($x.shape, axes), 2), outShape = _a[0], reduceShape = _a[1];
|
var outSize = tfjsCore.util.sizeFromShape(outShape);
|
var vals = tfjsCore.util.makeZerosTypedArray(outSize, 'int32');
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var aVals = backend.data.get($x.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var max = aVals[offset];
|
var maxIndex = 0;
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
if (value > max) {
|
max = value;
|
maxIndex = j;
|
}
|
}
|
vals[i] = maxIndex;
|
}
|
intermediateTensorInfos.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return backend.makeTensorInfo(outShape, 'int32', vals);
|
}
|
var argMaxConfig = {
|
kernelName: tfjsCore.ArgMax,
|
backendName: 'cpu',
|
kernelFunc: argMax
|
};
|
|
function argMin(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis;
|
assertNotComplex(x, 'argMin');
|
var axes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, x.shape.length);
|
var $x = x;
|
var intermediateTensorInfos = [];
|
if (permutedAxes != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutedAxes } });
|
intermediateTensorInfos.push($x);
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, $x.shape.length);
|
}
|
axes = [axes[0]];
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('argMin', axes, $x.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes($x.shape, axes), 2), outShape = _a[0], reduceShape = _a[1];
|
var outSize = tfjsCore.util.sizeFromShape(outShape);
|
var vals = tfjsCore.util.makeZerosTypedArray(outSize, 'int32');
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var aVals = backend.data.get($x.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var min = aVals[offset];
|
var minIndex = 0;
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
if (value < min) {
|
min = value;
|
minIndex = j;
|
}
|
}
|
vals[i] = minIndex;
|
}
|
intermediateTensorInfos.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return backend.makeTensorInfo(outShape, 'int32', vals);
|
}
|
var argMinConfig = {
|
kernelName: tfjsCore.ArgMin,
|
backendName: 'cpu',
|
kernelFunc: argMin
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var asin = unaryKernelFunc(tfjsCore.Asin, function (xi) { return Math.asin(xi); });
|
var asinConfig = {
|
kernelName: tfjsCore.Asin,
|
backendName: 'cpu',
|
kernelFunc: asin,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var asinh = unaryKernelFunc(tfjsCore.Asinh, function (xi) { return Math.asinh(xi); });
|
var asinhConfig = {
|
kernelName: tfjsCore.Asinh,
|
backendName: 'cpu',
|
kernelFunc: asinh,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var atan = unaryKernelFunc(tfjsCore.Atan, function (xi) { return Math.atan(xi); });
|
var atanConfig = {
|
kernelName: tfjsCore.Atan,
|
backendName: 'cpu',
|
kernelFunc: atan,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var atan2Impl = createSimpleBinaryKernelImpl(function (aValue, bValue) { return Math.atan2(aValue, bValue); });
|
var atan2 = binaryKernelFunc(tfjsCore.Atan2, atan2Impl);
|
var atan2Config = {
|
kernelName: tfjsCore.Atan2,
|
backendName: 'cpu',
|
kernelFunc: atan2,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var atanh = unaryKernelFunc(tfjsCore.Atanh, function (xi) { return Math.atanh(xi); });
|
var atanhConfig = {
|
kernelName: tfjsCore.Atanh,
|
backendName: 'cpu',
|
kernelFunc: atanh,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function pool(xValues, xShape, dtype, strides, convInfo, poolType) {
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padTop = convInfo.padInfo.top;
|
var padLeft = convInfo.padInfo.left;
|
var initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
|
Number.POSITIVE_INFINITY);
|
var output = tfjsCore.buffer(convInfo.outShape, dtype);
|
var outputVals = output.values;
|
var outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] * convInfo.outShape[3];
|
var outputRowStrides = convInfo.outShape[2] * convInfo.outShape[3];
|
var outputColStrides = convInfo.outShape[3];
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var outputBatchOffset = b * outputBatchStrides;
|
var inputBatchOffset = b * strides[0];
|
for (var d = 0; d < convInfo.inChannels; ++d) {
|
for (var yR = 0; yR < convInfo.outHeight; ++yR) {
|
var xRCorner = yR * strideHeight - padTop;
|
var xRMin = Math.max(0, xRCorner);
|
var xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
|
var outputRowOffset = outputBatchOffset + yR * outputRowStrides;
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var xCCorner = yC * strideWidth - padLeft;
|
var xCMin = Math.max(0, xCCorner);
|
var xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
|
var minMaxValue = initialValue;
|
var avgValue = 0;
|
var count = 0;
|
for (var xR = xRMin; xR < xRMax; xR += dilationHeight) {
|
var xROffset = inputBatchOffset + xR * strides[1];
|
for (var xC = xCMin; xC < xCMax; xC += dilationWidth) {
|
var xCOffset = xROffset + xC * strides[2];
|
var pixel = xValues[xCOffset + d];
|
if ((poolType === 'max' && pixel > minMaxValue)) {
|
minMaxValue = pixel;
|
}
|
else if (poolType === 'avg') {
|
avgValue += pixel;
|
count++;
|
}
|
}
|
if (isNaN(minMaxValue)) {
|
break;
|
}
|
}
|
var outputOffset = outputRowOffset + yC * outputColStrides + d;
|
outputVals[outputOffset] =
|
poolType === 'avg' ? avgValue / count : minMaxValue;
|
}
|
}
|
}
|
}
|
return output;
|
}
|
function maxPoolPositions(xValues, xShape, dtype, convInfo, flattenPositions, includeBatchInIndex) {
|
if (flattenPositions === void 0) { flattenPositions = false; }
|
if (includeBatchInIndex === void 0) { includeBatchInIndex = false; }
|
var maxPositions = tfjsCore.buffer(convInfo.outShape, 'int32');
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padTop = convInfo.padInfo.top;
|
var padLeft = convInfo.padInfo.left;
|
var xBuf = tfjsCore.buffer(xShape, dtype, xValues);
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
for (var d = 0; d < convInfo.inChannels; ++d) {
|
for (var yR = 0; yR < convInfo.outHeight; ++yR) {
|
var xRCorner = yR * strideHeight - padTop;
|
var xRMin = xRCorner;
|
while (xRMin < 0) {
|
xRMin += dilationHeight;
|
}
|
// const xRMin = Math.max(0, xRCorner);
|
var xRMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRCorner);
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var xCCorner = yC * strideWidth - padLeft;
|
var xCMin = xCCorner;
|
while (xCMin < 0) {
|
xCMin += dilationWidth;
|
}
|
var xCMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xCCorner);
|
var maxValue = Number.NEGATIVE_INFINITY;
|
var maxPosition = -1;
|
for (var xR = xRMin; xR < xRMax; xR += dilationHeight) {
|
var wR = xR - xRCorner;
|
for (var xC = xCMin; xC < xCMax; xC += dilationWidth) {
|
var wC = xC - xCCorner;
|
// For some reason, disable-next-line is not working
|
// TODO(mattsoulanille): Remove this when switching to TS5.
|
/* tslint:disable: no-unnecessary-type-assertion */
|
var pixel = xBuf.get(b, xR, xC, d);
|
if (pixel > maxValue) {
|
maxValue = pixel;
|
if (flattenPositions) {
|
maxPosition = includeBatchInIndex ?
|
((b * convInfo.inHeight + xR) * convInfo.inWidth + xC) *
|
convInfo.inChannels +
|
d :
|
(xR * convInfo.inWidth + xC) * convInfo.inChannels + d;
|
}
|
else {
|
maxPosition = wR * effectiveFilterWidth + wC;
|
}
|
}
|
}
|
}
|
maxPositions.set(maxPosition, b, yR, yC, d);
|
}
|
}
|
}
|
}
|
return maxPositions;
|
}
|
function pool3d(xValues, xShape, dtype, strides, convInfo, poolType) {
|
var strideDepth = convInfo.strideDepth;
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationDepth = convInfo.dilationDepth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterDepth = convInfo.effectiveFilterDepth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padFront = convInfo.padInfo.front;
|
var padTop = convInfo.padInfo.top;
|
var padLeft = convInfo.padInfo.left;
|
var initialValue = (poolType === 'max' ? Number.NEGATIVE_INFINITY :
|
Number.POSITIVE_INFINITY);
|
var output = tfjsCore.buffer(convInfo.outShape, dtype);
|
var outputVals = output.values;
|
var outputBatchStrides = convInfo.outShape[1] * convInfo.outShape[2] *
|
convInfo.outShape[3] * convInfo.outShape[4];
|
var outputDepthStrides = convInfo.outShape[2] * convInfo.outShape[3] * convInfo.outShape[4];
|
var outputRowStrides = convInfo.outShape[3] * convInfo.outShape[4];
|
var outputColStrides = convInfo.outShape[4];
|
for (var batch = 0; batch < convInfo.batchSize; ++batch) {
|
var outputBatchOffset = batch * outputBatchStrides;
|
var inputBatchOffset = batch * strides[0];
|
for (var channel = 0; channel < convInfo.inChannels; ++channel) {
|
for (var yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
|
var xDepthCorner = yDepth * strideDepth - padFront;
|
var xDepthMin = xDepthCorner;
|
while (xDepthMin < 0) {
|
xDepthMin += dilationDepth;
|
}
|
var xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
|
var outputDepthOffset = outputBatchOffset + yDepth * outputDepthStrides;
|
for (var yRow = 0; yRow < convInfo.outHeight; ++yRow) {
|
var xRowCorner = yRow * strideHeight - padTop;
|
var xRowMin = xRowCorner;
|
while (xRowMin < 0) {
|
xRowMin += dilationHeight;
|
}
|
var xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
|
var outputRowOffset = outputDepthOffset + yRow * outputRowStrides;
|
for (var yCol = 0; yCol < convInfo.outWidth; ++yCol) {
|
var xColCorner = yCol * strideWidth - padLeft;
|
var xColMin = xColCorner;
|
while (xColMin < 0) {
|
xColMin += dilationWidth;
|
}
|
var xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
|
// Shader code begins
|
var outputColOffset = outputRowOffset + yCol * outputColStrides;
|
var minMaxValue = initialValue;
|
var avgValue = 0;
|
var count = 0;
|
for (var xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
|
var xDepthOffset = inputBatchOffset + xDepth * strides[1];
|
for (var xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
|
var xRowOffset = xDepthOffset + xRow * strides[2];
|
for (var xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
|
var xColOffset = xRowOffset + xCol * strides[3];
|
var pixel = xValues[xColOffset + channel];
|
if ((poolType === 'max' && pixel > minMaxValue)) {
|
minMaxValue = pixel;
|
}
|
else if (poolType === 'avg') {
|
avgValue += pixel;
|
count++;
|
}
|
if (isNaN(minMaxValue)) {
|
break;
|
}
|
}
|
if (isNaN(minMaxValue)) {
|
break;
|
}
|
}
|
if (isNaN(minMaxValue)) {
|
break;
|
}
|
}
|
var outputOffset = outputColOffset + channel;
|
outputVals[outputOffset] = poolType === 'avg' ?
|
avgValue / Math.max(count, 1) :
|
minMaxValue;
|
}
|
}
|
}
|
}
|
}
|
return output;
|
}
|
function maxPool3dPositions(xBuf, convInfo) {
|
var maxPositions = tfjsCore.buffer(convInfo.outShape, 'int32');
|
var strideDepth = convInfo.strideDepth;
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationDepth = convInfo.dilationDepth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterDepth = convInfo.effectiveFilterDepth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padFront = convInfo.padInfo.front;
|
var padTop = convInfo.padInfo.top;
|
var padLeft = convInfo.padInfo.left;
|
for (var batch = 0; batch < convInfo.batchSize; ++batch) {
|
for (var channel = 0; channel < convInfo.inChannels; ++channel) {
|
for (var yDepth = 0; yDepth < convInfo.outDepth; ++yDepth) {
|
var xDepthCorner = yDepth * strideDepth - padFront;
|
var xDepthMin = xDepthCorner;
|
while (xDepthMin < 0) {
|
xDepthMin += dilationDepth;
|
}
|
var xDepthMax = Math.min(convInfo.inDepth, effectiveFilterDepth + xDepthCorner);
|
for (var yRow = 0; yRow < convInfo.outHeight; ++yRow) {
|
var xRowCorner = yRow * strideHeight - padTop;
|
var xRowMin = xRowCorner;
|
while (xRowMin < 0) {
|
xRowMin += dilationHeight;
|
}
|
var xRowMax = Math.min(convInfo.inHeight, effectiveFilterHeight + xRowCorner);
|
for (var yCol = 0; yCol < convInfo.outWidth; ++yCol) {
|
var xColCorner = yCol * strideWidth - padLeft;
|
var xColMin = xColCorner;
|
while (xColMin < 0) {
|
xColMin += dilationWidth;
|
}
|
var xColMax = Math.min(convInfo.inWidth, effectiveFilterWidth + xColCorner);
|
// Shader code begins
|
var maxValue = Number.NEGATIVE_INFINITY;
|
var maxPosition = -1;
|
for (var xDepth = xDepthMin; xDepth < xDepthMax; xDepth += dilationDepth) {
|
var wDepth = xDepth - xDepthCorner;
|
for (var xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
|
var wRow = xRow - xRowCorner;
|
for (var xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
|
var wCol = xCol - xColCorner;
|
var pixel = xBuf.get(batch, xDepth, xRow, xCol, channel);
|
if (pixel >= maxValue) {
|
maxValue = pixel;
|
maxPosition =
|
wDepth * effectiveFilterHeight * effectiveFilterWidth +
|
wRow * effectiveFilterHeight + wCol;
|
}
|
}
|
}
|
}
|
maxPositions.set(maxPosition, batch, yDepth, yRow, yCol, channel);
|
}
|
}
|
}
|
}
|
}
|
return maxPositions;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function avgPool(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
assertNotComplex(x, 'avgPool');
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode;
|
var dilations = 1;
|
tfjsCore.util.assert(tfjsCore.backend_util.eitherStridesOrDilationsAreOne(strides, dilations), function () { return 'Error in avgPool: Either strides or dilations must be 1. ' +
|
"Got strides ".concat(strides, " and dilations '").concat(dilations, "'"); });
|
var convInfo = tfjsCore.backend_util.computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
|
var res;
|
if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
|
tfjsCore.util.arraysEqual(convInfo.inShape, convInfo.outShape)) {
|
res = identity({ inputs: { x: x }, backend: backend });
|
}
|
else {
|
var xValues = backend.data.get(x.dataId).values;
|
var strides_1 = tfjsCore.util.computeStrides(x.shape);
|
var buffer = pool(xValues, x.shape, x.dtype, strides_1, convInfo, 'avg');
|
res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
|
}
|
return res;
|
}
|
var avgPoolConfig = {
|
kernelName: tfjsCore.AvgPool,
|
backendName: 'cpu',
|
kernelFunc: avgPool
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function avgPool3D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode, dataFormat = attrs.dataFormat;
|
assertNotComplex(x, 'avgPool3d');
|
var convInfo = tfjsCore.backend_util.computePool3DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode, dataFormat);
|
var xValues = backend.data.get(x.dataId).values;
|
var outBuf = pool3d(xValues, x.shape, x.dtype, tfjsCore.util.computeStrides(x.shape), convInfo, 'avg');
|
return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
|
}
|
var avgPool3DConfig = {
|
kernelName: tfjsCore.AvgPool3D,
|
backendName: 'cpu',
|
kernelFunc: avgPool3D
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function avgPool3DGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, input = inputs.input;
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode;
|
assertNotComplex([dy, input], 'avgPool3DGrad');
|
var convInfo = tfjsCore.backend_util.computePool3DInfo(input.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
|
var strideDepth = convInfo.strideDepth;
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var filterDepth = convInfo.filterDepth;
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var dilationDepth = convInfo.dilationDepth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterDepth = convInfo.effectiveFilterDepth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
|
var padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
|
var padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
|
var dx = tfjsCore.buffer(input.shape, 'float32');
|
var avgMultiplier = 1 / (filterDepth * filterHeight * filterWidth);
|
var dyBuf = backend.bufferSync(dy);
|
for (var batch = 0; batch < convInfo.batchSize; ++batch) {
|
for (var channel = 0; channel < convInfo.inChannels; ++channel) {
|
for (var dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
|
for (var dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
|
for (var dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
|
// Shader code begins.
|
var dyDepthCorner = dxDepth - padFront;
|
var dyRowCorner = dxRow - padTop;
|
var dyColCorner = dxCol - padLeft;
|
var dotProd = 0;
|
for (var wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
|
var dyDepth = (dyDepthCorner + wDepth) / strideDepth;
|
if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
|
Math.floor(dyDepth) !== dyDepth) {
|
continue;
|
}
|
for (var wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
|
var dyRow = (dyRowCorner + wRow) / strideHeight;
|
if (dyRow < 0 || dyRow >= convInfo.outHeight ||
|
Math.floor(dyRow) !== dyRow) {
|
continue;
|
}
|
for (var wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
|
var dyCol = (dyColCorner + wCol) / strideWidth;
|
if (dyCol < 0 || dyCol >= convInfo.outWidth ||
|
Math.floor(dyCol) !== dyCol) {
|
continue;
|
}
|
var pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
|
dotProd += pixel;
|
}
|
}
|
}
|
dx.set(dotProd * avgMultiplier, batch, dxDepth, dxRow, dxCol, channel);
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var avgPool3DGradConfig = {
|
kernelName: tfjsCore.AvgPool3DGrad,
|
backendName: 'cpu',
|
kernelFunc: avgPool3DGrad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function avgPoolGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, input = inputs.input;
|
var x = input;
|
assertNotComplex([dy, input], 'avgPoolGrad');
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad;
|
var convInfo = tfjsCore.backend_util.computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad);
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
|
var padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
|
var dx = tfjsCore.buffer(x.shape, 'float32');
|
var avgMultiplier = 1 / (filterHeight * filterWidth);
|
var dyData = backend.data.get(dy.dataId).values;
|
var dyBuf = tfjsCore.buffer(dy.shape, 'float32', dyData);
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
for (var d = 0; d < convInfo.inChannels; ++d) {
|
for (var dxR = 0; dxR < convInfo.inHeight; ++dxR) {
|
for (var dxC = 0; dxC < convInfo.inWidth; ++dxC) {
|
// Shader code begins.
|
var dyRCorner = dxR - padTop;
|
var dyCCorner = dxC - padLeft;
|
var dotProd = 0;
|
for (var wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
|
var dyR = (dyRCorner + wR) / strideHeight;
|
if (dyR < 0 || dyR >= convInfo.outHeight ||
|
Math.floor(dyR) !== dyR) {
|
continue;
|
}
|
for (var wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
|
var dyC = (dyCCorner + wC) / strideWidth;
|
if (dyC < 0 || dyC >= convInfo.outWidth ||
|
Math.floor(dyC) !== dyC) {
|
continue;
|
}
|
var pixel = dyBuf.get(b, dyR, dyC, d);
|
dotProd += pixel;
|
}
|
}
|
dx.set(dotProd * avgMultiplier, b, dxR, dxC, d);
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var avgPoolGradConfig = {
|
kernelName: tfjsCore.AvgPoolGrad,
|
backendName: 'cpu',
|
kernelFunc: avgPoolGrad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function batchNorm(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, scale = inputs.scale, offset = inputs.offset, mean = inputs.mean, variance = inputs.variance;
|
tfjsCore.util.assert(mean.shape.length === variance.shape.length, function () { return 'Batch normalization gradient requires mean and variance to have ' +
|
'equal ranks.'; });
|
tfjsCore.util.assert(offset == null || mean.shape.length === offset.shape.length, function () { return 'Batch normalization gradient requires mean and offset to have ' +
|
'equal ranks.'; });
|
tfjsCore.util.assert(scale == null || mean.shape.length === scale.shape.length, function () { return 'Batch normalization gradient requires mean and scale to have ' +
|
'equal ranks.'; });
|
assertNotComplex([x, mean, variance, scale, offset], 'batchNorm');
|
var varianceEpsilon = attrs.varianceEpsilon;
|
if (varianceEpsilon == null) {
|
varianceEpsilon = 0.001;
|
}
|
var xVals = backend.data.get(x.dataId).values;
|
var mVals = backend.data.get(mean.dataId).values;
|
var varVals = backend.data.get(variance.dataId).values;
|
var sVals = scale ? backend.data.get(scale.dataId).values :
|
new Float32Array([1]);
|
var offVals = offset ?
|
backend.data.get(offset.dataId).values :
|
new Float32Array([0]);
|
var outVals = new Float32Array(xVals.length);
|
var offValsLength = offVals.length;
|
var sValsLength = sVals.length;
|
var varValsLength = varVals.length;
|
var mValsLength = mVals.length;
|
var offi = 0;
|
var mi = 0;
|
var si = 0;
|
var vi = 0;
|
for (var i = 0; i < xVals.length; ++i) {
|
outVals[i] = offVals[offi++] +
|
(xVals[i] - mVals[mi++]) * sVals[si++] /
|
Math.sqrt(varVals[vi++] + varianceEpsilon);
|
if (offi >= offValsLength) {
|
offi = 0;
|
}
|
if (mi >= mValsLength) {
|
mi = 0;
|
}
|
if (si >= sValsLength) {
|
si = 0;
|
}
|
if (vi >= varValsLength) {
|
vi = 0;
|
}
|
}
|
return backend.makeTensorInfo(x.shape, x.dtype, outVals);
|
}
|
var batchNormConfig = {
|
kernelName: tfjsCore.FusedBatchNorm,
|
backendName: 'cpu',
|
kernelFunc: batchNorm,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function batchToSpaceND(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var blockShape = attrs.blockShape, crops = attrs.crops;
|
assertNotComplex([x], 'batchToSpaceND');
|
var prod = blockShape.reduce(function (a, b) { return a * b; });
|
var reshaped = tfjsCore.backend_util.getReshaped(x.shape, blockShape, prod);
|
var permuted = tfjsCore.backend_util.getPermuted(reshaped.length, blockShape.length);
|
var reshapedPermuted = tfjsCore.backend_util.getReshapedPermuted(x.shape, blockShape, prod);
|
var sliceBeginCoords = tfjsCore.backend_util.getSliceBeginCoords(crops, blockShape.length);
|
var sliceSize = tfjsCore.backend_util.getSliceSize(reshapedPermuted, crops, blockShape.length);
|
var xReshaped = reshape({ inputs: { x: x }, backend: backend, attrs: { shape: reshaped } });
|
var xTransposed = transpose({ inputs: { x: xReshaped }, backend: backend, attrs: { perm: permuted } });
|
var xTransposedReshaped = reshape({ inputs: { x: xTransposed }, backend: backend, attrs: { shape: reshapedPermuted } });
|
var result = slice({
|
inputs: { x: xTransposedReshaped },
|
backend: backend,
|
attrs: { begin: sliceBeginCoords, size: sliceSize }
|
});
|
backend.disposeIntermediateTensorInfo(xReshaped);
|
backend.disposeIntermediateTensorInfo(xTransposed);
|
backend.disposeIntermediateTensorInfo(xTransposedReshaped);
|
return result;
|
}
|
var batchToSpaceNDConfig = {
|
kernelName: tfjsCore.BatchToSpaceND,
|
backendName: 'cpu',
|
kernelFunc: batchToSpaceND
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function bincount(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, weights = inputs.weights;
|
var size = attrs.size;
|
var xVals = backend.data.get(x.dataId).values;
|
var weightsVals = backend.data.get(weights.dataId).values;
|
var outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
|
return backend.makeTensorInfo([size], weights.dtype, outVals);
|
}
|
var bincountConfig = {
|
kernelName: tfjsCore.Bincount,
|
backendName: 'cpu',
|
kernelFunc: bincount
|
};
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function broadcastArgs(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var s0 = inputs.s0, s1 = inputs.s1;
|
var s0Vals = backend.data.get(s0.dataId).values;
|
var s1Vals = backend.data.get(s1.dataId).values;
|
var broadcastShape = tfjsCore.backend_util.assertAndGetBroadcastShape(Array.from(s0Vals), Array.from(s1Vals));
|
return backend.makeTensorInfo([broadcastShape.length], 'int32', Int32Array.from(broadcastShape));
|
}
|
var broadcastArgsConfig = {
|
kernelName: tfjsCore.BroadcastArgs,
|
backendName: 'cpu',
|
kernelFunc: broadcastArgs
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var clipByValue = unaryKernelFunc(tfjsCore.ClipByValue, function (xi, attrs) {
|
var clipAttrs = attrs;
|
if (xi > clipAttrs.clipValueMax) {
|
return clipAttrs.clipValueMax;
|
}
|
return xi < clipAttrs.clipValueMin ? clipAttrs.clipValueMin : xi;
|
});
|
var clipByValueConfig = {
|
kernelName: tfjsCore.ClipByValue,
|
backendName: 'cpu',
|
kernelFunc: clipByValue,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var complexAbs = function (args) {
|
var x = args.inputs.x;
|
var cpuBackend = args.backend;
|
var resultValues = new Float32Array(tfjsCore.util.sizeFromShape(x.shape));
|
var complexVals = cpuBackend.data.get(x.dataId);
|
var real = complexVals.complexTensorInfos.real;
|
var imag = complexVals.complexTensorInfos.imag;
|
var realVals = cpuBackend.data.get(real.dataId).values;
|
var imagVals = cpuBackend.data.get(imag.dataId).values;
|
for (var i = 0; i < realVals.length; i++) {
|
var real_1 = realVals[i];
|
var imag_1 = imagVals[i];
|
resultValues[i] = Math.hypot(real_1, imag_1);
|
}
|
return cpuBackend.makeOutput(resultValues, x.shape, 'float32');
|
};
|
var complexAbsConfig = {
|
kernelName: tfjsCore.ComplexAbs,
|
backendName: 'cpu',
|
kernelFunc: complexAbs,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function imag(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var input = inputs.input;
|
var imag = backend.data.get(input.dataId).complexTensorInfos.imag;
|
var imagVal = backend.data.get(imag.dataId).values;
|
// When complex tensor is disposed, its underlying parts will be disposed too.
|
// Make new tensor out of the imag value of the complex. This makes sure the
|
// value is still accessible even if complex tensor is disposed.
|
return backend.makeTensorInfo(imag.shape, imag.dtype, imagVal);
|
}
|
var imagConfig = {
|
kernelName: tfjsCore.Imag,
|
backendName: 'cpu',
|
kernelFunc: imag
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function concat(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var axis = attrs.axis;
|
var $axis = tfjsCore.util.parseAxisParam(axis, inputs[0].shape)[0];
|
var shapes = inputs.map(function (t) { return t.shape; });
|
tfjsCore.backend_util.assertParamsConsistent(shapes, $axis);
|
var outShape = tfjsCore.backend_util.computeOutShape(inputs.map(function (t) { return t.shape; }), $axis);
|
if (tfjsCore.util.sizeFromShape(outShape) === 0) {
|
return backend.makeTensorInfo(outShape, inputs[0].dtype, []);
|
}
|
// Keep only non-empty tensors (ignore tensors with 0 in their shape).
|
var $inputs = inputs.filter(function (t) { return tfjsCore.util.sizeFromShape(t.shape) > 0; });
|
if ($inputs.length === 1) {
|
return identity({ inputs: { x: $inputs[0] }, backend: backend });
|
}
|
if ($inputs[0].dtype === 'complex64') {
|
var reals = $inputs.map(function (t) { return real({ inputs: { input: t }, backend: backend }); });
|
var imags = $inputs.map(function (t) { return imag({ inputs: { input: t }, backend: backend }); });
|
var realConcated = concat({ inputs: reals, backend: backend, attrs: { axis: $axis } });
|
var imagConcated = concat({ inputs: imags, backend: backend, attrs: { axis: $axis } });
|
var result = complex({ inputs: { real: realConcated, imag: imagConcated }, backend: backend });
|
reals.forEach(function (r) { return backend.disposeIntermediateTensorInfo(r); });
|
imags.forEach(function (i) { return backend.disposeIntermediateTensorInfo(i); });
|
backend.disposeIntermediateTensorInfo(realConcated);
|
backend.disposeIntermediateTensorInfo(imagConcated);
|
return result;
|
}
|
// Any concat of n-dimensional tensors across any axis can be reduced to
|
// a concatenation of two-dimensional tensors across the axis 1 by first
|
// partitioning the axes of the original tensors into those less than the
|
// axis to be concatenated and the rest. Then reshape the tensors
|
// into a two-dimensional tensor by collapsing these two sets of axes and
|
// concatenate the resulting matrices across the axis 1, finally reshaping
|
// the result to have the proper shape.
|
var inputs2D = $inputs.map(function (t) {
|
var innerSize = tfjsCore.util.sizeFromShape(t.shape.slice($axis));
|
var shape = [-1, innerSize];
|
return reshape({ inputs: { x: t }, backend: backend, attrs: { shape: shape } });
|
});
|
var inputsValShapes = inputs2D.map(function (t) {
|
return { vals: backend.data.get(t.dataId).values, shape: t.shape };
|
});
|
// Concats 2d tensors along axis=1.
|
outShape =
|
tfjsCore.backend_util.computeOutShape(inputs2D.map(function (t) { return t.shape; }), 1 /* axis */);
|
var simplyConcat = inputs2D[0].shape[0] === 1;
|
var outVals = concatImpl(inputsValShapes, outShape, inputs[0].dtype, simplyConcat);
|
var finalOutShape = tfjsCore.backend_util.computeOutShape($inputs.map(function (t) { return t.shape; }), $axis);
|
var outInfo = backend.makeTensorInfo(finalOutShape, inputs[0].dtype, outVals);
|
inputs2D.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return outInfo;
|
}
|
var concatConfig = {
|
kernelName: tfjsCore.Concat,
|
backendName: 'cpu',
|
kernelFunc: concat
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function conv2D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, filter = inputs.filter;
|
var strides = attrs.strides, pad = attrs.pad, dataFormat = attrs.dataFormat, dilations = attrs.dilations, dimRoundingMode = attrs.dimRoundingMode;
|
assertNotComplex([x, filter], 'conv2d');
|
var $dataFormat = tfjsCore.backend_util.convertConv2DDataFormat(dataFormat);
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(x.shape, filter.shape, strides, dilations, pad, dimRoundingMode, false /* depthwise */, $dataFormat);
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var padLeft = convInfo.padInfo.left;
|
var padTop = convInfo.padInfo.top;
|
var isChannelsLast = convInfo.dataFormat === 'channelsLast';
|
var y = new tfjsCore.TensorBuffer(convInfo.outShape, x.dtype);
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
var xBatchStride = xStrides[0];
|
var xRowStride = isChannelsLast ? xStrides[1] : xStrides[2];
|
var xColStride = isChannelsLast ? xStrides[2] : 1;
|
var xChannelStride = isChannelsLast ? 1 : xStrides[1];
|
var yBatchStride = y.strides[0];
|
var yRowStride = isChannelsLast ? y.strides[1] : y.strides[2];
|
var yColStride = isChannelsLast ? y.strides[2] : 1;
|
var yChannelStride = isChannelsLast ? 1 : y.strides[1];
|
var xVals = backend.data.get(x.dataId).values;
|
var wVals = backend.data.get(filter.dataId).values;
|
var yVals = y.values;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * xBatchStride;
|
var yOffset1 = b * yBatchStride;
|
for (var yR = 0; yR < convInfo.outHeight; ++yR) {
|
var yOffset2 = yOffset1 + yR * yRowStride;
|
var xRCorner = yR * convInfo.strideHeight - padTop;
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var xR = xRCorner + wR * dilationHeight;
|
if (xR < 0 || xR >= convInfo.inHeight) {
|
continue;
|
}
|
var wOffset1 = wR * filterStrides[0];
|
var xOffset2 = xOffset1 + xR * xRowStride;
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var yOffset3 = yOffset2 + yC * yColStride;
|
var xCCorner = yC * convInfo.strideWidth - padLeft;
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var xC = xCCorner + wC * dilationWidth;
|
if (xC < 0 || xC >= convInfo.inWidth) {
|
continue;
|
}
|
var wOffset2 = wOffset1 + wC * filterStrides[1];
|
var xOffset3 = xOffset2 + xC * xColStride;
|
var wOffset3 = wOffset2;
|
for (var d1 = 0; d1 < convInfo.inChannels; ++d1) {
|
var xVal = xVals[xOffset3 + d1 * xChannelStride];
|
for (var d2 = 0; d2 < convInfo.outChannels; ++d2) {
|
yVals[yOffset3 + d2 * yChannelStride] +=
|
xVal * wVals[wOffset3 + d2];
|
}
|
wOffset3 += convInfo.outChannels;
|
}
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(y.shape, y.dtype, yVals);
|
}
|
var conv2DConfig = {
|
kernelName: tfjsCore.Conv2D,
|
backendName: 'cpu',
|
kernelFunc: conv2D
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function conv2DBackpropFilter(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, dy = inputs.dy;
|
var strides = attrs.strides, pad = attrs.pad, dataFormat = attrs.dataFormat, dimRoundingMode = attrs.dimRoundingMode, filterShape = attrs.filterShape;
|
assertNotComplex([x, dy], 'conv2dBackpropFilter');
|
var $dataFormat = tfjsCore.backend_util.convertConv2DDataFormat(dataFormat);
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(x.shape, filterShape, strides, 1 /* dilations */, pad, dimRoundingMode, false /* depthwise */, $dataFormat);
|
var strideHeight = convInfo.strideHeight, strideWidth = convInfo.strideWidth, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth;
|
var isChannelsLast = convInfo.dataFormat === 'channelsLast';
|
var dW = new tfjsCore.TensorBuffer(convInfo.filterShape, 'float32');
|
var leftPad = convInfo.padInfo.left;
|
var topPad = convInfo.padInfo.top;
|
var xVals = backend.data.get(x.dataId).values;
|
var dyVals = backend.data.get(dy.dataId).values;
|
var xBuf = new tfjsCore.TensorBuffer(x.shape, x.dtype, xVals);
|
var dyBuf = new tfjsCore.TensorBuffer(dy.shape, dy.dtype, dyVals);
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
|
var yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
|
var yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
|
for (var d1 = 0; d1 < convInfo.inChannels; ++d1) {
|
for (var d2 = 0; d2 < convInfo.outChannels; ++d2) {
|
var dotProd = 0;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
for (var yR = yRMin; yR < yRMax; ++yR) {
|
var xR = wR + yR * strideHeight - topPad;
|
for (var yC = yCMin; yC < yCMax; ++yC) {
|
var xC = wC + yC * strideWidth - leftPad;
|
if (isChannelsLast) {
|
dotProd += xBuf.get(b, xR, xC, d1) *
|
dyBuf.get(b, yR, yC, d2);
|
}
|
else {
|
dotProd += xBuf.get(b, d1, xR, xC) *
|
dyBuf.get(b, d2, yR, yC);
|
}
|
}
|
}
|
}
|
dW.set(dotProd, wR, wC, d1, d2);
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
|
}
|
var conv2DBackpropFilterConfig = {
|
kernelName: tfjsCore.Conv2DBackpropFilter,
|
backendName: 'cpu',
|
kernelFunc: conv2DBackpropFilter
|
};
|
|
function conv2DBackpropInput(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, filter = inputs.filter;
|
var inputShape = attrs.inputShape, strides = attrs.strides, pad = attrs.pad, dataFormat = attrs.dataFormat, dimRoundingMode = attrs.dimRoundingMode;
|
assertNotComplex([dy, filter], 'conv2dBackpropInput');
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
var dyStrides = tfjsCore.util.computeStrides(dy.shape);
|
var $dataFormat = tfjsCore.backend_util.convertConv2DDataFormat(dataFormat);
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(inputShape, filter.shape, strides, 1 /* dilations */, pad, dimRoundingMode, false, $dataFormat);
|
var dx = new tfjsCore.TensorBuffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var dyValues = backend.data.get(dy.dataId).values;
|
var fltValues = backend.data.get(filter.dataId).values;
|
var _a = __read(filterStrides, 3), fltS0 = _a[0], fltS1 = _a[1], fltS2 = _a[2];
|
var batchSize = convInfo.batchSize, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth, inChannels = convInfo.inChannels, inHeight = convInfo.inHeight, inWidth = convInfo.inWidth, outChannels = convInfo.outChannels, outHeight = convInfo.outHeight, outWidth = convInfo.outWidth, strideHeight = convInfo.strideHeight, strideWidth = convInfo.strideWidth;
|
$dataFormat = convInfo.dataFormat;
|
var topPad = filterHeight - 1 - convInfo.padInfo.top;
|
var leftPad = filterWidth - 1 - convInfo.padInfo.left;
|
var isChannelsLast = $dataFormat === 'channelsLast';
|
var xBatchStride = dx.strides[0];
|
var xRowStride = isChannelsLast ? dx.strides[1] : dx.strides[2];
|
var xColStride = isChannelsLast ? dx.strides[2] : 1;
|
var xChannelStride = isChannelsLast ? 1 : dx.strides[1];
|
var yBatchStride = dyStrides[0];
|
var yRowStride = isChannelsLast ? dyStrides[1] : dyStrides[2];
|
var yColStride = isChannelsLast ? dyStrides[2] : 1;
|
var yChannelStride = isChannelsLast ? 1 : dyStrides[1];
|
for (var b = 0; b < batchSize; ++b) {
|
for (var d1 = 0; d1 < inChannels; ++d1) {
|
for (var xR = 0; xR < inHeight; ++xR) {
|
var xRCorner = xR - topPad;
|
var xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
|
var yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
|
for (var xC = 0; xC < inWidth; ++xC) {
|
var xCCorner = xC - leftPad;
|
var xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
|
var yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
|
var dotProd = 0;
|
for (var yR = xRMin; yR < yRMax; ++yR) {
|
var wR = yR * strideHeight - xRCorner;
|
for (var yC = xCMin; yC < yCMax; ++yC) {
|
var wC = yC * strideWidth - xCCorner;
|
var dyOffset = yBatchStride * b + yRowStride * yR + yColStride * yC;
|
var fltOffset = fltS0 * (filterHeight - 1 - wR) +
|
fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
|
for (var d2 = 0; d2 < outChannels; ++d2) {
|
var pixel = dyValues[dyOffset + yChannelStride * d2];
|
var weight = fltValues[fltOffset + d2];
|
dotProd += pixel * weight;
|
}
|
}
|
}
|
var dxOffset = xBatchStride * b + xRowStride * xR +
|
xColStride * xC + xChannelStride * d1;
|
dxValues[dxOffset] = dotProd;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var conv2DBackpropInputConfig = {
|
kernelName: tfjsCore.Conv2DBackpropInput,
|
backendName: 'cpu',
|
kernelFunc: conv2DBackpropInput
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function conv3D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, filter = inputs.filter;
|
var strides = attrs.strides, pad = attrs.pad, dilations = attrs.dilations;
|
assertNotComplex([x, filter], 'conv3d');
|
var convInfo = tfjsCore.backend_util.computeConv3DInfo(x.shape, filter.shape, strides, dilations, pad);
|
var filterDepth = convInfo.filterDepth, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth, dilationDepth = convInfo.dilationDepth, dilationHeight = convInfo.dilationHeight, dilationWidth = convInfo.dilationWidth, padInfo = convInfo.padInfo;
|
var padFront = padInfo.front;
|
var padLeft = padInfo.left;
|
var padTop = padInfo.top;
|
var y = new tfjsCore.TensorBuffer(convInfo.outShape, x.dtype);
|
var xVals = backend.data.get(x.dataId).values;
|
var wVals = backend.data.get(filter.dataId).values;
|
var yVals = y.values;
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * xStrides[0];
|
var yOffset1 = b * y.strides[0];
|
for (var yF = 0; yF < convInfo.outDepth; ++yF) {
|
var yOffset2 = yOffset1 + yF * y.strides[1];
|
var xFCorner = yF * convInfo.strideDepth - padFront;
|
for (var wF = 0; wF < filterDepth; ++wF) {
|
var xF = xFCorner + wF * dilationDepth;
|
if (xF < 0 || xF >= convInfo.inDepth) {
|
continue;
|
}
|
var wOffset1 = wF * filterStrides[0];
|
var xOffset2 = xOffset1 + xF * xStrides[1];
|
for (var yR = 0; yR < convInfo.outHeight; ++yR) {
|
var yOffset3 = yOffset2 + yR * y.strides[2];
|
var xRCorner = yR * convInfo.strideHeight - padTop;
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var xR = xRCorner + wR * dilationHeight;
|
if (xR < 0 || xR >= convInfo.inHeight) {
|
continue;
|
}
|
var wOffset2 = wOffset1 + wR * filterStrides[1];
|
var xOffset3 = xOffset2 + xR * xStrides[2];
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var yOffset4 = yOffset3 + yC * convInfo.outChannels;
|
var xCCorner = yC * convInfo.strideWidth - padLeft;
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var xC = xCCorner + wC * dilationWidth;
|
if (xC < 0 || xC >= convInfo.inWidth) {
|
continue;
|
}
|
var wOffset3 = wOffset2 + wC * filterStrides[2];
|
var xOffset4 = xOffset3 + xC * convInfo.inChannels;
|
var wOffset4 = wOffset3;
|
for (var d1 = 0; d1 < convInfo.inChannels; ++d1) {
|
var xVal = xVals[xOffset4 + d1];
|
for (var d2 = 0; d2 < convInfo.outChannels; ++d2) {
|
yVals[yOffset4 + d2] += xVal * wVals[wOffset4 + d2];
|
}
|
wOffset4 += convInfo.outChannels;
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(y.shape, y.dtype, y.values);
|
}
|
var conv3DConfig = {
|
kernelName: tfjsCore.Conv3D,
|
backendName: 'cpu',
|
kernelFunc: conv3D
|
};
|
|
function conv3DBackpropFilterV2(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, dy = inputs.dy;
|
var strides = attrs.strides, pad = attrs.pad, filterShape = attrs.filterShape;
|
assertNotComplex([x, dy], 'conv3dBackpropFilterV2');
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var dyStrides = tfjsCore.util.computeStrides(dy.shape);
|
var convInfo = tfjsCore.backend_util.computeConv3DInfo(x.shape, filterShape, strides, 1 /* dilations */, pad);
|
var strideDepth = convInfo.strideDepth;
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var filterDepth = convInfo.filterDepth;
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var dw = new tfjsCore.TensorBuffer(convInfo.filterShape, 'float32');
|
var dwValues = dw.values;
|
var _a = __read(dw.strides, 4), dwS0 = _a[0], dwS1 = _a[1], dwS2 = _a[2], dwS3 = _a[3];
|
var dyValues = backend.data.get(dy.dataId).values;
|
var _b = __read(dyStrides, 4), dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2], dyS3 = _b[3];
|
var xValues = backend.data.get(x.dataId).values;
|
var _c = __read(xStrides, 4), xS0 = _c[0], xS1 = _c[1], xS2 = _c[2], xS3 = _c[3];
|
var frontPad = convInfo.padInfo.front;
|
var leftPad = convInfo.padInfo.left;
|
var topPad = convInfo.padInfo.top;
|
for (var wF = 0; wF < filterDepth; ++wF) {
|
var yFMin = Math.max(0, Math.ceil((frontPad - wF) / strideDepth));
|
var yFMax = Math.min(convInfo.outDepth, (convInfo.inDepth + frontPad - wF) / strideDepth);
|
var wOffset1 = wF * dwS0;
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
|
var yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
|
var wOffset2 = wR * dwS1 + wOffset1;
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
|
var yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
|
var wOffset3 = wC * dwS2 + wOffset2;
|
for (var d1 = 0; d1 < convInfo.inChannels; ++d1) {
|
var wOffset4 = d1 * dwS3 + wOffset3;
|
for (var d2 = 0; d2 < convInfo.outChannels; ++d2) {
|
var dotProd = 0;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * xS0;
|
var yOffset1 = b * dyS0;
|
for (var yF = yFMin; yF < yFMax; ++yF) {
|
var xF = wF + yF * strideDepth - frontPad;
|
var xOffset2 = xF * xS1 + xOffset1;
|
var yOffset2 = yF * dyS1 + yOffset1;
|
for (var yR = yRMin; yR < yRMax; ++yR) {
|
var xR = wR + yR * strideHeight - topPad;
|
var xOffset3 = xR * xS2 + xOffset2;
|
var yOffset3 = yR * dyS2 + yOffset2;
|
for (var yC = yCMin; yC < yCMax; ++yC) {
|
var xC = wC + yC * strideWidth - leftPad;
|
var xOffset4 = xC * xS3 + xOffset3;
|
var yOffset4 = yC * dyS3 + yOffset3;
|
dotProd += xValues[xOffset4 + d1] * dyValues[yOffset4 + d2];
|
}
|
}
|
}
|
}
|
dwValues[wOffset4 + d2] = dotProd;
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dw.shape, dw.dtype, dw.values);
|
}
|
var conv3DBackpropFilterV2Config = {
|
kernelName: tfjsCore.Conv3DBackpropFilterV2,
|
backendName: 'cpu',
|
kernelFunc: conv3DBackpropFilterV2
|
};
|
|
function conv3DBackpropInputV2(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, filter = inputs.filter;
|
var pad = attrs.pad, strides = attrs.strides, inputShape = attrs.inputShape;
|
assertNotComplex([dy], 'conv3dBackpropInputV2');
|
var dyStrides = tfjsCore.util.computeStrides(dy.shape);
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
var convInfo = tfjsCore.backend_util.computeConv3DInfo(inputShape, filter.shape, strides, 1 /* dilations */, pad);
|
var dx = new tfjsCore.TensorBuffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var _a = __read(dx.strides, 4), dxS0 = _a[0], dxS1 = _a[1], dxS2 = _a[2], dxS3 = _a[3];
|
var dyValues = backend.data.get(dy.dataId).values;
|
var _b = __read(dyStrides, 4), dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2], dyS3 = _b[3];
|
var fltValues = backend.data.get(filter.dataId).values;
|
var _c = __read(filterStrides, 4), fltS0 = _c[0], fltS1 = _c[1], fltS2 = _c[2], fltS3 = _c[3];
|
var batchSize = convInfo.batchSize, filterDepth = convInfo.filterDepth, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth, inChannels = convInfo.inChannels, inDepth = convInfo.inDepth, inHeight = convInfo.inHeight, inWidth = convInfo.inWidth, outChannels = convInfo.outChannels, outDepth = convInfo.outDepth, outHeight = convInfo.outHeight, outWidth = convInfo.outWidth, strideDepth = convInfo.strideDepth, strideHeight = convInfo.strideHeight, strideWidth = convInfo.strideWidth;
|
var frontPad = filterDepth - 1 - convInfo.padInfo.front;
|
var topPad = filterHeight - 1 - convInfo.padInfo.top;
|
var leftPad = filterWidth - 1 - convInfo.padInfo.left;
|
for (var b = 0; b < batchSize; ++b) {
|
for (var d1 = 0; d1 < inChannels; ++d1) {
|
// Frames of depth
|
for (var xF = 0; xF < inDepth; ++xF) {
|
var xFCorner = xF - frontPad;
|
var xFMin = Math.max(0, Math.ceil(xFCorner / strideDepth));
|
var yFMax = Math.min(outDepth, (filterDepth + xFCorner) / strideDepth);
|
// Rows as per standard 2d matrix notation
|
for (var xR = 0; xR < inHeight; ++xR) {
|
var xRCorner = xR - topPad;
|
var xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
|
var yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
|
// Columns as per standard 2d matrix notation
|
for (var xC = 0; xC < inWidth; ++xC) {
|
var xCCorner = xC - leftPad;
|
var xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
|
var yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
|
var dotProd = 0;
|
for (var yF = xFMin; yF < yFMax; ++yF) {
|
var wF = yF * strideDepth - xFCorner;
|
for (var yR = xRMin; yR < yRMax; ++yR) {
|
var wR = yR * strideHeight - xRCorner;
|
for (var yC = xCMin; yC < yCMax; ++yC) {
|
var wC = yC * strideWidth - xCCorner;
|
var dyOffset = dyS0 * b + dyS1 * yF + dyS2 * yR + dyS3 * yC;
|
var fltOffset = fltS0 * (filterDepth - 1 - wF) +
|
fltS1 * (filterHeight - 1 - wR) +
|
fltS2 * (filterWidth - 1 - wC) + fltS3 * d1;
|
for (var d2 = 0; d2 < outChannels; ++d2) {
|
var pixel = dyValues[dyOffset + d2];
|
var weight = fltValues[fltOffset + d2];
|
dotProd += pixel * weight;
|
}
|
}
|
}
|
}
|
dxValues[dxS0 * b + dxS1 * xF + dxS2 * xR + dxS3 * xC + d1] =
|
dotProd;
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var conv3DBackpropInputV2Config = {
|
kernelName: tfjsCore.Conv3DBackpropInputV2,
|
backendName: 'cpu',
|
kernelFunc: conv3DBackpropInputV2
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var cos = unaryKernelFunc(tfjsCore.Cos, function (xi) { return Math.cos(xi); });
|
var cosConfig = {
|
kernelName: tfjsCore.Cos,
|
backendName: 'cpu',
|
kernelFunc: cos,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var cosh = unaryKernelFunc(tfjsCore.Cosh, function (xi) { return Math.cosh(xi); });
|
var coshConfig = {
|
kernelName: tfjsCore.Cosh,
|
backendName: 'cpu',
|
kernelFunc: cosh,
|
};
|
|
function cropAndResize(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var image = inputs.image, boxes = inputs.boxes, boxInd = inputs.boxInd;
|
var cropSize = attrs.cropSize, method = attrs.method, extrapolationValue = attrs.extrapolationValue;
|
var _a = __read(image.shape, 4), batch = _a[0], imageHeight = _a[1], imageWidth = _a[2], numChannels = _a[3];
|
var numBoxes = boxes.shape[0];
|
var _b = __read(cropSize, 2), cropHeight = _b[0], cropWidth = _b[1];
|
var output = tfjsCore.buffer([numBoxes, cropHeight, cropWidth, numChannels], 'float32');
|
var boxVals = backend.data.get(boxes.dataId).values;
|
var boxIndVals = backend.data.get(boxInd.dataId).values;
|
var imageVals = backend.data.get(image.dataId).values;
|
var inStride = tfjsCore.util.computeStrides(image.shape); // to calculate flat indexes into image
|
var outStride = tfjsCore.util.computeStrides(output.shape); // to calculate flat indexes into output
|
// Reference implementation
|
// tslint:disable-next-line:max-line-length
|
// https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/crop_and_resize_op.cc
|
for (var b = 0; b < numBoxes; b++) {
|
var startInd = b * 4;
|
var y1 = boxVals[startInd];
|
var x1 = boxVals[startInd + 1];
|
var y2 = boxVals[startInd + 2];
|
var x2 = boxVals[startInd + 3];
|
var bInd = boxIndVals[b];
|
if (bInd >= batch) {
|
continue;
|
}
|
var heightScale = (cropHeight > 1) ? (y2 - y1) * (imageHeight - 1) / (cropHeight - 1) : 0;
|
var widthScale = (cropWidth > 1) ? (x2 - x1) * (imageWidth - 1) / (cropWidth - 1) : 0;
|
for (var y = 0; y < cropHeight; y++) {
|
var yInd = (cropHeight > 1) ?
|
y1 * (imageHeight - 1) + y * (heightScale) :
|
0.5 * (y1 + y2) * (imageHeight - 1);
|
if (yInd < 0 || yInd > imageHeight - 1) {
|
for (var x = 0; x < cropWidth; x++) {
|
for (var c = 0; c < numChannels; c++) {
|
var ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
|
output.values[ind] = extrapolationValue;
|
}
|
}
|
continue;
|
}
|
if (method === 'bilinear') {
|
var topInd = Math.floor(yInd);
|
var bottomInd = Math.ceil(yInd);
|
var yLerp = yInd - topInd;
|
for (var x = 0; x < cropWidth; x++) {
|
var xInd = (cropWidth > 1) ?
|
x1 * (imageWidth - 1) + x * widthScale :
|
0.5 * (x1 + x2) * (imageWidth - 1);
|
if (xInd < 0 || xInd > imageWidth - 1) {
|
for (var c = 0; c < numChannels; c++) {
|
var ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
|
output.values[ind] = extrapolationValue;
|
}
|
continue;
|
}
|
var leftInd = Math.floor(xInd);
|
var rightInd = Math.ceil(xInd);
|
var xLerp = xInd - leftInd;
|
for (var c = 0; c < numChannels; c++) {
|
var ind = c + leftInd * inStride[2] + topInd * inStride[1] +
|
bInd * inStride[0];
|
var topLeft = imageVals[ind];
|
ind = c + rightInd * inStride[2] + topInd * inStride[1] +
|
bInd * inStride[0];
|
var topRight = imageVals[ind];
|
ind = c + leftInd * inStride[2] + bottomInd * inStride[1] +
|
bInd * inStride[0];
|
var bottomLeft = imageVals[ind];
|
ind = c + rightInd * inStride[2] + bottomInd * inStride[1] +
|
bInd * inStride[0];
|
var bottomRight = imageVals[ind];
|
var top = topLeft + (topRight - topLeft) * xLerp;
|
var bottom = bottomLeft + (bottomRight - bottomLeft) * xLerp;
|
ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
|
output.values[ind] = top + ((bottom - top) * yLerp);
|
}
|
}
|
}
|
else { // method == "nearest"
|
for (var x = 0; x < cropWidth; ++x) {
|
var xInd = (cropWidth > 1) ?
|
x1 * (imageWidth - 1) + x * widthScale :
|
0.5 * (x1 + x2) * (imageWidth - 1);
|
if (xInd < 0 || xInd > imageWidth - 1) {
|
for (var c = 0; c < numChannels; c++) {
|
var ind = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
|
output.values[ind] = extrapolationValue;
|
}
|
continue;
|
}
|
var closestX = Math.round(xInd);
|
var closestY = Math.round(yInd);
|
for (var c = 0; c < numChannels; c++) {
|
var inInd = c + closestX * inStride[2] + closestY * inStride[1] +
|
bInd * inStride[0];
|
var outInd = c + x * outStride[2] + y * outStride[1] + b * outStride[0];
|
output.values[outInd] = imageVals[inInd];
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(output.shape, output.dtype, output.values);
|
}
|
var cropAndResizeConfig = {
|
kernelName: tfjsCore.CropAndResize,
|
backendName: 'cpu',
|
kernelFunc: cropAndResize
|
};
|
|
/**
|
* @license
|
* Copyright 2022 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.
|
* =============================================================================
|
*/
|
function cumprod(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, exclusive = attrs.exclusive, reverse = attrs.reverse;
|
assertNotComplex(x, 'cumprod');
|
var permutation = tfjsCore.backend_util.getAxesPermutation([axis], x.shape.length);
|
var $x = x;
|
if (permutation != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutation } });
|
}
|
var permutedAxis = tfjsCore.backend_util.getInnerMostAxes(1, x.shape.length)[0];
|
if (permutedAxis !== $x.shape.length - 1) {
|
throw new Error("backend.cumprod in CPU expects an inner-most " +
|
"axis=".concat($x.shape.length - 1, " but got axis=").concat(permutedAxis));
|
}
|
var resultDtype = tfjsCore.upcastType($x.dtype, 'int32');
|
var vals = tfjsCore.util.makeOnesTypedArray(tfjsCore.util.sizeFromShape($x.shape), resultDtype);
|
var aVals = backend.data.get($x.dataId).values;
|
var finalDim = $x.shape[$x.shape.length - 1];
|
var indexAdjuster = reverse ?
|
function (i, j) { return i + finalDim - j - 1; } :
|
function (i, j) { return i + j; };
|
for (var i = 0; i < aVals.length; i += finalDim) {
|
for (var j = 0; j < finalDim; j++) {
|
var idx = indexAdjuster(i, j);
|
if (j === 0) {
|
vals[idx] = exclusive ? 1 : aVals[idx];
|
}
|
else {
|
var prevIdx = indexAdjuster(i, j - 1);
|
vals[idx] = exclusive ? aVals[prevIdx] * vals[prevIdx] :
|
aVals[idx] * vals[prevIdx];
|
}
|
}
|
}
|
var result = backend.makeTensorInfo($x.shape, resultDtype, vals);
|
if (permutation != null) {
|
var reversePermutation = tfjsCore.backend_util.getUndoAxesPermutation(permutation);
|
var reverseTransposedResult = transpose({ inputs: { x: result }, backend: backend, attrs: { perm: reversePermutation } });
|
backend.disposeIntermediateTensorInfo(result);
|
backend.disposeIntermediateTensorInfo($x);
|
return reverseTransposedResult;
|
}
|
return result;
|
}
|
var cumprodConfig = {
|
kernelName: tfjsCore.Cumprod,
|
backendName: 'cpu',
|
kernelFunc: cumprod
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function cumsum(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, exclusive = attrs.exclusive, reverse = attrs.reverse;
|
assertNotComplex(x, 'cumsum');
|
var permutation = tfjsCore.backend_util.getAxesPermutation([axis], x.shape.length);
|
var $x = x;
|
if (permutation != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutation } });
|
}
|
var permutedAxis = tfjsCore.backend_util.getInnerMostAxes(1, x.shape.length)[0];
|
if (permutedAxis !== $x.shape.length - 1) {
|
throw new Error("backend.cumsum in CPU expects an inner-most " +
|
"axis=".concat($x.shape.length - 1, " but got axis=").concat(permutedAxis));
|
}
|
var resultDtype = tfjsCore.upcastType($x.dtype, 'int32');
|
var vals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape($x.shape), resultDtype);
|
var aVals = backend.data.get($x.dataId).values;
|
var finalDim = $x.shape[$x.shape.length - 1];
|
var indexAdjuster = reverse ?
|
function (i, j) { return i + finalDim - j - 1; } :
|
function (i, j) { return i + j; };
|
for (var i = 0; i < aVals.length; i += finalDim) {
|
for (var j = 0; j < finalDim; j++) {
|
var idx = indexAdjuster(i, j);
|
if (j === 0) {
|
vals[idx] = exclusive ? 0 : aVals[idx];
|
}
|
else {
|
var prevIdx = indexAdjuster(i, j - 1);
|
vals[idx] = exclusive ? aVals[prevIdx] + vals[prevIdx] :
|
aVals[idx] + vals[prevIdx];
|
}
|
}
|
}
|
var result = backend.makeTensorInfo($x.shape, resultDtype, vals);
|
if (permutation != null) {
|
var reversePermutation = tfjsCore.backend_util.getUndoAxesPermutation(permutation);
|
var reverseTransposedResult = transpose({ inputs: { x: result }, backend: backend, attrs: { perm: reversePermutation } });
|
backend.disposeIntermediateTensorInfo(result);
|
backend.disposeIntermediateTensorInfo($x);
|
return reverseTransposedResult;
|
}
|
return result;
|
}
|
var cumsumConfig = {
|
kernelName: tfjsCore.Cumsum,
|
backendName: 'cpu',
|
kernelFunc: cumsum
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function denseBincount(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, weights = inputs.weights;
|
var size = attrs.size, binaryOutput = attrs.binaryOutput;
|
if (x.shape.length === 1) {
|
var xVals = backend.data.get(x.dataId).values;
|
var weightsVals = backend.data.get(weights.dataId).values;
|
var outVals = bincountImpl(xVals, weightsVals, weights.dtype, weights.shape, size);
|
return backend.makeTensorInfo([size], weights.dtype, outVals);
|
}
|
else if (x.shape.length === 2) {
|
var xBuf = backend.bufferSync(x);
|
var weightsBuf = backend.bufferSync(weights);
|
var outBuf = bincountReduceImpl(xBuf, weightsBuf, size, binaryOutput);
|
return backend.makeTensorInfo(outBuf.shape, weights.dtype, outBuf.values);
|
}
|
throw new Error("Error in denseBincount: input must be at most rank 2, but got rank" +
|
"".concat(x.shape.length, "."));
|
}
|
var denseBincountConfig = {
|
kernelName: tfjsCore.DenseBincount,
|
backendName: 'cpu',
|
kernelFunc: denseBincount
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function depthToSpace(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var blockSize = attrs.blockSize, dataFormat = attrs.dataFormat;
|
tfjsCore.util.assert(dataFormat === 'NHWC', function () { return "Only NHWC dataFormat supported on CPU for depthToSpace. Got ".concat(dataFormat); });
|
var batchSize = x.shape[0];
|
var inputHeight = x.shape[1];
|
var inputWidth = x.shape[2];
|
var inputDepth = x.shape[3];
|
var outputHeight = inputHeight * blockSize;
|
var outputWidth = inputWidth * blockSize;
|
var outputDepth = inputDepth / (blockSize * blockSize);
|
var xValues = backend.data.get(x.dataId).values;
|
var result = new Float32Array(batchSize * outputHeight * outputWidth * outputDepth);
|
var outputIdx = 0;
|
for (var b = 0; b < batchSize; ++b) {
|
for (var h = 0; h < outputHeight; ++h) {
|
var inH = Math.floor(h / blockSize);
|
var offsetH = (h % blockSize);
|
for (var w = 0; w < outputWidth; ++w) {
|
var inW = Math.floor(w / blockSize);
|
var offsetW = (w % blockSize);
|
var offsetD = (offsetH * blockSize + offsetW) * outputDepth;
|
for (var d = 0; d < outputDepth; ++d) {
|
var inD = d + offsetD;
|
var inputIdx = inD + inputDepth * (inW + inputWidth * (inH + inputHeight * b));
|
result[outputIdx++] = xValues[inputIdx];
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo([batchSize, outputHeight, outputWidth, outputDepth], x.dtype, result);
|
}
|
var depthToSpaceConfig = {
|
kernelName: tfjsCore.DepthToSpace,
|
backendName: 'cpu',
|
kernelFunc: depthToSpace
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function depthwiseConv2dNative(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, filter = inputs.filter;
|
var strides = attrs.strides, pad = attrs.pad, dilations = attrs.dilations, dimRoundingMode = attrs.dimRoundingMode;
|
assertNotComplex([x, filter], 'depthwiseConv2DNative');
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
var $dilations = dilations;
|
if ($dilations == null) {
|
$dilations = [1, 1];
|
}
|
tfjsCore.util.assert(tfjsCore.backend_util.eitherStridesOrDilationsAreOne(strides, $dilations), function () { return 'Error in depthwiseConv2d: Either strides or dilations must be ' +
|
"1. Got strides ".concat(strides, " and dilations '").concat($dilations, "'"); });
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad, dimRoundingMode, true /* depthwise */);
|
var filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth, dilationHeight = convInfo.dilationHeight, dilationWidth = convInfo.dilationWidth, padInfo = convInfo.padInfo;
|
var padLeft = padInfo.left;
|
var padTop = padInfo.top;
|
var chMul = convInfo.outChannels / convInfo.inChannels;
|
var y = new tfjsCore.TensorBuffer(convInfo.outShape, x.dtype);
|
var xVals = backend.data.get(x.dataId).values;
|
var wVals = backend.data.get(filter.dataId).values;
|
var yVals = y.values;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * xStrides[0];
|
var yOffset1 = b * y.strides[0];
|
for (var yR = 0; yR < convInfo.outHeight; ++yR) {
|
var yOffset2 = yOffset1 + yR * y.strides[1];
|
var xRCorner = yR * convInfo.strideHeight - padTop;
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var xR = xRCorner + wR * dilationHeight;
|
if (xR < 0 || xR >= convInfo.inHeight) {
|
continue;
|
}
|
var wOffset1 = wR * filterStrides[0];
|
var xOffset2 = xOffset1 + xR * xStrides[1];
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var yOffset3 = yOffset2 + yC * y.strides[2];
|
var xCCorner = yC * convInfo.strideWidth - padLeft;
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var xC = xCCorner + wC * dilationWidth;
|
if (xC < 0 || xC >= convInfo.inWidth) {
|
continue;
|
}
|
var wOffset2 = wOffset1 + wC * filterStrides[1];
|
var xOffset3 = xOffset2 + xC * convInfo.inChannels;
|
var yOffset4 = yOffset3;
|
var wOffset3 = wOffset2;
|
for (var d1 = 0; d1 < convInfo.inChannels; ++d1) {
|
var xVal = xVals[xOffset3 + d1];
|
for (var q = 0; q < chMul; ++q) {
|
yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];
|
}
|
yOffset4 += chMul;
|
wOffset3 += chMul;
|
}
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(y.shape, y.dtype, y.values);
|
}
|
var depthwiseConv2dNativeConfig = {
|
kernelName: tfjsCore.DepthwiseConv2dNative,
|
backendName: 'cpu',
|
kernelFunc: depthwiseConv2dNative
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function depthwiseConv2dNativeBackpropFilter(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, dy = inputs.dy;
|
var strides = attrs.strides, dilations = attrs.dilations, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode, filterShape = attrs.filterShape;
|
assertNotComplex([x, dy], 'depthwiseConv2dNativeBackpropFilter');
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(x.shape, filterShape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
|
var strideHeight = convInfo.strideHeight, strideWidth = convInfo.strideWidth, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth;
|
var dW = new tfjsCore.TensorBuffer(convInfo.filterShape, 'float32');
|
var leftPad = convInfo.padInfo.left;
|
var topPad = convInfo.padInfo.top;
|
var chMul = convInfo.outChannels / convInfo.inChannels;
|
var xVals = backend.data.get(x.dataId).values;
|
var xBuf = new tfjsCore.TensorBuffer(x.shape, x.dtype, xVals);
|
var dyVals = backend.data.get(dy.dataId).values;
|
var dyBuf = new tfjsCore.TensorBuffer(dy.shape, dy.dtype, dyVals);
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));
|
var yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));
|
var yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);
|
for (var d2 = 0; d2 < convInfo.outChannels; ++d2) {
|
var d1 = Math.trunc(d2 / chMul);
|
var dm = d2 % chMul;
|
var dotProd = 0;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
for (var yR = yRMin; yR < yRMax; ++yR) {
|
var xR = wR + yR * strideHeight - topPad;
|
for (var yC = yCMin; yC < yCMax; ++yC) {
|
var xC = wC + yC * strideWidth - leftPad;
|
dotProd += xBuf.get(b, xR, xC, d1) *
|
dyBuf.get(b, yR, yC, d2);
|
}
|
}
|
}
|
dW.set(dotProd, wR, wC, d1, dm);
|
}
|
}
|
}
|
return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);
|
}
|
var depthwiseConv2dNativeBackpropFilterConfig = {
|
kernelName: tfjsCore.DepthwiseConv2dNativeBackpropFilter,
|
backendName: 'cpu',
|
kernelFunc: depthwiseConv2dNativeBackpropFilter
|
};
|
|
function depthwiseConv2dNativeBackpropInput(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, filter = inputs.filter;
|
var strides = attrs.strides, dilations = attrs.dilations, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode, inputShape = attrs.inputShape;
|
assertNotComplex([dy, filter], 'depthwiseConv2DNativeBackpropInput');
|
var dyStrides = tfjsCore.util.computeStrides(dy.shape);
|
var filterStrides = tfjsCore.util.computeStrides(filter.shape);
|
var convInfo = tfjsCore.backend_util.computeConv2DInfo(inputShape, filter.shape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);
|
var dx = new tfjsCore.TensorBuffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var _a = __read(dx.strides, 3), dxS0 = _a[0], dxS1 = _a[1], dxS2 = _a[2];
|
var dyValues = backend.data.get(dy.dataId).values;
|
var _b = __read(dyStrides, 3), dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2];
|
var fltValues = backend.data.get(filter.dataId).values;
|
var _c = __read(filterStrides, 3), fltS0 = _c[0], fltS1 = _c[1], fltS2 = _c[2];
|
var batchSize = convInfo.batchSize, filterHeight = convInfo.filterHeight, filterWidth = convInfo.filterWidth, inChannels = convInfo.inChannels, inHeight = convInfo.inHeight, inWidth = convInfo.inWidth, outChannels = convInfo.outChannels, outHeight = convInfo.outHeight, outWidth = convInfo.outWidth, strideHeight = convInfo.strideHeight, strideWidth = convInfo.strideWidth;
|
var topPad = filterHeight - 1 - convInfo.padInfo.top;
|
var leftPad = filterWidth - 1 - convInfo.padInfo.left;
|
var chMul = outChannels / inChannels;
|
for (var b = 0; b < batchSize; ++b) {
|
for (var d1 = 0; d1 < inChannels; ++d1) {
|
for (var xR = 0; xR < inHeight; ++xR) {
|
var xRCorner = xR - topPad;
|
var xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));
|
var yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);
|
for (var xC = 0; xC < inWidth; ++xC) {
|
var xCCorner = xC - leftPad;
|
var xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));
|
var yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);
|
var dotProd = 0;
|
for (var yR = xRMin; yR < yRMax; ++yR) {
|
var wR = yR * strideHeight - xRCorner;
|
for (var yC = xCMin; yC < yCMax; ++yC) {
|
var wC = yC * strideWidth - xCCorner;
|
var dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;
|
var fltOffset = fltS0 * (filterHeight - 1 - wR) +
|
fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;
|
for (var dm = 0; dm < chMul; ++dm) {
|
var d2 = d1 * chMul + dm;
|
var pixel = dyValues[dyOffset + d2];
|
var weight = fltValues[fltOffset + dm];
|
dotProd += pixel * weight;
|
}
|
}
|
}
|
dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var depthwiseConv2dNativeBackpropInputConfig = {
|
kernelName: tfjsCore.DepthwiseConv2dNativeBackpropInput,
|
backendName: 'cpu',
|
kernelFunc: depthwiseConv2dNativeBackpropInput
|
};
|
|
function diag(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x;
|
var xSize = tfjsCore.util.sizeFromShape(x.shape);
|
var xVals = backend.data.get(x.dataId).values;
|
var outBuf = tfjsCore.buffer([xSize, xSize], x.dtype);
|
var vals = outBuf.values;
|
for (var i = 0; i < xVals.length; i++) {
|
vals[i * xSize + i] = xVals[i];
|
}
|
var outShape = __spreadArray(__spreadArray([], __read(x.shape), false), __read(x.shape), false);
|
return backend.makeTensorInfo(outShape, outBuf.dtype, outBuf.values);
|
}
|
var diagConfig = {
|
kernelName: tfjsCore.Diag,
|
backendName: 'cpu',
|
kernelFunc: diag
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var dilation2DConfig = {
|
kernelName: tfjsCore.Dilation2D,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, backend = _a.backend, attrs = _a.attrs;
|
var x = inputs.x, filter = inputs.filter;
|
var strides = attrs.strides, pad = attrs.pad, dilations = attrs.dilations;
|
var cpuBackend = backend;
|
var xVals = cpuBackend.data.get(x.dataId).values;
|
var xRank = x.shape.length;
|
var filterVals = cpuBackend.data.get(filter.dataId).values;
|
var filterRank = filter.shape.length;
|
var _b = tfjsCore.backend_util.computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations), batchSize = _b.batchSize, inHeight = _b.inHeight, inWidth = _b.inWidth, inChannels = _b.inChannels, outHeight = _b.outHeight, outWidth = _b.outWidth, padInfo = _b.padInfo, strideHeight = _b.strideHeight, strideWidth = _b.strideWidth, filterHeight = _b.filterHeight, filterWidth = _b.filterWidth, dilationHeight = _b.dilationHeight, dilationWidth = _b.dilationWidth, outShape = _b.outShape;
|
var outSize = tfjsCore.util.sizeFromShape(outShape);
|
var outRank = outShape.length;
|
var outputVals = tfjsCore.util.getArrayFromDType(x.dtype, outSize);
|
// Upsampling the input by fill in `dilation size - 1` values between each
|
// input value.
|
// This implementation follows the TF c++ implementation:
|
// https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
|
for (var b = 0; b < batchSize; ++b) {
|
for (var hOut = 0; hOut < outHeight; ++hOut) {
|
var hBeg = hOut * strideHeight - padInfo.top;
|
for (var wOut = 0; wOut < outWidth; ++wOut) {
|
var wBeg = wOut * strideWidth - padInfo.left;
|
for (var d = 0; d < inChannels; ++d) {
|
var curVal = Number.MIN_SAFE_INTEGER;
|
for (var h = 0; h < filterHeight; ++h) {
|
var hIn = hBeg + h * dilationHeight;
|
if (hIn >= 0 && hIn < inHeight) {
|
for (var w = 0; w < filterWidth; ++w) {
|
var wIn = wBeg + w * dilationWidth;
|
if (wIn >= 0 && wIn < inWidth) {
|
var xIndex = tfjsCore.util.locToIndex([b, hIn, wIn, d], xRank, tfjsCore.util.computeStrides(x.shape));
|
var filterIndex = tfjsCore.util.locToIndex([h, w, d], filterRank, tfjsCore.util.computeStrides(filter.shape));
|
var val = xVals[xIndex] + filterVals[filterIndex];
|
if (val > curVal) {
|
curVal = val;
|
}
|
}
|
}
|
}
|
}
|
var outputIndex = tfjsCore.util.locToIndex([b, hOut, wOut, d], outRank, tfjsCore.util.computeStrides(outShape));
|
outputVals[outputIndex] = curVal;
|
}
|
}
|
}
|
}
|
var dataId = cpuBackend.write(tfjsCore.util.toTypedArray(outputVals, x.dtype), outShape, x.dtype);
|
return { dataId: dataId, shape: outShape, dtype: x.dtype };
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var dilation2DBackpropFilterConfig = {
|
kernelName: tfjsCore.Dilation2DBackpropFilter,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, backend = _a.backend, attrs = _a.attrs;
|
var x = inputs.x, filter = inputs.filter, dy = inputs.dy;
|
var strides = attrs.strides, pad = attrs.pad, dilations = attrs.dilations;
|
var cpuBackend = backend;
|
var $x = tfjsCore.util.toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
|
var $filter = tfjsCore.util.toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
|
var _b = tfjsCore.backend_util.computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations), batchSize = _b.batchSize, inHeight = _b.inHeight, inWidth = _b.inWidth, inChannels = _b.inChannels, outHeight = _b.outHeight, outWidth = _b.outWidth, padInfo = _b.padInfo, strideHeight = _b.strideHeight, strideWidth = _b.strideWidth, filterHeight = _b.filterHeight, filterWidth = _b.filterWidth, dilationHeight = _b.dilationHeight, dilationWidth = _b.dilationWidth, outShape = _b.outShape;
|
tfjsCore.util.assert(dy.rank === outShape.length, function () { return "Error in ".concat(tfjsCore.Dilation2DBackpropFilter, ", dy ") +
|
"must have the same rank as output ".concat(outShape.length, ", but got ") +
|
"".concat(dy.rank); });
|
var $dy = tfjsCore.util.toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
|
// The computed filter gradients has the same dimensions as the filter:
|
// [filterHeight, filterWidth, depth]
|
var gradients = tfjsCore.util.makeZerosNestedTypedArray(filter.shape, filter.dtype);
|
// In the case of multiple argmax branches, we only back-propagate along the
|
// last branch, i.e., the one with largest value of `h * filter_cols + w`,
|
// similarly to the max-pooling backward routines.
|
// This implementation follows the TF c++ implementation:
|
// https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
|
for (var b = 0; b < batchSize; ++b) {
|
for (var hOut = 0; hOut < outHeight; ++hOut) {
|
var hBeg = hOut * strideHeight - padInfo.top;
|
for (var wOut = 0; wOut < outWidth; ++wOut) {
|
var wBeg = wOut * strideWidth - padInfo.left;
|
for (var d = 0; d < inChannels; ++d) {
|
var curVal = Number.MIN_SAFE_INTEGER;
|
var hMax = 0;
|
var wMax = 0;
|
for (var h = 0; h < filterHeight; ++h) {
|
var hIn = hBeg + h * dilationHeight;
|
if (hIn >= 0 && hIn < inHeight) {
|
for (var w = 0; w < filterWidth; ++w) {
|
var wIn = wBeg + w * dilationWidth;
|
if (wIn >= 0 && wIn < inWidth) {
|
var val = $x[b][hIn][wIn][d] + $filter[h][w][d];
|
if (val > curVal) {
|
curVal = val;
|
hMax = h;
|
wMax = w;
|
}
|
}
|
}
|
}
|
}
|
gradients[hMax][wMax][d] += $dy[b][hOut][wOut][d];
|
}
|
}
|
}
|
}
|
var dataId = cpuBackend.write(tfjsCore.util.toTypedArray(gradients, x.dtype), filter.shape, filter.dtype);
|
return { dataId: dataId, shape: filter.shape, dtype: filter.dtype };
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var dilation2DBackpropInputConfig = {
|
kernelName: tfjsCore.Dilation2DBackpropInput,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, backend = _a.backend, attrs = _a.attrs;
|
var x = inputs.x, filter = inputs.filter, dy = inputs.dy;
|
var strides = attrs.strides, pad = attrs.pad, dilations = attrs.dilations;
|
var cpuBackend = backend;
|
var $x = tfjsCore.util.toNestedArray(x.shape, cpuBackend.data.get(x.dataId).values);
|
var $filter = tfjsCore.util.toNestedArray(filter.shape, cpuBackend.data.get(filter.dataId).values);
|
var _b = tfjsCore.backend_util.computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations), batchSize = _b.batchSize, inHeight = _b.inHeight, inWidth = _b.inWidth, inChannels = _b.inChannels, outHeight = _b.outHeight, outWidth = _b.outWidth, padInfo = _b.padInfo, strideHeight = _b.strideHeight, strideWidth = _b.strideWidth, filterHeight = _b.filterHeight, filterWidth = _b.filterWidth, dilationHeight = _b.dilationHeight, dilationWidth = _b.dilationWidth, outShape = _b.outShape;
|
tfjsCore.util.assert(dy.rank === outShape.length, function () { return "Error in ".concat(tfjsCore.Dilation2DBackpropInput, ", dy ") +
|
"must have the same rank as output ".concat(outShape.length, ", but got ") +
|
"".concat(dy.rank); });
|
var $dy = tfjsCore.util.toNestedArray(outShape, cpuBackend.data.get(dy.dataId).values);
|
// The computed gradients has the same dimensions as the input:
|
// [batch, inputHeight, inputCols, inChannel]
|
var gradients = tfjsCore.util.makeZerosNestedTypedArray(x.shape, x.dtype);
|
// In the case of multiple argmax branches, we only back-propagate along the
|
// last branch, i.e., the one with largest value of `h * filter_cols + w`,
|
// similarly to the max-pooling backward routines.
|
// This implementation follows the TF c++ implementation:
|
// https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc
|
for (var b = 0; b < batchSize; ++b) {
|
for (var hOut = 0; hOut < outHeight; ++hOut) {
|
var hBeg = hOut * strideHeight - padInfo.top;
|
for (var wOut = 0; wOut < outWidth; ++wOut) {
|
var wBeg = wOut * strideWidth - padInfo.left;
|
for (var d = 0; d < inChannels; ++d) {
|
var curVal = Number.MIN_SAFE_INTEGER;
|
var hInMax = (hBeg < 0) ? 0 : hBeg;
|
var wInMax = (wBeg < 0) ? 0 : wBeg;
|
for (var h = 0; h < filterHeight; ++h) {
|
var hIn = hBeg + h * dilationHeight;
|
if (hIn >= 0 && hIn < inHeight) {
|
for (var w = 0; w < filterWidth; ++w) {
|
var wIn = wBeg + w * dilationWidth;
|
if (wIn >= 0 && wIn < inWidth) {
|
var val = $x[b][hIn][wIn][d] + $filter[h][w][d];
|
if (val > curVal) {
|
curVal = val;
|
hInMax = hIn;
|
wInMax = wIn;
|
}
|
}
|
}
|
}
|
}
|
gradients[b][hInMax][wInMax][d] += $dy[b][hOut][wOut][d];
|
}
|
}
|
}
|
}
|
var dataId = cpuBackend.write(tfjsCore.util.toTypedArray(gradients, x.dtype), x.shape, x.dtype);
|
return { dataId: dataId, shape: x.shape, dtype: x.dtype };
|
}
|
};
|
|
function draw(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var image = inputs.image;
|
var canvas = attrs.canvas, options = attrs.options;
|
var _a = options || {}, contextOptions = _a.contextOptions, imageOptions = _a.imageOptions;
|
var alpha = (imageOptions === null || imageOptions === void 0 ? void 0 : imageOptions.alpha) || 1;
|
var contextType = (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextType) || '2d';
|
if (contextType !== '2d') {
|
throw new Error("Context type ".concat(contextOptions.contextType, " is not supported by the CPU backend."));
|
}
|
var ctx = canvas.getContext(contextType, (contextOptions === null || contextOptions === void 0 ? void 0 : contextOptions.contextAttributes) || {});
|
if (ctx == null) {
|
throw new Error("Could not get the context with ".concat(contextType, " type."));
|
}
|
var _b = __read(image.shape.slice(0, 2), 2), height = _b[0], width = _b[1];
|
var depth = image.shape.length === 2 ? 1 : image.shape[2];
|
var data = backend.data.get(image.dataId).values;
|
var multiplier = image.dtype === 'float32' ? 255 : 1;
|
var bytes = new Uint8ClampedArray(width * height * 4);
|
for (var i = 0; i < height * width; ++i) {
|
var rgba = [0, 0, 0, 255 * alpha];
|
for (var d = 0; d < depth; d++) {
|
var value = data[i * depth + d];
|
if (image.dtype === 'float32') {
|
if (value < 0 || value > 1) {
|
throw new Error("Tensor values for a float32 Tensor must be in the " +
|
"range [0 - 1] but encountered ".concat(value, "."));
|
}
|
}
|
else if (image.dtype === 'int32') {
|
if (value < 0 || value > 255) {
|
throw new Error("Tensor values for a int32 Tensor must be in the " +
|
"range [0 - 255] but encountered ".concat(value, "."));
|
}
|
}
|
if (depth === 1) {
|
rgba[0] = value * multiplier;
|
rgba[1] = value * multiplier;
|
rgba[2] = value * multiplier;
|
}
|
else {
|
rgba[d] = value * multiplier;
|
}
|
}
|
var j = i * 4;
|
bytes[j + 0] = Math.round(rgba[0]);
|
bytes[j + 1] = Math.round(rgba[1]);
|
bytes[j + 2] = Math.round(rgba[2]);
|
bytes[j + 3] = Math.round(rgba[3]);
|
}
|
canvas.width = width;
|
canvas.height = height;
|
var imageData = new ImageData(bytes, width, height);
|
ctx.putImageData(imageData, 0, 0);
|
return image;
|
}
|
var drawConfig = {
|
kernelName: tfjsCore.Draw,
|
backendName: 'cpu',
|
kernelFunc: draw
|
};
|
|
function sum(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
assertNotComplex(x, 'sum');
|
var $x;
|
if (x.dtype === 'bool') {
|
$x = cast({ inputs: { x: x }, backend: backend, attrs: { dtype: 'int32' } });
|
}
|
else {
|
$x = identity({ inputs: { x: x }, backend: backend });
|
}
|
var xRank = $x.shape.length;
|
var axes = tfjsCore.util.parseAxisParam(axis, $x.shape);
|
var permutation = tfjsCore.backend_util.getAxesPermutation(axes, xRank);
|
var reductionAxes = axes;
|
var permutedX = $x;
|
if (permutation != null) {
|
permutedX =
|
transpose({ inputs: { x: $x }, backend: backend, attrs: { perm: permutation } });
|
reductionAxes = tfjsCore.backend_util.getInnerMostAxes(reductionAxes.length, xRank);
|
}
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('sum', reductionAxes, permutedX.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes(permutedX.shape, reductionAxes), 2), outShape = _a[0], reduceShape = _a[1];
|
var resultDtype = tfjsCore.backend_util.upcastType(permutedX.dtype, 'int32');
|
var result = zeros(backend, outShape, resultDtype);
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var vals = backend.data.get(result.dataId).values;
|
var aVals = backend.data.get(permutedX.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var sum_1 = 0;
|
for (var j = 0; j < reduceSize; ++j) {
|
sum_1 += aVals[offset + j];
|
}
|
vals[i] = sum_1;
|
}
|
if (keepDims) {
|
var newShape = tfjsCore.backend_util.expandShapeToKeepDim(result.shape, axes);
|
var oldResult = result;
|
result = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: newShape } });
|
backend.disposeIntermediateTensorInfo(oldResult);
|
}
|
backend.disposeIntermediateTensorInfo($x);
|
if (permutation != null) {
|
backend.disposeIntermediateTensorInfo(permutedX);
|
}
|
return result;
|
}
|
var sumConfig = {
|
kernelName: tfjsCore.Sum,
|
backendName: 'cpu',
|
kernelFunc: sum
|
};
|
|
function einsum(args) {
|
var e_1, _a, e_2, _b;
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var equation = attrs.equation;
|
var tensors = inputs;
|
var _c = tfjsCore.backend_util.decodeEinsumEquation(equation, tensors.length), allDims = _c.allDims, summedDims = _c.summedDims, idDims = _c.idDims;
|
tfjsCore.backend_util.checkEinsumDimSizes(allDims.length, idDims, tensors);
|
var _d = tfjsCore.backend_util.getEinsumComputePath(summedDims, idDims), path = _d.path, steps = _d.steps;
|
var nSteps = steps.length;
|
var out = null;
|
var numDimsRemaining = allDims.length;
|
var tensorsToDispose = [];
|
for (var i = 0; i < nSteps; ++i) {
|
try {
|
for (var _e = (e_1 = void 0, __values(steps[i])), _f = _e.next(); !_f.done; _f = _e.next()) {
|
var idTerm = _f.value;
|
var _g = tfjsCore.backend_util.getEinsumPermutation(numDimsRemaining, idDims[idTerm]), perm = _g.permutationIndices, dimsToExpand = _g.expandDims;
|
var x = void 0;
|
if (tfjsCore.backend_util.isIdentityPermutation(perm)) {
|
x = tensors[idTerm];
|
}
|
else {
|
x = transpose({ inputs: { x: tensors[idTerm] }, backend: backend, attrs: { perm: perm } });
|
tensorsToDispose.push(x);
|
}
|
var targetShape = x.shape.slice();
|
for (var k = 0; k < dimsToExpand.length; ++k) {
|
targetShape.splice(dimsToExpand[k], 0, 1);
|
}
|
if (!tfjsCore.util.arraysEqual(x.shape, targetShape)) {
|
x = reshape({ inputs: { x: x }, backend: backend, attrs: { shape: targetShape } });
|
tensorsToDispose.push(x);
|
}
|
if (out === null) {
|
out = x;
|
}
|
else {
|
// tslint:disable-next-line: no-unnecessary-type-assertion
|
out = multiply({ inputs: { a: x, b: out }, backend: backend });
|
tensorsToDispose.push(out);
|
}
|
}
|
}
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
finally {
|
try {
|
if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
|
}
|
finally { if (e_1) throw e_1.error; }
|
}
|
if (i < nSteps - 1) {
|
if (path[i] >= 0) {
|
out = sum({
|
inputs: { x: out },
|
backend: backend,
|
attrs: {
|
axis: path[i] - (allDims.length - numDimsRemaining),
|
keepDims: false
|
}
|
});
|
tensorsToDispose.push(out);
|
}
|
numDimsRemaining--;
|
}
|
}
|
try {
|
// Clean up intermediate tensors.
|
for (var tensorsToDispose_1 = __values(tensorsToDispose), tensorsToDispose_1_1 = tensorsToDispose_1.next(); !tensorsToDispose_1_1.done; tensorsToDispose_1_1 = tensorsToDispose_1.next()) {
|
var tensorInfo = tensorsToDispose_1_1.value;
|
if (tensorInfo === out) {
|
continue;
|
}
|
backend.disposeIntermediateTensorInfo(tensorInfo);
|
}
|
}
|
catch (e_2_1) { e_2 = { error: e_2_1 }; }
|
finally {
|
try {
|
if (tensorsToDispose_1_1 && !tensorsToDispose_1_1.done && (_b = tensorsToDispose_1.return)) _b.call(tensorsToDispose_1);
|
}
|
finally { if (e_2) throw e_2.error; }
|
}
|
return out;
|
}
|
var einsumConfig = {
|
kernelName: tfjsCore.Einsum,
|
backendName: 'cpu',
|
kernelFunc: einsum
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function eluGrad(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var dy = inputs.dy, y = inputs.y;
|
assertNotComplex([dy, y], 'eluGrad');
|
var resultValues = new Float32Array(tfjsCore.util.sizeFromShape(y.shape));
|
var values = backend.data.get(y.dataId).values;
|
var dyValues = backend.data.get(dy.dataId).values;
|
for (var i = 0; i < values.length; ++i) {
|
var v = values[i];
|
if (v >= 0) {
|
resultValues[i] = dyValues[i];
|
}
|
else {
|
resultValues[i] = dyValues[i] * (v + 1);
|
}
|
}
|
return backend.makeTensorInfo(y.shape, 'float32', resultValues);
|
}
|
var eluGradConfig = {
|
kernelName: tfjsCore.EluGrad,
|
backendName: 'cpu',
|
kernelFunc: eluGrad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var p = tfjsCore.backend_util.ERF_P;
|
var a1 = tfjsCore.backend_util.ERF_A1;
|
var a2 = tfjsCore.backend_util.ERF_A2;
|
var a3 = tfjsCore.backend_util.ERF_A3;
|
var a4 = tfjsCore.backend_util.ERF_A4;
|
var a5 = tfjsCore.backend_util.ERF_A5;
|
var erf = unaryKernelFunc(tfjsCore.Erf, function (xi) {
|
var sign = Math.sign(xi);
|
var v = Math.abs(xi);
|
var t = 1.0 / (1.0 + p * v);
|
return sign *
|
(1.0 -
|
(((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *
|
Math.exp(-v * v));
|
});
|
var erfConfig = {
|
kernelName: tfjsCore.Erf,
|
backendName: 'cpu',
|
kernelFunc: erf,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function expandDims(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var input = inputs.input;
|
var dim = attrs.dim;
|
var inputRank = input.shape.length;
|
var newShape = input.shape.slice();
|
var $dim = dim;
|
if (dim < 0) {
|
// Negative value is counted from the tail of rank.
|
tfjsCore.util.assert(-(inputRank + 1) <= dim, function () { return "Axis must be in the interval [".concat(-(inputRank + 1), ", ").concat(inputRank, "]"); });
|
$dim = inputRank + dim + 1;
|
}
|
newShape.splice($dim, 0, 1);
|
return reshape({ inputs: { x: input }, backend: backend, attrs: { shape: newShape } });
|
}
|
var expandDimsConfig = {
|
kernelName: tfjsCore.ExpandDims,
|
backendName: 'cpu',
|
kernelFunc: expandDims
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var realDivImpl = createSimpleBinaryKernelImpl(function (a, b) { return a / b; });
|
var div = binaryKernelFunc(tfjsCore.RealDiv, realDivImpl);
|
var realDivConfig = {
|
kernelName: tfjsCore.RealDiv,
|
backendName: 'cpu',
|
kernelFunc: div
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
/**
|
* Calculate FFT of inner most elements of batch tensor.
|
*/
|
function fftBatch(input, inverse, cpuBackend) {
|
var inputShape = input.shape;
|
var batch = inputShape[0];
|
var innerDim = inputShape[1];
|
var inputVals = cpuBackend.data.get(input.dataId);
|
var real2D = inputVals.complexTensorInfos.real;
|
var imag2D = inputVals.complexTensorInfos.imag;
|
// Collects real and imaginary values separately.
|
var resultShape = [batch, innerDim];
|
var resultSize = tfjsCore.util.sizeFromShape(resultShape);
|
var resultReal = tfjsCore.util.getTypedArrayFromDType('float32', resultSize);
|
var resultImag = tfjsCore.util.getTypedArrayFromDType('float32', resultSize);
|
for (var b = 0; b < batch; b++) {
|
// TODO: Support slice ops for complex type.
|
var r = slice({
|
inputs: { x: real2D },
|
backend: cpuBackend,
|
attrs: { begin: [b, 0], size: [1, innerDim] }
|
});
|
var i = slice({
|
inputs: { x: imag2D },
|
backend: cpuBackend,
|
attrs: { begin: [b, 0], size: [1, innerDim] }
|
});
|
var input_1 = complex({ inputs: { real: r, imag: i }, backend: cpuBackend });
|
// Run FFT by batch element.
|
var _a = fftImpl(input_1, inverse, cpuBackend), real_1 = _a.real, imag_1 = _a.imag;
|
var res = tfjsCore.backend_util.mergeRealAndImagArrays(real_1, imag_1);
|
for (var d = 0; d < innerDim; d++) {
|
var c = tfjsCore.backend_util.getComplexWithIndex(res, d);
|
resultReal[b * innerDim + d] = c.real;
|
resultImag[b * innerDim + d] = c.imag;
|
}
|
cpuBackend.disposeIntermediateTensorInfo(r);
|
cpuBackend.disposeIntermediateTensorInfo(i);
|
cpuBackend.disposeIntermediateTensorInfo(input_1);
|
}
|
var $realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultReal);
|
var $imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', resultImag);
|
var result = complex({ inputs: { real: $realInfo, imag: $imagInfo }, backend: cpuBackend });
|
cpuBackend.disposeIntermediateTensorInfo($realInfo);
|
cpuBackend.disposeIntermediateTensorInfo($imagInfo);
|
return result;
|
}
|
function fftImpl(input, inverse, cpuBackend) {
|
var inputSize = tfjsCore.util.sizeFromShape(input.shape);
|
var inputVals = cpuBackend.data.get(input.dataId);
|
var realVals = cpuBackend.data.get(inputVals.complexTensorInfos.real.dataId).values;
|
var imagVals = cpuBackend.data.get(inputVals.complexTensorInfos.imag.dataId).values;
|
if (isExponentOf2(inputSize)) {
|
var result = fftRadix2(realVals, imagVals, inputSize, inverse, cpuBackend);
|
var resultShape = [input.shape[0], input.shape[1]];
|
if (inverse) {
|
var realInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.real);
|
var imagInfo = cpuBackend.makeTensorInfo(resultShape, 'float32', result.imag);
|
var sizeInfo = cpuBackend.makeTensorInfo([], 'float32', tfjsCore.util.createScalarValue(inputSize, 'float32'));
|
var sizeInfoCopy = identity({ inputs: { x: sizeInfo }, backend: cpuBackend });
|
var divRealInfo = realDivConfig.kernelFunc({ inputs: { a: realInfo, b: sizeInfo }, backend: cpuBackend });
|
var divImagInfo = realDivConfig.kernelFunc({ inputs: { a: imagInfo, b: sizeInfoCopy }, backend: cpuBackend });
|
var divRealVals = cpuBackend.data.get(divRealInfo.dataId).values;
|
var divImagVals = cpuBackend.data.get(divImagInfo.dataId).values;
|
cpuBackend.disposeIntermediateTensorInfo(realInfo);
|
cpuBackend.disposeIntermediateTensorInfo(imagInfo);
|
cpuBackend.disposeIntermediateTensorInfo(sizeInfo);
|
cpuBackend.disposeIntermediateTensorInfo(sizeInfoCopy);
|
cpuBackend.disposeIntermediateTensorInfo(divRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo(divImagInfo);
|
return { real: divRealVals, imag: divImagVals };
|
}
|
return result;
|
}
|
else {
|
var data = tfjsCore.backend_util.mergeRealAndImagArrays(realVals, imagVals);
|
var rawOutput = fourierTransformByMatmul(data, inputSize, inverse);
|
return tfjsCore.backend_util.splitRealAndImagArrays(rawOutput);
|
}
|
}
|
function isExponentOf2(size) {
|
return (size & size - 1) === 0;
|
}
|
// FFT using Cooley-Tukey algorithm on radix 2 dimensional input.
|
function fftRadix2(realVals, imagVals, size, inverse, cpuBackend) {
|
if (size === 1) {
|
return { real: realVals, imag: imagVals };
|
}
|
var data = tfjsCore.backend_util.mergeRealAndImagArrays(realVals, imagVals);
|
var half = size / 2;
|
var evenComplex = tfjsCore.backend_util.complexWithEvenIndex(data);
|
var evenRealVals = evenComplex.real;
|
var evenImagVals = evenComplex.imag;
|
var evenShape = [evenRealVals.length];
|
var evenRealInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenRealVals);
|
var evenImagInfo = cpuBackend.makeTensorInfo(evenShape, 'float32', evenImagVals);
|
var evenTensorInfo = complex({ inputs: { real: evenRealInfo, imag: evenImagInfo }, backend: cpuBackend });
|
var oddComplex = tfjsCore.backend_util.complexWithOddIndex(data);
|
var oddRealVals = oddComplex.real;
|
var oddImagVals = oddComplex.imag;
|
var oddShape = [oddRealVals.length];
|
var oddRealInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddRealVals);
|
var oddImagInfo = cpuBackend.makeTensorInfo(oddShape, 'float32', oddImagVals);
|
var oddTensorInfo = complex({ inputs: { real: oddRealInfo, imag: oddImagInfo }, backend: cpuBackend });
|
// Recursive call for half part of original input.
|
var $evenComplex = fftRadix2(evenRealVals, evenImagVals, half, inverse, cpuBackend);
|
var $evenRealVals = $evenComplex.real;
|
var $evenImagVals = $evenComplex.imag;
|
var $evenShape = [$evenRealVals.length];
|
var $evenRealInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenRealVals);
|
var $evenImagInfo = cpuBackend.makeTensorInfo($evenShape, 'float32', $evenImagVals);
|
var $evenTensorInfo = complex({
|
inputs: { real: $evenRealInfo, imag: $evenImagInfo },
|
backend: cpuBackend
|
});
|
var $oddComplex = fftRadix2(oddRealVals, oddImagVals, half, inverse, cpuBackend);
|
var $oddRealVals = $oddComplex.real;
|
var $oddImagVals = $oddComplex.imag;
|
var $oddShape = [$oddRealVals.length];
|
var $oddRealInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddRealVals);
|
var $oddImagInfo = cpuBackend.makeTensorInfo($oddShape, 'float32', $oddImagVals);
|
var $oddTensorInfo = complex({ inputs: { real: $oddRealInfo, imag: $oddImagInfo }, backend: cpuBackend });
|
var e = tfjsCore.backend_util.exponents(size, inverse);
|
var eShape = [e.real.length];
|
var eRealInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.real);
|
var eImagInfo = cpuBackend.makeTensorInfo(eShape, 'float32', e.imag);
|
var complexInfo = complex({ inputs: { real: eRealInfo, imag: eImagInfo }, backend: cpuBackend });
|
var exponentInfo = multiply({ inputs: { a: complexInfo, b: $oddTensorInfo }, backend: cpuBackend });
|
var addPart = add({
|
inputs: { a: $evenTensorInfo, b: exponentInfo },
|
backend: cpuBackend
|
});
|
var subPart = sub({
|
inputs: { a: $evenTensorInfo, b: exponentInfo },
|
backend: cpuBackend
|
});
|
var addPartReal = real({ inputs: { input: addPart }, backend: cpuBackend });
|
var subPartReal = real({ inputs: { input: subPart }, backend: cpuBackend });
|
var addPartImag = imag({ inputs: { input: addPart }, backend: cpuBackend });
|
var subPartImag = imag({ inputs: { input: subPart }, backend: cpuBackend });
|
var $real = concat({
|
inputs: [addPartReal, subPartReal],
|
backend: cpuBackend,
|
attrs: { axis: 0 }
|
});
|
var $imag = concat({
|
inputs: [addPartImag, subPartImag],
|
backend: cpuBackend,
|
attrs: { axis: 0 }
|
});
|
var $realVals = cpuBackend.data.get($real.dataId).values;
|
var $imagVals = cpuBackend.data.get($imag.dataId).values;
|
cpuBackend.disposeIntermediateTensorInfo(evenRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo(evenImagInfo);
|
cpuBackend.disposeIntermediateTensorInfo(evenTensorInfo);
|
cpuBackend.disposeIntermediateTensorInfo(oddRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo(oddImagInfo);
|
cpuBackend.disposeIntermediateTensorInfo(oddTensorInfo);
|
cpuBackend.disposeIntermediateTensorInfo($evenRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo($evenImagInfo);
|
cpuBackend.disposeIntermediateTensorInfo($evenTensorInfo);
|
cpuBackend.disposeIntermediateTensorInfo($oddRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo($oddImagInfo);
|
cpuBackend.disposeIntermediateTensorInfo($oddTensorInfo);
|
cpuBackend.disposeIntermediateTensorInfo(eRealInfo);
|
cpuBackend.disposeIntermediateTensorInfo(eImagInfo);
|
cpuBackend.disposeIntermediateTensorInfo(complexInfo);
|
cpuBackend.disposeIntermediateTensorInfo(exponentInfo);
|
cpuBackend.disposeIntermediateTensorInfo(addPart);
|
cpuBackend.disposeIntermediateTensorInfo(subPart);
|
cpuBackend.disposeIntermediateTensorInfo(addPartReal);
|
cpuBackend.disposeIntermediateTensorInfo(addPartImag);
|
cpuBackend.disposeIntermediateTensorInfo(subPartReal);
|
cpuBackend.disposeIntermediateTensorInfo(subPartImag);
|
cpuBackend.disposeIntermediateTensorInfo($real);
|
cpuBackend.disposeIntermediateTensorInfo($imag);
|
return { real: $realVals, imag: $imagVals };
|
}
|
// Calculate fourier transform by multplying sinusoid matrix.
|
function fourierTransformByMatmul(data, size, inverse) {
|
var ret = new Float32Array(size * 2);
|
// TODO: Use matmul instead once it supports complex64 type.
|
for (var r = 0; r < size; r++) {
|
var real_2 = 0.0;
|
var imag_2 = 0.0;
|
for (var c = 0; c < size; c++) {
|
var e = tfjsCore.backend_util.exponent(r * c, size, inverse);
|
var term = tfjsCore.backend_util.getComplexWithIndex(data, c);
|
real_2 += term.real * e.real - term.imag * e.imag;
|
imag_2 += term.real * e.imag + term.imag * e.real;
|
}
|
if (inverse) {
|
real_2 /= size;
|
imag_2 /= size;
|
}
|
tfjsCore.backend_util.assignToTypedArray(ret, real_2, imag_2, r);
|
}
|
return ret;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function fft(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var input = inputs.input;
|
var inputSize = tfjsCore.util.sizeFromShape(input.shape);
|
// Collapse all outer dimensions to a single batch dimension.
|
var innerDimensionSize = input.shape[input.shape.length - 1];
|
var batch = inputSize / innerDimensionSize;
|
var input2D = reshape({
|
inputs: { x: input },
|
backend: backend,
|
attrs: { shape: [batch, innerDimensionSize] }
|
});
|
var result = fftBatch(input2D, false, backend);
|
var resultReshaped = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: input.shape } });
|
backend.disposeIntermediateTensorInfo(input2D);
|
backend.disposeIntermediateTensorInfo(result);
|
return resultReshaped;
|
}
|
var fftConfig = {
|
kernelName: tfjsCore.FFT,
|
backendName: 'cpu',
|
kernelFunc: fft
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function fill(args) {
|
var backend = args.backend, attrs = args.attrs;
|
var shape = attrs.shape, value = attrs.value, dtype = attrs.dtype;
|
var $dtype = dtype || tfjsCore.util.inferDtype(value);
|
var values = tfjsCore.util.getArrayFromDType($dtype, tfjsCore.util.sizeFromShape(shape));
|
fillValues(values, value, $dtype);
|
return backend.makeTensorInfo(shape, $dtype, values);
|
}
|
var fillConfig = {
|
kernelName: tfjsCore.Fill,
|
backendName: 'cpu',
|
kernelFunc: fill
|
};
|
function fillValues(values, value, dtype) {
|
if (dtype === 'string') {
|
values.fill(value);
|
}
|
else {
|
values.fill(value);
|
}
|
}
|
|
var flipLeftRightConfig = {
|
kernelName: tfjsCore.FlipLeftRight,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs; _a.attrs; var backend = _a.backend;
|
var image = inputs.image;
|
var cpuBackend = backend;
|
var output = tfjsCore.util.getTypedArrayFromDType(image.dtype, tfjsCore.util.sizeFromShape(image.shape));
|
var _b = __read(image.shape, 4), batch = _b[0], imageHeight = _b[1], imageWidth = _b[2], numChannels = _b[3];
|
var imageVals = cpuBackend.data.get(image.dataId).values;
|
for (var batchIdx = 0; batchIdx < batch; batchIdx++) {
|
var batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
|
for (var row = 0; row < imageHeight; row++) {
|
var rowOffset = row * (imageWidth * numChannels);
|
for (var col = 0; col < imageWidth; col++) {
|
var colOffset = col * numChannels;
|
for (var channel = 0; channel < numChannels; channel++) {
|
var coordX = Math.round(imageWidth - col - 1);
|
var outIdx = batchOffset + rowOffset + colOffset + channel;
|
var outputValue = imageVals[outIdx];
|
// If the coordinate position falls within the image boundaries...
|
if (coordX >= 0 && coordX < imageWidth) {
|
// set the output to the image value at the coordinate position.
|
var rotatedColOffset = coordX * numChannels;
|
var imageIdx = batchOffset + rowOffset + rotatedColOffset + channel;
|
outputValue = imageVals[imageIdx];
|
}
|
output[outIdx] = outputValue;
|
}
|
}
|
}
|
}
|
var dataId = cpuBackend.write(output, image.shape, image.dtype);
|
return { dataId: dataId, shape: image.shape, dtype: image.dtype };
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function fusedConv2D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, filter = inputs.filter, bias = inputs.bias, preluActivationWeights = inputs.preluActivationWeights;
|
var strides = attrs.strides, pad = attrs.pad, dataFormat = attrs.dataFormat, dilations = attrs.dilations, dimRoundingMode = attrs.dimRoundingMode, activation = attrs.activation, leakyreluAlpha = attrs.leakyreluAlpha;
|
var result = conv2D({
|
inputs: { x: x, filter: filter },
|
backend: backend,
|
attrs: { strides: strides, pad: pad, dataFormat: dataFormat, dilations: dilations, dimRoundingMode: dimRoundingMode }
|
});
|
if (bias) {
|
var resultOld = result;
|
// For NCHW format, if bias is a 1-D tensor, it is supposed to be aligned
|
// to the channel of the conv2d's result; if the bias is a scalar, the
|
// bias_add is computed as if the bias was broadcasted to the shape of the
|
// conv2d's result.
|
if (dataFormat === 'NCHW' && bias.shape.length === 1 &&
|
bias.shape[0] !== 1) {
|
var reshapedBias = reshape({ inputs: { x: bias }, backend: backend, attrs: { shape: [bias.shape[0], 1, 1] } });
|
result =
|
add({ inputs: { a: result, b: reshapedBias }, backend: backend });
|
backend.disposeIntermediateTensorInfo(reshapedBias);
|
}
|
else {
|
// This condition handles NHWC and NCHW (scalar case). The only other case
|
// for NCHW (1D case) is handled above.
|
result = add({ inputs: { a: result, b: bias }, backend: backend });
|
}
|
backend.disposeIntermediateTensorInfo(resultOld);
|
}
|
if (activation) {
|
var resultOld = result;
|
// For NCHW format, if PReLu activation weights is a 1-D tensor, it is
|
// supposed to be aligned with the channel of the conv2d's result. For other
|
// cases, whether NCHW or NHWC data format, the conv2d result is
|
// already aligned with the activation weights.
|
if (dataFormat === 'NCHW' && activation === 'prelu' &&
|
preluActivationWeights.shape.length === 1 &&
|
preluActivationWeights.shape[0] !== 1) {
|
var reshapedAlpha = reshape({
|
inputs: { x: preluActivationWeights },
|
backend: backend,
|
attrs: { shape: [preluActivationWeights.shape[0], 1, 1] }
|
});
|
result = applyActivation(backend, result, activation, reshapedAlpha, leakyreluAlpha);
|
backend.disposeIntermediateTensorInfo(reshapedAlpha);
|
}
|
else {
|
result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
|
}
|
backend.disposeIntermediateTensorInfo(resultOld);
|
}
|
return result;
|
}
|
var fusedConv2DConfig = {
|
kernelName: tfjsCore.FusedConv2D,
|
backendName: 'cpu',
|
kernelFunc: fusedConv2D
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function fusedDepthwiseConv2D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, filter = inputs.filter, bias = inputs.bias, preluActivationWeights = inputs.preluActivationWeights;
|
var strides = attrs.strides, pad = attrs.pad, dataFormat = attrs.dataFormat, dilations = attrs.dilations, dimRoundingMode = attrs.dimRoundingMode, activation = attrs.activation, leakyreluAlpha = attrs.leakyreluAlpha;
|
var result = depthwiseConv2dNative({
|
inputs: { x: x, filter: filter },
|
backend: backend,
|
attrs: { strides: strides, pad: pad, dataFormat: dataFormat, dilations: dilations, dimRoundingMode: dimRoundingMode }
|
});
|
if (bias) {
|
var oldResult = result;
|
result = add({ inputs: { a: result, b: bias }, backend: backend });
|
backend.disposeIntermediateTensorInfo(oldResult);
|
}
|
if (activation) {
|
var oldResult = result;
|
result = applyActivation(backend, result, activation, preluActivationWeights, leakyreluAlpha);
|
backend.disposeIntermediateTensorInfo(oldResult);
|
}
|
return result;
|
}
|
var fusedDepthwiseConv2DConfig = {
|
kernelName: tfjsCore.FusedDepthwiseConv2D,
|
backendName: 'cpu',
|
kernelFunc: fusedDepthwiseConv2D
|
};
|
|
function gatherNd(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var params = inputs.params, indices = inputs.indices;
|
var paramsSize = tfjsCore.util.sizeFromShape(params.shape);
|
var indicesShape = indices.shape;
|
var sliceRank = indicesShape[indicesShape.length - 1];
|
var _a = __read(tfjsCore.backend_util.prepareAndValidate(params, indices), 4), resultShape = _a[0], numSlices = _a[1], sliceSize = _a[2], strides = _a[3];
|
if (numSlices === 0) {
|
return backend.makeTensorInfo(resultShape, params.dtype, []);
|
}
|
var indicesData = backend.data.get(indices.dataId).values;
|
var paramsBuf = backend.bufferSync(params);
|
var outBuf = gatherNdImpl(indicesData, paramsBuf, params.dtype, numSlices, sliceRank, sliceSize, strides, params.shape, paramsSize);
|
return backend.makeTensorInfo(resultShape, params.dtype, outBuf.values);
|
}
|
var gatherNdConfig = {
|
kernelName: tfjsCore.GatherNd,
|
backendName: 'cpu',
|
kernelFunc: gatherNd
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function gatherV2(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, indices = inputs.indices;
|
var axis = attrs.axis, batchDims = attrs.batchDims;
|
assertNotComplex([x, indices], 'gatherV2');
|
// Throw error when any index is out of bound.
|
var parsedAxis = tfjsCore.util.parseAxisParam(axis, x.shape)[0];
|
var indicesVals = backend.data.get(indices.dataId).values;
|
var axisDim = x.shape[parsedAxis];
|
var _loop_1 = function (i) {
|
var index = indicesVals[i];
|
tfjsCore.util.assert(index <= axisDim - 1 && index >= 0, function () { return "GatherV2: the index value ".concat(index, " is not in [0, ").concat(axisDim - 1, "]"); });
|
};
|
for (var i = 0; i < indicesVals.length; ++i) {
|
_loop_1(i);
|
}
|
var $batchDims = batchDims;
|
if (batchDims == null) {
|
$batchDims = 0;
|
}
|
var indicesSize = tfjsCore.util.sizeFromShape(indices.shape);
|
var shapeInfo = tfjsCore.backend_util.segment_util.collectGatherOpShapeInfo(x, indices, parsedAxis, $batchDims);
|
var flattenX = reshape({
|
inputs: { x: x },
|
backend: backend,
|
attrs: {
|
shape: [
|
shapeInfo.batchSize, shapeInfo.outerSize, shapeInfo.dimSize,
|
shapeInfo.sliceSize
|
]
|
}
|
});
|
var flattenIndex = reshape({
|
inputs: { x: indices },
|
backend: backend,
|
attrs: { shape: [shapeInfo.batchSize, indicesSize / shapeInfo.batchSize] }
|
});
|
var flattenOutputShape = [
|
shapeInfo.batchSize, shapeInfo.outerSize, indicesSize / shapeInfo.batchSize,
|
shapeInfo.sliceSize
|
];
|
var indicesBuf = backend.bufferSync(flattenIndex);
|
var xBuf = backend.bufferSync(flattenX);
|
var outBuf = gatherV2Impl(xBuf, indicesBuf, flattenOutputShape);
|
backend.disposeIntermediateTensorInfo(flattenX);
|
backend.disposeIntermediateTensorInfo(flattenIndex);
|
return backend.makeTensorInfo(shapeInfo.outputShape, outBuf.dtype, outBuf.values);
|
}
|
var gatherV2Config = {
|
kernelName: tfjsCore.GatherV2,
|
backendName: 'cpu',
|
kernelFunc: gatherV2
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function ifft(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var input = inputs.input;
|
var inputSize = tfjsCore.util.sizeFromShape(input.shape);
|
// Collapse all outer dimensions to a single batch dimension.
|
var innerDimensionSize = input.shape[input.shape.length - 1];
|
var batch = inputSize / innerDimensionSize;
|
var input2D = reshape({
|
inputs: { x: input },
|
backend: backend,
|
attrs: { shape: [batch, innerDimensionSize] }
|
});
|
var result = fftBatch(input2D, true, backend);
|
var resultReshaped = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: input.shape } });
|
backend.disposeIntermediateTensorInfo(input2D);
|
backend.disposeIntermediateTensorInfo(result);
|
return resultReshaped;
|
}
|
var ifftConfig = {
|
kernelName: tfjsCore.IFFT,
|
backendName: 'cpu',
|
kernelFunc: ifft
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var isFinite = unaryKernelFunc(tfjsCore.IsFinite, function (xi) { return Number.isFinite(xi) ? 1 : 0; }, 'bool');
|
var isFiniteConfig = {
|
kernelName: tfjsCore.IsFinite,
|
backendName: 'cpu',
|
kernelFunc: isFinite,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var isInf = unaryKernelFunc(tfjsCore.IsInf, function (xi) { return Math.abs(xi) === Infinity ? 1 : 0; }, 'bool');
|
var isInfConfig = {
|
kernelName: tfjsCore.IsInf,
|
backendName: 'cpu',
|
kernelFunc: isInf,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var isNaN$1 = unaryKernelFunc(tfjsCore.IsNan, function (xi) { return Number.isNaN(xi) ? 1 : 0; }, 'bool');
|
var isNaNConfig = {
|
kernelName: tfjsCore.IsNan,
|
backendName: 'cpu',
|
kernelFunc: isNaN$1,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function linSpace(args) {
|
var backend = args.backend, attrs = args.attrs;
|
var start = attrs.start, stop = attrs.stop, num = attrs.num;
|
var outVals = linSpaceImpl(start, stop, num);
|
return backend.makeTensorInfo([outVals.length], 'float32', outVals);
|
}
|
var linSpaceConfig = {
|
kernelName: tfjsCore.LinSpace,
|
backendName: 'cpu',
|
kernelFunc: linSpace
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var log1p = unaryKernelFunc(tfjsCore.Log1p, function (xi) { return Math.log1p(xi); });
|
var log1pConfig = {
|
kernelName: tfjsCore.Log1p,
|
backendName: 'cpu',
|
kernelFunc: log1p,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var logicalAndImpl = createSimpleBinaryKernelImpl(function (a, b) { return a && b; });
|
var logicalAnd = binaryKernelFunc(tfjsCore.LogicalAnd, logicalAndImpl, null /* complexImpl */, 'bool');
|
var logicalAndConfig = {
|
kernelName: tfjsCore.LogicalAnd,
|
backendName: 'cpu',
|
kernelFunc: logicalAnd
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var logicalNot = unaryKernelFunc(tfjsCore.LogicalNot, function (xi) { return xi ? 0 : 1; }, 'bool');
|
var logicalNotConfig = {
|
kernelName: tfjsCore.LogicalNot,
|
backendName: 'cpu',
|
kernelFunc: logicalNot,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var logicalOrImpl = createSimpleBinaryKernelImpl(function (a, b) { return a || b; });
|
var logicalOr = binaryKernelFunc(tfjsCore.LogicalOr, logicalOrImpl, null /* complexImpl */, 'bool');
|
var logicalOrConfig = {
|
kernelName: tfjsCore.LogicalOr,
|
backendName: 'cpu',
|
kernelFunc: logicalOr
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function lRN(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var depthRadius = attrs.depthRadius, bias = attrs.bias, alpha = attrs.alpha, beta = attrs.beta;
|
assertNotComplex(x, 'LRN');
|
var channels = x.shape[3];
|
var maxD = channels - 1;
|
var xValues = backend.data.get(x.dataId).values;
|
var size = tfjsCore.util.sizeFromShape(x.shape);
|
var result = new Float32Array(size);
|
function sumAcrossChannels(offset) {
|
var currentChannel = offset % channels;
|
var beginSumOffset = offset - currentChannel + Math.max(0, currentChannel - depthRadius);
|
var endSumOffset = offset - currentChannel + Math.min(currentChannel + depthRadius, maxD);
|
var sum = 0.0;
|
for (; beginSumOffset <= endSumOffset; beginSumOffset++) {
|
var z = xValues[beginSumOffset];
|
sum += z * z;
|
}
|
return sum;
|
}
|
for (var offset = 0; offset < size; offset++) {
|
var sum = sumAcrossChannels(offset);
|
var val = xValues[offset] * Math.pow(bias + alpha * sum, -beta);
|
result[offset] = val;
|
}
|
return backend.makeTensorInfo(x.shape, x.dtype, result);
|
}
|
// tslint:disable-next-line: variable-name
|
var LRNConfig = {
|
kernelName: tfjsCore.LRN,
|
backendName: 'cpu',
|
kernelFunc: lRN
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function lRNGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, y = inputs.y, dy = inputs.dy;
|
var depthRadius = attrs.depthRadius, bias = attrs.bias, alpha = attrs.alpha, beta = attrs.beta;
|
assertNotComplex(dy, 'LRNGrad');
|
var dySize = tfjsCore.util.sizeFromShape(dy.shape);
|
var channels = dy.shape[3];
|
var dyValues = backend.data.get(dy.dataId).values;
|
var xValues = backend.data.get(x.dataId).values;
|
var yValues = backend.data.get(y.dataId).values;
|
var result = new Float32Array(dySize);
|
var size = dySize;
|
for (var offset = 0; offset < size; offset++) {
|
var currentChannel = offset % channels;
|
var depthBegin = (offset - currentChannel) + Math.max(0, currentChannel - depthRadius);
|
var depthEnd = (offset - currentChannel) +
|
Math.min(channels, currentChannel + depthRadius + 1);
|
var norm = 0;
|
for (var k = depthBegin; k < depthEnd; k++) {
|
norm += Math.pow(xValues[k], 2);
|
}
|
norm = alpha * norm + bias;
|
for (var k = depthBegin; k < depthEnd; k++) {
|
var dyi = -2 * alpha * beta * xValues[k] * yValues[offset] / norm;
|
if (offset === k) {
|
dyi += Math.pow(norm, -beta);
|
}
|
dyi *= dyValues[offset];
|
result[k] += dyi;
|
}
|
}
|
return backend.makeTensorInfo(dy.shape, x.dtype, result);
|
}
|
// tslint:disable-next-line: variable-name
|
var LRNGradConfig = {
|
kernelName: tfjsCore.LRNGrad,
|
backendName: 'cpu',
|
kernelFunc: lRNGrad
|
};
|
|
function max(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var reductionIndices = attrs.reductionIndices, keepDims = attrs.keepDims;
|
var cpuBackend = backend;
|
var xShape = x.shape;
|
var xRank = xShape.length;
|
var origAxes = tfjsCore.util.parseAxisParam(reductionIndices, xShape);
|
var axes = origAxes;
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, xRank);
|
var xVals = cpuBackend.data.get(x.dataId).values;
|
if (permutedAxes != null) {
|
var newShape = new Array(xRank);
|
for (var i = 0; i < newShape.length; i++) {
|
newShape[i] = xShape[permutedAxes[i]];
|
}
|
xVals = transposeImpl(xVals, xShape, x.dtype, permutedAxes, newShape);
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, xRank);
|
xShape = newShape;
|
}
|
assertNotComplex(x, 'max');
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('max', axes, xRank);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes(xShape, axes), 2), maxOutShape = _a[0], reduceShape = _a[1];
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var result = maxImpl(xVals, reduceSize, maxOutShape, x.dtype);
|
var dataId = cpuBackend.write(result, maxOutShape, x.dtype);
|
var outShape = maxOutShape;
|
if (keepDims) {
|
// reshape
|
var newShape = tfjsCore.backend_util.expandShapeToKeepDim(maxOutShape, origAxes);
|
outShape = newShape;
|
}
|
return { dataId: dataId, shape: outShape, dtype: x.dtype };
|
}
|
var maxConfig = {
|
kernelName: tfjsCore.Max,
|
backendName: 'cpu',
|
kernelFunc: max
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxPool(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
assertNotComplex(x, 'maxPool');
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode;
|
var dilations = 1;
|
tfjsCore.util.assert(tfjsCore.backend_util.eitherStridesOrDilationsAreOne(strides, dilations), function () { return 'Error in maxPool: Either strides or dilations must be 1. ' +
|
"Got strides ".concat(strides, " and dilations '").concat(dilations, "'"); });
|
var convInfo = tfjsCore.backend_util.computePool2DInfo(x.shape, filterSize, strides, dilations, pad, dimRoundingMode);
|
var res;
|
if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 &&
|
tfjsCore.util.arraysEqual(convInfo.inShape, convInfo.outShape)) {
|
res = identity({ inputs: { x: x }, backend: backend });
|
}
|
else {
|
var xValues = backend.data.get(x.dataId).values;
|
var strides_1 = tfjsCore.util.computeStrides(x.shape);
|
var buffer = pool(xValues, x.shape, x.dtype, strides_1, convInfo, 'max');
|
res = backend.makeTensorInfo(convInfo.outShape, x.dtype, buffer.values);
|
}
|
return res;
|
}
|
var maxPoolConfig = {
|
kernelName: tfjsCore.MaxPool,
|
backendName: 'cpu',
|
kernelFunc: maxPool
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxPool3D(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode, dataFormat = attrs.dataFormat;
|
assertNotComplex(x, 'maxPool3d');
|
var convInfo = tfjsCore.backend_util.computePool3DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode, dataFormat);
|
var xValues = backend.data.get(x.dataId).values;
|
var outBuf = pool3d(xValues, x.shape, x.dtype, tfjsCore.util.computeStrides(x.shape), convInfo, 'max');
|
return backend.makeTensorInfo(outBuf.shape, 'float32', outBuf.values);
|
}
|
var maxPool3DConfig = {
|
kernelName: tfjsCore.MaxPool3D,
|
backendName: 'cpu',
|
kernelFunc: maxPool3D
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxPool3DGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, input = inputs.input;
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode;
|
assertNotComplex([dy, input], 'maxPool3DGrad');
|
var convInfo = tfjsCore.backend_util.computePool3DInfo(input.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
|
var inputBuf = backend.bufferSync(input);
|
var maxPosBuf = maxPool3dPositions(inputBuf, convInfo);
|
var strideDepth = convInfo.strideDepth;
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationDepth = convInfo.dilationDepth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterDepth = convInfo.effectiveFilterDepth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padFront = effectiveFilterDepth - 1 - convInfo.padInfo.front;
|
var padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
|
var padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
|
var dx = tfjsCore.buffer(input.shape, 'float32');
|
var dyBuf = backend.bufferSync(dy);
|
for (var batch = 0; batch < convInfo.batchSize; ++batch) {
|
for (var channel = 0; channel < convInfo.inChannels; ++channel) {
|
for (var dxDepth = 0; dxDepth < convInfo.inDepth; ++dxDepth) {
|
for (var dxRow = 0; dxRow < convInfo.inHeight; ++dxRow) {
|
for (var dxCol = 0; dxCol < convInfo.inWidth; ++dxCol) {
|
// Shader code begins
|
var dyDepthCorner = dxDepth - padFront;
|
var dyRowCorner = dxRow - padTop;
|
var dyColCorner = dxCol - padLeft;
|
var dotProd = 0;
|
for (var wDepth = 0; wDepth < effectiveFilterDepth; wDepth += dilationDepth) {
|
var dyDepth = (dyDepthCorner + wDepth) / strideDepth;
|
if (dyDepth < 0 || dyDepth >= convInfo.outDepth ||
|
Math.floor(dyDepth) !== dyDepth) {
|
continue;
|
}
|
for (var wRow = 0; wRow < effectiveFilterHeight; wRow += dilationHeight) {
|
var dyRow = (dyRowCorner + wRow) / strideHeight;
|
if (dyRow < 0 || dyRow >= convInfo.outHeight ||
|
Math.floor(dyRow) !== dyRow) {
|
continue;
|
}
|
for (var wCol = 0; wCol < effectiveFilterWidth; wCol += dilationWidth) {
|
var dyCol = (dyColCorner + wCol) / strideWidth;
|
if (dyCol < 0 || dyCol >= convInfo.outWidth ||
|
Math.floor(dyCol) !== dyCol) {
|
continue;
|
}
|
var maxPos = effectiveFilterDepth * effectiveFilterHeight *
|
effectiveFilterWidth -
|
1 -
|
maxPosBuf.get(batch, dyDepth, dyRow, dyCol, channel);
|
var curPos = wDepth * effectiveFilterHeight * effectiveFilterWidth +
|
wRow * effectiveFilterWidth + wCol;
|
var mask = maxPos === curPos ? 1 : 0;
|
if (mask === 0) {
|
continue;
|
}
|
var pixel = dyBuf.get(batch, dyDepth, dyRow, dyCol, channel);
|
dotProd += pixel * mask;
|
}
|
}
|
}
|
dx.set(dotProd, batch, dxDepth, dxRow, dxCol, channel);
|
}
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var maxPool3DGradConfig = {
|
kernelName: tfjsCore.MaxPool3DGrad,
|
backendName: 'cpu',
|
kernelFunc: maxPool3DGrad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxPoolGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var dy = inputs.dy, input = inputs.input, output = inputs.output;
|
var x = input;
|
assertNotComplex([input, output], 'maxPoolGrad');
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, dimRoundingMode = attrs.dimRoundingMode;
|
var convInfo = tfjsCore.backend_util.computePool2DInfo(x.shape, filterSize, strides, 1 /* dilations */, pad, dimRoundingMode);
|
var xValues = backend.data.get(x.dataId).values;
|
var maxPosBuf = tfjsCore.buffer(convInfo.outShape, x.dtype, maxPoolPositions(xValues, x.shape, x.dtype, convInfo).values);
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var dilationHeight = convInfo.dilationHeight;
|
var dilationWidth = convInfo.dilationWidth;
|
var effectiveFilterHeight = convInfo.effectiveFilterHeight;
|
var effectiveFilterWidth = convInfo.effectiveFilterWidth;
|
var padLeft = effectiveFilterWidth - 1 - convInfo.padInfo.left;
|
var padTop = effectiveFilterHeight - 1 - convInfo.padInfo.top;
|
var dx = tfjsCore.buffer(x.shape, 'float32');
|
var dyData = backend.data.get(dy.dataId).values;
|
var dyBuf = tfjsCore.buffer(dy.shape, 'float32', dyData);
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
for (var d = 0; d < convInfo.inChannels; ++d) {
|
for (var dxR = 0; dxR < convInfo.inHeight; ++dxR) {
|
for (var dxC = 0; dxC < convInfo.inWidth; ++dxC) {
|
// Shader code begins.
|
var dyRCorner = dxR - padTop;
|
var dyCCorner = dxC - padLeft;
|
var dotProd = 0;
|
for (var wR = 0; wR < effectiveFilterHeight; wR += dilationHeight) {
|
var dyR = (dyRCorner + wR) / strideHeight;
|
if (dyR < 0 || dyR >= convInfo.outHeight ||
|
Math.floor(dyR) !== dyR) {
|
continue;
|
}
|
for (var wC = 0; wC < effectiveFilterWidth; wC += dilationWidth) {
|
var dyC = (dyCCorner + wC) / strideWidth;
|
if (dyC < 0 || dyC >= convInfo.outWidth ||
|
Math.floor(dyC) !== dyC) {
|
continue;
|
}
|
var maxPos = effectiveFilterHeight * effectiveFilterWidth - 1 -
|
maxPosBuf.get(b, dyR, dyC, d);
|
var curPos = wR * effectiveFilterWidth + wC;
|
var mask = maxPos === curPos ? 1 : 0;
|
if (mask === 0) {
|
continue;
|
}
|
var pixel = dyBuf.get(b, dyR, dyC, d);
|
dotProd += pixel * mask;
|
}
|
}
|
dx.set(dotProd, b, dxR, dxC, d);
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);
|
}
|
var maxPoolGradConfig = {
|
kernelName: tfjsCore.MaxPoolGrad,
|
backendName: 'cpu',
|
kernelFunc: maxPoolGrad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function maxPoolWithArgmaxImpl(xValues, xShape, dtype, includeBatchInIndex, convInfo) {
|
var strides = tfjsCore.util.computeStrides(xShape);
|
var maxPools = pool(xValues, xShape, dtype, strides, convInfo, 'max');
|
var maxPositions = maxPoolPositions(xValues, xShape, dtype, convInfo, true, includeBatchInIndex);
|
return [maxPools.values, maxPositions.values];
|
}
|
|
var maxPoolWithArgmaxConfig = {
|
kernelName: tfjsCore.MaxPoolWithArgmax,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, attrs = _a.attrs, backend = _a.backend;
|
var x = inputs.x;
|
var filterSize = attrs.filterSize, strides = attrs.strides, pad = attrs.pad, includeBatchInIndex = attrs.includeBatchInIndex;
|
var cpuBackend = backend;
|
assertNotComplex(x, 'MaxPoolWithArgmax');
|
var values = cpuBackend.data.get(x.dataId).values;
|
var convInfo = tfjsCore.backend_util.computePool2DInfo(x.shape, filterSize, strides, [1, 1], pad);
|
var _b = __read(maxPoolWithArgmaxImpl(values, x.shape, x.dtype, includeBatchInIndex, convInfo), 2), pooled = _b[0], indexes = _b[1];
|
var pooledDataId = cpuBackend.write(pooled, convInfo.outShape, x.dtype);
|
var indexesDataId = cpuBackend.write(indexes, convInfo.outShape, x.dtype);
|
return [
|
{ dataId: pooledDataId, shape: convInfo.outShape, dtype: x.dtype },
|
{ dataId: indexesDataId, shape: convInfo.outShape, dtype: 'int32' }
|
];
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function mean(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
var axes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var shapes = tfjsCore.backend_util.computeOutAndReduceShapes(x.shape, axes);
|
var reduceShape = shapes[1];
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var toDispose = [];
|
var reduceSizeScalar = backend.makeTensorInfo([], 'float32', new Float32Array([reduceSize]));
|
toDispose.push(reduceSizeScalar);
|
var $x = cast({ inputs: { x: x }, backend: backend, attrs: { dtype: 'float32' } });
|
toDispose.push($x);
|
var res = div({ inputs: { a: $x, b: reduceSizeScalar }, backend: backend });
|
toDispose.push(res);
|
var result = sum({ inputs: { x: res }, backend: backend, attrs: { axis: axis, keepDims: keepDims } });
|
toDispose.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return result;
|
}
|
var meanConfig = {
|
kernelName: tfjsCore.Mean,
|
backendName: 'cpu',
|
kernelFunc: mean
|
};
|
|
function min(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var axis = attrs.axis, keepDims = attrs.keepDims;
|
assertNotComplex(x, 'min');
|
var origAxes = tfjsCore.util.parseAxisParam(axis, x.shape);
|
var axes = origAxes;
|
var permutedAxes = tfjsCore.backend_util.getAxesPermutation(axes, x.shape.length);
|
var $x = x;
|
if (permutedAxes != null) {
|
$x = transpose({ inputs: { x: x }, backend: backend, attrs: { perm: permutedAxes } });
|
axes = tfjsCore.backend_util.getInnerMostAxes(axes.length, x.shape.length);
|
}
|
tfjsCore.backend_util.assertAxesAreInnerMostDims('min', axes, $x.shape.length);
|
var _a = __read(tfjsCore.backend_util.computeOutAndReduceShapes($x.shape, axes), 2), outShape = _a[0], reduceShape = _a[1];
|
var reduceSize = tfjsCore.util.sizeFromShape(reduceShape);
|
var vals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(outShape), $x.dtype);
|
var aVals = backend.data.get($x.dataId).values;
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var min_1 = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
if (Number.isNaN(value) ||
|
value < min_1) { // comparison with NaN always return false
|
min_1 = value;
|
}
|
}
|
vals[i] = min_1;
|
}
|
if (permutedAxes != null) {
|
backend.disposeIntermediateTensorInfo($x);
|
}
|
var result = backend.makeTensorInfo(outShape, $x.dtype, vals);
|
if (keepDims) {
|
var expandedShape = tfjsCore.backend_util.expandShapeToKeepDim(outShape, origAxes);
|
var reshapedResult = reshape({ inputs: { x: result }, backend: backend, attrs: { shape: expandedShape } });
|
backend.disposeIntermediateTensorInfo(result);
|
return reshapedResult;
|
}
|
return result;
|
}
|
var minConfig = {
|
kernelName: tfjsCore.Min,
|
backendName: 'cpu',
|
kernelFunc: min
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function mirrorPad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var paddings = attrs.paddings, mode = attrs.mode;
|
assertNotComplex(x, 'mirrorPad');
|
var outShape = paddings.map(function (p, i) { return p[0] /* beforePad */ + x.shape[i] + p[1]; } /* afterPad */);
|
var start = paddings.map(function (p) { return p[0]; });
|
var end = paddings.map(function (p, i) { return p[0] + x.shape[i]; });
|
var offset = mode === 'reflect' ? 0 : 1;
|
var xVals = backend.data.get(x.dataId).values;
|
var xRank = x.shape.length;
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var resultSize = tfjsCore.util.sizeFromShape(outShape);
|
var resultRank = outShape.length;
|
var resultStrides = tfjsCore.util.computeStrides(outShape);
|
var resVals = tfjsCore.util.getTypedArrayFromDType(x.dtype, resultSize);
|
for (var i = 0; i < resultSize; i++) {
|
var coords = tfjsCore.util.indexToLoc(i, resultRank, resultStrides);
|
for (var i_1 = 0; i_1 < resultRank; i_1++) {
|
if (coords[i_1] < start[i_1]) {
|
coords[i_1] = start[i_1] * 2 - coords[i_1] - offset;
|
}
|
else if (coords[i_1] >= end[i_1]) {
|
coords[i_1] = (end[i_1] - 1) * 2 - coords[i_1] + offset;
|
}
|
}
|
coords = coords.map(function (c, i) { return c - start[i]; });
|
var inIndex = tfjsCore.util.locToIndex(coords, xRank, xStrides);
|
resVals[i] = xVals[inIndex];
|
}
|
var outId = backend.write(resVals, outShape, x.dtype);
|
return { dataId: outId, shape: outShape, dtype: x.dtype };
|
}
|
var mirrorPadConfig = {
|
kernelName: tfjsCore.MirrorPad,
|
backendName: 'cpu',
|
kernelFunc: mirrorPad
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var modImpl = createSimpleBinaryKernelImpl((function (aValue, bValue) {
|
var rem = aValue % bValue;
|
if ((aValue < 0 && bValue < 0) || (aValue >= 0 && bValue >= 0)) {
|
return rem;
|
}
|
else {
|
return (rem + bValue) % bValue;
|
}
|
}));
|
var mod = binaryKernelFunc(tfjsCore.Mod, modImpl);
|
var modConfig = {
|
kernelName: tfjsCore.Mod,
|
backendName: 'cpu',
|
kernelFunc: mod
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function softmax(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var logits = inputs.logits;
|
var dim = attrs.dim;
|
var logitsRank = logits.shape.length;
|
var $dim = dim;
|
if ($dim === -1) {
|
$dim = logitsRank - 1;
|
}
|
if ($dim !== logitsRank - 1) {
|
throw Error('Softmax along a non-last dimension is not yet supported. ' +
|
"Logits was rank ".concat(logitsRank, " and dim was ").concat($dim));
|
}
|
var axes = tfjsCore.util.parseAxisParam([$dim], logits.shape);
|
var maxLogit = max({
|
inputs: { x: logits },
|
backend: backend,
|
attrs: { reductionIndices: axes, keepDims: false }
|
});
|
var expandedShape = tfjsCore.backend_util.expandShapeToKeepDim(maxLogit.shape, axes);
|
var maxLogitReshaped = reshape({ inputs: { x: maxLogit }, backend: backend, attrs: { shape: expandedShape } });
|
var a = sub({ inputs: { a: logits, b: maxLogitReshaped }, backend: backend });
|
var b = exp({ inputs: { x: a }, backend: backend });
|
var sumExp = sum({ inputs: { x: b }, backend: backend, attrs: { axis: axes, keepDims: false } });
|
var sumReshaped = reshape({ inputs: { x: sumExp }, backend: backend, attrs: { shape: expandedShape } });
|
var result = div({ inputs: { a: b, b: sumReshaped }, backend: backend });
|
backend.disposeIntermediateTensorInfo(maxLogit);
|
backend.disposeIntermediateTensorInfo(maxLogitReshaped);
|
backend.disposeIntermediateTensorInfo(a);
|
backend.disposeIntermediateTensorInfo(b);
|
backend.disposeIntermediateTensorInfo(sumExp);
|
backend.disposeIntermediateTensorInfo(sumReshaped);
|
return result;
|
}
|
var softmaxConfig = {
|
kernelName: tfjsCore.Softmax,
|
backendName: 'cpu',
|
kernelFunc: softmax
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function multinomial(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var logits = inputs.logits;
|
var numSamples = attrs.numSamples, seed = attrs.seed, normalized = attrs.normalized;
|
assertNotComplex(logits, 'multinomial');
|
var probabilities = normalized ?
|
logits :
|
softmax({ inputs: { logits: logits }, backend: backend, attrs: { dim: -1 } });
|
var batchSize = probabilities.shape[0];
|
var numEvents = probabilities.shape[1];
|
var probVals = backend.data.get(probabilities.dataId).values;
|
var resShape = [batchSize, numSamples];
|
var resVals = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(resShape), 'int32');
|
for (var b = 0; b < batchSize; ++b) {
|
var offset = b * numEvents;
|
// The cdf won't include the last event. It will be implicit if no other
|
// event happened.
|
var cdf = new Float32Array(numEvents - 1);
|
cdf[0] = probVals[offset];
|
for (var event = 1; event < cdf.length; ++event) {
|
cdf[event] = cdf[event - 1] + probVals[offset + event];
|
}
|
var random = seedrandom__namespace.alea(seed.toString());
|
var outOffset = b * numSamples;
|
for (var sampleId = 0; sampleId < numSamples; ++sampleId) {
|
var r = random();
|
// Assume last event happened by default.
|
resVals[outOffset + sampleId] = cdf.length;
|
for (var event = 0; event < cdf.length; event++) {
|
if (r < cdf[event]) {
|
resVals[outOffset + sampleId] = event;
|
break;
|
}
|
}
|
}
|
}
|
if (!normalized) {
|
backend.disposeIntermediateTensorInfo(probabilities);
|
}
|
return backend.makeTensorInfo(resShape, 'int32', resVals);
|
}
|
var multinomialConfig = {
|
kernelName: tfjsCore.Multinomial,
|
backendName: 'cpu',
|
kernelFunc: multinomial
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var nonMaxSuppressionV3Impl = tfjsCore.kernel_impls.nonMaxSuppressionV3Impl;
|
function nonMaxSuppressionV3(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var boxes = inputs.boxes, scores = inputs.scores;
|
var maxOutputSize = attrs.maxOutputSize, iouThreshold = attrs.iouThreshold, scoreThreshold = attrs.scoreThreshold;
|
assertNotComplex(boxes, 'NonMaxSuppression');
|
var boxesVals = backend.data.get(boxes.dataId).values;
|
var scoresVals = backend.data.get(scores.dataId).values;
|
var selectedIndices = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold).selectedIndices;
|
return backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices));
|
}
|
var nonMaxSuppressionV3Config = {
|
kernelName: tfjsCore.NonMaxSuppressionV3,
|
backendName: 'cpu',
|
kernelFunc: nonMaxSuppressionV3
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var nonMaxSuppressionV4Impl = tfjsCore.kernel_impls.nonMaxSuppressionV4Impl;
|
function nonMaxSuppressionV4(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var boxes = inputs.boxes, scores = inputs.scores;
|
var maxOutputSize = attrs.maxOutputSize, iouThreshold = attrs.iouThreshold, scoreThreshold = attrs.scoreThreshold, padToMaxOutputSize = attrs.padToMaxOutputSize;
|
assertNotComplex(boxes, 'NonMaxSuppressionPadded');
|
var boxesVals = backend.data.get(boxes.dataId).values;
|
var scoresVals = backend.data.get(scores.dataId).values;
|
var _a = nonMaxSuppressionV4Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize), selectedIndices = _a.selectedIndices, validOutputs = _a.validOutputs;
|
return [
|
backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
|
backend.makeTensorInfo([], 'int32', new Int32Array([validOutputs]))
|
];
|
}
|
var nonMaxSuppressionV4Config = {
|
kernelName: tfjsCore.NonMaxSuppressionV4,
|
backendName: 'cpu',
|
kernelFunc: nonMaxSuppressionV4
|
};
|
|
/**
|
* @license
|
* Copyright 2019 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.
|
* =============================================================================
|
*/
|
var nonMaxSuppressionV5Impl = tfjsCore.kernel_impls.nonMaxSuppressionV5Impl;
|
function nonMaxSuppressionV5(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var boxes = inputs.boxes, scores = inputs.scores;
|
var maxOutputSize = attrs.maxOutputSize, iouThreshold = attrs.iouThreshold, scoreThreshold = attrs.scoreThreshold, softNmsSigma = attrs.softNmsSigma;
|
assertNotComplex(boxes, 'NonMaxSuppressionWithScore');
|
var boxesVals = backend.data.get(boxes.dataId).values;
|
var scoresVals = backend.data.get(scores.dataId).values;
|
var maxOutputSizeVal = maxOutputSize;
|
var iouThresholdVal = iouThreshold;
|
var scoreThresholdVal = scoreThreshold;
|
var softNmsSigmaVal = softNmsSigma;
|
var _a = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSizeVal, iouThresholdVal, scoreThresholdVal, softNmsSigmaVal), selectedIndices = _a.selectedIndices, selectedScores = _a.selectedScores;
|
return [
|
backend.makeTensorInfo([selectedIndices.length], 'int32', new Int32Array(selectedIndices)),
|
backend.makeTensorInfo([selectedScores.length], 'float32', new Float32Array(selectedScores))
|
];
|
}
|
var nonMaxSuppressionV5Config = {
|
kernelName: tfjsCore.NonMaxSuppressionV5,
|
backendName: 'cpu',
|
kernelFunc: nonMaxSuppressionV5
|
};
|
|
function oneHot(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var indices = inputs.indices;
|
var dtype = attrs.dtype, depth = attrs.depth, onValue = attrs.onValue, offValue = attrs.offValue;
|
assertNotComplex(indices, 'oneHot');
|
var indicesSize = tfjsCore.util.sizeFromShape(indices.shape);
|
var res = new Float32Array(indicesSize * depth);
|
res.fill(offValue);
|
var indicesVal = backend.data.get(indices.dataId).values;
|
for (var event = 0; event < indicesSize; ++event) {
|
if (indicesVal[event] >= 0 && indicesVal[event] < depth) {
|
res[event * depth + indicesVal[event]] = onValue;
|
}
|
}
|
return backend.makeTensorInfo(__spreadArray(__spreadArray([], __read(indices.shape), false), [depth], false), dtype, res);
|
}
|
var oneHotConfig = {
|
kernelName: tfjsCore.OneHot,
|
backendName: 'cpu',
|
kernelFunc: oneHot
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function zerosLike(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x;
|
if (x.dtype === 'string') {
|
throw new Error('zerosLike is not supported for string tensors');
|
}
|
else if (x.dtype === 'complex64') {
|
var realPart = real({ inputs: { input: x }, backend: backend });
|
var r = zerosLike({ inputs: { x: realPart }, backend: backend });
|
var imagPart = imag({ inputs: { input: x }, backend: backend });
|
var i = zerosLike({ inputs: { x: imagPart }, backend: backend });
|
var result = complex({ inputs: { real: r, imag: i }, backend: backend });
|
backend.disposeIntermediateTensorInfo(realPart);
|
backend.disposeIntermediateTensorInfo(r);
|
backend.disposeIntermediateTensorInfo(imagPart);
|
backend.disposeIntermediateTensorInfo(i);
|
return result;
|
}
|
else {
|
return fill({ backend: backend, attrs: { shape: x.shape, value: 0, dtype: x.dtype } });
|
}
|
}
|
var zerosLikeConfig = {
|
kernelName: tfjsCore.ZerosLike,
|
backendName: 'cpu',
|
kernelFunc: zerosLike
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function onesLike(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var x = inputs.x;
|
if (x.dtype === 'string') {
|
throw new Error('onesLike is not supported for string tensors');
|
}
|
else if (x.dtype === 'complex64') {
|
var realPart = real({ inputs: { input: x }, backend: backend });
|
var r = onesLike({ inputs: { x: realPart }, backend: backend });
|
var imagPart = imag({ inputs: { input: x }, backend: backend });
|
var i = zerosLike({ inputs: { x: imagPart }, backend: backend });
|
var result = complex({ inputs: { real: r, imag: i }, backend: backend });
|
backend.disposeIntermediateTensorInfo(realPart);
|
backend.disposeIntermediateTensorInfo(r);
|
backend.disposeIntermediateTensorInfo(imagPart);
|
backend.disposeIntermediateTensorInfo(i);
|
return result;
|
}
|
else {
|
return fill({ backend: backend, attrs: { shape: x.shape, value: 1, dtype: x.dtype } });
|
}
|
}
|
var onesLikeConfig = {
|
kernelName: tfjsCore.OnesLike,
|
backendName: 'cpu',
|
kernelFunc: onesLike
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function pack(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var axis = attrs.axis;
|
if (inputs.length === 1) {
|
return expandDims({ inputs: { input: inputs[0] }, backend: backend, attrs: { dim: axis } });
|
}
|
var shape = inputs[0].shape;
|
var dtype = inputs[0].dtype;
|
inputs.forEach(function (t) {
|
tfjsCore.util.assertShapesMatch(shape, t.shape, 'All tensors passed to stack must have matching shapes');
|
tfjsCore.util.assert(dtype === t.dtype, function () { return 'All tensors passed to stack must have matching dtypes'; });
|
});
|
var intermediateTensorInfos = [];
|
var expandedTensors = inputs.map(function (t) {
|
var expandedT = expandDims({ inputs: { input: t }, backend: backend, attrs: { dim: axis } });
|
intermediateTensorInfos.push(expandedT);
|
return expandedT;
|
});
|
var result = concat({ inputs: expandedTensors, backend: backend, attrs: { axis: axis } });
|
intermediateTensorInfos.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return result;
|
}
|
var packConfig = {
|
kernelName: tfjsCore.Pack,
|
backendName: 'cpu',
|
kernelFunc: pack
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function padV2(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var paddings = attrs.paddings, constantValue = attrs.constantValue;
|
assertNotComplex(x, 'pad');
|
var outShape = paddings.map(function (p, i) { return p[0] /* beforePad */ + x.shape[i] + p[1]; } /* afterPad */);
|
var start = paddings.map(function (p) { return p[0]; });
|
var xVals = backend.data.get(x.dataId).values;
|
var xSize = tfjsCore.util.sizeFromShape(x.shape);
|
var xRank = x.shape.length;
|
var xStrides = tfjsCore.util.computeStrides(x.shape);
|
var resultSize = tfjsCore.util.sizeFromShape(outShape);
|
var resultRank = outShape.length;
|
var resultStrides = tfjsCore.util.computeStrides(outShape);
|
var resVals = tfjsCore.util.getTypedArrayFromDType(x.dtype, resultSize);
|
if (constantValue !== 0) {
|
resVals.fill(constantValue);
|
}
|
for (var i = 0; i < xSize; i++) {
|
var coords = tfjsCore.util.indexToLoc(i, xRank, xStrides);
|
var outCoords = coords.map(function (c, i) { return c + start[i]; });
|
var outIndex = tfjsCore.util.locToIndex(outCoords, resultRank, resultStrides);
|
resVals[outIndex] = xVals[i];
|
}
|
var outId = backend.write(resVals, outShape, x.dtype);
|
return { dataId: outId, shape: outShape, dtype: x.dtype };
|
}
|
var padV2Config = {
|
kernelName: tfjsCore.PadV2,
|
backendName: 'cpu',
|
kernelFunc: padV2
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var powImpl = createSimpleBinaryKernelImpl(function (a, b) { return Math.pow(a, b); });
|
var pow = binaryKernelFunc(tfjsCore.Pow, powImpl);
|
var powConfig = {
|
kernelName: tfjsCore.Pow,
|
backendName: 'cpu',
|
kernelFunc: pow
|
};
|
|
function raggedGather(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var paramsNestedSplits = inputs.paramsNestedSplits, paramsDenseValues = inputs.paramsDenseValues, indices = inputs.indices;
|
attrs.outputRaggedRank;
|
var $paramsNestedSplits = paramsNestedSplits.map(function (t) { return backend.data.get(t.dataId).values; });
|
var $paramsNestedSplitsShapes = paramsNestedSplits.map(function (t) { return t.shape; });
|
var $paramsDenseValues = backend.data.get(paramsDenseValues.dataId).values;
|
var $indices = backend.data.get(indices.dataId).values;
|
var _a = __read(raggedGatherImpl($paramsNestedSplits, $paramsNestedSplitsShapes, $paramsDenseValues, paramsDenseValues.shape, paramsDenseValues.dtype, $indices, indices.shape), 3), outputNestedSplits = _a[0], outputDenseValues = _a[1], outputDenseValuesShape = _a[2];
|
var outputNestedSplitsTensors = outputNestedSplits.map(function (splits) { return backend.makeTensorInfo([splits.length], 'int32', splits); });
|
var outputDenseValuesTensor = backend.makeTensorInfo(outputDenseValuesShape, paramsDenseValues.dtype, outputDenseValues);
|
return outputNestedSplitsTensors.concat([outputDenseValuesTensor]);
|
}
|
var raggedGatherConfig = {
|
kernelName: tfjsCore.RaggedGather,
|
backendName: 'cpu',
|
kernelFunc: raggedGather,
|
};
|
|
function raggedRange(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var starts = inputs.starts, limits = inputs.limits, deltas = inputs.deltas;
|
var $starts = backend.data.get(starts.dataId).values;
|
var $limits = backend.data.get(limits.dataId).values;
|
var $deltas = backend.data.get(deltas.dataId).values;
|
var _a = __read(raggedRangeImpl($starts, starts.shape, starts.dtype, $limits, limits.shape, $deltas, deltas.shape), 2), rtNestedSplitsData = _a[0], rtDenseValuesData = _a[1];
|
var rtNestedSplits = backend.makeTensorInfo([rtNestedSplitsData.length], 'int32', rtNestedSplitsData);
|
var rtDenseValues = backend.makeTensorInfo([rtDenseValuesData.length], starts.dtype, rtDenseValuesData);
|
return [rtNestedSplits, rtDenseValues];
|
}
|
var raggedRangeConfig = {
|
kernelName: tfjsCore.RaggedRange,
|
backendName: 'cpu',
|
kernelFunc: raggedRange,
|
};
|
|
function raggedTensorToTensor(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var shape = inputs.shape, values = inputs.values, defaultValue = inputs.defaultValue, rowPartitionTensors = inputs.rowPartitionTensors;
|
var rowPartitionTypes = attrs.rowPartitionTypes;
|
var $shape = backend.data.get(shape.dataId).values;
|
var $values = backend.data.get(values.dataId).values;
|
var $defaultValue = backend.data.get(defaultValue.dataId).values;
|
var $rowPartitionValues = rowPartitionTensors.map(function (t) { return backend.data.get(t.dataId).values; });
|
var rowPartitionValuesShapes = rowPartitionTensors.map(function (t) { return t.shape; });
|
var _a = __read(raggedTensorToTensorImpl($shape, shape.shape, $values, values.shape, values.dtype, $defaultValue, defaultValue.shape, $rowPartitionValues, rowPartitionValuesShapes, rowPartitionTypes), 2), outputShape = _a[0], output = _a[1];
|
return backend.makeTensorInfo(outputShape, values.dtype, output);
|
}
|
var raggedTensorToTensorConfig = {
|
kernelName: tfjsCore.RaggedTensorToTensor,
|
backendName: 'cpu',
|
kernelFunc: raggedTensorToTensor,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function range(args) {
|
var backend = args.backend, attrs = args.attrs;
|
var start = attrs.start, stop = attrs.stop, dtype = attrs.dtype, step = attrs.step;
|
var values = rangeImpl(start, stop, step, dtype);
|
return backend.makeTensorInfo([values.length], dtype, values);
|
}
|
var rangeConfig = {
|
kernelName: tfjsCore.Range,
|
backendName: 'cpu',
|
kernelFunc: range
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var reciprocal = unaryKernelFunc(tfjsCore.Reciprocal, function (xi) { return 1 / xi; });
|
var reciprocalConfig = {
|
kernelName: tfjsCore.Reciprocal,
|
backendName: 'cpu',
|
kernelFunc: reciprocal,
|
};
|
|
function resizeBilinear(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var images = inputs.images;
|
var alignCorners = attrs.alignCorners, halfPixelCenters = attrs.halfPixelCenters, size = attrs.size;
|
assertNotComplex(images, 'resizeBilinear');
|
var imagesStrides = tfjsCore.util.computeStrides(images.shape);
|
var _a = __read(size, 2), newHeight = _a[0], newWidth = _a[1];
|
var _b = __read(images.shape, 4), batch = _b[0], oldHeight = _b[1], oldWidth = _b[2], numChannels = _b[3];
|
var xValues = backend.data.get(images.dataId).values;
|
var result = new Float32Array(tfjsCore.util.sizeFromShape([batch, newHeight, newWidth, numChannels]));
|
var effectiveInputSize = [
|
(alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
|
(alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
|
];
|
var effectiveOutputSize = [
|
(alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
|
(alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
|
];
|
var outputIdx = 0;
|
var effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
|
var effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
|
for (var b = 0; b < batch; b++) {
|
for (var r = 0; r < newHeight; r++) {
|
var sourceFracRow = void 0;
|
if (halfPixelCenters) {
|
sourceFracRow = effectiveRowSizeRatio * (r + 0.5) - 0.5;
|
}
|
else {
|
sourceFracRow = effectiveRowSizeRatio * r;
|
}
|
var sourceRowFloor = Math.max(0, Math.floor(sourceFracRow));
|
var rowFrac = sourceFracRow - sourceRowFloor;
|
var sourceRowCeil = Math.min(oldHeight - 1, Math.ceil(sourceFracRow));
|
var topRowOffset = b * imagesStrides[0] + sourceRowFloor * imagesStrides[1];
|
var botRowOffset = b * imagesStrides[0] + sourceRowCeil * imagesStrides[1];
|
for (var c = 0; c < newWidth; c++) {
|
var sourceFracCol = void 0;
|
if (halfPixelCenters) {
|
sourceFracCol = effectiveColSizeRatio * (c + 0.5) - 0.5;
|
}
|
else {
|
sourceFracCol = effectiveColSizeRatio * c;
|
}
|
var sourceColFloor = Math.max(0, Math.floor(sourceFracCol));
|
var colFrac = sourceFracCol - sourceColFloor;
|
var sourceColCeil = Math.min(oldWidth - 1, Math.ceil(sourceFracCol));
|
var topLeftOffest = topRowOffset + sourceColFloor * imagesStrides[2];
|
var botLeftOffset = botRowOffset + sourceColFloor * imagesStrides[2];
|
var topRightOffset = topRowOffset + sourceColCeil * imagesStrides[2];
|
var botRightOffest = botRowOffset + sourceColCeil * imagesStrides[2];
|
for (var d = 0; d < numChannels; d++) {
|
// Begin shader.
|
// Compute the fractional index of the source.
|
var topLeft = xValues[topLeftOffest + d];
|
var bottomLeft = xValues[botLeftOffset + d];
|
var topRight = xValues[topRightOffset + d];
|
var bottomRight = xValues[botRightOffest + d];
|
var top = topLeft + (topRight - topLeft) * colFrac;
|
var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;
|
var newValue = top + (bottom - top) * rowFrac;
|
result[outputIdx++] = newValue;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], 'float32', result);
|
}
|
var resizeBilinearConfig = {
|
kernelName: tfjsCore.ResizeBilinear,
|
backendName: 'cpu',
|
kernelFunc: resizeBilinear
|
};
|
|
function resizeBilinearGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var images = inputs.images, dy = inputs.dy;
|
var alignCorners = attrs.alignCorners;
|
assertNotComplex([dy, images], 'resizeBilinearGrad');
|
var imagesStrides = tfjsCore.util.computeStrides(images.shape);
|
var _a = __read(images.shape, 4), batch = _a[0], xHeight = _a[1], xWidth = _a[2], depth = _a[3];
|
var _b = __read(dy.shape, 3), yHeight = _b[1], yWidth = _b[2];
|
var output = new Float32Array(batch * xHeight * xWidth * depth);
|
// In the backwards pass, we want to find the pixels that were generated
|
// for each pixel in the input image the forward pass and add the
|
// corresponding coefficient from dy to the gradient (with some
|
// interpolation).
|
var effectiveXSize = [
|
(alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
|
(alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
|
];
|
var effectiveYSize = [
|
(alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
|
(alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
|
];
|
var heightScale = effectiveXSize[0] / effectiveYSize[0];
|
var widthScale = effectiveXSize[1] / effectiveYSize[1];
|
// Reference implementation
|
// tslint:disable-next-line:max-line-length
|
// https://github.com/tensorflow/tensorflow/blob/3039375c86a5bbc9610c7725dcaa95d635f87ba2/tensorflow/core/kernels/resize_bilinear_op.cc#L275
|
var dyValues = backend.data.get(dy.dataId).values;
|
var offset = 0;
|
for (var b = 0; b < batch; b++) {
|
var bOffset = b * imagesStrides[0];
|
for (var r = 0; r < yHeight; r++) {
|
var dxR = r * heightScale;
|
var topDxRIndex = Math.floor(dxR);
|
var bottomDxRIndex = Math.min(Math.ceil(dxR), xHeight - 1);
|
var topDxROffset = bOffset + topDxRIndex * imagesStrides[1];
|
var bottomDxROffset = bOffset + bottomDxRIndex * imagesStrides[1];
|
var dxRLerp = dxR - topDxRIndex;
|
var inverseDxRLerp = 1.0 - dxRLerp;
|
for (var c = 0; c < yWidth; c++) {
|
var dxC = c * widthScale;
|
var leftDxCIndex = Math.floor(dxC);
|
var rightDxCIndex = Math.min(Math.ceil(dxC), xWidth - 1);
|
var dxCLerp = dxC - leftDxCIndex;
|
var inverseDxCLerp = 1.0 - dxCLerp;
|
var topLeftRCOffset = topDxROffset + leftDxCIndex * imagesStrides[2];
|
var topRightRCOffset = topDxROffset + rightDxCIndex * imagesStrides[2];
|
var bottomLeftRCOffset = bottomDxROffset + leftDxCIndex * imagesStrides[2];
|
var bottomRightRCOffset = bottomDxROffset + rightDxCIndex * imagesStrides[2];
|
var inverseDxRLerpTimesInverseDxCLerp = inverseDxRLerp * inverseDxCLerp;
|
var inverseDxRLerpTimesDxCLerp = inverseDxRLerp * dxCLerp;
|
var dxRLerpTimesInverseDxCLerp = dxRLerp * inverseDxCLerp;
|
var dxRLerpTimesDxCLerp = dxRLerp * dxCLerp;
|
for (var d = 0; d < depth; d++) {
|
var dyVal = dyValues[offset++];
|
output[topLeftRCOffset + d] +=
|
dyVal * inverseDxRLerpTimesInverseDxCLerp;
|
output[topRightRCOffset + d] += dyVal * inverseDxRLerpTimesDxCLerp;
|
output[bottomLeftRCOffset + d] += dyVal * dxRLerpTimesInverseDxCLerp;
|
output[bottomRightRCOffset + d] += dyVal * dxRLerpTimesDxCLerp;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo([batch, xWidth, xHeight, depth], 'float32', output);
|
}
|
var resizeBilinearGradConfig = {
|
kernelName: tfjsCore.ResizeBilinearGrad,
|
backendName: 'cpu',
|
kernelFunc: resizeBilinearGrad
|
};
|
|
function resizeNearestNeighbor(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var images = inputs.images;
|
var alignCorners = attrs.alignCorners, halfPixelCenters = attrs.halfPixelCenters, size = attrs.size;
|
assertNotComplex(images, 'resizeNearestNeighbor');
|
var imagesStrides = tfjsCore.util.computeStrides(images.shape);
|
var _a = __read(size, 2), newHeight = _a[0], newWidth = _a[1];
|
var _b = __read(images.shape, 4), batch = _b[0], oldHeight = _b[1], oldWidth = _b[2], numChannels = _b[3];
|
var xValues = backend.data.get(images.dataId).values;
|
var output = new Float32Array(batch * newHeight * newWidth * numChannels);
|
var effectiveInputSize = [
|
(alignCorners && newHeight > 1) ? oldHeight - 1 : oldHeight,
|
(alignCorners && newWidth > 1) ? oldWidth - 1 : oldWidth
|
];
|
var effectiveOutputSize = [
|
(alignCorners && newHeight > 1) ? newHeight - 1 : newHeight,
|
(alignCorners && newWidth > 1) ? newWidth - 1 : newWidth
|
];
|
var effectiveRowSizeRatio = effectiveInputSize[0] / effectiveOutputSize[0];
|
var effectiveColSizeRatio = effectiveInputSize[1] / effectiveOutputSize[1];
|
var outputOffset = 0;
|
for (var b = 0; b < batch; b++) {
|
var batchOffset = b * imagesStrides[0];
|
for (var r = 0; r < newHeight; r++) {
|
var sourceFracRow = halfPixelCenters ?
|
effectiveRowSizeRatio * (r + 0.5) :
|
effectiveRowSizeRatio * r;
|
var sourceNearestRow = Math.min(oldHeight - 1, alignCorners ? Math.round(sourceFracRow) : Math.floor(sourceFracRow));
|
if (halfPixelCenters) {
|
sourceNearestRow = Math.max(0, sourceNearestRow);
|
}
|
var rowOffset = batchOffset + sourceNearestRow * imagesStrides[1];
|
for (var c = 0; c < newWidth; c++) {
|
var sourceFracCol = halfPixelCenters ?
|
effectiveColSizeRatio * (c + 0.5) :
|
effectiveColSizeRatio * c;
|
var sourceNearestCol = Math.min(oldWidth - 1, alignCorners ? Math.round(sourceFracCol) :
|
Math.floor(sourceFracCol));
|
if (halfPixelCenters) {
|
sourceNearestCol = Math.max(0, sourceNearestCol);
|
}
|
var colOffset = rowOffset + sourceNearestCol * imagesStrides[2];
|
for (var d = 0; d < numChannels; d++) {
|
// Begin shader.
|
// Compute the fractional index of the source.
|
var newVal = xValues[colOffset + d];
|
output[outputOffset++] = newVal;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo([batch, newHeight, newWidth, numChannels], images.dtype, output);
|
}
|
var resizeNearestNeighborConfig = {
|
kernelName: tfjsCore.ResizeNearestNeighbor,
|
backendName: 'cpu',
|
kernelFunc: resizeNearestNeighbor
|
};
|
|
function resizeNearestNeighborGrad(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var images = inputs.images, dy = inputs.dy;
|
var alignCorners = attrs.alignCorners;
|
assertNotComplex([dy, images], 'resizeNearestNeighborGrad');
|
var imagesStrides = tfjsCore.util.computeStrides(images.shape);
|
var dyStrides = tfjsCore.util.computeStrides(dy.shape);
|
var _a = __read(images.shape, 4), batch = _a[0], xHeight = _a[1], xWidth = _a[2], depth = _a[3];
|
var _b = __read(dy.shape, 3), yHeight = _b[1], yWidth = _b[2];
|
var output = new Float32Array(batch * xHeight * xWidth * depth);
|
var dyValues = backend.data.get(dy.dataId).values;
|
// In the backwards pass, we want to find the pixels that were generated
|
// for each pixel in the input image the forward pass
|
var effectiveXSize = [
|
(alignCorners && yHeight > 1) ? xHeight - 1 : xHeight,
|
(alignCorners && yWidth > 1) ? xWidth - 1 : xWidth
|
];
|
var effectiveYSize = [
|
(alignCorners && yHeight > 1) ? yHeight - 1 : yHeight,
|
(alignCorners && yWidth > 1) ? yWidth - 1 : yWidth
|
];
|
var heightScale = effectiveXSize[0] / effectiveYSize[0];
|
var widthScale = effectiveXSize[1] / effectiveYSize[1];
|
var invHeightScale = 1 / heightScale;
|
var invWidthScale = 1 / widthScale;
|
// This defines the size of the window of values around a particular
|
// index in dy that we want to search for contributions to dx.
|
var winHeight = (Math.ceil(invHeightScale) * 2) + 2;
|
var winWidth = (Math.ceil(invWidthScale) * 2) + 2;
|
// Loop over the output space.
|
for (var b = 0; b < batch; b++) {
|
var batchOffset = b * imagesStrides[0];
|
for (var r = 0; r < xHeight; r++) {
|
var rowOffset = batchOffset + r * imagesStrides[1];
|
// Compute bounds for where in dy we will look
|
var startRLerp = Math.floor(r * invHeightScale);
|
var startDyR = Math.floor(startRLerp - (winHeight / 2));
|
for (var c = 0; c < xWidth; c++) {
|
var colOffset = rowOffset + c * imagesStrides[2];
|
// Compute bounds for where in dy we will look
|
var startCLerp = Math.floor(c * invWidthScale);
|
var startDyC = Math.floor(startCLerp - (winWidth / 2));
|
for (var d = 0; d < depth; d++) {
|
var accum = 0;
|
// loop over dy
|
for (var dyRIndex = 0; dyRIndex < winHeight; dyRIndex++) {
|
var dyR = dyRIndex + startDyR;
|
// Guard against the window exceeding the bounds of dy
|
if (dyR < 0 || dyR >= yHeight) {
|
continue;
|
}
|
var dyROffset = batchOffset + dyR * dyStrides[1];
|
var sourceFracRow = dyR * heightScale;
|
var sourceNearestRow = Math.min(xHeight - 1, alignCorners ? Math.round(sourceFracRow) :
|
Math.floor(sourceFracRow));
|
if (r !== sourceNearestRow) {
|
continue;
|
}
|
for (var dyCIndex = 0; dyCIndex < winWidth; dyCIndex++) {
|
var dyC = dyCIndex + startDyC;
|
// Guard against the window exceeding the bounds of dy
|
if (dyC < 0 || dyC >= yWidth) {
|
continue;
|
}
|
var dyCOffset = dyROffset + dyC * dyStrides[2];
|
var sourceFracCol = dyC * widthScale;
|
var sourceNearestCol = Math.min(xWidth - 1, alignCorners ? Math.round(sourceFracCol) :
|
Math.floor(sourceFracCol));
|
if (c === sourceNearestCol) {
|
accum += dyValues[dyCOffset + d];
|
}
|
}
|
}
|
output[colOffset + d] = accum;
|
}
|
}
|
}
|
}
|
return backend.makeTensorInfo(images.shape, images.dtype, output);
|
}
|
var resizeNearestNeighborGradConfig = {
|
kernelName: tfjsCore.ResizeNearestNeighborGrad,
|
backendName: 'cpu',
|
kernelFunc: resizeNearestNeighborGrad
|
};
|
|
function reverse(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var dims = attrs.dims;
|
assertNotComplex(x, 'reverse');
|
var xRank = x.shape.length;
|
var $dims = tfjsCore.util.parseAxisParam(dims, x.shape);
|
if (xRank === 0) {
|
return identity({ inputs: { x: x }, backend: backend });
|
}
|
var outBuf = new tfjsCore.TensorBuffer(x.shape, x.dtype);
|
var xBuf = backend.bufferSync(x);
|
var _loop_1 = function (i) {
|
var outLoc = outBuf.indexToLoc(i);
|
var inLoc = outLoc.slice();
|
$dims.forEach(function (d) { return inLoc[d] = x.shape[d] - 1 - inLoc[d]; });
|
outBuf.set.apply(outBuf, __spreadArray([xBuf.get.apply(xBuf, __spreadArray([], __read(inLoc), false))], __read(outLoc), false));
|
};
|
for (var i = 0; i < outBuf.size; i++) {
|
_loop_1(i);
|
}
|
return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
|
}
|
var reverseConfig = {
|
kernelName: tfjsCore.Reverse,
|
backendName: 'cpu',
|
kernelFunc: reverse
|
};
|
|
var rotateWithOffsetConfig = {
|
kernelName: tfjsCore.RotateWithOffset,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, attrs = _a.attrs, backend = _a.backend;
|
var image = inputs.image;
|
var radians = attrs.radians, fillValue = attrs.fillValue, center = attrs.center;
|
var cpuBackend = backend;
|
var output = tfjsCore.util.getTypedArrayFromDType(image.dtype, tfjsCore.util.sizeFromShape(image.shape));
|
var _b = __read(image.shape, 4), batch = _b[0], imageHeight = _b[1], imageWidth = _b[2], numChannels = _b[3];
|
var _c = __read(tfjsCore.backend_util.getImageCenter(center, imageHeight, imageWidth), 2), centerX = _c[0], centerY = _c[1];
|
var fullOpacityValue = 255;
|
var sinFactor = Math.sin(radians);
|
var cosFactor = Math.cos(radians);
|
var imageVals = cpuBackend.data.get(image.dataId).values;
|
for (var batchIdx = 0; batchIdx < batch; batchIdx++) {
|
var batchOffset = batchIdx * imageWidth * imageHeight * numChannels;
|
for (var row = 0; row < imageHeight; row++) {
|
var rowOffset = row * (imageWidth * numChannels);
|
for (var col = 0; col < imageWidth; col++) {
|
var colOffset = col * numChannels;
|
for (var channel = 0; channel < numChannels; channel++) {
|
var coords = [batch, row, col, channel];
|
var x = coords[2];
|
var y = coords[1];
|
// coordX/coordY are the result of rotating and translating x/y.
|
var coordX = (x - centerX) * cosFactor - (y - centerY) * sinFactor;
|
var coordY = (x - centerX) * sinFactor + (y - centerY) * cosFactor;
|
coordX = Math.round(coordX + centerX);
|
coordY = Math.round(coordY + centerY);
|
var outputValue = fillValue;
|
if (typeof fillValue !== 'number') {
|
if (channel === 3) {
|
outputValue = fullOpacityValue;
|
}
|
else {
|
outputValue = fillValue[channel];
|
}
|
}
|
// If the coordinate position falls within the image boundaries...
|
if (coordX >= 0 && coordX < imageWidth && coordY >= 0 &&
|
coordY < imageHeight) {
|
// set the output to the image value at the coordinate position.
|
var rotatedRowOffset = coordY * (imageWidth * numChannels);
|
var rotatedColOffset = coordX * numChannels;
|
var imageIdx = batchOffset + rotatedRowOffset + rotatedColOffset + channel;
|
outputValue = imageVals[imageIdx];
|
}
|
var outIdx = batchOffset + rowOffset + colOffset + channel;
|
output[outIdx] = outputValue;
|
}
|
}
|
}
|
}
|
var dataId = cpuBackend.write(output, image.shape, image.dtype);
|
return { dataId: dataId, shape: image.shape, dtype: image.dtype };
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var round = unaryKernelFunc(tfjsCore.Round, function (xi) {
|
// The algorithm is based on banker's rounding.
|
var base = Math.floor(xi);
|
if (xi - base < 0.5) {
|
return Math.floor(xi);
|
}
|
else if (xi - base > 0.5) {
|
return Math.ceil(xi);
|
}
|
else {
|
if (base % 2.0 === 0.0) {
|
return base;
|
}
|
else {
|
return base + 1.0;
|
}
|
}
|
});
|
var roundConfig = {
|
kernelName: tfjsCore.Round,
|
backendName: 'cpu',
|
kernelFunc: round,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function scatterNd(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var indices = inputs.indices, updates = inputs.updates;
|
var shape = attrs.shape;
|
var _a = tfjsCore.backend_util.calculateShapes(updates, indices, shape), sliceRank = _a.sliceRank, numUpdates = _a.numUpdates, sliceSize = _a.sliceSize, strides = _a.strides, outputSize = _a.outputSize;
|
var sumDupeIndices = true;
|
var indicesBuf = backend.bufferSync(indices);
|
var updatesBuf = backend.bufferSync(updates);
|
var outBuf = scatterImpl(indicesBuf, updatesBuf, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, 0 /* defaultValue */, sumDupeIndices);
|
return backend.makeTensorInfo(shape, outBuf.dtype, outBuf.values);
|
}
|
var scatterNdConfig = {
|
kernelName: tfjsCore.ScatterNd,
|
backendName: 'cpu',
|
kernelFunc: scatterNd
|
};
|
|
/**
|
* @license
|
* Copyright 2022 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.
|
* =============================================================================
|
*/
|
function lowerBound(array, value) {
|
var left = 0;
|
var right = array.length;
|
var mid = 0;
|
while (left < right) {
|
mid = Math.floor((left + right) / 2);
|
if (array[mid] < value) {
|
left = mid + 1;
|
}
|
else {
|
right = mid;
|
}
|
}
|
return right;
|
}
|
function upperBound(array, value) {
|
var left = 0;
|
var right = array.length;
|
var mid = 0;
|
while (left < right) {
|
mid = Math.floor((left + right) / 2);
|
if (array[mid] <= value) {
|
left = mid + 1;
|
}
|
else {
|
right = mid;
|
}
|
}
|
return right;
|
}
|
function searchSortedImpl(sortedInputs, values, batchSize, numInputs, numValues, side) {
|
var output = tfjsCore.util.getArrayFromDType('int32', batchSize * numValues);
|
for (var b = 0; b < batchSize; ++b) {
|
var sortedInputsSlice = sortedInputs.slice(b * numInputs, (b + 1) * numInputs);
|
var outputOffset = b * numValues;
|
for (var i = 0; i < numValues; ++i) {
|
output[outputOffset + i] = side === 'left' ?
|
lowerBound(sortedInputsSlice, values[i + outputOffset]) :
|
upperBound(sortedInputsSlice, values[i + outputOffset]);
|
}
|
}
|
return output;
|
}
|
|
/**
|
* @license
|
* Copyright 2022 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.
|
* =============================================================================
|
*/
|
function searchSorted(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var sortedSequence = inputs.sortedSequence, values = inputs.values;
|
var side = attrs.side;
|
var $sortedSequence = backend.data.get(sortedSequence.dataId).values;
|
var $values = backend.data.get(values.dataId).values;
|
var output = searchSortedImpl($sortedSequence, $values, sortedSequence.shape[0], sortedSequence.shape[1], values.shape[1], side);
|
return backend.makeTensorInfo(values.shape, 'int32', output);
|
}
|
var searchSortedConfig = {
|
kernelName: tfjsCore.SearchSorted,
|
backendName: 'cpu',
|
kernelFunc: searchSorted,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function select(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var condition = inputs.condition, t = inputs.t, e = inputs.e;
|
assertNotComplex([condition, t, e], 'select');
|
var conditionRank = condition.shape.length;
|
var values = backend.data.get(condition.dataId).values;
|
var tValues = backend.data.get(t.dataId).values;
|
var eValues = backend.data.get(e.dataId).values;
|
var resultDtype = tfjsCore.upcastType(t.dtype, e.dtype);
|
var newValues = tfjsCore.util.makeZerosTypedArray(tfjsCore.util.sizeFromShape(t.shape), resultDtype);
|
var index = 0;
|
var offset = conditionRank === 0 || conditionRank > 1 || t.shape.length === 1 ?
|
1 :
|
tfjsCore.util.sizeFromShape(t.shape.slice(1));
|
for (var i = 0; i < values.length; i++) {
|
for (var j = 0; j < offset; j++) {
|
if (values[i] === 1) {
|
newValues[index++] = tValues[i];
|
}
|
else {
|
newValues[index++] = eValues[i];
|
}
|
}
|
}
|
return backend.makeTensorInfo(t.shape, resultDtype, newValues);
|
}
|
var selectConfig = {
|
kernelName: tfjsCore.Select,
|
backendName: 'cpu',
|
kernelFunc: select
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var scaleAlpha = tfjsCore.backend_util.SELU_SCALEALPHA;
|
var scale = tfjsCore.backend_util.SELU_SCALE;
|
var selu = unaryKernelFunc(tfjsCore.Selu, function (xi) {
|
if (xi >= 0) {
|
return scale * xi;
|
}
|
else {
|
return scaleAlpha * (Math.exp(xi) - 1);
|
}
|
});
|
var seluConfig = {
|
kernelName: tfjsCore.Selu,
|
backendName: 'cpu',
|
kernelFunc: selu,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var sign = unaryKernelFunc(tfjsCore.Sign, function (xi) {
|
if (xi < 0) {
|
return -1;
|
}
|
else if (xi > 0) {
|
return 1;
|
}
|
else {
|
return 0;
|
}
|
});
|
var signConfig = {
|
kernelName: tfjsCore.Sign,
|
backendName: 'cpu',
|
kernelFunc: sign,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var sin = unaryKernelFunc(tfjsCore.Sin, function (xi) { return Math.sin(xi); });
|
var sinConfig = {
|
kernelName: tfjsCore.Sin,
|
backendName: 'cpu',
|
kernelFunc: sin,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var sinh = unaryKernelFunc(tfjsCore.Sinh, function (xi) { return Math.sinh(xi); });
|
var sinhConfig = {
|
kernelName: tfjsCore.Sinh,
|
backendName: 'cpu',
|
kernelFunc: sinh,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
// mirrors the implementation of tf.nn.softplus: https://goo.gl/vkcvwX
|
// epsilon is the difference between 1.0 and the next representable float.
|
// For a single precision 32 bit float this should be 2^-23, see:
|
// https://math.byu.edu/~schow/work/IEEEFloatingPoint.htm
|
var epsilon = 1.1920928955078125e-7;
|
var threshold = Math.log(epsilon) + 2.0;
|
var softplus = unaryKernelFunc(tfjsCore.Softplus, function (xi) {
|
// Value above which exp(x) may overflow, but softplus(x) == x
|
// is within machine epsilon.
|
var tooLarge = xi > -threshold;
|
// Value below which exp(x) may underflow, but softplus(x) == exp(x)
|
// is within machine epsilon.
|
var tooSmall = xi < threshold;
|
var expX = Math.exp(xi);
|
var result;
|
if (tooSmall) {
|
result = expX;
|
}
|
else if (tooLarge) {
|
result = xi;
|
}
|
else {
|
result = Math.log(1.0 + expX);
|
}
|
return result;
|
});
|
var softplusConfig = {
|
kernelName: tfjsCore.Softplus,
|
backendName: 'cpu',
|
kernelFunc: softplus,
|
};
|
|
function spaceToBatchND(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var blockShape = attrs.blockShape, paddings = attrs.paddings;
|
assertNotComplex([x], 'spaceToBatchND');
|
var prod = tfjsCore.util.sizeFromShape(blockShape);
|
var completePaddings = [[0, 0]];
|
completePaddings.push.apply(completePaddings, __spreadArray([], __read(paddings), false));
|
for (var i = 1 + blockShape.length; i < x.shape.length; ++i) {
|
completePaddings.push([0, 0]);
|
}
|
var paddedX = padV2Config.kernelFunc({
|
inputs: { x: x },
|
backend: backend,
|
attrs: { paddings: completePaddings, constantValue: 0 }
|
});
|
var reshapedPaddedShape = tfjsCore.backend_util.getReshaped(paddedX.shape, blockShape, prod, false);
|
var permutedReshapedPaddedPermutation = tfjsCore.backend_util.getPermuted(reshapedPaddedShape.length, blockShape.length, false);
|
var flattenShape = tfjsCore.backend_util.getReshapedPermuted(paddedX.shape, blockShape, prod, false);
|
var reshapeInputs = { x: paddedX };
|
var reshapeAttrs = { shape: reshapedPaddedShape };
|
var paddedXReshaped = reshape({ inputs: reshapeInputs, backend: backend, attrs: reshapeAttrs });
|
var transposeInputs = { x: paddedXReshaped };
|
var transposeAttrs = { perm: permutedReshapedPaddedPermutation };
|
var paddedXT = transpose({ inputs: transposeInputs, backend: backend, attrs: transposeAttrs });
|
var resultReshapeInputs = { x: paddedXT };
|
var resultReshapeAttrs = { shape: flattenShape };
|
var result = reshape({ inputs: resultReshapeInputs, backend: backend, attrs: resultReshapeAttrs });
|
backend.disposeIntermediateTensorInfo(paddedX);
|
backend.disposeIntermediateTensorInfo(paddedXReshaped);
|
backend.disposeIntermediateTensorInfo(paddedXT);
|
return result;
|
}
|
var spaceToBatchNDConfig = {
|
kernelName: tfjsCore.SpaceToBatchND,
|
backendName: 'cpu',
|
kernelFunc: spaceToBatchND
|
};
|
|
function sparseFillEmptyRows(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var indices = inputs.indices, values = inputs.values, denseShape = inputs.denseShape, defaultValue = inputs.defaultValue;
|
if (denseShape.shape.length !== 1) {
|
throw new Error("Dense shape must be a vector, saw:\n ".concat(denseShape.shape));
|
}
|
if (indices.shape.length !== 2) {
|
throw new Error("Indices must be a matrix, saw:\n ".concat(indices.shape));
|
}
|
if (values.shape.length !== 1) {
|
throw new Error("Values must be a vector, saw:\n ".concat(values.shape));
|
}
|
if (defaultValue.shape.length !== 0) {
|
throw new Error("Default value must be a scalar, saw:\n ".concat(defaultValue.shape));
|
}
|
var $indices = backend.data.get(indices.dataId).values;
|
var $values = backend.data.get(values.dataId).values;
|
var $denseShape = backend.data.get(denseShape.dataId).values;
|
var $defaultValue = backend.data.get(defaultValue.dataId).values[0];
|
var _a = __read(sparseFillEmptyRowsImpl($indices, indices.shape, indices.dtype, $values, values.dtype, $denseShape, $defaultValue), 5), outputIndices = _a[0], outputIndicesShape = _a[1], outputValues = _a[2], emptyRowIndicator = _a[3], reverseIndexMap = _a[4];
|
return [
|
backend.makeTensorInfo(outputIndicesShape, indices.dtype, outputIndices),
|
backend.makeTensorInfo([outputIndicesShape[0]], values.dtype, outputValues),
|
backend.makeTensorInfo([emptyRowIndicator.length], 'bool', new Uint8Array(emptyRowIndicator.map(function (value) { return Number(value); }))),
|
backend.makeTensorInfo([reverseIndexMap.length], indices.dtype, new Int32Array(reverseIndexMap)),
|
];
|
}
|
var sparseFillEmptyRowsConfig = {
|
kernelName: tfjsCore.SparseFillEmptyRows,
|
backendName: 'cpu',
|
kernelFunc: sparseFillEmptyRows,
|
};
|
|
function sparseReshape(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var inputIndices = inputs.inputIndices, inputShape = inputs.inputShape, newShape = inputs.newShape;
|
if (inputIndices.shape.length !== 2) {
|
throw new Error("Input indices should be a matrix but received shape\n ".concat(inputIndices.shape));
|
}
|
if (inputShape.shape.length !== 1) {
|
throw new Error("Input shape should be a vector but received shape\n ".concat(inputShape.shape));
|
}
|
if (newShape.shape.length !== 1) {
|
throw new Error("Target shape should be a vector but received shape ".concat(newShape.shape));
|
}
|
var $inputShape = Array.from(backend.data.get(inputShape.dataId).values);
|
var $inputIndices = backend.data.get(inputIndices.dataId).values;
|
var targetShape = Array.from(backend.data.get(newShape.dataId).values);
|
var _a = __read(sparseReshapeImpl($inputIndices, inputIndices.shape, inputIndices.dtype, $inputShape, targetShape), 3), newIndices = _a[0], indicesShape = _a[1], outputShape = _a[2];
|
return [
|
backend.makeTensorInfo(indicesShape, inputIndices.dtype, newIndices),
|
backend.makeTensorInfo([outputShape.length], newShape.dtype, new Int32Array(outputShape)),
|
];
|
}
|
var sparseReshapeConfig = {
|
kernelName: tfjsCore.SparseReshape,
|
backendName: 'cpu',
|
kernelFunc: sparseReshape,
|
};
|
|
function sparseSegmentMean(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var data = inputs.data, indices = inputs.indices, segmentIds = inputs.segmentIds;
|
if (data.shape.length < 1) {
|
throw new Error("Data should be at least 1 dimensional but received scalar");
|
}
|
if (indices.shape.length !== 1) {
|
throw new Error("Indices should be a vector but received shape\n ".concat(indices.shape));
|
}
|
if (segmentIds.shape.length !== 1) {
|
throw new Error("Segment ids should be a vector but received shape\n ".concat(segmentIds.shape));
|
}
|
if (indices.shape[0] !== segmentIds.shape[0]) {
|
throw new Error("segmentIds and indices should have same size.");
|
}
|
var $data = backend.data.get(data.dataId).values;
|
var $indices = backend.data.get(indices.dataId).values;
|
var $segmentIds = backend.data.get(segmentIds.dataId).values;
|
var _a = __read(sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds, true), 2), outputData = _a[0], outputDataShape = _a[1];
|
return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
|
}
|
var sparseSegmentMeanConfig = {
|
kernelName: tfjsCore.SparseSegmentMean,
|
backendName: 'cpu',
|
kernelFunc: sparseSegmentMean,
|
};
|
|
function sparseSegmentSum(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var data = inputs.data, indices = inputs.indices, segmentIds = inputs.segmentIds;
|
if (data.shape.length < 1) {
|
throw new Error("Data should be at least 1 dimensional but received scalar");
|
}
|
if (indices.shape.length !== 1) {
|
throw new Error("Indices should be a vector but received shape\n ".concat(indices.shape));
|
}
|
if (segmentIds.shape.length !== 1) {
|
throw new Error("Segment ids should be a vector but received shape\n ".concat(segmentIds.shape));
|
}
|
if (indices.shape[0] !== segmentIds.shape[0]) {
|
throw new Error("segmentIds and indices should have same size.");
|
}
|
var $data = backend.data.get(data.dataId).values;
|
var $indices = backend.data.get(indices.dataId).values;
|
var $segmentIds = backend.data.get(segmentIds.dataId).values;
|
var _a = __read(sparseSegmentReductionImpl($data, data.shape, data.dtype, $indices, $segmentIds), 2), outputData = _a[0], outputDataShape = _a[1];
|
return backend.makeTensorInfo(outputDataShape, data.dtype, outputData);
|
}
|
var sparseSegmentSumConfig = {
|
kernelName: tfjsCore.SparseSegmentSum,
|
backendName: 'cpu',
|
kernelFunc: sparseSegmentSum,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function sparseToDense(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var sparseIndices = inputs.sparseIndices, sparseValues = inputs.sparseValues, defaultValue = inputs.defaultValue;
|
var outputShape = attrs.outputShape;
|
var _a = tfjsCore.backend_util.calculateShapes(sparseValues, sparseIndices, outputShape), sliceRank = _a.sliceRank, numUpdates = _a.numUpdates, sliceSize = _a.sliceSize, strides = _a.strides, outputSize = _a.outputSize;
|
var sumDupeIndices = false;
|
var indicesBuf = backend.bufferSync(sparseIndices);
|
var outBuf;
|
switch (sparseValues.dtype) {
|
case 'bool': {
|
var updatesBuf = backend.bufferSync(sparseValues);
|
var $defaultValue = Boolean(backend.data.get(defaultValue.dataId).values[0]);
|
outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
|
break;
|
}
|
case 'float32': {
|
var updatesBuf = backend.bufferSync(sparseValues);
|
var $defaultValue = backend.data.get(defaultValue.dataId).values[0];
|
outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
|
break;
|
}
|
case 'int32': {
|
var updatesBuf = backend.bufferSync(sparseValues);
|
var $defaultValue = backend.data.get(defaultValue.dataId).values[0];
|
outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
|
break;
|
}
|
case 'string': {
|
var updatesBuf = backend.bufferSync(sparseValues);
|
var $defaultValue = tfjsCore.util.decodeString(backend.data.get(defaultValue.dataId).values[0]);
|
outBuf = scatterImpl(indicesBuf, updatesBuf, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, $defaultValue, sumDupeIndices);
|
break;
|
}
|
default:
|
throw new Error("Unsupported type ".concat(sparseValues.dtype));
|
}
|
return backend.makeTensorInfo(outputShape, outBuf.dtype, outBuf.values);
|
}
|
var sparseToDenseConfig = {
|
kernelName: tfjsCore.SparseToDense,
|
backendName: 'cpu',
|
kernelFunc: sparseToDense
|
};
|
|
function splitV(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var numOrSizeSplits = attrs.numOrSizeSplits, axis = attrs.axis;
|
var $axis = tfjsCore.util.parseAxisParam(axis, x.shape)[0];
|
var splitSizes = tfjsCore.backend_util.prepareSplitSize(x, numOrSizeSplits, $axis);
|
var begin = new Array(x.shape.length).fill(0);
|
var size = x.shape.slice();
|
return splitSizes.map(function (s) {
|
var sliceSize = __spreadArray([], __read(size), false);
|
sliceSize[$axis] = s;
|
var sliceT = slice({ inputs: { x: x }, backend: backend, attrs: { begin: begin, size: sliceSize } });
|
begin[$axis] += s;
|
return sliceT;
|
});
|
}
|
var splitVConfig = {
|
kernelName: tfjsCore.SplitV,
|
backendName: 'cpu',
|
kernelFunc: splitV
|
};
|
|
/**
|
* @license
|
* Copyright 2019 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.
|
* =============================================================================
|
*/
|
var squareConfig = {
|
kernelName: tfjsCore.Square,
|
backendName: 'cpu',
|
kernelFunc: function (_a) {
|
var inputs = _a.inputs, backend = _a.backend;
|
var x = inputs.x;
|
var cpuBackend = backend;
|
assertNotComplex(x, 'square');
|
var values = cpuBackend.data.get(x.dataId).values;
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
newValues[i] = value * value;
|
}
|
var dataId = cpuBackend.write(newValues, x.shape, x.dtype);
|
return { dataId: dataId, shape: x.shape, dtype: x.dtype };
|
}
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var step = unaryKernelFunc(tfjsCore.Step, function (xi, attrs) {
|
var stepAttrs = attrs;
|
if (isNaN(xi)) {
|
return NaN;
|
}
|
else {
|
return xi > 0 ? 1 : stepAttrs.alpha;
|
}
|
});
|
var stepConfig = {
|
kernelName: tfjsCore.Step,
|
backendName: 'cpu',
|
kernelFunc: step,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function stridedSlice(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var begin = attrs.begin, end = attrs.end, strides = attrs.strides, beginMask = attrs.beginMask, endMask = attrs.endMask, ellipsisMask = attrs.ellipsisMask, newAxisMask = attrs.newAxisMask, shrinkAxisMask = attrs.shrinkAxisMask;
|
assertNotComplex(x, 'stridedSlice');
|
var _a = tfjsCore.slice_util.sliceInfo(x.shape, begin, end, strides, beginMask, endMask, ellipsisMask, newAxisMask, shrinkAxisMask), finalShapeSparse = _a.finalShapeSparse, finalShape = _a.finalShape, isIdentity = _a.isIdentity, sliceDim0 = _a.sliceDim0, isSimpleSlice = _a.isSimpleSlice, $begin = _a.begin, $end = _a.end, $strides = _a.strides;
|
var result;
|
// ref:
|
// https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/strided_slice_op.cc
|
if (isIdentity) {
|
// Optimization #1, slice is a no-op plus reshape
|
result = reshape({ inputs: { x: x }, backend: backend, attrs: { shape: finalShape } });
|
}
|
else if (sliceDim0 || isSimpleSlice) {
|
// Optimization #2, slice is memory contiguous (only occurs in dim 0)
|
tfjsCore.util.assert(x.shape.length >= 1, function () { return "Input must have rank at least 1, got: ".concat(x.shape.length); });
|
var size = tfjsCore.slice_util.computeOutShape($begin, $end, $strides);
|
// To tolerate begin[0] > end[0] (a 0-output slice), we min(begin, end).
|
var sliced = slice({ inputs: { x: x }, backend: backend, attrs: { begin: $begin, size: size } });
|
result =
|
reshape({ inputs: { x: sliced }, backend: backend, attrs: { shape: finalShape } });
|
backend.disposeIntermediateTensorInfo(sliced);
|
}
|
else {
|
var xBuf = backend.bufferSync(x);
|
var outBuf = stridedSliceImpl(finalShapeSparse, xBuf, $strides, $begin);
|
result = backend.makeTensorInfo(finalShape, outBuf.dtype, outBuf.values);
|
}
|
return result;
|
}
|
var stridedSliceConfig = {
|
kernelName: tfjsCore.StridedSlice,
|
backendName: 'cpu',
|
kernelFunc: stridedSlice
|
};
|
|
function stringNGrams(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var separator = attrs.separator, nGramWidths = attrs.nGramWidths, leftPad = attrs.leftPad, rightPad = attrs.rightPad, padWidth = attrs.padWidth, preserveShortSequences = attrs.preserveShortSequences;
|
var data = inputs.data, dataSplits = inputs.dataSplits;
|
var $data = backend.data.get(data.dataId).values;
|
var $dataSplits = backend.data.get(dataSplits.dataId).values;
|
var _a = __read(stringNGramsImpl($data, $dataSplits, separator, nGramWidths, leftPad, rightPad, padWidth, preserveShortSequences), 2), nGrams = _a[0], nGramsSplits = _a[1];
|
return [
|
backend.makeTensorInfo([nGrams.length], 'string', nGrams),
|
backend.makeTensorInfo(dataSplits.shape, 'int32', nGramsSplits),
|
];
|
}
|
var stringNGramsConfig = {
|
kernelName: tfjsCore.StringNGrams,
|
backendName: 'cpu',
|
kernelFunc: stringNGrams,
|
};
|
|
function stringSplit(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var skipEmpty = attrs.skipEmpty;
|
var input = inputs.input, delimiter = inputs.delimiter;
|
if (input.dtype !== 'string') {
|
throw new Error('Input must be of datatype string');
|
}
|
if (input.shape.length !== 1) {
|
throw new Error("Input must be a vector, got shape: ".concat(input.shape));
|
}
|
if (delimiter.shape.length !== 0) {
|
throw new Error("Delimiter must be a scalar, got shape: ".concat(delimiter.shape));
|
}
|
var $input = backend.data.get(input.dataId).values;
|
var $delimiter = backend.data.get(delimiter.dataId).values[0];
|
var _a = __read(stringSplitImpl($input, $delimiter, skipEmpty), 3), indices = _a[0], values = _a[1], shape = _a[2];
|
var outputSize = values.length;
|
return [
|
backend.makeTensorInfo([outputSize, 2], 'int32', indices),
|
backend.makeTensorInfo([outputSize], 'string', values),
|
backend.makeTensorInfo([2], 'int32', new Int32Array(shape))
|
];
|
}
|
var stringSplitConfig = {
|
kernelName: tfjsCore.StringSplit,
|
backendName: 'cpu',
|
kernelFunc: stringSplit,
|
};
|
|
/**
|
* @license
|
* Copyright 2021 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.
|
* =============================================================================
|
*/
|
function stringToHashBucketFast(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var numBuckets = attrs.numBuckets;
|
var input = inputs.input;
|
if (input.dtype !== 'string') {
|
throw new Error('Input must be of datatype string');
|
}
|
if (numBuckets <= 0) {
|
throw new Error("Number of buckets must be at least 1");
|
}
|
var $input = backend.data.get(input.dataId).values;
|
var output = stringToHashBucketFastImpl($input, numBuckets);
|
return backend.makeTensorInfo(input.shape, 'int32', output);
|
}
|
var stringToHashBucketFastConfig = {
|
kernelName: tfjsCore.StringToHashBucketFast,
|
backendName: 'cpu',
|
kernelFunc: stringToHashBucketFast,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var tan = unaryKernelFunc(tfjsCore.Tan, function (xi) { return Math.tan(xi); });
|
var tanConfig = {
|
kernelName: tfjsCore.Tan,
|
backendName: 'cpu',
|
kernelFunc: tan,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
var tanh = unaryKernelFunc(tfjsCore.Tanh, function (xi) { return Math.tanh(xi); });
|
var tanhConfig = {
|
kernelName: tfjsCore.Tanh,
|
backendName: 'cpu',
|
kernelFunc: tanh,
|
};
|
|
/**
|
* @license
|
* Copyright 2022 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.
|
* =============================================================================
|
*/
|
function tensorScatterUpdate(args) {
|
var inputs = args.inputs, backend = args.backend;
|
var tensor = inputs.tensor, indices = inputs.indices, updates = inputs.updates;
|
var _a = tfjsCore.backend_util.calculateShapes(updates, indices, tensor.shape), sliceRank = _a.sliceRank, numUpdates = _a.numUpdates, sliceSize = _a.sliceSize, strides = _a.strides, outputSize = _a.outputSize;
|
var sumDupeIndices = false;
|
var indicesBuf = backend.bufferSync(indices);
|
var updatesBuf = backend.bufferSync(updates);
|
var tensorBuf = backend.bufferSync(tensor);
|
var outBuf = scatterImpl(indicesBuf, updatesBuf, tensor.shape, outputSize, sliceSize, numUpdates, sliceRank, strides, tensorBuf, sumDupeIndices);
|
return backend.makeTensorInfo(tensor.shape, outBuf.dtype, outBuf.values);
|
}
|
var tensorScatterUpdateConfig = {
|
kernelName: tfjsCore.TensorScatterUpdate,
|
backendName: 'cpu',
|
kernelFunc: tensorScatterUpdate
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function tile(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var reps = attrs.reps;
|
assertNotComplex(x, 'tile');
|
var outBuf = tileImpl(backend.bufferSync(x), reps);
|
return backend.makeTensorInfo(outBuf.shape, outBuf.dtype, outBuf.values);
|
}
|
var tileConfig = {
|
kernelName: tfjsCore.Tile,
|
backendName: 'cpu',
|
kernelFunc: tile
|
};
|
|
function topK(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x;
|
var k = attrs.k, sorted = attrs.sorted;
|
assertNotComplex(x, 'topk');
|
var xVals = backend.data.get(x.dataId).values;
|
var _a = __read(topKImpl(xVals, x.shape, x.dtype, k, sorted), 2), allTopKVals = _a[0], allTopKIndices = _a[1];
|
return [
|
backend.makeTensorInfo(allTopKVals.shape, allTopKVals.dtype, allTopKVals.values),
|
backend.makeTensorInfo(allTopKIndices.shape, allTopKIndices.dtype, allTopKIndices.values)
|
];
|
}
|
var topKConfig = {
|
kernelName: tfjsCore.TopK,
|
backendName: 'cpu',
|
kernelFunc: topK
|
};
|
|
function transform(args) {
|
var inputs = args.inputs, attrs = args.attrs, backend = args.backend;
|
var image = inputs.image, transforms = inputs.transforms;
|
var interpolation = attrs.interpolation, fillMode = attrs.fillMode, fillValue = attrs.fillValue, outputShape = attrs.outputShape;
|
var _a = __read(image.shape, 4), batch = _a[0], imageHeight = _a[1], imageWidth = _a[2], numChannels = _a[3];
|
var _b = __read(outputShape != null ? outputShape : [imageHeight, imageWidth], 2), outHeight = _b[0], outWidth = _b[1];
|
var outShape = [batch, outHeight, outWidth, numChannels];
|
var inStrides = tfjsCore.util.computeStrides(image.shape);
|
var batchInStride = inStrides[0];
|
var rowInStride = inStrides[1];
|
var colInStride = inStrides[2];
|
var outStrides = tfjsCore.util.computeStrides(outShape);
|
var batchOutStride = outStrides[0];
|
var rowOutStride = outStrides[1];
|
var colOutStride = outStrides[2];
|
var outVals = tfjsCore.util.getTypedArrayFromDType(image.dtype, tfjsCore.util.sizeFromShape(outShape));
|
outVals.fill(fillValue);
|
var imageVals = backend.data.get(image.dataId).values;
|
var transformVals = backend.data.get(transforms.dataId).values;
|
// Ref TF implementation:
|
// https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/kernels/image/image_ops.h
|
for (var b = 0; b < batch; ++b) {
|
var transform_1 = transforms.shape[0] === 1 ?
|
transformVals :
|
transformVals.subarray(b * 8, b * 8 + 8);
|
for (var outY = 0; outY < outHeight; ++outY) {
|
for (var outX = 0; outX < outWidth; ++outX) {
|
for (var channel = 0; channel < numChannels; ++channel) {
|
var val = void 0;
|
var projection = transform_1[6] * outX + transform_1[7] * outY + 1;
|
if (projection === 0) {
|
// Return the fill value for infinite coordinates,
|
// which are outside the input image
|
continue;
|
}
|
var inX = (transform_1[0] * outX + transform_1[1] * outY + transform_1[2]) /
|
projection;
|
var inY = (transform_1[3] * outX + transform_1[4] * outY + transform_1[5]) /
|
projection;
|
var x = mapCoord(inX, imageWidth, fillMode);
|
var y = mapCoord(inY, imageHeight, fillMode);
|
switch (interpolation) {
|
case 'nearest':
|
val = nearestInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
|
break;
|
case 'bilinear':
|
val = bilinearInterpolation(imageVals, imageHeight, imageWidth, batchInStride, rowInStride, colInStride, b, y, x, channel, fillValue);
|
break;
|
default:
|
throw new Error("Error in Transform: Expect 'nearest' or " +
|
"'bilinear', but got ".concat(interpolation));
|
}
|
var ind = b * batchOutStride + outY * rowOutStride +
|
outX * colOutStride + channel;
|
outVals[ind] = val;
|
}
|
}
|
}
|
return backend.makeTensorInfo(outShape, image.dtype, outVals);
|
}
|
var dataId = backend.write(outVals, outShape, image.dtype);
|
return { dataId: dataId, shape: image.shape, dtype: image.dtype };
|
}
|
var transformConfig = {
|
kernelName: tfjsCore.Transform,
|
backendName: 'cpu',
|
kernelFunc: transform
|
};
|
function mapCoord(outCoord, len, mode) {
|
switch (mode) {
|
case 'reflect':
|
return mapCoordReflect(outCoord, len);
|
case 'wrap':
|
return mapCoordWrap(outCoord, len);
|
case 'nearest':
|
return mapCoordNearest(outCoord, len);
|
case 'constant':
|
default:
|
return mapCoordConstant(outCoord);
|
}
|
}
|
function mapCoordReflect(outCoord, len) {
|
// Reflect [abcd] to [dcba|abcd|dcba].
|
var inCoord = outCoord;
|
if (inCoord < 0) {
|
if (len <= 1) {
|
inCoord = 0;
|
}
|
else {
|
var sz2 = 2 * len;
|
if (inCoord < sz2) {
|
inCoord = sz2 * Math.trunc(-inCoord / sz2) + inCoord;
|
}
|
inCoord = inCoord < -len ? inCoord + sz2 : -inCoord - 1;
|
}
|
}
|
else if (inCoord > len - 1) {
|
if (len <= 1) {
|
inCoord = 0;
|
}
|
else {
|
var sz2 = 2 * len;
|
inCoord -= sz2 * Math.trunc(inCoord / sz2);
|
if (inCoord >= len) {
|
inCoord = sz2 - inCoord - 1;
|
}
|
}
|
}
|
// clamp is necessary because when outCoord = 3.5 and len = 4,
|
// inCoord = 3.5 and will be rounded to 4 in nearest interpolation.
|
return tfjsCore.util.clamp(0, inCoord, len - 1);
|
}
|
function mapCoordWrap(outCoord, len) {
|
// Wrap [abcd] to [abcd|abcd|abcd].
|
var inCoord = outCoord;
|
if (inCoord < 0) {
|
if (len <= 1) {
|
inCoord = 0;
|
}
|
else {
|
var sz = len - 1;
|
inCoord += len * (Math.trunc(-inCoord / sz) + 1);
|
}
|
}
|
else if (inCoord > len - 1) {
|
if (len <= 1) {
|
inCoord = 0;
|
}
|
else {
|
var sz = len - 1;
|
inCoord -= len * Math.trunc(inCoord / sz);
|
}
|
}
|
// clamp is necessary because when outCoord = -0.5 and len = 4,
|
// inCoord = 3.5 and will be rounded to 4 in nearest interpolation.
|
return tfjsCore.util.clamp(0, inCoord, len - 1);
|
}
|
function mapCoordConstant(outCoord, len) {
|
return outCoord;
|
}
|
function mapCoordNearest(outCoord, len) {
|
return tfjsCore.util.clamp(0, outCoord, len - 1);
|
}
|
function readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
|
var ind = batch * batchStride + y * rowStride + x * colStride + channel;
|
if (0 <= y && y < imageHeight && 0 <= x && x < imageWidth) {
|
return imageVals[ind];
|
}
|
else {
|
return fillValue;
|
}
|
}
|
function nearestInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
|
var $y = Math.round(y);
|
var $x = Math.round(x);
|
return readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, $y, $x, channel, fillValue);
|
}
|
function bilinearInterpolation(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, y, x, channel, fillValue) {
|
var yFloor = Math.floor(y);
|
var xFloor = Math.floor(x);
|
var yCeil = yFloor + 1;
|
var xCeil = xFloor + 1;
|
// f(x, yFloor) = (xCeil - x) / (xCeil - xFloor) * f(xFloor, yFloor)
|
// + (x - xFloor) / (xCeil - xFloor) * f(xCeil, yFloor)
|
var valueYFloor = (xCeil - x) *
|
readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xFloor, channel, fillValue) +
|
(x - xFloor) *
|
readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yFloor, xCeil, channel, fillValue);
|
// f(x, yCeil) = (xCeil - x) / (xCeil - xFloor) * f(xFloor, yCeil)
|
// + (x - xFloor) / (xCeil - xFloor) * f(xCeil, yCeil)
|
var valueYCeil = (xCeil - x) *
|
readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xFloor, channel, fillValue) +
|
(x - xFloor) *
|
readWithFillValue(imageVals, imageHeight, imageWidth, batchStride, rowStride, colStride, batch, yCeil, xCeil, channel, fillValue);
|
// f(x, y) = (yCeil - y) / (yCeil - yFloor) * f(x, yFloor)
|
// + (y - yFloor) / (yCeil - yFloor) * f(x, yCeil)
|
return (yCeil - y) * valueYFloor + (y - yFloor) * valueYCeil;
|
}
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function unique(args) {
|
var inputs = args.inputs, attrs = args.attrs, backend = args.backend;
|
var axis = attrs.axis;
|
var x = inputs.x;
|
assertNotComplex(x, 'unique');
|
var values = backend.data.get(x.dataId).values;
|
var _a = uniqueImpl(values, axis, x.shape, x.dtype), outputValues = _a.outputValues, outputShape = _a.outputShape, indices = _a.indices;
|
return [
|
backend.makeTensorInfo(outputShape, x.dtype, outputValues),
|
backend.makeTensorInfo([indices.length], 'int32', indices),
|
];
|
}
|
var uniqueConfig = {
|
kernelName: tfjsCore.Unique,
|
backendName: 'cpu',
|
kernelFunc: unique,
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function unpack(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var value = inputs.value;
|
var axis = attrs.axis;
|
if (axis < 0) {
|
axis += value.shape.length;
|
}
|
var valueRank = value.shape.length;
|
var num = value.shape[axis];
|
var outShape = new Array(valueRank - 1);
|
var outIndex = 0;
|
for (var i = 0; i < valueRank; i++) {
|
if (i !== axis) {
|
outShape[outIndex++] = value.shape[i];
|
}
|
}
|
var begin = new Array(valueRank).fill(0);
|
var size = value.shape.slice();
|
size[axis] = 1;
|
var res = new Array(num);
|
for (var i = 0; i < res.length; i++) {
|
begin[axis] = i;
|
var tempRes = slice({ inputs: { x: value }, backend: backend, attrs: { begin: begin, size: size } });
|
res[i] = reshape({ inputs: { x: tempRes }, backend: backend, attrs: { shape: outShape } });
|
backend.disposeIntermediateTensorInfo(tempRes);
|
}
|
return res;
|
}
|
var unpackConfig = {
|
kernelName: tfjsCore.Unpack,
|
backendName: 'cpu',
|
kernelFunc: unpack
|
};
|
|
/**
|
* @license
|
* Copyright 2020 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.
|
* =============================================================================
|
*/
|
function unsortedSegmentSum(args) {
|
var inputs = args.inputs, backend = args.backend, attrs = args.attrs;
|
var x = inputs.x, segmentIds = inputs.segmentIds;
|
var numSegments = attrs.numSegments;
|
assertNotComplex(x, 'unsortedSegmentSum');
|
var xRank = x.shape.length;
|
var segmentIdsRank = segmentIds.shape.length;
|
var res = [];
|
var intermediates = [];
|
// Reshape the segment id's so that they can be broadcast with
|
// x. The new shape should be [segmentIds.shape, 1, ..., 1]
|
var numIters = xRank - segmentIdsRank;
|
var $segmentIds = segmentIds;
|
for (var i = 0; i < numIters; ++i) {
|
var expanded = expandDims({ inputs: { input: $segmentIds }, backend: backend, attrs: { dim: i + 1 } });
|
$segmentIds = expanded;
|
intermediates.push(expanded);
|
}
|
for (var i = 0; i < numSegments; ++i) {
|
var scalarValue = tfjsCore.util.createScalarValue(i, 'int32');
|
var segmentId = backend.makeTensorInfo([], 'int32', scalarValue);
|
var mask = equal({ inputs: { a: segmentId, b: $segmentIds }, backend: backend });
|
var maskCasted = cast({ inputs: { x: mask }, backend: backend, attrs: { dtype: 'float32' } });
|
var mul = multiply({ inputs: { a: maskCasted, b: x }, backend: backend });
|
var sumTensorInfo = sum({ inputs: { x: mul }, backend: backend, attrs: { axis: 0, keepDims: false } });
|
res.push(sumTensorInfo);
|
intermediates.push(segmentId);
|
intermediates.push(mask);
|
intermediates.push(maskCasted);
|
intermediates.push(mul);
|
intermediates.push(sumTensorInfo);
|
}
|
var result = pack({ inputs: res, backend: backend, attrs: { axis: 0 } });
|
intermediates.forEach(function (t) { return backend.disposeIntermediateTensorInfo(t); });
|
return result;
|
}
|
var unsortedSegmentSumConfig = {
|
kernelName: tfjsCore.UnsortedSegmentSum,
|
backendName: 'cpu',
|
kernelFunc: unsortedSegmentSum
|
};
|
|
var e_1, _a;
|
// List all kernel configs here
|
var kernelConfigs = [
|
_fusedMatMulConfig,
|
absConfig,
|
acosConfig,
|
acoshConfig,
|
addConfig,
|
addNConfig,
|
allConfig,
|
anyConfig,
|
argMaxConfig,
|
argMinConfig,
|
asinConfig,
|
asinhConfig,
|
atanConfig,
|
atan2Config,
|
atanhConfig,
|
avgPoolConfig,
|
avgPool3DConfig,
|
avgPool3DGradConfig,
|
avgPoolGradConfig,
|
batchMatMulConfig,
|
batchNormConfig,
|
batchToSpaceNDConfig,
|
bincountConfig,
|
bitwiseAndConfig,
|
broadcastArgsConfig,
|
castConfig,
|
ceilConfig,
|
clipByValueConfig,
|
complexConfig,
|
complexAbsConfig,
|
concatConfig,
|
conv2DConfig,
|
conv2DBackpropFilterConfig,
|
conv2DBackpropInputConfig,
|
conv3DConfig,
|
conv3DBackpropFilterV2Config,
|
conv3DBackpropInputV2Config,
|
cosConfig,
|
coshConfig,
|
cropAndResizeConfig,
|
cumprodConfig,
|
cumsumConfig,
|
denseBincountConfig,
|
depthToSpaceConfig,
|
depthwiseConv2dNativeConfig,
|
depthwiseConv2dNativeBackpropFilterConfig,
|
depthwiseConv2dNativeBackpropInputConfig,
|
diagConfig,
|
dilation2DConfig,
|
dilation2DBackpropFilterConfig,
|
dilation2DBackpropInputConfig,
|
drawConfig,
|
einsumConfig,
|
eluConfig,
|
eluGradConfig,
|
equalConfig,
|
erfConfig,
|
expConfig,
|
expandDimsConfig,
|
expm1Config,
|
fftConfig,
|
fillConfig,
|
flipLeftRightConfig,
|
floorConfig,
|
floorDivConfig,
|
fusedConv2DConfig,
|
fusedDepthwiseConv2DConfig,
|
gatherNdConfig,
|
gatherV2Config,
|
greaterConfig,
|
greaterEqualConfig,
|
identityConfig,
|
ifftConfig,
|
imagConfig,
|
isFiniteConfig,
|
isInfConfig,
|
isNaNConfig,
|
leakyReluConfig,
|
lessConfig,
|
lessEqualConfig,
|
linSpaceConfig,
|
logConfig,
|
log1pConfig,
|
logicalAndConfig,
|
logicalNotConfig,
|
logicalOrConfig,
|
LRNConfig,
|
LRNGradConfig,
|
maxConfig,
|
maximumConfig,
|
maxPoolConfig,
|
maxPool3DConfig,
|
maxPool3DGradConfig,
|
maxPoolGradConfig,
|
maxPoolWithArgmaxConfig,
|
meanConfig,
|
minConfig,
|
minimumConfig,
|
mirrorPadConfig,
|
modConfig,
|
multinomialConfig,
|
multiplyConfig,
|
negConfig,
|
nonMaxSuppressionV3Config,
|
nonMaxSuppressionV4Config,
|
nonMaxSuppressionV5Config,
|
notEqualConfig,
|
oneHotConfig,
|
onesLikeConfig,
|
packConfig,
|
padV2Config,
|
powConfig,
|
preluConfig,
|
prodConfig,
|
raggedGatherConfig,
|
raggedRangeConfig,
|
raggedTensorToTensorConfig,
|
rangeConfig,
|
realConfig,
|
realDivConfig,
|
reciprocalConfig,
|
reluConfig,
|
relu6Config,
|
reshapeConfig,
|
resizeBilinearConfig,
|
resizeBilinearGradConfig,
|
resizeNearestNeighborConfig,
|
resizeNearestNeighborGradConfig,
|
reverseConfig,
|
rotateWithOffsetConfig,
|
roundConfig,
|
rsqrtConfig,
|
scatterNdConfig,
|
searchSortedConfig,
|
selectConfig,
|
seluConfig,
|
sigmoidConfig,
|
signConfig,
|
sinConfig,
|
sinhConfig,
|
sliceConfig,
|
softmaxConfig,
|
softplusConfig,
|
spaceToBatchNDConfig,
|
sparseFillEmptyRowsConfig,
|
sparseReshapeConfig,
|
sparseSegmentMeanConfig,
|
sparseSegmentSumConfig,
|
sparseToDenseConfig,
|
splitVConfig,
|
sqrtConfig,
|
squareConfig,
|
squaredDifferenceConfig,
|
staticRegexReplaceConfig,
|
stepConfig,
|
stridedSliceConfig,
|
stringNGramsConfig,
|
stringSplitConfig,
|
stringToHashBucketFastConfig,
|
subConfig,
|
sumConfig,
|
tanConfig,
|
tanhConfig,
|
tensorScatterUpdateConfig,
|
tileConfig,
|
topKConfig,
|
transformConfig,
|
transposeConfig,
|
uniqueConfig,
|
unpackConfig,
|
unsortedSegmentSumConfig,
|
zerosLikeConfig
|
];
|
try {
|
for (var kernelConfigs_1 = __values(kernelConfigs), kernelConfigs_1_1 = kernelConfigs_1.next(); !kernelConfigs_1_1.done; kernelConfigs_1_1 = kernelConfigs_1.next()) {
|
var kernelConfig = kernelConfigs_1_1.value;
|
tfjsCore.registerKernel(kernelConfig);
|
}
|
}
|
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
finally {
|
try {
|
if (kernelConfigs_1_1 && !kernelConfigs_1_1.done && (_a = kernelConfigs_1.return)) _a.call(kernelConfigs_1);
|
}
|
finally { if (e_1) throw e_1.error; }
|
}
|
|
exports.MathBackendCPU = MathBackendCPU;
|
exports.shared = shared;
|
exports.version_cpu = version;
|
//# sourceMappingURL=tf-backend-cpu.node.js.map
|
