@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthToSpace.js

@@ -0,0 +1,47 @@
+import "../../../tfjs-core/dist/index.js";
+import { DepthToSpace as I } from "../../../tfjs-core/dist/kernel_names.js";
+import { assert as N } from "../../../tfjs-core/dist/util_base.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function y(k) {
+  const { inputs: D, backend: i, attrs: H } = k, { x: o } = D, { blockSize: t, dataFormat: f } = H;
+  N(f === "NHWC", () => `Only NHWC dataFormat supported on CPU for depthToSpace. Got ${f}`);
+  const a = o.shape[0], h = o.shape[1], d = o.shape[2], l = o.shape[3], c = h * t, p = d * t, e = l / (t * t), S = i.data.get(o.dataId).values, m = new Float32Array(a * c * p * e);
+  let W = 0;
+  for (let r = 0; r < a; ++r)
+    for (let n = 0; n < c; ++n) {
+      const b = Math.floor(n / t), x = n % t;
+      for (let s = 0; s < p; ++s) {
+        const T = Math.floor(s / t), g = s % t, C = (x * t + g) * e;
+        for (let u = 0; u < e; ++u) {
+          const F = u + C + l * (T + d * (b + h * r));
+          m[W++] = S[F];
+        }
+      }
+    }
+  return i.makeTensorInfo([a, c, p, e], o.dtype, m);
+}
+const A = {
+  kernelName: I,
+  backendName: "cpu",
+  kernelFunc: y
+};
+export {
+  y as depthToSpace,
+  A as depthToSpaceConfig
+};
+//# sourceMappingURL=DepthToSpace.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthToSpace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthToSpace.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthToSpace.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { DepthToSpace, util } from '@tensorflow/tfjs-core';\nexport function depthToSpace(args) {\n    const { inputs, backend, attrs } = args;\n    const { x } = inputs;\n    const { blockSize, dataFormat } = attrs;\n    util.assert(dataFormat === 'NHWC', () => `Only NHWC dataFormat supported on CPU for depthToSpace. Got ${dataFormat}`);\n    const batchSize = x.shape[0];\n    const inputHeight = x.shape[1];\n    const inputWidth = x.shape[2];\n    const inputDepth = x.shape[3];\n    const outputHeight = inputHeight * blockSize;\n    const outputWidth = inputWidth * blockSize;\n    const outputDepth = inputDepth / (blockSize * blockSize);\n    const xValues = backend.data.get(x.dataId).values;\n    const result = new Float32Array(batchSize * outputHeight * outputWidth * outputDepth);\n    let outputIdx = 0;\n    for (let b = 0; b < batchSize; ++b) {\n        for (let h = 0; h < outputHeight; ++h) {\n            const inH = Math.floor(h / blockSize);\n            const offsetH = (h % blockSize);\n            for (let w = 0; w < outputWidth; ++w) {\n                const inW = Math.floor(w / blockSize);\n                const offsetW = (w % blockSize);\n                const offsetD = (offsetH * blockSize + offsetW) * outputDepth;\n                for (let d = 0; d < outputDepth; ++d) {\n                    const inD = d + offsetD;\n                    const inputIdx = inD + inputDepth * (inW + inputWidth * (inH + inputHeight * b));\n                    result[outputIdx++] = xValues[inputIdx];\n                }\n            }\n        }\n    }\n    return backend.makeTensorInfo([batchSize, outputHeight, outputWidth, outputDepth], x.dtype, result);\n}\nexport const depthToSpaceConfig = {\n    kernelName: DepthToSpace,\n    backendName: 'cpu',\n    kernelFunc: depthToSpace\n};\n//# sourceMappingURL=data:application/json;base64,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"],"names":["depthToSpace","args","inputs","backend","attrs","x","blockSize","dataFormat","util.assert","batchSize","inputHeight","inputWidth","inputDepth","outputHeight","outputWidth","outputDepth","xValues","result","outputIdx","b","h","inH","offsetH","w","inW","offsetW","offsetD","d","inputIdx","depthToSpaceConfig","DepthToSpace"],"mappings":";;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAASA,EAAaC,GAAM;AAC/B,QAAM,EAAE,QAAAC,GAAQ,SAAAC,GAAS,OAAAC,EAAK,IAAKH,GAC7B,EAAE,GAAAI,EAAG,IAAGH,GACR,EAAE,WAAAI,GAAW,YAAAC,EAAY,IAAGH;AAClCI,EAAAA,EAAYD,MAAe,QAAQ,MAAM,+DAA+DA,CAAU,EAAE;AACpH,QAAME,IAAYJ,EAAE,MAAM,CAAC,GACrBK,IAAcL,EAAE,MAAM,CAAC,GACvBM,IAAaN,EAAE,MAAM,CAAC,GACtBO,IAAaP,EAAE,MAAM,CAAC,GACtBQ,IAAeH,IAAcJ,GAC7BQ,IAAcH,IAAaL,GAC3BS,IAAcH,KAAcN,IAAYA,IACxCU,IAAUb,EAAQ,KAAK,IAAIE,EAAE,MAAM,EAAE,QACrCY,IAAS,IAAI,aAAaR,IAAYI,IAAeC,IAAcC,CAAW;AACpF,MAAIG,IAAY;AAChB,WAASC,IAAI,GAAGA,IAAIV,GAAW,EAAEU;AAC7B,aAASC,IAAI,GAAGA,IAAIP,GAAc,EAAEO,GAAG;AACnC,YAAMC,IAAM,KAAK,MAAMD,IAAId,CAAS,GAC9BgB,IAAWF,IAAId;AACrB,eAASiB,IAAI,GAAGA,IAAIT,GAAa,EAAES,GAAG;AAClC,cAAMC,IAAM,KAAK,MAAMD,IAAIjB,CAAS,GAC9BmB,IAAWF,IAAIjB,GACfoB,KAAWJ,IAAUhB,IAAYmB,KAAWV;AAClD,iBAASY,IAAI,GAAGA,IAAIZ,GAAa,EAAEY,GAAG;AAElC,gBAAMC,IADMD,IAAID,IACOd,KAAcY,IAAMb,KAAcU,IAAMX,IAAcS;AAC7E,UAAAF,EAAOC,GAAW,IAAIF,EAAQY,CAAQ;AAAA,QACzC;AAAA,MACJ;AAAA,IACJ;AAEL,SAAOzB,EAAQ,eAAe,CAACM,GAAWI,GAAcC,GAAaC,CAAW,GAAGV,EAAE,OAAOY,CAAM;AACtG;AACY,MAACY,IAAqB;AAAA,EAC9B,YAAYC;AAAA,EACZ,aAAa;AAAA,EACb,YAAY9B;AAChB;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNative.js

