"use strict";
|
/**
|
* @license
|
* Copyright 2017 Google Inc. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
* =============================================================================
|
*/
|
var __extends = (this && this.__extends) || (function () {
|
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 (b.hasOwnProperty(p)) d[p] = b[p]; };
|
return extendStatics(d, b);
|
};
|
return function (d, b) {
|
extendStatics(d, b);
|
function __() { this.constructor = d; }
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
};
|
})();
|
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
|
return new (P || (P = Promise))(function (resolve, reject) {
|
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
|
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
});
|
};
|
var __generator = (this && this.__generator) || function (thisArg, body) {
|
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
function verb(n) { return function (v) { return step([n, v]); }; }
|
function step(op) {
|
if (f) throw new TypeError("Generator is already executing.");
|
while (_) try {
|
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
if (y = 0, t) op = [op[0] & 2, t.value];
|
switch (op[0]) {
|
case 0: case 1: t = op; break;
|
case 4: _.label++; return { value: op[1], done: false };
|
case 5: _.label++; y = op[1]; op = [0]; continue;
|
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
default:
|
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
if (t[2]) _.ops.pop();
|
_.trys.pop(); continue;
|
}
|
op = body.call(thisArg, _);
|
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
}
|
};
|
Object.defineProperty(exports, "__esModule", { value: true });
|
var seedrandom = require("seedrandom");
|
var engine_1 = require("../../engine");
|
var environment_1 = require("../../environment");
|
var log_1 = require("../../log");
|
var array_ops_util = require("../../ops/array_ops_util");
|
var axis_util = require("../../ops/axis_util");
|
var broadcast_util = require("../../ops/broadcast_util");
|
var complex_ops_1 = require("../../ops/complex_ops");
|
var concat_util = require("../../ops/concat_util");
|
var erf_util = require("../../ops/erf_util");
|
var gather_nd_util = require("../../ops/gather_nd_util");
|
var ops = require("../../ops/ops");
|
var ops_1 = require("../../ops/ops");
|
var scatter_nd_util = require("../../ops/scatter_nd_util");
|
var selu_util = require("../../ops/selu_util");
|
var slice_util_1 = require("../../ops/slice_util");
|
var tensor_1 = require("../../tensor");
|
var types_1 = require("../../types");
|
var util = require("../../util");
|
var util_1 = require("../../util");
|
var backend_1 = require("../backend");
|
var backend_util = require("../backend_util");
|
var complex_util = require("../complex_util");
|
var non_max_suppression_impl_1 = require("../non_max_suppression_impl");
|
var split_shared_1 = require("../split_shared");
|
var tile_impl_1 = require("../tile_impl");
|
var topk_impl_1 = require("../topk_impl");
|
var where_impl_1 = require("../where_impl");
|
var cpu_util_1 = require("./cpu_util");
|
function mapActivation(backend, x, activation, preluActivationWeights) {
|
if (activation === 'linear') {
|
return backend.linear(x);
|
}
|
else if (activation === 'relu') {
|
return backend.relu(x);
|
}
|
else if (activation === 'elu') {
|
return backend.elu(x);
|
}
|
else if (activation === 'relu6') {
|
return backend.relu6(x);
|
}
|
else if (activation === 'prelu') {
|
return backend.prelu(x, preluActivationWeights);
|
}
|
throw new Error("Activation " + activation + " has not been implemented for the CPU backend.");
|
}
|
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 backend_1.DataStorage(_this, engine_1.ENGINE);
|
return _this;
|
}
|
MathBackendCPU.prototype.write = function (values, shape, dtype) {
|
if (this.firstUse) {
|
this.firstUse = false;
|
if (environment_1.env().get('IS_NODE')) {
|
log_1.warn('\n============================\n' +
|
'Hi there 👋. Looks like you are running TensorFlow.js in ' +
|
'Node.js. To speed things up dramatically, install our node ' +
|
'backend, which binds to TensorFlow C++, by running ' +
|
'npm i @tensorflow/tfjs-node, ' +
|
'or npm i @tensorflow/tfjs-node-gpu if you have CUDA. ' +
|
'Then call require(\'@tensorflow/tfjs-node\'); (-gpu ' +
|
'suffix for CUDA) at the start of your program. ' +
|
'Visit https://github.com/tensorflow/tfjs-node for more details.' +
|
'\n============================');
|
}
|
}
|
var dataId = {};
|
this.data.set(dataId, { values: values, dtype: dtype });
|
return dataId;
|
};
|
MathBackendCPU.prototype.move = function (dataId, values, shape, dtype) {
|
this.data.set(dataId, { values: values, dtype: dtype });
|
};
|
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 (_a) {
|
return [2 /*return*/, this.readSync(dataId)];
|
});
|
});
|
};
|
MathBackendCPU.prototype.readSync = function (dataId) {
|
var _a = this.data.get(dataId), dtype = _a.dtype, complexTensors = _a.complexTensors;
|
if (dtype === 'complex64') {
|
var realValues = this.readSync(complexTensors.real.dataId);
|
var imagValues = this.readSync(complexTensors.imag.dataId);
|
return complex_util.mergeRealAndImagArrays(realValues, imagValues);
|
}
|
return this.data.get(dataId).values;
|
};
|
MathBackendCPU.prototype.bufferSync = function (t) {
|
var data = this.readSync(t.dataId);
|
var decodedData = data;
|
if (t.dtype === 'string') {
|
try {
|
// Decode the bytes into string.
|
decodedData = data.map(function (d) { return util.decodeString(d); });
|
}
|
catch (_a) {
|
throw new Error('Failed to decode encoded string bytes into utf-8');
|
}
|
}
|
return ops_1.buffer(t.shape, t.dtype, decodedData);
|
};
|
MathBackendCPU.prototype.makeOutput = function (values, shape, dtype) {
|
var dataId = this.write(values, shape, dtype);
|
return engine_1.ENGINE.makeTensorFromDataId(dataId, shape, dtype, this);
|
};
|
MathBackendCPU.prototype.disposeData = function (dataId) {
|
if (this.data.has(dataId)) {
|
var complexTensors = this.data.get(dataId).complexTensors;
|
if (complexTensors != null) {
|
complexTensors.real.dispose();
|
complexTensors.imag.dispose();
|
}
|
this.data.delete(dataId);
|
}
|
};
|
MathBackendCPU.prototype.time = function (f) {
|
return __awaiter(this, void 0, void 0, function () {
|
var start, kernelMs;
|
return __generator(this, function (_a) {
|
start = util_1.now();
|
f();
|
kernelMs = util_1.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.complex = function (real, imag) {
|
var result = this.makeOutput(null, real.shape, 'complex64');
|
var resultData = this.data.get(result.dataId);
|
// The backend owns the reference to the underlying real and imaginary
|
// clones. These will explicitly get disposed when the complex tensor is
|
// disposed.
|
resultData.complexTensors = {
|
real: engine_1.ENGINE.keep(real.clone()),
|
imag: engine_1.ENGINE.keep(imag.clone())
|
};
|
return result;
|
};
|
MathBackendCPU.prototype.real = function (input) {
|
var resultData = this.data.get(input.dataId);
|
return resultData.complexTensors.real.clone();
|
};
|
MathBackendCPU.prototype.imag = function (input) {
|
var resultData = this.data.get(input.dataId);
|
return resultData.complexTensors.imag.clone();
|
};
|
MathBackendCPU.prototype.slice = function (x, begin, size) {
|
cpu_util_1.assertNotComplex(x, 'slice');
|
var isContinous = slice_util_1.isSliceContinous(x.shape, begin, size);
|
if (isContinous) {
|
var flatOffset = slice_util_1.computeFlatOffset(begin, x.strides);
|
var length_1 = util.sizeFromShape(size);
|
var vals = this.readSync(x.dataId);
|
return ops_1.tensor(vals.subarray(flatOffset, flatOffset + length_1), size, x.dtype);
|
}
|
var buffer = ops.buffer(size, x.dtype);
|
var xBuf = this.bufferSync(x);
|
for (var i = 0; i < buffer.size; ++i) {
|
var loc = buffer.indexToLoc(i);
|
var xLoc = loc.map(function (idx, j) { return idx + begin[j]; });
|
buffer.values[i] = xBuf.get.apply(xBuf, xLoc);
|
}
|
return buffer.toTensor();
|
};
|
MathBackendCPU.prototype.stridedSlice = function (x, begin, end, strides) {
|
cpu_util_1.assertNotComplex(x, 'stridedSlice');
|
var outShape = slice_util_1.computeOutShape(begin, end, strides);
|
if (outShape.some(function (axis) { return axis === 0; })) {
|
return ops.tensor([], outShape);
|
}
|
var buffer = ops.buffer(outShape, x.dtype);
|
var xBuf = this.bufferSync(x);
|
for (var i = 0; i < buffer.size; i++) {
|
var loc = buffer.indexToLoc(i);
|
var newLoc = new Array(loc.length);
|
for (var j = 0; j < newLoc.length; j++) {
|
newLoc[j] = loc[j] * strides[j] + begin[j];
|
}
|
buffer.set.apply(buffer, [xBuf.get.apply(xBuf, newLoc)].concat(loc));
|
}
|
return buffer.toTensor();
|
};
|
MathBackendCPU.prototype.diag = function (x) {
|
var xVals = this.readSync(x.dataId);
|
var buffer = ops.buffer([x.size, x.size], x.dtype);
|
var vals = buffer.values;
|
for (var i = 0; i < xVals.length; i++) {
|
vals[i * x.size + i] = xVals[i];
|
}
|
return buffer.toTensor();
|
};
|
MathBackendCPU.prototype.unstack = function (x, axis) {
|
var num = x.shape[axis];
|
var outShape = new Array(x.rank - 1);
|
var outIndex = 0;
|
for (var i = 0; i < x.rank; i++) {
|
if (i !== axis) {
|
outShape[outIndex++] = x.shape[i];
|
}
|
}
|
var begin = new Array(x.rank).fill(0);
|
var size = x.shape.slice();
|
size[axis] = 1;
|
var res = new Array(num);
|
for (var i = 0; i < res.length; i++) {
|
begin[axis] = i;
|
res[i] = this.slice(x, begin, size).reshape(outShape);
|
}
|
return res;
|
};
|
MathBackendCPU.prototype.reverse = function (x, axis) {
|
cpu_util_1.assertNotComplex(x, 'reverse');
|
var buffer = ops.buffer(x.shape, x.dtype);
|
var xBuf = this.bufferSync(x);
|
var _loop_1 = function (i) {
|
var outLoc = buffer.indexToLoc(i);
|
var inLoc = outLoc.slice();
|
axis.forEach(function (ax) { return inLoc[ax] = x.shape[ax] - 1 - inLoc[ax]; });
|
buffer.set.apply(buffer, [xBuf.get.apply(xBuf, inLoc)].concat(outLoc));
|
};
|
for (var i = 0; i < buffer.size; i++) {
|
_loop_1(i);
|
}
|
return buffer.toTensor();
|
};
|
MathBackendCPU.prototype.concat = function (tensors, axis) {
|
var _this = this;
|
if (tensors[0].dtype === 'complex64') {
|
var reals = tensors.map(function (t) { return complex_ops_1.real(t); });
|
var imags = tensors.map(function (t) { return complex_ops_1.imag(t); });
|
return complex_ops_1.complex(this.concat(reals, axis), this.concat(imags, axis));
|
}
|
var tensors2D = tensors.map(function (t) {
|
var innerSize = util.sizeFromShape(t.shape.slice(axis));
|
return t.as2D(-1, innerSize);
|
});
|
var outShape = concat_util.computeOutShape(tensors2D.map(function (t) { return t.shape; }), 1 /* axis */);
|
var values = ops.buffer(outShape, tensors[0].dtype)
|
.values;
|
if (tensors2D[0].shape[0] === 1) {
|
// Use built-in TypedArray.set() method for speed.
|
var offset_1 = 0;
|
tensors2D.forEach(function (t) {
|
values.set(_this.readSync(t.dataId), offset_1);
|
offset_1 += t.size;
|
});
|
}
|
else {
|
var colOffset_1 = 0;
|
tensors2D.forEach(function (t) {
|
var tVals = _this.readSync(t.dataId);
|
var tIdx = 0;
|
for (var row = 0; row < t.shape[0]; ++row) {
|
var resIdx = row * outShape[1] + colOffset_1;
|
for (var col = 0; col < t.shape[1]; ++col) {
|
values[resIdx + col] = tVals[tIdx++];
|
}
|
}
|
colOffset_1 += t.shape[1];
|
});
|
}
|
var finalOutShape = concat_util.computeOutShape(tensors.map(function (t) { return t.shape; }), axis);
|
return ops_1.tensor(values, finalOutShape, tensors[0].dtype);
|
};
|
MathBackendCPU.prototype.neg = function (x) {
|
cpu_util_1.assertNotComplex(x, 'neg');
|
return this.multiply(ops.scalar(-1), x);
|
};
|
MathBackendCPU.prototype.add = function (a, b) {
|
if (a.dtype === 'complex64' || b.dtype === 'complex64') {
|
return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), function (aReal, aImag, bReal, bImag) {
|
return { real: aReal + bReal, imag: aImag + bImag };
|
});
|
}
|
return this.broadcastedBinaryOp(a, b, types_1.upcastType(a.dtype, b.dtype), function (aValue, bValue) { return aValue + bValue; });
|
};
|
MathBackendCPU.prototype.addN = function (tensors) {
|
var _this = this;
|
cpu_util_1.assertNotComplex(tensors, 'addN');
|
var vals = tensors.map(function (t) { return _this.readSync(t.dataId); });
|
var result = ops.buffer(tensors[0].shape, tensors[0].dtype);
|
var resultVals = result.values;
|
for (var i = 0; i < tensors.length; i++) {
|
var currVals = vals[i];
|
for (var j = 0; j < resultVals.length; j++) {
|
resultVals[j] += currVals[j];
|
}
|
}
|
return result.toTensor();
|
};
|
MathBackendCPU.prototype.softmax = function (logits, dim) {
|
var axes = util.parseAxisParam([dim], logits.shape);
|
var maxLogit = this.max(logits, axes);
|
var expandedShape = axis_util.expandShapeToKeepDim(maxLogit.shape, axes);
|
var a = this.subtract(logits, maxLogit.reshape(expandedShape));
|
var b = this.exp(a);
|
var sumExp = this.sum(b, axes).reshape(expandedShape);
|
return this.realDivide(b, sumExp);
|
};
|
MathBackendCPU.prototype.subtract = function (a, b) {
|
if (a.dtype === 'complex64' || b.dtype === 'complex64') {
|
return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), function (aReal, aImag, bReal, bImag) {
|
return { real: aReal - bReal, imag: aImag - bImag };
|
});
|
}
|
return this.broadcastedBinaryOp(a, b, types_1.upcastType(a.dtype, b.dtype), function (aValue, bValue) { return aValue - bValue; });
|
};
|
MathBackendCPU.prototype.pow = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'pow');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aValue, bValue) { return Math.pow(aValue, bValue); });
|
};
|
MathBackendCPU.prototype.batchMatMul = function (a, b, transposeA, transposeB) {
|
cpu_util_1.assertNotComplex([a, b], 'matMul');
|
var sharedDim = transposeA ? a.shape[1] : a.shape[2];
|
var leftDim = transposeA ? a.shape[2] : a.shape[1];
|
var rightDim = transposeB ? b.shape[1] : b.shape[2];
|
var batchDim = a.shape[0];
|
var aValues = this.readSync(a.dataId);
|
var bValues = this.readSync(b.dataId);
|
var _a = transposeA ?
|
[a.strides[0], 1, a.strides[1]] :
|
[a.strides[0], a.strides[1], 1], aBatch = _a[0], aOuterStep = _a[1], aInnerStep = _a[2];
|
var _b = transposeB ?
|
[1, b.strides[1], b.strides[0]] :
|
[b.strides[1], 1, b.strides[0]], bInnerStep = _b[0], bOuterStep = _b[1], bBatch = _b[2];
|
var size = leftDim * rightDim;
|
var result = ops_1.buffer([batchDim, leftDim, rightDim], a.dtype);
|
var resVals = result.values;
|
var blockSize = this.blockSize;
|
for (var b_1 = 0; b_1 < batchDim; b_1++) {
|
for (var i0 = 0; i0 < leftDim; i0 += blockSize) {
|
for (var j0 = 0; j0 < rightDim; j0 += blockSize) {
|
for (var k0 = 0; k0 < sharedDim; k0 += blockSize) {
|
// for when blockSize doesn't evenly divide the input
|
var iBlock = Math.min(i0 + blockSize, leftDim);
|
var jBlock = Math.min(j0 + blockSize, rightDim);
|
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++) {
|
sum += aValues[b_1 * aBatch + i * aOuterStep + k * aInnerStep] *
|
bValues[k * bInnerStep + j * bOuterStep + b_1 * bBatch];
|
}
|
resVals[b_1 * size + (i * rightDim + j)] += sum;
|
}
|
}
|
}
|
}
|
}
|
}
|
return result.toTensor();
|
};
|
MathBackendCPU.prototype.fusedBatchMatMul = function (_a) {
|
var a = _a.a, b = _a.b, transposeA = _a.transposeA, transposeB = _a.transposeB, bias = _a.bias, activation = _a.activation, preluActivationWeights = _a.preluActivationWeights;
|
var result = this.batchMatMul(a, b, transposeA, transposeB);
|
if (bias) {
|
result = this.add(result, bias);
|
}
|
if (activation) {
|
result =
|
mapActivation(this, result, activation, preluActivationWeights);
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.multiply = function (a, b) {
|
if (a.dtype === 'complex64' || b.dtype === 'complex64') {
|
return this.broadcastedBinaryComplexOp(a.cast('complex64'), b.cast('complex64'), function (aReal, aImag, bReal, bImag) {
|
return {
|
real: aReal * bReal - aImag * bImag,
|
imag: aReal * bImag + aImag * bReal
|
};
|
});
|
}
|
return this.broadcastedBinaryOp(a, b, types_1.upcastType(a.dtype, b.dtype), function (aValue, bValue) { return aValue * bValue; });
|
};
|
MathBackendCPU.prototype.realDivide = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'realDivide');
|
var op = function (a, b) { return a / b; };
|
var outputDtype = 'float32';
|
return this.broadcastedBinaryOp(a, b, outputDtype, op);
|
};
|
MathBackendCPU.prototype.floorDiv = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'floorDiv');
|
var op = function (a, b) { return Math.floor(a / b); };
|
var outputDtype = 'int32';
|
return this.broadcastedBinaryOp(a, b, outputDtype, op);
|
};
|
MathBackendCPU.prototype.sum = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'sum');
|
axis_util.assertAxesAreInnerMostDims('sum', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var resultDtype = types_1.upcastType(x.dtype, 'int32');
|
var result = ops.zeros(outShape, resultDtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var sum = 0;
|
for (var j = 0; j < reduceSize; ++j) {
|
sum += aVals[offset + j];
|
}
|
vals[i] = sum;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.prod = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'sum');
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var resultDtype = types_1.upcastType(x.dtype, 'int32');
|
var result = ops.zeros(outShape, resultDtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var prod = 1;
|
for (var j = 0; j < reduceSize; ++j) {
|
prod *= aVals[offset + j];
|
}
|
vals[i] = prod;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.unsortedSegmentSum = function (x, segmentIds, numSegments) {
|
cpu_util_1.assertNotComplex(x, 'unsortedSegmentSum');
|
var res = [];
|
// Reshape the segment id's so that they can be broadcast with
|
// x. The new shape should be [segmentIds.shape, 1, ..., 1]
|
var numIters = x.rank - segmentIds.rank;
|
for (var i = 0; i < numIters; ++i) {
|
segmentIds = segmentIds.expandDims(i + 1);
|
}
|
for (var i = 0; i < numSegments; ++i) {
|
var segmentId = ops.scalar(i, 'int32');
|
var mask = ops.equal(segmentId, segmentIds).asType('float32');
|
var sum = mask.mul(x).sum(0);
|
res.push(sum);
|
}
|
return ops.stack(res);
|
};
|
MathBackendCPU.prototype.argMin = function (x, axis) {
|
cpu_util_1.assertNotComplex(x, 'argMin');
|
var axes = [axis];
|
axis_util.assertAxesAreInnerMostDims('argMin', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, 'int32');
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
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;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.argMax = function (x, axis) {
|
cpu_util_1.assertNotComplex(x, 'argMax');
|
var axes = [axis];
|
axis_util.assertAxesAreInnerMostDims('argMax', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, 'int32');
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
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;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.cumsum = function (x, axis, exclusive, reverse) {
|
cpu_util_1.assertNotComplex(x, 'cumsum');
|
if (axis !== x.rank - 1) {
|
throw new Error("backend.cumsum in CPU expects an inner-most axis=" + (x.rank - 1) + " " +
|
("but got axis=" + axis));
|
}
|
var resultDtype = types_1.upcastType(x.dtype, 'int32');
|
var result = ops.zeros(x.shape, resultDtype);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
var finalDim = x.shape[x.rank - 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];
|
}
|
}
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.equal = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'equal');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal === bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.notEqual = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'notEqual');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal !== bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.less = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'less');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal < bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.lessEqual = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'lessEqual');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal <= bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.greater = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'greater');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal > bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.greaterEqual = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'greaterEqual');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return (aVal >= bVal) ? 1 : 0;
|
});
|
};
|
MathBackendCPU.prototype.logicalNot = function (x) {
|
cpu_util_1.assertNotComplex(x, 'logicalNot');
|
var values = this.readSync(x.dataId);
|
var newValues = new Uint8Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = values[i] ? 0 : 1;
|
}
|
return this.makeOutput(newValues, x.shape, 'bool');
|
};
|
MathBackendCPU.prototype.logicalAnd = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'logicalAnd');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return aVal && bVal;
|
});
|
};
|
MathBackendCPU.prototype.logicalOr = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'logicalOr');
|
return this.broadcastedBinaryOp(a, b, 'bool', function (aVal, bVal) {
|
return aVal || bVal;
|
});
|
};
|
MathBackendCPU.prototype.select = function (condition, a, b) {
|
cpu_util_1.assertNotComplex([condition, a, b], 'select');
|
var values = this.readSync(condition.dataId);
|
var aValues = this.readSync(a.dataId);
|
var bValues = this.readSync(b.dataId);
|
var result = ops.zeros(a.shape, types_1.upcastType(a.dtype, b.dtype));
|
var newValues = this.readSync(result.dataId);
|
var index = 0;
|
var offset = condition.rank === 0 || condition.rank > 1 || a.rank === 1 ?
|
1 :
|
util.sizeFromShape(a.shape.slice(1));
|
for (var i = 0; i < values.length; i++) {
|
for (var j = 0; j < offset; j++) {
|
if (values[i] === 1) {
|
newValues[index++] = aValues[i];
|
}
|
else {
|
newValues[index++] = bValues[i];
|
}
|
}
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.where = function (condition) {
|
cpu_util_1.assertNotComplex([condition], 'where');
|
var condVals = this.readSync(condition.dataId);
|
return where_impl_1.whereImpl(condition.shape, condVals);
|
};
|
MathBackendCPU.prototype.topk = function (x, k, sorted) {
|
cpu_util_1.assertNotComplex(x, 'topk');
|
var xVals = this.readSync(x.dataId);
|
return topk_impl_1.topkImpl(xVals, x.shape, x.dtype, k, sorted);
|
};
|
MathBackendCPU.prototype.min = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'min');
|
axis_util.assertAxesAreInnerMostDims('min', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, x.dtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var min = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
if (value < min) {
|
min = value;
|
}
|
}
|
vals[i] = min;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.minimum = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'minimum');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aVal, bVal) { return Math.min(aVal, bVal); });
|
};
|
MathBackendCPU.prototype.mod = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'mod');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aVal, bVal) {
|
var rem = aVal % bVal;
|
if ((aVal < 0 && bVal < 0) || (aVal >= 0 && bVal >= 0)) {
|
return rem;
|
}
|
else {
|
return (rem + bVal) % bVal;
|
}
|
});
|
};
|
MathBackendCPU.prototype.max = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'max');
|
axis_util.assertAxesAreInnerMostDims('max', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, x.dtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
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 (value > max) {
|
max = value;
|
}
|
}
|
vals[i] = max;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.maximum = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'maximum');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aVal, bVal) { return Math.max(aVal, bVal); });
|
};
|
MathBackendCPU.prototype.all = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'all');
|
axis_util.assertAxesAreInnerMostDims('all', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, x.dtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
for (var i = 0; i < vals.length; ++i) {
|
var offset = i * reduceSize;
|
var all = aVals[offset];
|
for (var j = 0; j < reduceSize; ++j) {
|
var value = aVals[offset + j];
|
all = all && value;
|
}
|
vals[i] = all;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.any = function (x, axes) {
|
cpu_util_1.assertNotComplex(x, 'any');
|
axis_util.assertAxesAreInnerMostDims('any', axes, x.rank);
|
var _a = axis_util.computeOutAndReduceShapes(x.shape, axes), outShape = _a[0], reduceShape = _a[1];
|
var result = ops.zeros(outShape, x.dtype);
|
var reduceSize = util.sizeFromShape(reduceShape);
|
var vals = this.readSync(result.dataId);
|
var aVals = this.readSync(x.dataId);
|
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;
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.squaredDifference = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'squaredDifference');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aVal, bVal) {
|
var diff = aVal - bVal;
|
return diff * diff;
|
});
|
};
|
MathBackendCPU.prototype.ceil = function (x) {
|
cpu_util_1.assertNotComplex(x, 'ceil');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = Math.ceil(values[i]);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.floor = function (x) {
|
cpu_util_1.assertNotComplex(x, 'floor');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = Math.floor(values[i]);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.sign = function (x) {
|
cpu_util_1.assertNotComplex(x, 'x');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
if (values[i] < 0) {
|
newValues[i] = -1;
|
}
|
else if (values[i] > 0) {
|
newValues[i] = 1;
|
}
|
else {
|
newValues[i] = 0;
|
}
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.isNaN = function (x) {
|
cpu_util_1.assertNotComplex(x, 'x');
|
var values = this.readSync(x.dataId);
|
var newValues = new Uint8Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
if (Number.isNaN(values[i])) {
|
newValues[i] = 1;
|
}
|
}
|
return this.makeOutput(newValues, x.shape, 'bool');
|
};
|
MathBackendCPU.prototype.isInf = function (x) {
|
cpu_util_1.assertNotComplex(x, 'x');
|
var values = this.readSync(x.dataId);
|
var newValues = new Uint8Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
if (Math.abs(values[i]) === Infinity) {
|
newValues[i] = 1;
|
}
|
}
|
return this.makeOutput(newValues, x.shape, 'bool');
|
};
|
MathBackendCPU.prototype.isFinite = function (x) {
|
cpu_util_1.assertNotComplex(x, 'x');
|
var values = this.readSync(x.dataId);
|
var newValues = new Uint8Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
if (Number.isFinite(values[i])) {
|
newValues[i] = 1;
|
}
|
}
|
return this.makeOutput(newValues, x.shape, 'bool');
|
};
|
MathBackendCPU.prototype.round = function (x) {
|
cpu_util_1.assertNotComplex(x, 'round');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
// The algorithm is based on banker's rounding.
|
var base = Math.floor(values[i]);
|
if (values[i] - base < 0.5) {
|
newValues[i] = Math.floor(values[i]);
|
}
|
else if (values[i] - base > 0.5) {
|
newValues[i] = Math.ceil(values[i]);
|
}
|
else {
|
if (base % 2.0 === 0.0) {
|
newValues[i] = base;
|
}
|
else {
|
newValues[i] = base + 1.0;
|
}
|
}
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.exp = function (x) {
|
cpu_util_1.assertNotComplex(x, 'exp');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = Math.exp(values[i]);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.expm1 = function (x) {
|
cpu_util_1.assertNotComplex(x, 'expm1');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = Math.expm1(values[i]);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.log = function (x) {
|
cpu_util_1.assertNotComplex(x, 'log');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
newValues[i] = Math.log(value);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.log1p = function (x) {
|
cpu_util_1.assertNotComplex(x, 'log1p');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
newValues[i] = Math.log1p(value);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.sqrt = function (x) {
|
cpu_util_1.assertNotComplex(x, 'sqrt');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
newValues[i] = Math.sqrt(value);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.rsqrt = function (x) {
|
cpu_util_1.assertNotComplex(x, 'rsqrt');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
newValues[i] = 1 / Math.sqrt(value);
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.reciprocal = function (x) {
|
cpu_util_1.assertNotComplex(x, 'reciprocal');
|
var values = this.readSync(x.dataId);
|
var newValues = new Float32Array(values.length);
|
for (var i = 0; i < values.length; ++i) {
|
newValues[i] = 1 / values[i];
|
}
|
return this.makeOutput(newValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.linear = function (x) {
|
return x;
|
};
|
MathBackendCPU.prototype.relu = function (x) {
|
cpu_util_1.assertNotComplex(x, 'relu');
|
var res = ops.zeros(x.shape, x.dtype);
|
var resVals = this.readSync(res.dataId);
|
var inVals = this.readSync(x.dataId);
|
for (var i = 0; i < inVals.length; ++i) {
|
resVals[i] = Math.max(0, inVals[i]);
|
}
|
return res;
|
};
|
MathBackendCPU.prototype.relu6 = function (x) {
|
cpu_util_1.assertNotComplex(x, 'relu');
|
var res = ops.zeros(x.shape, x.dtype);
|
var resVals = this.readSync(res.dataId);
|
var inVals = this.readSync(x.dataId);
|
for (var i = 0; i < inVals.length; ++i) {
|
resVals[i] = Math.min(Math.max(0, inVals[i]), 6);
|
}
|
return res;
|
};
|
MathBackendCPU.prototype.prelu = function (x, a) {
|
cpu_util_1.assertNotComplex([x, a], 'prelu');
|
return this.broadcastedBinaryOp(x, a, x.dtype, function (xValue, aValue) { return xValue < 0 ? aValue * xValue : xValue; });
|
};
|
MathBackendCPU.prototype.elu = function (x) {
|
cpu_util_1.assertNotComplex(x, 'elu');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
var v = values[i];
|
if (v >= 0) {
|
resultValues[i] = v;
|
}
|
else {
|
resultValues[i] = (Math.exp(v) - 1);
|
}
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.eluDer = function (dy, y) {
|
cpu_util_1.assertNotComplex([dy, y], 'eluDer');
|
var resultValues = new Float32Array(y.size);
|
var values = this.readSync(y.dataId);
|
var dyValues = this.readSync(dy.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
var v = values[i];
|
if (v >= 1) {
|
resultValues[i] = dyValues[i];
|
}
|
else {
|
resultValues[i] = dyValues[i] * (v + 1);
|
}
|
}
|
return this.makeOutput(resultValues, y.shape, 'float32');
|
};
|
MathBackendCPU.prototype.selu = function (x) {
|
cpu_util_1.assertNotComplex(x, 'selu');
|
// Stable and Attracting Fixed Point (0, 1) for Normalized Weights.
|
// see: https://arxiv.org/abs/1706.02515
|
var scaleAlpha = selu_util.SELU_SCALEALPHA;
|
var scale = selu_util.SELU_SCALE;
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
var v = values[i];
|
if (v >= 0) {
|
resultValues[i] = scale * v;
|
}
|
else {
|
resultValues[i] = scaleAlpha * (Math.exp(v) - 1);
|
}
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.clip = function (x, min, max) {
|
cpu_util_1.assertNotComplex(x, 'clip');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
var v = values[i];
|
resultValues[i] = v > max ? max : (v < min ? min : v);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.abs = function (x) {
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.abs(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.complexAbs = function (x) {
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < x.size; ++i) {
|
var real_1 = values[i * 2];
|
var imag_1 = values[i * 2 + 1];
|
resultValues[i] = Math.hypot(real_1, imag_1);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.int = function (x) {
|
cpu_util_1.assertNotComplex(x, 'int');
|
var resultValues = new Int32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = values[i];
|
}
|
return this.makeOutput(resultValues, x.shape, 'int32');
|
};
|
MathBackendCPU.prototype.sigmoid = function (x) {
|
cpu_util_1.assertNotComplex(x, 'sigmoid');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = 1 / (1 + Math.exp(-values[i]));
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.softplus = function (x) {
|
cpu_util_1.assertNotComplex(x, 'softplus');
|
// 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 resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
// Value above which exp(x) may overflow, but softplus(x) == x
|
// is within machine epsilon.
|
var tooLarge = values[i] > -threshold;
|
// Value below which exp(x) may underflow, but softplus(x) == exp(x)
|
// is within machine epsilon.
|
var tooSmall = values[i] < threshold;
|
var expX = Math.exp(values[i]);
|
var result = void 0;
|
if (tooSmall) {
|
result = expX;
|
}
|
else if (tooLarge) {
|
result = values[i];
|
}
|
else {
|
result = Math.log(1.0 + expX);
|
}
|
resultValues[i] = result;
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.sin = function (x) {
|
cpu_util_1.assertNotComplex(x, 'sin');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.sin(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.cos = function (x) {
|
cpu_util_1.assertNotComplex(x, 'cos');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.cos(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.tan = function (x) {
|
cpu_util_1.assertNotComplex(x, 'tan');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.tan(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.asin = function (x) {
|
cpu_util_1.assertNotComplex(x, 'asin');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.asin(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.acos = function (x) {
|
cpu_util_1.assertNotComplex(x, 'acos');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.acos(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.atan = function (x) {
|
cpu_util_1.assertNotComplex(x, 'atan');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.atan(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.atan2 = function (a, b) {
|
cpu_util_1.assertNotComplex([a, b], 'atan2');
|
return this.broadcastedBinaryOp(a, b, a.dtype, function (aValue, bValue) { return Math.atan2(aValue, bValue); });
|
};
|
MathBackendCPU.prototype.sinh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'sinh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.sinh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.cosh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'cosh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.cosh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.tanh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'tanh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = util.tanh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.asinh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'asinh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.asinh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.acosh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'acosh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.acosh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.atanh = function (x) {
|
cpu_util_1.assertNotComplex(x, 'atanh');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
resultValues[i] = Math.atanh(values[i]);
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.erf = function (x) {
|
cpu_util_1.assertNotComplex(x, 'erf');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
var p = erf_util.ERF_P;
|
var a1 = erf_util.ERF_A1;
|
var a2 = erf_util.ERF_A2;
|
var a3 = erf_util.ERF_A3;
|
var a4 = erf_util.ERF_A4;
|
var a5 = erf_util.ERF_A5;
|
for (var i = 0; i < values.length; ++i) {
|
var sign = Math.sign(values[i]);
|
var v = Math.abs(values[i]);
|
var t = 1.0 / (1.0 + p * v);
|
resultValues[i] = sign *
|
(1.0 -
|
(((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t *
|
Math.exp(-v * v));
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.step = function (x, alpha) {
|
if (alpha === void 0) { alpha = 0; }
|
cpu_util_1.assertNotComplex(x, 'step');
|
var resultValues = new Float32Array(x.size);
|
var values = this.readSync(x.dataId);
|
for (var i = 0; i < values.length; ++i) {
|
var value = values[i];
|
if (isNaN(value)) {
|
resultValues[i] = NaN;
|
}
|
else {
|
resultValues[i] = value > 0 ? 1 : alpha;
|
}
|
}
|
return this.makeOutput(resultValues, x.shape, 'float32');
|
};
|
MathBackendCPU.prototype.fusedConv2d = function (_a) {
|
var input = _a.input, filter = _a.filter, convInfo = _a.convInfo, bias = _a.bias, activation = _a.activation, preluActivationWeights = _a.preluActivationWeights;
|
var result = this.conv2d(input, filter, convInfo);
|
if (bias) {
|
result = this.add(result, bias);
|
}
|
if (activation) {
|
result =
|
mapActivation(this, result, activation, preluActivationWeights);
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.conv2d = function (x, filter, convInfo) {
|
cpu_util_1.assertNotComplex([x, filter], 'conv2d');
|
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 = ops.buffer(convInfo.outShape, x.dtype);
|
var xBatchStride = x.strides[0];
|
var xRowStride = isChannelsLast ? x.strides[1] : x.strides[2];
|
var xColStride = isChannelsLast ? x.strides[2] : 1;
|
var xChannelStride = isChannelsLast ? 1 : x.strides[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 = this.readSync(x.dataId);
|
var wVals = this.readSync(filter.dataId);
|
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 * filter.strides[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 * filter.strides[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 y.toTensor();
|
};
|
MathBackendCPU.prototype.conv3d = function (x, filter, convInfo) {
|
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 padFront = convInfo.padInfo.front;
|
var padLeft = convInfo.padInfo.left;
|
var padTop = convInfo.padInfo.top;
|
var y = ops.buffer(convInfo.outShape, x.dtype);
|
var xVals = this.readSync(x.dataId);
|
var wVals = this.readSync(filter.dataId);
|
var yVals = y.values;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * x.strides[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 * filter.strides[0];
|
var xOffset2 = xOffset1 + xF * x.strides[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 * filter.strides[1];
|
var xOffset3 = xOffset2 + xR * x.strides[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 * filter.strides[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 y.toTensor();
|
};
|
MathBackendCPU.prototype.conv2dDerInput = function (dy, filter, convInfo) {
|
cpu_util_1.assertNotComplex([dy, filter], 'conv2dDerInput');
|
var dx = ops.buffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var dyValues = this.readSync(dy.dataId);
|
var fltValues = this.readSync(filter.dataId);
|
var _a = filter.strides, 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 = dy.strides[0];
|
var yRowStride = isChannelsLast ? dy.strides[1] : dy.strides[2];
|
var yColStride = isChannelsLast ? dy.strides[2] : 1;
|
var yChannelStride = isChannelsLast ? 1 : dy.strides[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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.conv3dDerInput = function (dy, filter, convInfo) {
|
var dx = ops.buffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var _a = dx.strides, dxS0 = _a[0], dxS1 = _a[1], dxS2 = _a[2], dxS3 = _a[3];
|
var dyValues = this.readSync(dy.dataId);
|
var _b = dy.strides, dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2], dyS3 = _b[3];
|
var fltValues = this.readSync(filter.dataId);
|
var _c = filter.strides, 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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.conv2dDerFilter = function (x, dy, convInfo) {
|
cpu_util_1.assertNotComplex([x, dy], 'conv2dDerFilter');
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var isChannelsLast = convInfo.dataFormat === 'channelsLast';
|
var dW = ops.buffer(convInfo.filterShape, 'float32');
|
var leftPad = convInfo.padInfo.left;
|
var topPad = convInfo.padInfo.top;
|
var xBuf = this.bufferSync(x);
|
var dyBuf = this.bufferSync(dy);
|
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) {
|
// Need to convolve.
|
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 dW.toTensor();
|
};
|
MathBackendCPU.prototype.conv3dDerFilter = function (x, dy, convInfo) {
|
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 = ops.buffer(convInfo.filterShape, 'float32');
|
var dwValues = dw.values;
|
var _a = dw.strides, dwS0 = _a[0], dwS1 = _a[1], dwS2 = _a[2], dwS3 = _a[3];
|
var dyValues = this.readSync(dy.dataId);
|
var _b = dy.strides, dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2], dyS3 = _b[3];
|
var xValues = this.readSync(x.dataId);
|
var _c = x.strides, 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 dw.toTensor();
|
};
|
MathBackendCPU.prototype.fusedDepthwiseConv2D = function (_a) {
|
var input = _a.input, filter = _a.filter, convInfo = _a.convInfo, bias = _a.bias, activation = _a.activation, preluActivationWeights = _a.preluActivationWeights;
|
var result = this.depthwiseConv2D(input, filter, convInfo);
|
if (bias) {
|
result = this.add(result, bias);
|
}
|
if (activation) {
|
result =
|
mapActivation(this, result, activation, preluActivationWeights);
|
}
|
return result;
|
};
|
MathBackendCPU.prototype.depthwiseConv2D = function (x, filter, convInfo) {
|
cpu_util_1.assertNotComplex([x, filter], 'depthwiseConv2D');
|
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 chMul = convInfo.outChannels / convInfo.inChannels;
|
var y = ops.buffer(convInfo.outShape, x.dtype);
|
var xVals = this.readSync(x.dataId);
|
var wVals = this.readSync(filter.dataId);
|
var yVals = y.values;
|
for (var b = 0; b < convInfo.batchSize; ++b) {
|
var xOffset1 = b * x.strides[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 - padLeft;
|
for (var wR = 0; wR < filterHeight; ++wR) {
|
var xR = xRCorner + wR * dilationHeight;
|
if (xR < 0 || xR >= convInfo.inHeight) {
|
continue;
|
}
|
var wOffset1 = wR * filter.strides[0];
|
var xOffset2 = xOffset1 + xR * x.strides[1];
|
for (var yC = 0; yC < convInfo.outWidth; ++yC) {
|
var yOffset3 = yOffset2 + yC * y.strides[2];
|
var xCCorner = yC * convInfo.strideWidth - padTop;
|
for (var wC = 0; wC < filterWidth; ++wC) {
|
var xC = xCCorner + wC * dilationWidth;
|
if (xC < 0 || xC >= convInfo.inWidth) {
|
continue;
|
}
|
var wOffset2 = wOffset1 + wC * filter.strides[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 y.toTensor();
|
};
|
MathBackendCPU.prototype.depthwiseConv2DDerInput = function (dy, filter, convInfo) {
|
cpu_util_1.assertNotComplex([dy, filter], 'depthwiseConv2DDerInput');
|
var dx = ops.buffer(convInfo.inShape, 'float32');
|
var dxValues = dx.values;
|
var _a = dx.strides, dxS0 = _a[0], dxS1 = _a[1], dxS2 = _a[2];
|
var dyValues = this.readSync(dy.dataId);
|
var _b = dy.strides, dyS0 = _b[0], dyS1 = _b[1], dyS2 = _b[2];
|
var fltValues = this.readSync(filter.dataId);
|
var _c = filter.strides, 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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.depthwiseConv2DDerFilter = function (x, dy, convInfo) {
|
cpu_util_1.assertNotComplex([x, dy], 'depthwiseConv2DDerFilter');
|
var strideHeight = convInfo.strideHeight;
|
var strideWidth = convInfo.strideWidth;
|
var filterHeight = convInfo.filterHeight;
|
var filterWidth = convInfo.filterWidth;
|
var dW = ops.buffer(convInfo.filterShape, 'float32');
|
var leftPad = convInfo.padInfo.left;
|
var topPad = convInfo.padInfo.top;
|
var chMul = convInfo.outChannels / convInfo.inChannels;
|
var xBuf = this.bufferSync(x);
|
var dyBuf = this.bufferSync(dy);
|
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 dW.toTensor();
|
};
|
MathBackendCPU.prototype.tile = function (x, reps) {
|
cpu_util_1.assertNotComplex(x, 'tile');
|
return tile_impl_1.tile(this.bufferSync(x), reps);
|
};
|
MathBackendCPU.prototype.pad = function (x, paddings, constantValue) {
|
cpu_util_1.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 xBuffer = this.bufferSync(x);
|
var buffer = ops.buffer(outShape, x.dtype);
|
if (constantValue !== 0) {
|
buffer.values.fill(constantValue);
|
}
|
for (var i = 0; i < x.size; i++) {
|
var coords = xBuffer.indexToLoc(i);
|
var outCoords = coords.map(function (c, i) { return c + start[i]; });
|
buffer.set.apply(buffer, [xBuffer.get.apply(xBuffer, coords)].concat(outCoords));
|
}
|
return buffer.toTensor();
|
};
|
MathBackendCPU.prototype.transpose = function (x, perm) {
|
cpu_util_1.assertNotComplex(x, 'transpose');
|
var newShape = new Array(x.rank);
|
for (var i = 0; i < newShape.length; i++) {
|
newShape[i] = x.shape[perm[i]];
|
}
|
var values = this.readSync(x.dataId);
|
var result = ops_1.buffer(newShape, x.dtype);
|
var xBuf = this.bufferSync(x);
|
for (var i = 0; i < x.size; ++i) {
|
var loc = xBuf.indexToLoc(i);
|
// 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 = result.locToIndex(newLoc);
|
result.values[newIndex] = values[i];
|
}
|
return result.toTensor();
|
};
|
MathBackendCPU.prototype.gather = function (x, indices, axis) {
|
cpu_util_1.assertNotComplex([x, indices], 'gather');
|
var newShape = x.shape.slice();
|
var indicesValues = this.readSync(indices.dataId);
|
newShape[axis] = indicesValues.length;
|
var result = ops_1.buffer(newShape, x.dtype);
|
var xBuf = this.bufferSync(x);
|
for (var i = 0; i < result.size; ++i) {
|
var newLoc = result.indexToLoc(i);
|
var originalLoc = newLoc.slice();
|
originalLoc[axis] = indicesValues[newLoc[axis]];
|
var originalIndex = xBuf.locToIndex(originalLoc);
|
result.values[i] = xBuf.values[originalIndex];
|
}
|
return result.toTensor();
|
};
|
MathBackendCPU.prototype.batchToSpaceND = function (x, blockShape, crops) {
|
cpu_util_1.assertNotComplex([x], 'batchToSpaceND');
|
var prod = blockShape.reduce(function (a, b) { return a * b; });
|
var reshaped = array_ops_util.getReshaped(x.shape, blockShape, prod);
|
var permuted = array_ops_util.getPermuted(reshaped.length, blockShape.length);
|
var reshapedPermuted = array_ops_util.getReshapedPermuted(x.shape, blockShape, prod);
|
var sliceBeginCoords = array_ops_util.getSliceBeginCoords(crops, blockShape.length);
|
var sliceSize = array_ops_util.getSliceSize(reshapedPermuted, crops, blockShape.length);
|
return x.reshape(reshaped)
|
.transpose(permuted)
|
.reshape(reshapedPermuted)
|
.slice(sliceBeginCoords, sliceSize);
|
};
|
MathBackendCPU.prototype.spaceToBatchND = function (x, blockShape, paddings) {
|
cpu_util_1.assertNotComplex([x], 'spaceToBatchND');
|
var prod = blockShape.reduce(function (a, b) { return a * b; });
|
var completePaddings = [[0, 0]];
|
completePaddings.push.apply(completePaddings, paddings);
|
for (var i = 1 + blockShape.length; i < x.shape.length; ++i) {
|
completePaddings.push([0, 0]);
|
}
|
var paddedX = x.pad(completePaddings);
|
var reshapedPaddedShape = array_ops_util.getReshaped(paddedX.shape, blockShape, prod, false);
|
var permutedReshapedPaddedPermutation = array_ops_util.getPermuted(reshapedPaddedShape.length, blockShape.length, false);
|
var flattenShape = array_ops_util.getReshapedPermuted(paddedX.shape, blockShape, prod, false);
|
return paddedX.reshape(reshapedPaddedShape)
|
.transpose(permutedReshapedPaddedPermutation)
|
.reshape(flattenShape);
|
};
|
MathBackendCPU.prototype.pool = function (x, convInfo, poolType) {
|
cpu_util_1.assertNotComplex(x, 'pool');
|
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 xValues = this.readSync(x.dataId);
|
var output = ops.buffer(convInfo.outShape, x.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 * x.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 * x.strides[1];
|
for (var xC = xCMin; xC < xCMax; xC += dilationWidth) {
|
var xCOffset = xROffset + xC * x.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.toTensor();
|
};
|
MathBackendCPU.prototype.maxPool = function (x, convInfo) {
|
return this.pool(x, convInfo, 'max');
|
};
|
MathBackendCPU.prototype.maxPoolPositions = function (x, convInfo) {
|
var maxPositions = ops.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 = this.bufferSync(x);
|
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;
|
var pixel = xBuf.get(b, xR, xC, d);
|
if (pixel > maxValue) {
|
maxValue = pixel;
|
maxPosition = wR * effectiveFilterWidth + wC;
|
}
|
}
|
}
|
maxPositions.set(maxPosition, b, yR, yC, d);
|
}
|
}
|
}
|
}
|
return maxPositions.toTensor();
|
};
|
MathBackendCPU.prototype.maxPoolBackprop = function (dy, x, y, convInfo) {
|
cpu_util_1.assertNotComplex([x, y], 'maxPoolBackprop');
|
var maxPositions = this.maxPoolPositions(x, convInfo);
|
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 = ops.buffer(x.shape, 'float32');
|
var maxPosBuf = this.bufferSync(maxPositions);
|
var dyBuf = this.bufferSync(dy);
|
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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.avgPoolBackprop = function (dy, x, convInfo) {
|
cpu_util_1.assertNotComplex([dy, x], 'avgPoolBackprop');
|
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 = ops.buffer(x.shape, 'float32');
|
var avgMultiplier = 1 / (filterHeight * filterWidth);
|
var dyBuf = this.bufferSync(dy);
|
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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.pool3d = function (x, convInfo, poolType) {
|
cpu_util_1.assertNotComplex(x, 'pool3d');
|
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 xValues = this.readSync(x.dataId);
|
var output = ops.buffer(convInfo.outShape, x.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 * x.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 * x.strides[1];
|
for (var xRow = xRowMin; xRow < xRowMax; xRow += dilationHeight) {
|
var xRowOffset = xDepthOffset + xRow * x.strides[2];
|
for (var xCol = xColMin; xCol < xColMax; xCol += dilationWidth) {
|
var xColOffset = xRowOffset + xCol * x.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 / count : minMaxValue;
|
}
|
}
|
}
|
}
|
}
|
return output.toTensor();
|
};
|
MathBackendCPU.prototype.avgPool3d = function (x, convInfo) {
|
cpu_util_1.assertNotComplex(x, 'avgPool3d');
|
return this.pool3d(x, convInfo, 'avg').toFloat();
|
};
|
MathBackendCPU.prototype.avgPool3dBackprop = function (dy, x, convInfo) {
|
cpu_util_1.assertNotComplex([dy, x], 'avgPool3dBackprop');
|
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 = ops.buffer(x.shape, 'float32');
|
var avgMultiplier = 1 / (filterDepth * filterHeight * filterWidth);
|
var dyBuf = this.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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.maxPool3d = function (x, convInfo) {
|
cpu_util_1.assertNotComplex(x, 'maxPool3d');
|
return this.pool3d(x, convInfo, 'max').toFloat();
|
};
|
MathBackendCPU.prototype.maxPool3dPositions = function (x, convInfo) {
|
var maxPositions = ops.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;
|
var xBuf = this.bufferSync(x);
|
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.toTensor();
|
};
|
MathBackendCPU.prototype.maxPool3dBackprop = function (dy, x, y, convInfo) {
|
cpu_util_1.assertNotComplex([x, y], 'maxPool3dBackprop');
|
var maxPositions = this.maxPool3dPositions(x, 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 = ops.buffer(x.shape, 'float32');
|
var maxPosBuf = this.bufferSync(maxPositions);
|
var dyBuf = this.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 dx.toTensor();
|
};
|
MathBackendCPU.prototype.cast = function (x, dtype) {
|
return backend_util.castTensor(x, dtype, this);
|
};
|
MathBackendCPU.prototype.reshape = function (x, shape) {
|
return backend_util.reshapeTensor(x, shape);
|
};
|
MathBackendCPU.prototype.avgPool = function (x, convInfo) {
|
cpu_util_1.assertNotComplex(x, 'avgPool');
|
return this.pool(x, convInfo, 'avg').toFloat();
|
};
|
MathBackendCPU.prototype.resizeBilinear = function (x, newHeight, newWidth, alignCorners) {
|
cpu_util_1.assertNotComplex(x, 'resizeBilinear');
|
var _a = x.shape, batch = _a[0], oldHeight = _a[1], oldWidth = _a[2], numChannels = _a[3];
|
var xValues = this.readSync(x.dataId);
|
var result = new Float32Array(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 = effectiveRowSizeRatio * r;
|
var sourceRowFloor = Math.floor(sourceFracRow);
|
var rowFrac = sourceFracRow - sourceRowFloor;
|
var sourceRowCeil = Math.min(oldHeight - 1, Math.ceil(sourceFracRow));
|
var topRowOffset = b * x.strides[0] + sourceRowFloor * x.strides[1];
|
var botRowOffset = b * x.strides[0] + sourceRowCeil * x.strides[1];
|
for (var c = 0; c < newWidth; c++) {
|
var sourceFracCol = effectiveColSizeRatio * c;
|
var sourceColFloor = Math.floor(sourceFracCol);
|
var colFrac = sourceFracCol - sourceColFloor;
|
var sourceColCeil = Math.min(oldWidth - 1, Math.ceil(sourceFracCol));
|
var topLeftOffest = topRowOffset + sourceColFloor * x.strides[2];
|
var botLeftOffset = botRowOffset + sourceColFloor * x.strides[2];
|
var topRightOffset = topRowOffset + sourceColCeil * x.strides[2];
|
var botRightOffest = botRowOffset + sourceColCeil * x.strides[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_1 = topLeft + (topRight - topLeft) * colFrac;
|
var bottom = bottomLeft + (bottomRight - bottomLeft) * colFrac;
|
var newValue = top_1 + (bottom - top_1) * rowFrac;
|
result[outputIdx++] = newValue;
|
}
|
}
|
}
|
}
|
return ops.tensor(result, [batch, newHeight, newWidth, numChannels]);
|
};
|
MathBackendCPU.prototype.resizeBilinearBackprop = function (dy, x, alignCorners) {
|
cpu_util_1.assertNotComplex([dy, x], 'resizeBilinearBackprop');
|
var _a = x.shape, batch = _a[0], xHeight = _a[1], xWidth = _a[2], depth = _a[3];
|
var _b = dy.shape, 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 = this.readSync(dy.dataId);
|
var offset = 0;
|
for (var b = 0; b < batch; b++) {
|
var bOffset = b * x.strides[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 * x.strides[1];
|
var bottomDxROffset = bOffset + bottomDxRIndex * x.strides[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 * x.strides[2];
|
var topRightRCOffset = topDxROffset + rightDxCIndex * x.strides[2];
|
var bottomLeftRCOffset = bottomDxROffset + leftDxCIndex * x.strides[2];
|
var bottomRightRCOffset = bottomDxROffset + rightDxCIndex * x.strides[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 ops.tensor4d(output, [batch, xWidth, xHeight, depth], x.dtype);
|
};
|
MathBackendCPU.prototype.resizeNearestNeighbor = function (x, newHeight, newWidth, alignCorners) {
|
cpu_util_1.assertNotComplex(x, 'resizeNearestNeighbor');
|
var _a = x.shape, batch = _a[0], oldHeight = _a[1], oldWidth = _a[2], numChannels = _a[3];
|
var xValues = this.readSync(x.dataId);
|
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 * x.strides[0];
|
for (var r = 0; r < newHeight; r++) {
|
var sourceFracRow = effectiveRowSizeRatio * r;
|
var sourceNearestRow = Math.min(oldHeight - 1, alignCorners ? Math.round(sourceFracRow) :
|
Math.floor(sourceFracRow));
|
var rowOffset = batchOffset + sourceNearestRow * x.strides[1];
|
for (var c = 0; c < newWidth; c++) {
|
var sourceFracCol = effectiveColSizeRatio * c;
|
var sourceNearestCol = Math.min(oldWidth - 1, alignCorners ? Math.round(sourceFracCol) :
|
Math.floor(sourceFracCol));
|
var colOffset = rowOffset + sourceNearestCol * x.strides[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 ops.tensor(output, [batch, newHeight, newWidth, numChannels], x.dtype);
|
};
|
MathBackendCPU.prototype.resizeNearestNeighborBackprop = function (dy, x, alignCorners) {
|
cpu_util_1.assertNotComplex([dy, x], 'resizeNearestNeighborBackprop');
|
var _a = x.shape, batch = _a[0], xHeight = _a[1], xWidth = _a[2], depth = _a[3];
|
var _b = dy.shape, yHeight = _b[1], yWidth = _b[2];
|
var output = new Float32Array(batch * xHeight * xWidth * depth);
|
var dyValues = this.readSync(dy.dataId);
|
// 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 * x.strides[0];
|
for (var r = 0; r < xHeight; r++) {
|
var rowOffset = batchOffset + r * x.strides[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 * x.strides[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 * dy.strides[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 * dy.strides[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 ops.tensor4d(output, x.shape, x.dtype);
|
};
|
MathBackendCPU.prototype.batchNormalization = function (x, mean, variance, varianceEpsilon, scale, offset) {
|
cpu_util_1.assertNotComplex([x, mean, variance, scale, offset], 'batchNorm');
|
var xVals = this.readSync(x.dataId);
|
var mVals = this.readSync(mean.dataId);
|
var varVals = this.readSync(variance.dataId);
|
var sVals = scale ? this.readSync(scale.dataId) :
|
new Float32Array([1]);
|
var offVals = offset ? this.readSync(offset.dataId) :
|
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 ops_1.tensor4d(outVals, x.shape);
|
};
|
MathBackendCPU.prototype.localResponseNormalization4D = function (x, depthRadius, bias, alpha, beta) {
|
cpu_util_1.assertNotComplex(x, 'localResponseNormalization4D');
|
var channels = x.shape[3];
|
var maxD = channels - 1;
|
var xValues = this.readSync(x.dataId);
|
var size = x.size;
|
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 ops.tensor4d(result, x.shape);
|
};
|
MathBackendCPU.prototype.LRNGrad = function (dy, inputImage, outputImage, depthRadius, bias, alpha, beta) {
|
cpu_util_1.assertNotComplex(dy, 'LRNGrad');
|
var channels = dy.shape[3];
|
var dyValues = this.readSync(dy.dataId);
|
var inputImageValues = this.readSync(inputImage.dataId);
|
var outputImageValues = this.readSync(outputImage.dataId);
|
var result = new Float32Array(dy.size);
|
var size = dy.size;
|
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(inputImageValues[k], 2);
|
}
|
norm = alpha * norm + bias;
|
for (var k = depthBegin; k < depthEnd; k++) {
|
var dyi = -2 * alpha * beta * inputImageValues[k] *
|
outputImageValues[offset] / norm;
|
if (offset === k) {
|
dyi += Math.pow(norm, -beta);
|
}
|
dyi *= dyValues[offset];
|
result[k] += dyi;
|
}
|
}
|
return ops.tensor4d(result, dy.shape);
|
};
|
MathBackendCPU.prototype.multinomial = function (logits, normalized, numSamples, seed) {
|
cpu_util_1.assertNotComplex(logits, 'multinomial');
|
var probabilities = normalized ? logits : ops.softmax(logits);
|
var batchSize = probabilities.shape[0];
|
var numEvents = probabilities.shape[1];
|
var res = ops.zeros([batchSize, numSamples], 'int32');
|
var resVals = this.readSync(res.dataId);
|
var probVals = this.readSync(probabilities.dataId);
|
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 = 1; event_1 < cdf.length; ++event_1) {
|
cdf[event_1] = cdf[event_1 - 1] + probVals[offset + event_1];
|
}
|
var random = seedrandom.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_2 = 0; event_2 < cdf.length; event_2++) {
|
if (r < cdf[event_2]) {
|
resVals[outOffset + sampleId] = event_2;
|
break;
|
}
|
}
|
}
|
}
|
return res;
|
};
|
MathBackendCPU.prototype.oneHot = function (indices, depth, onValue, offValue) {
|
cpu_util_1.assertNotComplex(indices, 'oneHot');
|
var res = new Float32Array(indices.size * depth);
|
res.fill(offValue);
|
var indicesVal = this.readSync(indices.dataId);
|
for (var event_3 = 0; event_3 < indices.size; ++event_3) {
|
if (indicesVal[event_3] >= 0 && indicesVal[event_3] < depth) {
|
res[event_3 * depth + indicesVal[event_3]] = onValue;
|
}
|
}
|
return ops.tensor2d(res, [indices.size, depth], 'int32');
|
};
|
MathBackendCPU.prototype.nonMaxSuppression = function (boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
|
cpu_util_1.assertNotComplex(boxes, 'nonMaxSuppression');
|
var boxesVals = this.readSync(boxes.dataId);
|
var scoresVals = this.readSync(scores.dataId);
|
return non_max_suppression_impl_1.nonMaxSuppressionV3(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
|
};
|
MathBackendCPU.prototype.fft = function (x) {
|
return this.fftBatch(x, false);
|
};
|
MathBackendCPU.prototype.ifft = function (x) {
|
return this.fftBatch(x, true);
|
};
|
/**
|
* Calculate FFT of inner most elements of batch tensor.
|
*/
|
MathBackendCPU.prototype.fftBatch = function (x, inverse) {
|
var batch = x.shape[0];
|
var innerDim = x.shape[1];
|
// Collects real and imaginary values separately.
|
var realResult = ops.buffer(x.shape, 'float32');
|
var imagResult = ops.buffer(x.shape, 'float32');
|
var real = ops.real(x).as2D(batch, innerDim);
|
var imag = ops.imag(x).as2D(batch, innerDim);
|
for (var b = 0; b < batch; b++) {
|
// TODO: Support slice ops for complex type.
|
var r = real.slice([b, 0], [1, innerDim]);
|
var i = imag.slice([b, 0], [1, innerDim]);
|
var input = ops.complex(r, i);
|
// Run FFT by batch element.
|
var res = this.readSync(this.fftImpl(input, inverse).dataId);
|
for (var d = 0; d < innerDim; d++) {
|
var c = complex_util.getComplexWithIndex(res, d);
|
realResult.values[b * innerDim + d] = c.real;
|
imagResult.values[b * innerDim + d] = c.imag;
|
}
|
}
|
var t = ops.complex(realResult.toTensor(), imagResult.toTensor());
|
return t.as2D(batch, innerDim);
|
};
|
MathBackendCPU.prototype.fftImpl = function (x, inverse) {
|
var x1D = x.as1D();
|
var n = x1D.size;
|
if (this.isExponentOf2(n)) {
|
var result = this.fftRadix2(x1D, n, inverse).as2D(x.shape[0], x.shape[1]);
|
if (inverse) {
|
result = ops.complex(ops.real(result).div(ops_1.scalar(n)), ops.imag(result).div(ops_1.scalar(n)));
|
}
|
return result;
|
}
|
else {
|
var data = this.readSync(x.dataId);
|
var rawOutput = this.fourierTransformByMatmul(data, n, inverse);
|
var output = complex_util.splitRealAndImagArrays(rawOutput);
|
return ops.complex(output.real, output.imag).as2D(x.shape[0], x.shape[1]);
|
}
|
};
|
MathBackendCPU.prototype.isExponentOf2 = function (size) {
|
return (size & size - 1) === 0;
|
};
|
// FFT using Cooley-Tukey algorithm on radix 2 dimensional input.
|
MathBackendCPU.prototype.fftRadix2 = function (input, size, inverse) {
|
if (size === 1) {
|
return input;
|
}
|
var data = this.readSync(input.dataId);
|
var half = size / 2;
|
var evenComplex = complex_util.complexWithEvenIndex(data);
|
var evenTensor = ops.complex(evenComplex.real, evenComplex.imag).as1D();
|
var oddComplex = complex_util.complexWithOddIndex(data);
|
var oddTensor = ops.complex(oddComplex.real, oddComplex.imag).as1D();
|
// Recursive call for half part of original input.
|
evenTensor = this.fftRadix2(evenTensor, half, inverse);
|
oddTensor = this.fftRadix2(oddTensor, half, inverse);
|
var e = complex_util.exponents(size, inverse);
|
var exponent = ops.complex(e.real, e.imag).mul(oddTensor);
|
var addPart = evenTensor.add(exponent);
|
var subPart = evenTensor.sub(exponent);
|
var realTensor = ops.real(addPart).concat(ops.real(subPart));
|
var imagTensor = ops.imag(addPart).concat(ops.imag(subPart));
|
return ops.complex(realTensor, imagTensor).as1D();
|
};
|
// Calculate fourier transform by multplying sinusoid matrix.
|
MathBackendCPU.prototype.fourierTransformByMatmul = function (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 = complex_util.exponent(r * c, size, inverse);
|
var term = complex_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;
|
}
|
complex_util.assignToTypedArray(ret, real_2, imag_2, r);
|
}
|
return ret;
|
};
|
MathBackendCPU.prototype.depthToSpace = function (x, blockSize, dataFormat) {
|
util.assert(dataFormat === 'NHWC', function () { return "Only NHWC dataFormat supported on CPU for depthToSpace. Got " + dataFormat; });
|
util.assert(blockSize > 1, function () {
|
return "blockSize should be > 1 for depthToSpace, but was: " + blockSize;
|
});
|
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 = this.readSync(x.dataId);
|
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 ops.tensor4d(result, [batchSize, outputHeight, outputWidth, outputDepth]);
|
};
|
MathBackendCPU.prototype.broadcastedBinaryOp = function (a, b, dtype, op) {
|
var newShape = broadcast_util.assertAndGetBroadcastShape(a.shape, b.shape);
|
var result = ops.buffer(newShape, dtype);
|
var aVals = this.readSync(a.dataId);
|
var bVals = this.readSync(b.dataId);
|
var aBroadcastDims = broadcast_util.getBroadcastDims(a.shape, newShape);
|
var bBroadcastDims = broadcast_util.getBroadcastDims(b.shape, newShape);
|
var resVals = result.values;
|
if (aBroadcastDims.length + bBroadcastDims.length === 0) {
|
for (var i = 0; i < resVals.length; ++i) {
|
resVals[i] = op(aVals[i % aVals.length], bVals[i % bVals.length]);
|
}
|
}
|
else {
|
var aBuf = this.bufferSync(a);
|
var bBuf = this.bufferSync(b);
|
var _loop_2 = function (i) {
|
var loc = result.indexToLoc(i);
|
var aLoc = loc.slice(-a.rank);
|
aBroadcastDims.forEach(function (d) { return aLoc[d] = 0; });
|
var aIndex = aBuf.locToIndex(aLoc);
|
var bLoc = loc.slice(-b.rank);
|
bBroadcastDims.forEach(function (d) { return bLoc[d] = 0; });
|
var bIndex = bBuf.locToIndex(bLoc);
|
resVals[i] = op(aVals[aIndex], bVals[bIndex]);
|
};
|
for (var i = 0; i < resVals.length; ++i) {
|
_loop_2(i);
|
}
|
}
|
return result.toTensor();
|
};
|
MathBackendCPU.prototype.broadcastedBinaryComplexOp = function (a, b, op) {
|
var newShape = broadcast_util.assertAndGetBroadcastShape(a.shape, b.shape);
|
var realResult = ops.buffer(newShape, 'float32');
|
var imagResult = ops.buffer(newShape, 'float32');
|
var aVals = this.readSync(a.dataId);
|
var bVals = this.readSync(b.dataId);
|
var aBroadcastDims = broadcast_util.getBroadcastDims(a.shape, newShape);
|
var bBroadcastDims = broadcast_util.getBroadcastDims(b.shape, newShape);
|
var realVals = realResult.values;
|
var imagVals = imagResult.values;
|
if (aBroadcastDims.length + bBroadcastDims.length === 0) {
|
for (var i = 0; i < realVals.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]);
|
realVals[i] = result.real;
|
imagVals[i] = result.imag;
|
}
|
}
|
else {
|
var aRealBuf = this.bufferSync(this.data.get(a.dataId).complexTensors.real);
|
var bRealBuf = this.bufferSync(this.data.get(b.dataId).complexTensors.real);
|
var _loop_3 = function (i) {
|
var loc = realResult.indexToLoc(i);
|
var aLoc = loc.slice(-a.rank);
|
aBroadcastDims.forEach(function (d) { return aLoc[d] = 0; });
|
var aIndex = aRealBuf.locToIndex(aLoc);
|
var bLoc = loc.slice(-b.rank);
|
bBroadcastDims.forEach(function (d) { return bLoc[d] = 0; });
|
var bIndex = bRealBuf.locToIndex(bLoc);
|
var opResult = op(aVals[aIndex * 2], aVals[aIndex * 2 + 1], bVals[bIndex * 2], bVals[bIndex * 2 + 1]);
|
realVals[i] = opResult.real;
|
imagVals[i] = opResult.imag;
|
};
|
for (var i = 0; i < realVals.length; i++) {
|
_loop_3(i);
|
}
|
}
|
return this.complex(realResult.toTensor(), imagResult.toTensor());
|
};
|
MathBackendCPU.prototype.split = function (x, sizeSplits, axis) {
|
return split_shared_1.split(x, sizeSplits, axis);
|
};
|
MathBackendCPU.prototype.dispose = function () { };
|
MathBackendCPU.prototype.floatPrecision = function () {
|
return 32;
|
};
|
/** Returns the smallest representable number. */
|
MathBackendCPU.prototype.epsilon = function () {
|
return backend_1.EPSILON_FLOAT32;
|
};
|
MathBackendCPU.prototype.cropAndResize = function (images, boxes, boxIndex, cropSize, method, extrapolationValue) {
|
var _a = images.shape, batch = _a[0], imageHeight = _a[1], imageWidth = _a[2], numChannels = _a[3];
|
var numBoxes = boxes.shape[0];
|
var cropHeight = cropSize[0], cropWidth = cropSize[1];
|
var output = ops.buffer([numBoxes, cropHeight, cropWidth, numChannels], 'float32');
|
var boxVals = this.readSync(boxes.dataId);
|
var boxIndVals = this.readSync(boxIndex.dataId);
|
var imageVals = this.readSync(images.dataId);
|
var inStride = images.strides; // to calculate flat indexes into image
|
var outStride = output.strides; // 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_2 = 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_2 + ((bottom - top_2) * 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 output.toTensor();
|
};
|
MathBackendCPU.prototype.sparseToDense = function (sparseIndices, sparseValues, outputShape, defaultValue) {
|
var _a = scatter_nd_util.calculateShapes(sparseValues, sparseIndices, outputShape), sliceRank = _a.sliceRank, numUpdates = _a.numUpdates, sliceSize = _a.sliceSize, strides = _a.strides, outputSize = _a.outputSize;
|
var sumDupeIndices = false;
|
return this.scatter(sparseIndices, sparseValues, outputShape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices);
|
};
|
MathBackendCPU.prototype.gatherND = function (x, indices) {
|
var indicesShape = indices.shape;
|
var sliceRank = indicesShape[indicesShape.length - 1];
|
var _a = gather_nd_util.prepareAndValidate(x, indices), resultShape = _a[0], numSlices = _a[1], sliceSize = _a[2], strides = _a[3];
|
if (numSlices === 0) {
|
return ops_1.tensor([], resultShape, x.dtype);
|
}
|
var buffer = new tensor_1.TensorBuffer([numSlices, sliceSize], x.dtype);
|
var indicesData = this.readSync(indices.dataId);
|
var xData = this.readSync(x.dataId);
|
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 >= x.size / sliceSize) {
|
throw new Error("Invalid indices: " + index + " does not index into " + x.shape);
|
}
|
for (var k = 0; k < sliceSize; k++) {
|
buffer.values[i * sliceSize + k] = xData[flattenIndex * sliceSize + k];
|
}
|
}
|
return buffer.toTensor().reshape(resultShape);
|
};
|
MathBackendCPU.prototype.scatterND = function (indices, updates, shape) {
|
var _a = scatter_nd_util.calculateShapes(updates, indices, shape), sliceRank = _a.sliceRank, numUpdates = _a.numUpdates, sliceSize = _a.sliceSize, strides = _a.strides, outputSize = _a.outputSize;
|
var defaultValue = ops_1.scalar(0);
|
var sumDupeIndices = true;
|
return this.scatter(indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices);
|
};
|
MathBackendCPU.prototype.fill = function (shape, value, dtype) {
|
dtype = dtype || util_1.inferDtype(value);
|
var values = util_1.getArrayFromDType(dtype, util_1.sizeFromShape(shape));
|
values.fill(value);
|
return engine_1.ENGINE.makeTensor(values, shape, dtype, this);
|
};
|
MathBackendCPU.prototype.onesLike = function (x) {
|
if (x.dtype === 'string') {
|
throw new Error('onesLike is not supported for string tensors');
|
}
|
else {
|
return this.fill(x.shape, 1, x.dtype);
|
}
|
};
|
MathBackendCPU.prototype.zerosLike = function (x) {
|
var values = util_1.getArrayFromDType(x.dtype, util_1.sizeFromShape(x.shape));
|
return this.makeOutput(values, x.shape, x.dtype);
|
};
|
MathBackendCPU.prototype.linspace = function (start, stop, num) {
|
return backend_util.linspaceImpl(start, stop, num);
|
};
|
MathBackendCPU.prototype.scatter = function (indices, updates, shape, outputSize, sliceSize, numUpdates, sliceRank, strides, defaultValue, sumDupeIndices) {
|
var flattenShape = [outputSize / sliceSize, sliceSize];
|
var indicesData = this.readSync(indices.dataId);
|
var updatesData = this.readSync(updates.dataId);
|
if (outputSize === 0) {
|
return ops_1.tensor([], shape, updates.dtype);
|
}
|
var buffer = new tensor_1.TensorBuffer(flattenShape, updates.dtype);
|
buffer.values.fill(this.readSync(defaultValue.dataId)[0]);
|
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: " + index + " does not index into " + shape);
|
}
|
for (var k = 0; k < sliceSize; k++) {
|
if (sumDupeIndices) {
|
buffer.values[flattenIndex * sliceSize + k] +=
|
updatesData[i * sliceSize + k];
|
}
|
else {
|
buffer.values[flattenIndex * sliceSize + k] = updates.rank === 0 ?
|
updatesData[0] :
|
updatesData[i * sliceSize + k];
|
}
|
}
|
}
|
return buffer.toTensor().reshape(shape);
|
};
|
return MathBackendCPU;
|
}(backend_1.KernelBackend));
|
exports.MathBackendCPU = MathBackendCPU;
|
engine_1.ENGINE.registerBackend('cpu', function () { return new MathBackendCPU(); }, 1 /* priority */);
|
//# sourceMappingURL=backend_cpu.js.map
|