@@ -0,0 +1,78 @@
+import "../../../tfjs-core/dist/index.js";
+import { assertNotComplex as U } from "../cpu_util.js";
+import { DepthwiseConv2dNative as X } from "../../../tfjs-core/dist/kernel_names.js";
+import { computeStrides as g, assert as Y } from "../../../tfjs-core/dist/util_base.js";
+import { eitherStridesOrDilationsAreOne as Z, computeConv2DInfo as _ } from "../../../tfjs-core/dist/ops/conv_util.js";
+import { TensorBuffer as tt } from "../../../tfjs-core/dist/tensor.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function et(N) {
+  const { inputs: I, backend: l, attrs: S } = N, { x: s, filter: n } = I, { strides: p, pad: b, dilations: k, dimRoundingMode: H } = S;
+  U([s, n], "depthwiseConv2DNative");
+  const v = g(s.shape), x = g(n.shape);
+  let o = k;
+  o == null && (o = [1, 1]), Y(Z(p, o), () => `Error in depthwiseConv2d: Either strides or dilations must be 1. Got strides ${p} and dilations '${o}'`);
+  const t = _(
+    s.shape,
+    n.shape,
+    p,
+    o,
+    b,
+    H,
+    !0
+    /* depthwise */
+  ), { filterHeight: R, filterWidth: W, dilationHeight: D, dilationWidth: V, padInfo: w } = t, T = w.left, $ = w.top, h = t.outChannels / t.inChannels, e = new tt(t.outShape, s.dtype), E = l.data.get(s.dataId).values, M = l.data.get(n.dataId).values, q = e.values;
+  for (let i = 0; i < t.batchSize; ++i) {
+    const z = i * v[0], A = i * e.strides[0];
+    for (let r = 0; r < t.outHeight; ++r) {
+      const B = A + r * e.strides[1], F = r * t.strideHeight - $;
+      for (let a = 0; a < R; ++a) {
+        const u = F + a * D;
+        if (u < 0 || u >= t.inHeight)
+          continue;
+        const G = a * x[0], L = z + u * v[1];
+        for (let d = 0; d < t.outWidth; ++d) {
+          const j = B + d * e.strides[2], J = d * t.strideWidth - T;
+          for (let f = 0; f < W; ++f) {
+            const m = J + f * V;
+            if (m < 0 || m >= t.inWidth)
+              continue;
+            const K = G + f * x[1], P = L + m * t.inChannels;
+            let O = j, y = K;
+            for (let C = 0; C < t.inChannels; ++C) {
+              const Q = E[P + C];
+              for (let c = 0; c < h; ++c)
+                q[O + c] += Q * M[y + c];
+              O += h, y += h;
+            }
+          }
+        }
+      }
+    }
+  }
+  return l.makeTensorInfo(e.shape, e.dtype, e.values);
+}
+const dt = {
+  kernelName: X,
+  backendName: "cpu",
+  kernelFunc: et
+};
+export {
+  et as depthwiseConv2dNative,
+  dt as depthwiseConv2dNativeConfig
+};
+//# sourceMappingURL=DepthwiseConv2dNative.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNative.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthwiseConv2dNative.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNative.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { backend_util, DepthwiseConv2dNative, TensorBuffer, util } from '@tensorflow/tfjs-core';\nimport { assertNotComplex } from '../cpu_util';\nexport function depthwiseConv2dNative(args) {\n    const { inputs, backend, attrs } = args;\n    const { x, filter } = inputs;\n    const { strides, pad, dilations, dimRoundingMode } = attrs;\n    assertNotComplex([x, filter], 'depthwiseConv2DNative');\n    const xStrides = util.computeStrides(x.shape);\n    const filterStrides = util.computeStrides(filter.shape);\n    let $dilations = dilations;\n    if ($dilations == null) {\n        $dilations = [1, 1];\n    }\n    util.assert(backend_util.eitherStridesOrDilationsAreOne(strides, $dilations), () => 'Error in depthwiseConv2d: Either strides or dilations must be ' +\n        `1. Got strides ${strides} and dilations '${$dilations}'`);\n    const convInfo = backend_util.computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad, dimRoundingMode, true /* depthwise */);\n    const { filterHeight, filterWidth, dilationHeight, dilationWidth, padInfo } = convInfo;\n    const padLeft = padInfo.left;\n    const padTop = padInfo.top;\n    const chMul = convInfo.outChannels / convInfo.inChannels;\n    const y = new TensorBuffer(convInfo.outShape, x.dtype);\n    const xVals = backend.data.get(x.dataId).values;\n    const wVals = backend.data.get(filter.dataId).values;\n    const yVals = y.values;\n    for (let b = 0; b < convInfo.batchSize; ++b) {\n        const xOffset1 = b * xStrides[0];\n        const yOffset1 = b * y.strides[0];\n        for (let yR = 0; yR < convInfo.outHeight; ++yR) {\n            const yOffset2 = yOffset1 + yR * y.strides[1];\n            const xRCorner = yR * convInfo.strideHeight - padTop;\n            for (let wR = 0; wR < filterHeight; ++wR) {\n                const xR = xRCorner + wR * dilationHeight;\n                if (xR < 0 || xR >= convInfo.inHeight) {\n                    continue;\n                }\n                const wOffset1 = wR * filterStrides[0];\n                const xOffset2 = xOffset1 + xR * xStrides[1];\n                for (let yC = 0; yC < convInfo.outWidth; ++yC) {\n                    const yOffset3 = yOffset2 + yC * y.strides[2];\n                    const xCCorner = yC * convInfo.strideWidth - padLeft;\n                    for (let wC = 0; wC < filterWidth; ++wC) {\n                        const xC = xCCorner + wC * dilationWidth;\n                        if (xC < 0 || xC >= convInfo.inWidth) {\n                            continue;\n                        }\n                        const wOffset2 = wOffset1 + wC * filterStrides[1];\n                        const xOffset3 = xOffset2 + xC * convInfo.inChannels;\n                        let yOffset4 = yOffset3;\n                        let wOffset3 = wOffset2;\n                        for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {\n                            const xVal = xVals[xOffset3 + d1];\n                            for (let q = 0; q < chMul; ++q) {\n                                yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];\n                            }\n                            yOffset4 += chMul;\n                            wOffset3 += chMul;\n                        }\n                    }\n                }\n            }\n        }\n    }\n    return backend.makeTensorInfo(y.shape, y.dtype, y.values);\n}\nexport const depthwiseConv2dNativeConfig = {\n    kernelName: DepthwiseConv2dNative,\n    backendName: 'cpu',\n    kernelFunc: depthwiseConv2dNative\n};\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DepthwiseConv2dNative.js","sourceRoot":"","sources":["../../../../../../tfjs-backend-cpu/src/kernels/DepthwiseConv2dNative.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {backend_util, DepthwiseConv2dNative, DepthwiseConv2dNativeAttrs, DepthwiseConv2dNativeInputs, KernelConfig, KernelFunc, TensorBuffer, TensorInfo, TypedArray, util} from '@tensorflow/tfjs-core';\n\nimport {MathBackendCPU} from '../backend_cpu';\nimport {assertNotComplex} from '../cpu_util';\n\nexport function depthwiseConv2dNative(args: {\n  inputs: DepthwiseConv2dNativeInputs,\n  backend: MathBackendCPU,\n  attrs: DepthwiseConv2dNativeAttrs\n}): TensorInfo {\n  const {inputs, backend, attrs} = args;\n  const {x, filter} = inputs;\n  const {strides, pad, dilations, dimRoundingMode} = attrs;\n\n  assertNotComplex([x, filter], 'depthwiseConv2DNative');\n\n  const xStrides = util.computeStrides(x.shape);\n  const filterStrides = util.computeStrides(filter.shape);\n\n  let $dilations = dilations;\n  if ($dilations == null) {\n    $dilations = [1, 1];\n  }\n\n  util.assert(\n      backend_util.eitherStridesOrDilationsAreOne(strides, $dilations),\n      () => 'Error in depthwiseConv2d: Either strides or dilations must be ' +\n          `1. Got strides ${strides} and dilations '${$dilations}'`);\n\n  const convInfo = backend_util.computeConv2DInfo(\n      x.shape as [number, number, number, number],\n      filter.shape as [number, number, number, number], strides, $dilations,\n      pad, dimRoundingMode, true /* depthwise */);\n\n  const {filterHeight, filterWidth, dilationHeight, dilationWidth, padInfo} =\n      convInfo;\n  const padLeft = padInfo.left;\n  const padTop = padInfo.top;\n  const chMul = convInfo.outChannels / convInfo.inChannels;\n  const y = new TensorBuffer(convInfo.outShape, x.dtype as 'float32');\n  const xVals = backend.data.get(x.dataId).values as TypedArray;\n  const wVals = backend.data.get(filter.dataId).values as TypedArray;\n  const yVals = y.values;\n\n  for (let b = 0; b < convInfo.batchSize; ++b) {\n    const xOffset1 = b * xStrides[0];\n    const yOffset1 = b * y.strides[0];\n    for (let yR = 0; yR < convInfo.outHeight; ++yR) {\n      const yOffset2 = yOffset1 + yR * y.strides[1];\n      const xRCorner = yR * convInfo.strideHeight - padTop;\n      for (let wR = 0; wR < filterHeight; ++wR) {\n        const xR = xRCorner + wR * dilationHeight;\n        if (xR < 0 || xR >= convInfo.inHeight) {\n          continue;\n        }\n        const wOffset1 = wR * filterStrides[0];\n        const xOffset2 = xOffset1 + xR * xStrides[1];\n        for (let yC = 0; yC < convInfo.outWidth; ++yC) {\n          const yOffset3 = yOffset2 + yC * y.strides[2];\n          const xCCorner = yC * convInfo.strideWidth - padLeft;\n          for (let wC = 0; wC < filterWidth; ++wC) {\n            const xC = xCCorner + wC * dilationWidth;\n            if (xC < 0 || xC >= convInfo.inWidth) {\n              continue;\n            }\n            const wOffset2 = wOffset1 + wC * filterStrides[1];\n            const xOffset3 = xOffset2 + xC * convInfo.inChannels;\n            let yOffset4 = yOffset3;\n            let wOffset3 = wOffset2;\n            for (let d1 = 0; d1 < convInfo.inChannels; ++d1) {\n              const xVal = xVals[xOffset3 + d1];\n              for (let q = 0; q < chMul; ++q) {\n                yVals[yOffset4 + q] += xVal * wVals[wOffset3 + q];\n              }\n              yOffset4 += chMul;\n              wOffset3 += chMul;\n            }\n          }\n        }\n      }\n    }\n  }\n\n  return backend.makeTensorInfo(y.shape, y.dtype, y.values);\n}\n\nexport const depthwiseConv2dNativeConfig: KernelConfig = {\n  kernelName: DepthwiseConv2dNative,\n  backendName: 'cpu',\n  kernelFunc: depthwiseConv2dNative as unknown as KernelFunc\n};\n"]}"],"names":["depthwiseConv2dNative","args","inputs","backend","attrs","x","filter","strides","pad","dilations","dimRoundingMode","assertNotComplex","xStrides","util.computeStrides","filterStrides","$dilations","util.assert","backend_util.eitherStridesOrDilationsAreOne","convInfo","backend_util.computeConv2DInfo","filterHeight","filterWidth","dilationHeight","dilationWidth","padInfo","padLeft","padTop","chMul","y","TensorBuffer","xVals","wVals","yVals","b","xOffset1","yOffset1","yR","yOffset2","xRCorner","wR","xR","wOffset1","xOffset2","yC","yOffset3","xCCorner","wC","xC","wOffset2","xOffset3","yOffset4","wOffset3","d1","xVal","q","depthwiseConv2dNativeConfig","DepthwiseConv2dNative"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropFilter.js

@@ -0,0 +1,65 @@
+import "../../../tfjs-core/dist/index.js";
+import { assertNotComplex as A } from "../cpu_util.js";
+import { DepthwiseConv2dNativeBackpropFilter as E } from "../../../tfjs-core/dist/kernel_names.js";
+import { computeConv2DInfo as G } from "../../../tfjs-core/dist/ops/conv_util.js";
+import { TensorBuffer as u } from "../../../tfjs-core/dist/tensor.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function J(y) {
+  const { inputs: x, backend: p, attrs: g } = y, { x: n, dy: s } = x, { strides: k, dilations: w, pad: B, dimRoundingMode: I, filterShape: N } = g;
+  A([n, s], "depthwiseConv2dNativeBackpropFilter");
+  const t = G(
+    n.shape,
+    N,
+    k,
+    w,
+    B,
+    I,
+    !0
+    /* depthwise */
+  ), { strideHeight: l, strideWidth: h, filterHeight: R, filterWidth: F } = t, i = new u(t.filterShape, "float32"), f = t.padInfo.left, m = t.padInfo.top, C = t.outChannels / t.inChannels, W = p.data.get(n.dataId).values, b = new u(n.shape, n.dtype, W), H = p.data.get(s.dataId).values, P = new u(s.shape, s.dtype, H);
+  for (let e = 0; e < R; ++e) {
+    const S = Math.max(0, Math.ceil((m - e) / l)), D = Math.min(t.outHeight, (t.inHeight + m - e) / l);
+    for (let o = 0; o < F; ++o) {
+      const T = Math.max(0, Math.ceil((f - o) / h)), V = Math.min(t.outWidth, (t.inWidth + f - o) / h);
+      for (let a = 0; a < t.outChannels; ++a) {
+        const v = Math.trunc(a / C), z = a % C;
+        let M = 0;
+        for (let d = 0; d < t.batchSize; ++d)
+          for (let r = S; r < D; ++r) {
+            const j = e + r * l - m;
+            for (let c = T; c < V; ++c) {
+              const q = o + c * h - f;
+              M += b.get(d, j, q, v) * P.get(d, r, c, a);
+            }
+          }
+        i.set(M, e, o, v, z);
+      }
+    }
+  }
+  return p.makeTensorInfo(i.shape, i.dtype, i.values);
+}
+const X = {
+  kernelName: E,
+  backendName: "cpu",
+  kernelFunc: J
+};
+export {
+  J as depthwiseConv2dNativeBackpropFilter,
+  X as depthwiseConv2dNativeBackpropFilterConfig
+};
+//# sourceMappingURL=DepthwiseConv2dNativeBackpropFilter.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthwiseConv2dNativeBackpropFilter.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropFilter.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { backend_util, DepthwiseConv2dNativeBackpropFilter, TensorBuffer } from '@tensorflow/tfjs-core';\nimport { assertNotComplex } from '../cpu_util';\nexport function depthwiseConv2dNativeBackpropFilter(args) {\n    const { inputs, backend, attrs } = args;\n    const { x, dy } = inputs;\n    const { strides, dilations, pad, dimRoundingMode, filterShape } = attrs;\n    assertNotComplex([x, dy], 'depthwiseConv2dNativeBackpropFilter');\n    const convInfo = backend_util.computeConv2DInfo(x.shape, filterShape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);\n    const { strideHeight, strideWidth, filterHeight, filterWidth } = convInfo;\n    const dW = new TensorBuffer(convInfo.filterShape, 'float32');\n    const leftPad = convInfo.padInfo.left;\n    const topPad = convInfo.padInfo.top;\n    const chMul = convInfo.outChannels / convInfo.inChannels;\n    const xVals = backend.data.get(x.dataId).values;\n    const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);\n    const dyVals = backend.data.get(dy.dataId).values;\n    const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);\n    for (let wR = 0; wR < filterHeight; ++wR) {\n        const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));\n        const yRMax = Math.min(convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);\n        for (let wC = 0; wC < filterWidth; ++wC) {\n            const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));\n            const yCMax = Math.min(convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);\n            for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {\n                const d1 = Math.trunc(d2 / chMul);\n                const dm = d2 % chMul;\n                let dotProd = 0;\n                for (let b = 0; b < convInfo.batchSize; ++b) {\n                    for (let yR = yRMin; yR < yRMax; ++yR) {\n                        const xR = wR + yR * strideHeight - topPad;\n                        for (let yC = yCMin; yC < yCMax; ++yC) {\n                            const xC = wC + yC * strideWidth - leftPad;\n                            dotProd += xBuf.get(b, xR, xC, d1) *\n                                dyBuf.get(b, yR, yC, d2);\n                        }\n                    }\n                }\n                dW.set(dotProd, wR, wC, d1, dm);\n            }\n        }\n    }\n    return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);\n}\nexport const depthwiseConv2dNativeBackpropFilterConfig = {\n    kernelName: DepthwiseConv2dNativeBackpropFilter,\n    backendName: 'cpu',\n    kernelFunc: depthwiseConv2dNativeBackpropFilter\n};\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DepthwiseConv2dNativeBackpropFilter.js","sourceRoot":"","sources":["../../../../../../tfjs-backend-cpu/src/kernels/DepthwiseConv2dNativeBackpropFilter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAC,YAAY,EAAE,mCAAmC,EAAiH,YAAY,EAAyB,MAAM,uBAAuB,CAAC;AAG7O,OAAO,EAAC,gBAAgB,EAAC,MAAM,aAAa,CAAC;AAE7C,MAAM,UAAU,mCAAmC,CAAC,IAInD;IACC,MAAM,EAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAC,GAAG,IAAI,CAAC;IACtC,MAAM,EAAC,CAAC,EAAE,EAAE,EAAC,GAAG,MAAM,CAAC;IACvB,MAAM,EAAC,OAAO,EAAE,SAAS,EAAE,GAAG,EAAE,eAAe,EAAE,WAAW,EAAC,GAAG,KAAK,CAAC;IAEtE,gBAAgB,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,qCAAqC,CAAC,CAAC;IAEjE,MAAM,QAAQ,GAAG,YAAY,CAAC,iBAAiB,CAC3C,CAAC,CAAC,KAAyC,EAAE,WAAW,EAAE,OAAO,EACjE,SAAS,EAAE,GAAG,EAAE,eAAe,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IAE3D,MAAM,EAAC,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,EAAC,GAAG,QAAQ,CAAC;IAExE,MAAM,EAAE,GAAG,IAAI,YAAY,CAAC,QAAQ,CAAC,WAAW,EAAE,SAAS,CAAC,CAAC;IAE7D,MAAM,OAAO,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC;IACtC,MAAM,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC;IACpC,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,UAAU,CAAC;IAEzD,MAAM,KAAK,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,MAAoB,CAAC;IAC9D,MAAM,IAAI,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACvD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,MAAoB,CAAC;IAChE,MAAM,KAAK,GAAG,IAAI,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;IAC3D,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,YAAY,EAAE,EAAE,EAAE,EAAE;QACxC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAClB,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,CAAC,QAAQ,GAAG,MAAM,GAAG,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC;QAE1E,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,WAAW,EAAE,EAAE,EAAE,EAAE;YACvC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;YACnE,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAClB,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,CAAC,OAAO,GAAG,OAAO,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC;YAExE,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,QAAQ,CAAC,WAAW,EAAE,EAAE,EAAE,EAAE;gBAChD,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC;gBAClC,MAAM,EAAE,GAAG,EAAE,GAAG,KAAK,CAAC;gBAEtB,IAAI,OAAO,GAAG,CAAC,CAAC;gBAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,CAAC,SAAS,EAAE,EAAE,CAAC,EAAE;oBAC3C,KAAK,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE;wBACrC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,YAAY,GAAG,MAAM,CAAC;wBAC3C,KAAK,IAAI,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,EAAE,EAAE;4BACrC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,WAAW,GAAG,OAAO,CAAC;4BAC3C,OAAO,IAAK,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAY;gCACzC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAY,CAAC;yBAC1C;qBACF;iBACF;gBACD,EAAE,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;aACjC;SACF;KACF;IAED,OAAO,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,MAAM,CAAC,CAAC;AAC/D,CAAC;AAED,MAAM,CAAC,MAAM,yCAAyC,GAAiB;IACrE,UAAU,EAAE,mCAAmC;IAC/C,WAAW,EAAE,KAAK;IAClB,UAAU,EAAE,mCAA4D;CACzE,CAAC","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {backend_util, DepthwiseConv2dNativeBackpropFilter, DepthwiseConv2dNativeBackpropFilterAttrs, DepthwiseConv2dNativeBackpropFilterInputs, KernelConfig, KernelFunc, TensorBuffer, TensorInfo, TypedArray} from '@tensorflow/tfjs-core';\n\nimport {MathBackendCPU} from '../backend_cpu';\nimport {assertNotComplex} from '../cpu_util';\n\nexport function depthwiseConv2dNativeBackpropFilter(args: {\n  inputs: DepthwiseConv2dNativeBackpropFilterInputs,\n  backend: MathBackendCPU,\n  attrs: DepthwiseConv2dNativeBackpropFilterAttrs\n}): TensorInfo {\n  const {inputs, backend, attrs} = args;\n  const {x, dy} = inputs;\n  const {strides, dilations, pad, dimRoundingMode, filterShape} = attrs;\n\n  assertNotComplex([x, dy], 'depthwiseConv2dNativeBackpropFilter');\n\n  const convInfo = backend_util.computeConv2DInfo(\n      x.shape as [number, number, number, number], filterShape, strides,\n      dilations, pad, dimRoundingMode, true /* depthwise */);\n\n  const {strideHeight, strideWidth, filterHeight, filterWidth} = convInfo;\n\n  const dW = new TensorBuffer(convInfo.filterShape, 'float32');\n\n  const leftPad = convInfo.padInfo.left;\n  const topPad = convInfo.padInfo.top;\n  const chMul = convInfo.outChannels / convInfo.inChannels;\n\n  const xVals = backend.data.get(x.dataId).values as TypedArray;\n  const xBuf = new TensorBuffer(x.shape, x.dtype, xVals);\n  const dyVals = backend.data.get(dy.dataId).values as TypedArray;\n  const dyBuf = new TensorBuffer(dy.shape, dy.dtype, dyVals);\n  for (let wR = 0; wR < filterHeight; ++wR) {\n    const yRMin = Math.max(0, Math.ceil((topPad - wR) / strideHeight));\n    const yRMax = Math.min(\n        convInfo.outHeight, (convInfo.inHeight + topPad - wR) / strideHeight);\n\n    for (let wC = 0; wC < filterWidth; ++wC) {\n      const yCMin = Math.max(0, Math.ceil((leftPad - wC) / strideWidth));\n      const yCMax = Math.min(\n          convInfo.outWidth, (convInfo.inWidth + leftPad - wC) / strideWidth);\n\n      for (let d2 = 0; d2 < convInfo.outChannels; ++d2) {\n        const d1 = Math.trunc(d2 / chMul);\n        const dm = d2 % chMul;\n\n        let dotProd = 0;\n        for (let b = 0; b < convInfo.batchSize; ++b) {\n          for (let yR = yRMin; yR < yRMax; ++yR) {\n            const xR = wR + yR * strideHeight - topPad;\n            for (let yC = yCMin; yC < yCMax; ++yC) {\n              const xC = wC + yC * strideWidth - leftPad;\n              dotProd += (xBuf.get(b, xR, xC, d1) as number) *\n                  (dyBuf.get(b, yR, yC, d2) as number);\n            }\n          }\n        }\n        dW.set(dotProd, wR, wC, d1, dm);\n      }\n    }\n  }\n\n  return backend.makeTensorInfo(dW.shape, dW.dtype, dW.values);\n}\n\nexport const depthwiseConv2dNativeBackpropFilterConfig: KernelConfig = {\n  kernelName: DepthwiseConv2dNativeBackpropFilter,\n  backendName: 'cpu',\n  kernelFunc: depthwiseConv2dNativeBackpropFilter as unknown as KernelFunc\n};\n"]}"],"names":["depthwiseConv2dNativeBackpropFilter","args","inputs","backend","attrs","x","dy","strides","dilations","pad","dimRoundingMode","filterShape","assertNotComplex","convInfo","backend_util.computeConv2DInfo","strideHeight","strideWidth","filterHeight","filterWidth","dW","TensorBuffer","leftPad","topPad","chMul","xVals","xBuf","dyVals","dyBuf","wR","yRMin","yRMax","wC","yCMin","yCMax","d2","d1","dm","dotProd","b","yR","xR","yC","xC","depthwiseConv2dNativeBackpropFilterConfig","DepthwiseConv2dNativeBackpropFilter"],"mappings":";;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBO,SAASA,EAAoCC,GAAM;AACtD,QAAM,EAAE,QAAAC,GAAQ,SAAAC,GAAS,OAAAC,EAAK,IAAKH,GAC7B,EAAE,GAAAI,GAAG,IAAAC,EAAI,IAAGJ,GACZ,EAAE,SAAAK,GAAS,WAAAC,GAAW,KAAAC,GAAK,iBAAAC,GAAiB,aAAAC,EAAa,IAAGP;AAClE,EAAAQ,EAAiB,CAACP,GAAGC,CAAE,GAAG,qCAAqC;AAC/D,QAAMO,IAAWC;AAAAA,IAA+BT,EAAE;AAAA,IAAOM;AAAA,IAAaJ;AAAA,IAASC;AAAA,IAAWC;AAAA,IAAKC;AAAA,IAAiB;AAAA;AAAA,EAAI,GAC9G,EAAE,cAAAK,GAAc,aAAAC,GAAa,cAAAC,GAAc,aAAAC,EAAW,IAAKL,GAC3DM,IAAK,IAAIC,EAAaP,EAAS,aAAa,SAAS,GACrDQ,IAAUR,EAAS,QAAQ,MAC3BS,IAAST,EAAS,QAAQ,KAC1BU,IAAQV,EAAS,cAAcA,EAAS,YACxCW,IAAQrB,EAAQ,KAAK,IAAIE,EAAE,MAAM,EAAE,QACnCoB,IAAO,IAAIL,EAAaf,EAAE,OAAOA,EAAE,OAAOmB,CAAK,GAC/CE,IAASvB,EAAQ,KAAK,IAAIG,EAAG,MAAM,EAAE,QACrCqB,IAAQ,IAAIP,EAAad,EAAG,OAAOA,EAAG,OAAOoB,CAAM;AACzD,WAASE,IAAK,GAAGA,IAAKX,GAAc,EAAEW,GAAI;AACtC,UAAMC,IAAQ,KAAK,IAAI,GAAG,KAAK,MAAMP,IAASM,KAAMb,CAAY,CAAC,GAC3De,IAAQ,KAAK,IAAIjB,EAAS,YAAYA,EAAS,WAAWS,IAASM,KAAMb,CAAY;AAC3F,aAASgB,IAAK,GAAGA,IAAKb,GAAa,EAAEa,GAAI;AACrC,YAAMC,IAAQ,KAAK,IAAI,GAAG,KAAK,MAAMX,IAAUU,KAAMf,CAAW,CAAC,GAC3DiB,IAAQ,KAAK,IAAIpB,EAAS,WAAWA,EAAS,UAAUQ,IAAUU,KAAMf,CAAW;AACzF,eAASkB,IAAK,GAAGA,IAAKrB,EAAS,aAAa,EAAEqB,GAAI;AAC9C,cAAMC,IAAK,KAAK,MAAMD,IAAKX,CAAK,GAC1Ba,IAAKF,IAAKX;AAChB,YAAIc,IAAU;AACd,iBAASC,IAAI,GAAGA,IAAIzB,EAAS,WAAW,EAAEyB;AACtC,mBAASC,IAAKV,GAAOU,IAAKT,GAAO,EAAES,GAAI;AACnC,kBAAMC,IAAKZ,IAAKW,IAAKxB,IAAeO;AACpC,qBAASmB,IAAKT,GAAOS,IAAKR,GAAO,EAAEQ,GAAI;AACnC,oBAAMC,IAAKX,IAAKU,IAAKzB,IAAcK;AACnC,cAAAgB,KAAWZ,EAAK,IAAIa,GAAGE,GAAIE,GAAIP,CAAE,IAC7BR,EAAM,IAAIW,GAAGC,GAAIE,GAAIP,CAAE;AAAA,YAC9B;AAAA,UACJ;AAEL,QAAAf,EAAG,IAAIkB,GAAST,GAAIG,GAAII,GAAIC,CAAE;AAAA,MACjC;AAAA,IACJ;AAAA,EACJ;AACD,SAAOjC,EAAQ,eAAegB,EAAG,OAAOA,EAAG,OAAOA,EAAG,MAAM;AAC/D;AACY,MAACwB,IAA4C;AAAA,EACrD,YAAYC;AAAA,EACZ,aAAa;AAAA,EACb,YAAY5C;AAChB;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropInput.js

@@ -0,0 +1,67 @@
+import "../../../tfjs-core/dist/index.js";
+import { assertNotComplex as ct } from "../cpu_util.js";
+import { DepthwiseConv2dNativeBackpropInput as pt } from "../../../tfjs-core/dist/kernel_names.js";
+import { computeStrides as M } from "../../../tfjs-core/dist/util_base.js";
+import { computeConv2DInfo as ft } from "../../../tfjs-core/dist/ops/conv_util.js";
+import { TensorBuffer as lt } from "../../../tfjs-core/dist/tensor.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ht(I) {
+  const { inputs: g, backend: p, attrs: k } = I, { dy: f, filter: e } = g, { strides: w, dilations: N, pad: R, dimRoundingMode: B, inputShape: b } = k;
+  ct([f, e], "depthwiseConv2DNativeBackpropInput");
+  const H = M(f.shape), W = M(e.shape), n = ft(
+    b,
+    e.shape,
+    w,
+    N,
+    R,
+    B,
+    !0
+    /* depthwise */
+  ), t = new lt(n.inShape, "float32"), D = t.values, [P, V, O] = t.strides, T = p.data.get(f.dataId).values, [z, F, j] = H, q = p.data.get(e.dataId).values, [A, E, G] = W, { batchSize: J, filterHeight: l, filterWidth: h, inChannels: S, inHeight: K, inWidth: L, outChannels: Q, outHeight: U, outWidth: X, strideHeight: u, strideWidth: m } = n, Y = l - 1 - n.padInfo.top, Z = h - 1 - n.padInfo.left, v = Q / S;
+  for (let s = 0; s < J; ++s)
+    for (let o = 0; o < S; ++o)
+      for (let a = 0; a < K; ++a) {
+        const x = a - Y, _ = Math.max(0, Math.ceil(x / u)), $ = Math.min(U, (l + x) / u);
+        for (let i = 0; i < L; ++i) {
+          const C = i - Z, tt = Math.max(0, Math.ceil(C / m)), ot = Math.min(X, (h + C) / m);
+          let y = 0;
+          for (let d = _; d < $; ++d) {
+            const et = d * u - x;
+            for (let r = tt; r < ot; ++r) {
+              const nt = r * m - C, st = z * s + F * d + j * r, at = A * (l - 1 - et) + E * (h - 1 - nt) + G * o;
+              for (let c = 0; c < v; ++c) {
+                const it = o * v + c, dt = T[st + it], rt = q[at + c];
+                y += dt * rt;
+              }
+            }
+          }
+          D[P * s + V * a + O * i + o] = y;
+        }
+      }
+  return p.makeTensorInfo(t.shape, t.dtype, t.values);
+}
+const yt = {
+  kernelName: pt,
+  backendName: "cpu",
+  kernelFunc: ht
+};
+export {
+  ht as depthwiseConv2dNativeBackpropInput,
+  yt as depthwiseConv2dNativeBackpropInputConfig
+};
+//# sourceMappingURL=DepthwiseConv2dNativeBackpropInput.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DepthwiseConv2dNativeBackpropInput.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/DepthwiseConv2dNativeBackpropInput.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { backend_util, DepthwiseConv2dNativeBackpropInput, TensorBuffer, util } from '@tensorflow/tfjs-core';\nimport { assertNotComplex } from '../cpu_util';\nexport function depthwiseConv2dNativeBackpropInput(args) {\n    const { inputs, backend, attrs } = args;\n    const { dy, filter } = inputs;\n    const { strides, dilations, pad, dimRoundingMode, inputShape } = attrs;\n    assertNotComplex([dy, filter], 'depthwiseConv2DNativeBackpropInput');\n    const dyStrides = util.computeStrides(dy.shape);\n    const filterStrides = util.computeStrides(filter.shape);\n    const convInfo = backend_util.computeConv2DInfo(inputShape, filter.shape, strides, dilations, pad, dimRoundingMode, true /* depthwise */);\n    const dx = new TensorBuffer(convInfo.inShape, 'float32');\n    const dxValues = dx.values;\n    const [dxS0, dxS1, dxS2] = dx.strides;\n    const dyValues = backend.data.get(dy.dataId).values;\n    const [dyS0, dyS1, dyS2] = dyStrides;\n    const fltValues = backend.data.get(filter.dataId).values;\n    const [fltS0, fltS1, fltS2] = filterStrides;\n    const { batchSize, filterHeight, filterWidth, inChannels, inHeight, inWidth, outChannels, outHeight, outWidth, strideHeight, strideWidth } = convInfo;\n    const topPad = filterHeight - 1 - convInfo.padInfo.top;\n    const leftPad = filterWidth - 1 - convInfo.padInfo.left;\n    const chMul = outChannels / inChannels;\n    for (let b = 0; b < batchSize; ++b) {\n        for (let d1 = 0; d1 < inChannels; ++d1) {\n            for (let xR = 0; xR < inHeight; ++xR) {\n                const xRCorner = xR - topPad;\n                const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));\n                const yRMax = Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);\n                for (let xC = 0; xC < inWidth; ++xC) {\n                    const xCCorner = xC - leftPad;\n                    const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));\n                    const yCMax = Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);\n                    let dotProd = 0;\n                    for (let yR = xRMin; yR < yRMax; ++yR) {\n                        const wR = yR * strideHeight - xRCorner;\n                        for (let yC = xCMin; yC < yCMax; ++yC) {\n                            const wC = yC * strideWidth - xCCorner;\n                            const dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;\n                            const fltOffset = fltS0 * (filterHeight - 1 - wR) +\n                                fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;\n                            for (let dm = 0; dm < chMul; ++dm) {\n                                const d2 = d1 * chMul + dm;\n                                const pixel = dyValues[dyOffset + d2];\n                                const weight = fltValues[fltOffset + dm];\n                                dotProd += pixel * weight;\n                            }\n                        }\n                    }\n                    dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;\n                }\n            }\n        }\n    }\n    return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);\n}\nexport const depthwiseConv2dNativeBackpropInputConfig = {\n    kernelName: DepthwiseConv2dNativeBackpropInput,\n    backendName: 'cpu',\n    kernelFunc: depthwiseConv2dNativeBackpropInput\n};\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DepthwiseConv2dNativeBackpropInput.js","sourceRoot":"","sources":["../../../../../../tfjs-backend-cpu/src/kernels/DepthwiseConv2dNativeBackpropInput.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {backend_util, DepthwiseConv2dNativeBackpropInput, DepthwiseConv2dNativeBackpropInputAttrs, DepthwiseConv2dNativeBackpropInputInputs, KernelConfig, KernelFunc, TensorBuffer, TensorInfo, TypedArray, util} from '@tensorflow/tfjs-core';\n\nimport {MathBackendCPU} from '../backend_cpu';\nimport {assertNotComplex} from '../cpu_util';\n\nexport function depthwiseConv2dNativeBackpropInput(args: {\n  inputs: DepthwiseConv2dNativeBackpropInputInputs,\n  backend: MathBackendCPU,\n  attrs: DepthwiseConv2dNativeBackpropInputAttrs\n}): TensorInfo {\n  const {inputs, backend, attrs} = args;\n  const {dy, filter} = inputs;\n  const {strides, dilations, pad, dimRoundingMode, inputShape} = attrs;\n\n  assertNotComplex([dy, filter], 'depthwiseConv2DNativeBackpropInput');\n\n  const dyStrides = util.computeStrides(dy.shape);\n  const filterStrides = util.computeStrides(filter.shape);\n\n  const convInfo = backend_util.computeConv2DInfo(\n      inputShape, filter.shape as [number, number, number, number], strides,\n      dilations, pad, dimRoundingMode, true /* depthwise */);\n\n  const dx = new TensorBuffer(convInfo.inShape, 'float32');\n  const dxValues = dx.values;\n  const [dxS0, dxS1, dxS2] = dx.strides;\n  const dyValues = backend.data.get(dy.dataId).values as TypedArray;\n  const [dyS0, dyS1, dyS2] = dyStrides;\n  const fltValues = backend.data.get(filter.dataId).values as TypedArray;\n  const [fltS0, fltS1, fltS2] = filterStrides;\n  const {\n    batchSize,\n    filterHeight,\n    filterWidth,\n    inChannels,\n    inHeight,\n    inWidth,\n    outChannels,\n    outHeight,\n    outWidth,\n    strideHeight,\n    strideWidth\n  } = convInfo;\n  const topPad = filterHeight - 1 - convInfo.padInfo.top;\n  const leftPad = filterWidth - 1 - convInfo.padInfo.left;\n  const chMul = outChannels / inChannels;\n\n  for (let b = 0; b < batchSize; ++b) {\n    for (let d1 = 0; d1 < inChannels; ++d1) {\n      for (let xR = 0; xR < inHeight; ++xR) {\n        const xRCorner = xR - topPad;\n        const xRMin = Math.max(0, Math.ceil(xRCorner / strideHeight));\n        const yRMax =\n            Math.min(outHeight, (filterHeight + xRCorner) / strideHeight);\n\n        for (let xC = 0; xC < inWidth; ++xC) {\n          const xCCorner = xC - leftPad;\n          const xCMin = Math.max(0, Math.ceil(xCCorner / strideWidth));\n          const yCMax =\n              Math.min(outWidth, (filterWidth + xCCorner) / strideWidth);\n\n          let dotProd = 0;\n          for (let yR = xRMin; yR < yRMax; ++yR) {\n            const wR = yR * strideHeight - xRCorner;\n\n            for (let yC = xCMin; yC < yCMax; ++yC) {\n              const wC = yC * strideWidth - xCCorner;\n              const dyOffset = dyS0 * b + dyS1 * yR + dyS2 * yC;\n              const fltOffset = fltS0 * (filterHeight - 1 - wR) +\n                  fltS1 * (filterWidth - 1 - wC) + fltS2 * d1;\n\n              for (let dm = 0; dm < chMul; ++dm) {\n                const d2 = d1 * chMul + dm;\n                const pixel = dyValues[dyOffset + d2];\n                const weight = fltValues[fltOffset + dm];\n                dotProd += pixel * weight;\n              }\n            }\n          }\n          dxValues[dxS0 * b + dxS1 * xR + dxS2 * xC + d1] = dotProd;\n        }\n      }\n    }\n  }\n\n  return backend.makeTensorInfo(dx.shape, dx.dtype, dx.values);\n}\n\nexport const depthwiseConv2dNativeBackpropInputConfig: KernelConfig = {\n  kernelName: DepthwiseConv2dNativeBackpropInput,\n  backendName: 'cpu',\n  kernelFunc: depthwiseConv2dNativeBackpropInput as unknown as KernelFunc\n};\n"]}"],"names":["depthwiseConv2dNativeBackpropInput","args","inputs","backend","attrs","dy","filter","strides","dilations","pad","dimRoundingMode","inputShape","assertNotComplex","dyStrides","util.computeStrides","filterStrides","convInfo","backend_util.computeConv2DInfo","dx","TensorBuffer","dxValues","dxS0","dxS1","dxS2","dyValues","dyS0","dyS1","dyS2","fltValues","fltS0","fltS1","fltS2","batchSize","filterHeight","filterWidth","inChannels","inHeight","inWidth","outChannels","outHeight","outWidth","strideHeight","strideWidth","topPad","leftPad","chMul","b","d1","xR","xRCorner","xRMin","yRMax","xC","xCCorner","xCMin","yCMax","dotProd","yR","wR","yC","wC","dyOffset","fltOffset","dm","d2","pixel","weight","depthwiseConv2dNativeBackpropInputConfig","DepthwiseConv2dNativeBackpropInput"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Diag.js

@@ -0,0 +1,37 @@
+import "../../../tfjs-core/dist/index.js";
+import { Diag as u } from "../../../tfjs-core/dist/kernel_names.js";
+import { sizeFromShape as m } from "../../../tfjs-core/dist/util_base.js";
+import { buffer as f } from "../../../tfjs-core/dist/ops/buffer.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function d(r) {
+  const { inputs: p, backend: n } = r, { x: e } = p, o = m(e.shape), s = n.data.get(e.dataId).values, a = f([o, o], e.dtype), c = a.values;
+  for (let t = 0; t < s.length; t++)
+    c[t * o + t] = s[t];
+  const i = [...e.shape, ...e.shape];
+  return n.makeTensorInfo(i, a.dtype, a.values);
+}
+const v = {
+  kernelName: u,
+  backendName: "cpu",
+  kernelFunc: d
+};
+export {
+  d as diag,
+  v as diagConfig
+};
+//# sourceMappingURL=Diag.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Diag.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Diag.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Diag.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { buffer, Diag, util } from '@tensorflow/tfjs-core';\nexport function diag(args) {\n    const { inputs, backend } = args;\n    const { x } = inputs;\n    const xSize = util.sizeFromShape(x.shape);\n    const xVals = backend.data.get(x.dataId).values;\n    const outBuf = buffer([xSize, xSize], x.dtype);\n    const vals = outBuf.values;\n    for (let i = 0; i < xVals.length; i++) {\n        vals[i * xSize + i] = xVals[i];\n    }\n    const outShape = [...x.shape, ...x.shape];\n    return backend.makeTensorInfo(outShape, outBuf.dtype, outBuf.values);\n}\nexport const diagConfig = {\n    kernelName: Diag,\n    backendName: 'cpu',\n    kernelFunc: diag\n};\n//# sourceMappingURL=data:application/json;base64,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"],"names":["diag","args","inputs","backend","x","xSize","util.sizeFromShape","xVals","outBuf","buffer","vals","i","outShape","diagConfig","Diag"],"mappings":";;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBO,SAASA,EAAKC,GAAM;AACvB,QAAM,EAAE,QAAAC,GAAQ,SAAAC,EAAS,IAAGF,GACtB,EAAE,GAAAG,EAAG,IAAGF,GACRG,IAAQC,EAAmBF,EAAE,KAAK,GAClCG,IAAQJ,EAAQ,KAAK,IAAIC,EAAE,MAAM,EAAE,QACnCI,IAASC,EAAO,CAACJ,GAAOA,CAAK,GAAGD,EAAE,KAAK,GACvCM,IAAOF,EAAO;AACpB,WAASG,IAAI,GAAGA,IAAIJ,EAAM,QAAQI;AAC9B,IAAAD,EAAKC,IAAIN,IAAQM,CAAC,IAAIJ,EAAMI,CAAC;AAEjC,QAAMC,IAAW,CAAC,GAAGR,EAAE,OAAO,GAAGA,EAAE,KAAK;AACxC,SAAOD,EAAQ,eAAeS,GAAUJ,EAAO,OAAOA,EAAO,MAAM;AACvE;AACY,MAACK,IAAa;AAAA,EACtB,YAAYC;AAAA,EACZ,aAAa;AAAA,EACb,YAAYd;AAChB;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Dilation2D.js

@@ -0,0 +1,56 @@
+import "../../../tfjs-core/dist/index.js";
+import { Dilation2D as P } from "../../../tfjs-core/dist/kernel_names.js";
+import { computeDilation2DInfo as Q } from "../../../tfjs-core/dist/ops/conv_util.js";
+import { sizeFromShape as U, getArrayFromDType as X, locToIndex as f, computeStrides as u } from "../../../tfjs-core/dist/util_base.js";
+import { toTypedArray as Y } from "../../../tfjs-core/dist/util.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const it = {
+  kernelName: P,
+  backendName: "cpu",
+  kernelFunc: ({ inputs: x, backend: y, attrs: k }) => {
+    const { x: t, filter: n } = x, { strides: D, pad: H, dilations: N } = k, l = y, S = l.data.get(t.dataId).values, W = t.shape.length, w = l.data.get(n.dataId).values, b = n.shape.length, { batchSize: F, inHeight: R, inWidth: T, inChannels: V, outHeight: v, outWidth: z, padInfo: m, strideHeight: A, strideWidth: B, filterHeight: C, filterWidth: E, dilationHeight: O, dilationWidth: _, outShape: e } = Q(t.shape, n.shape, D, H, "NHWC", N), G = U(e), M = e.length, g = X(t.dtype, G);
+    for (let i = 0; i < F; ++i)
+      for (let a = 0; a < v; ++a) {
+        const j = a * A - m.top;
+        for (let s = 0; s < z; ++s) {
+          const q = s * B - m.left;
+          for (let o = 0; o < V; ++o) {
+            let c = Number.MIN_SAFE_INTEGER;
+            for (let r = 0; r < C; ++r) {
+              const p = j + r * O;
+              if (p >= 0 && p < R)
+                for (let d = 0; d < E; ++d) {
+                  const h = q + d * _;
+                  if (h >= 0 && h < T) {
+                    const K = f([i, p, h, o], W, u(t.shape)), L = f([r, d, o], b, u(n.shape)), I = S[K] + w[L];
+                    I > c && (c = I);
+                  }
+                }
+            }
+            const J = f([i, a, s, o], M, u(e));
+            g[J] = c;
+          }
+        }
+      }
+    return { dataId: l.write(Y(g, t.dtype), e, t.dtype), shape: e, dtype: t.dtype };
+  }
+};
+export {
+  it as dilation2DConfig
+};
+//# sourceMappingURL=Dilation2D.js.map

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Dilation2D.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Dilation2D.js","sources":["../../../../../../node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Dilation2D.js"],"sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport { backend_util, Dilation2D, util } from '@tensorflow/tfjs-core';\nexport const dilation2DConfig = {\n    kernelName: Dilation2D,\n    backendName: 'cpu',\n    kernelFunc: ({ inputs, backend, attrs }) => {\n        const { x, filter } = inputs;\n        const { strides, pad, dilations } = attrs;\n        const cpuBackend = backend;\n        const xVals = cpuBackend.data.get(x.dataId).values;\n        const xRank = x.shape.length;\n        const filterVals = cpuBackend.data.get(filter.dataId).values;\n        const filterRank = filter.shape.length;\n        const { batchSize, inHeight, inWidth, inChannels, outHeight, outWidth, padInfo, strideHeight, strideWidth, filterHeight, filterWidth, dilationHeight, dilationWidth, outShape } = backend_util.computeDilation2DInfo(x.shape, filter.shape, strides, pad, 'NHWC' /* dataFormat */, dilations);\n        const outSize = util.sizeFromShape(outShape);\n        const outRank = outShape.length;\n        const outputVals = util.getArrayFromDType(x.dtype, outSize);\n        // Upsampling the input by fill in `dilation size - 1` values between each\n        // input value.\n        // This implementation follows the TF c++ implementation:\n        // https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc\n        for (let b = 0; b < batchSize; ++b) {\n            for (let hOut = 0; hOut < outHeight; ++hOut) {\n                const hBeg = hOut * strideHeight - padInfo.top;\n                for (let wOut = 0; wOut < outWidth; ++wOut) {\n                    const wBeg = wOut * strideWidth - padInfo.left;\n                    for (let d = 0; d < inChannels; ++d) {\n                        let curVal = Number.MIN_SAFE_INTEGER;\n                        for (let h = 0; h < filterHeight; ++h) {\n                            const hIn = hBeg + h * dilationHeight;\n                            if (hIn >= 0 && hIn < inHeight) {\n                                for (let w = 0; w < filterWidth; ++w) {\n                                    const wIn = wBeg + w * dilationWidth;\n                                    if (wIn >= 0 && wIn < inWidth) {\n                                        const xIndex = util.locToIndex([b, hIn, wIn, d], xRank, util.computeStrides(x.shape));\n                                        const filterIndex = util.locToIndex([h, w, d], filterRank, util.computeStrides(filter.shape));\n                                        const val = xVals[xIndex] + filterVals[filterIndex];\n                                        if (val > curVal) {\n                                            curVal = val;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                        const outputIndex = util.locToIndex([b, hOut, wOut, d], outRank, util.computeStrides(outShape));\n                        outputVals[outputIndex] = curVal;\n                    }\n                }\n            }\n        }\n        const dataId = cpuBackend.write(util.toTypedArray(outputVals, x.dtype), outShape, x.dtype);\n        return { dataId, shape: outShape, dtype: x.dtype };\n    }\n};\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Dilation2D.js","sourceRoot":"","sources":["../../../../../../tfjs-backend-cpu/src/kernels/Dilation2D.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2020 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\n\nimport {backend_util, Dilation2D, Dilation2DAttrs, Dilation2DInputs, KernelConfig, TypedArray, util} from '@tensorflow/tfjs-core';\n\nimport {MathBackendCPU} from '../backend_cpu';\n\nexport const dilation2DConfig: KernelConfig = {\n  kernelName: Dilation2D,\n  backendName: 'cpu',\n  kernelFunc: ({inputs, backend, attrs}) => {\n    const {x, filter} = inputs as Dilation2DInputs;\n    const {strides, pad, dilations} = attrs as unknown as Dilation2DAttrs;\n    const cpuBackend = backend as MathBackendCPU;\n\n    const xVals = cpuBackend.data.get(x.dataId).values as TypedArray;\n    const xRank = x.shape.length;\n\n    const filterVals = cpuBackend.data.get(filter.dataId).values as TypedArray;\n    const filterRank = filter.shape.length;\n\n    const {\n      batchSize,\n      inHeight,\n      inWidth,\n      inChannels,\n      outHeight,\n      outWidth,\n      padInfo,\n      strideHeight,\n      strideWidth,\n      filterHeight,\n      filterWidth,\n      dilationHeight,\n      dilationWidth,\n      outShape\n    } =\n        backend_util.computeDilation2DInfo(\n            x.shape as [number, number, number, number],\n            filter.shape as [number, number, number], strides, pad,\n            'NHWC' /* dataFormat */, dilations);\n\n    const outSize = util.sizeFromShape(outShape);\n    const outRank = outShape.length;\n    const outputVals = util.getArrayFromDType(x.dtype, outSize);\n\n    // Upsampling the input by fill in `dilation size - 1` values between each\n    // input value.\n    // This implementation follows the TF c++ implementation:\n    // https://github.com/tensorflow/tensorflow/blob/d9a3a849edc198e90172bc58eb293de457f9d986/tensorflow/core/kernels/dilation_ops.cc\n    for (let b = 0; b < batchSize; ++b) {\n      for (let hOut = 0; hOut < outHeight; ++hOut) {\n        const hBeg = hOut * strideHeight - padInfo.top;\n        for (let wOut = 0; wOut < outWidth; ++wOut) {\n          const wBeg = wOut * strideWidth - padInfo.left;\n          for (let d = 0; d < inChannels; ++d) {\n            let curVal = Number.MIN_SAFE_INTEGER;\n            for (let h = 0; h < filterHeight; ++h) {\n              const hIn = hBeg + h * dilationHeight;\n              if (hIn >= 0 && hIn < inHeight) {\n                for (let w = 0; w < filterWidth; ++w) {\n                  const wIn = wBeg + w * dilationWidth;\n                  if (wIn >= 0 && wIn < inWidth) {\n                    const xIndex = util.locToIndex(\n                        [b, hIn, wIn, d], xRank, util.computeStrides(x.shape));\n                    const filterIndex = util.locToIndex(\n                        [h, w, d], filterRank,\n                        util.computeStrides(filter.shape));\n                    const val = xVals[xIndex] + filterVals[filterIndex];\n                    if (val > curVal) {\n                      curVal = val;\n                    }\n                  }\n                }\n              }\n            }\n            const outputIndex = util.locToIndex(\n                [b, hOut, wOut, d], outRank, util.computeStrides(outShape));\n            outputVals[outputIndex] = curVal;\n          }\n        }\n      }\n    }\n\n    const dataId = cpuBackend.write(\n        util.toTypedArray(outputVals, x.dtype), outShape, x.dtype);\n\n    return {dataId, shape: outShape, dtype: x.dtype};\n  }\n};\n"]}"],"names":["dilation2DConfig","Dilation2D","inputs","backend","attrs","x","filter","strides","pad","dilations","cpuBackend","xVals","xRank","filterVals","filterRank","batchSize","inHeight","inWidth","inChannels","outHeight","outWidth","padInfo","strideHeight","strideWidth","filterHeight","filterWidth","dilationHeight","dilationWidth","outShape","backend_util.computeDilation2DInfo","outSize","util.sizeFromShape","outRank","outputVals","util.getArrayFromDType","b","hOut","hBeg","wOut","wBeg","d","curVal","h","hIn","w","wIn","xIndex","util.locToIndex","util.computeStrides","filterIndex","val","outputIndex","util.toTypedArray"],"mappings":";;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBY,MAACA,KAAmB;AAAA,EAC5B,YAAYC;AAAA,EACZ,aAAa;AAAA,EACb,YAAY,CAAC,EAAE,QAAAC,GAAQ,SAAAC,GAAS,OAAAC,EAAK,MAAO;AACxC,UAAM,EAAE,GAAAC,GAAG,QAAAC,EAAQ,IAAGJ,GAChB,EAAE,SAAAK,GAAS,KAAAC,GAAK,WAAAC,EAAS,IAAKL,GAC9BM,IAAaP,GACbQ,IAAQD,EAAW,KAAK,IAAIL,EAAE,MAAM,EAAE,QACtCO,IAAQP,EAAE,MAAM,QAChBQ,IAAaH,EAAW,KAAK,IAAIJ,EAAO,MAAM,EAAE,QAChDQ,IAAaR,EAAO,MAAM,QAC1B,EAAE,WAAAS,GAAW,UAAAC,GAAU,SAAAC,GAAS,YAAAC,GAAY,WAAAC,GAAW,UAAAC,GAAU,SAAAC,GAAS,cAAAC,GAAc,aAAAC,GAAa,cAAAC,GAAc,aAAAC,GAAa,gBAAAC,GAAgB,eAAAC,GAAe,UAAAC,EAAQ,IAAKC,EAAmCxB,EAAE,OAAOC,EAAO,OAAOC,GAASC,GAAK,QAAyBC,CAAS,GACtRqB,IAAUC,EAAmBH,CAAQ,GACrCI,IAAUJ,EAAS,QACnBK,IAAaC,EAAuB7B,EAAE,OAAOyB,CAAO;AAK1D,aAASK,IAAI,GAAGA,IAAIpB,GAAW,EAAEoB;AAC7B,eAASC,IAAO,GAAGA,IAAOjB,GAAW,EAAEiB,GAAM;AACzC,cAAMC,IAAOD,IAAOd,IAAeD,EAAQ;AAC3C,iBAASiB,IAAO,GAAGA,IAAOlB,GAAU,EAAEkB,GAAM;AACxC,gBAAMC,IAAOD,IAAOf,IAAcF,EAAQ;AAC1C,mBAASmB,IAAI,GAAGA,IAAItB,GAAY,EAAEsB,GAAG;AACjC,gBAAIC,IAAS,OAAO;AACpB,qBAASC,IAAI,GAAGA,IAAIlB,GAAc,EAAEkB,GAAG;AACnC,oBAAMC,IAAMN,IAAOK,IAAIhB;AACvB,kBAAIiB,KAAO,KAAKA,IAAM3B;AAClB,yBAAS4B,IAAI,GAAGA,IAAInB,GAAa,EAAEmB,GAAG;AAClC,wBAAMC,IAAMN,IAAOK,IAAIjB;AACvB,sBAAIkB,KAAO,KAAKA,IAAM5B,GAAS;AAC3B,0BAAM6B,IAASC,EAAgB,CAACZ,GAAGQ,GAAKE,GAAKL,CAAC,GAAG5B,GAAOoC,EAAoB3C,EAAE,KAAK,CAAC,GAC9E4C,IAAcF,EAAgB,CAACL,GAAGE,GAAGJ,CAAC,GAAG1B,GAAYkC,EAAoB1C,EAAO,KAAK,CAAC,GACtF4C,IAAMvC,EAAMmC,CAAM,IAAIjC,EAAWoC,CAAW;AAClD,oBAAIC,IAAMT,MACNA,IAASS;AAAA,kBAEhB;AAAA,gBACJ;AAAA,YAER;AACD,kBAAMC,IAAcJ,EAAgB,CAACZ,GAAGC,GAAME,GAAME,CAAC,GAAGR,GAASgB,EAAoBpB,CAAQ,CAAC;AAC9F,YAAAK,EAAWkB,CAAW,IAAIV;AAAA,UAC7B;AAAA,QACJ;AAAA,MACJ;AAGL,WAAO,EAAE,QADM/B,EAAW,MAAM0C,EAAkBnB,GAAY5B,EAAE,KAAK,GAAGuB,GAAUvB,EAAE,KAAK,GACxE,OAAOuB,GAAU,OAAOvB,EAAE;EAC9C;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@tensorflow/tfjs-backend-cpu/dist/kernels/Dilation2DBackpropFilter.js

@@ -0,0 +1,57 @@
+import "../../../tfjs-core/dist/index.js";
+import { Dilation2DBackpropFilter as N } from "../../../tfjs-core/dist/kernel_names.js";
+import { toNestedArray as f, assert as j, makeZerosNestedTypedArray as q } from "../../../tfjs-core/dist/util_base.js";
+import { computeDilation2DInfo as J } from "../../../tfjs-core/dist/ops/conv_util.js";
+import { toTypedArray as K } from "../../../tfjs-core/dist/util.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+const tt = {
+  kernelName: N,
+  backendName: "cpu",
+  kernelFunc: ({ inputs: w, backend: H, attrs: W }) => {
+    const { x: r, filter: t, dy: p } = w, { strides: $, pad: b, dilations: v } = W, i = H, x = f(r.shape, i.data.get(r.dataId).values), B = f(t.shape, i.data.get(t.dataId).values), { batchSize: D, inHeight: A, inWidth: E, inChannels: F, outHeight: C, outWidth: M, padInfo: u, strideHeight: S, strideWidth: T, filterHeight: O, filterWidth: _, dilationHeight: z, dilationWidth: G, outShape: l } = J(r.shape, t.shape, $, b, "NHWC", v);
+    j(p.rank === l.length, () => `Error in ${N}, dy must have the same rank as output ${l.length}, but got ${p.rank}`);
+    const R = f(l, i.data.get(p.dataId).values), m = q(t.shape, t.dtype);
+    for (let n = 0; n < D; ++n)
+      for (let d = 0; d < C; ++d) {
+        const V = d * S - u.top;
+        for (let s = 0; s < M; ++s) {
+          const Z = s * T - u.left;
+          for (let e = 0; e < F; ++e) {
+            let g = Number.MIN_SAFE_INTEGER, y = 0, I = 0;
+            for (let a = 0; a < O; ++a) {
+              const h = V + a * z;
+              if (h >= 0 && h < A)
+                for (let o = 0; o < _; ++o) {
+                  const c = Z + o * G;
+                  if (c >= 0 && c < E) {
+                    const k = x[n][h][c][e] + B[a][o][e];
+                    k > g && (g = k, y = a, I = o);
+                  }
+                }
+            }
+            m[y][I][e] += R[n][d][s][e];
+          }
+        }
+      }
+    return { dataId: i.write(K(m, r.dtype), t.shape, t.dtype), shape: t.shape, dtype: t.dtype };
+  }
+};
+export {
+  tt as dilation2DBackpropFilterConfig
+};
+//# sourceMappingURL=Dilation2DBackpropFilter.js.map