@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-layers/dist/layers/convolutional.js

@@ -0,0 +1,452 @@
+import "../../../tfjs-core/dist/index.js";
+import { getActivation as rt, serializeActivation as at } from "../activations.js";
+import { imageDataFormat as K } from "../backend/common.js";
+import { biasAdd as S, sliceAlongAxis as T } from "../backend/tfjs_backend.js";
+import { checkDataFormat as b, checkInterpolationFormat as ot, checkPaddingMode as lt } from "../common.js";
+import { getConstraint as L, serializeConstraint as E } from "../constraints.js";
+import { InputSpec as y, Layer as Z } from "../engine/topology.js";
+import { ValueError as l, NotImplementedError as w } from "../errors.js";
+import { getInitializer as x, serializeInitializer as B } from "../initializers.js";
+import { getRegularizer as A, serializeRegularizer as F } from "../regularizers.js";
+import { deconvLength as u, normalizeArray as J, convOutputLength as ht } from "../utils/conv_utils.js";
+import { checkArrayTypeAndLength as M, assertPositiveInteger as q, assert as dt, mapActivationToFusedKernel as ct } from "../utils/generic_utils.js";
+import { getExactlyOneShape as k, getExactlyOneTensor as z } from "../utils/types_utils.js";
+import { registerClass as f } from "../../../tfjs-core/dist/serialization.js";
+import { tidy as c } from "../../../tfjs-core/dist/globals.js";
+import { transpose as d } from "../../../tfjs-core/dist/ops/transpose.js";
+import { conv2dTranspose as ut } from "../../../tfjs-core/dist/ops/conv2d_transpose.js";
+import { conv3dTranspose as pt } from "../../../tfjs-core/dist/ops/conv3d_transpose.js";
+import { separableConv2d as ft } from "../../../tfjs-core/dist/ops/separable_conv2d.js";
+import { image as W } from "../../../tfjs-core/dist/ops/ops.js";
+import { conv1d as gt } from "../../../tfjs-core/dist/ops/conv1d.js";
+import { conv2d as mt } from "../../../tfjs-core/dist/ops/fused/conv2d.js";
+import { conv3d as kt } from "../../../tfjs-core/dist/ops/conv3d.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC
+ *
+ * Use of this source code is governed by an MIT-style
+ * license that can be found in the LICENSE file or at
+ * https://opensource.org/licenses/MIT.
+ * =============================================================================
+ */
+function bt(o, t) {
+  return c(() => (b(t), t === "channelsFirst" ? d(o, [0, 2, 3, 1]) : o));
+}
+function wt(o, t) {
+  return c(() => (b(t), t === "channelsFirst" ? d(o, [0, 2, 3, 4, 1]) : o));
+}
+function zt(o, t, i, e = 1, s = "valid", n, r = 1) {
+  return c(() => {
+    if (n == null && (n = K()), b(n), o.shape.length !== 3)
+      throw new l(`The input of a conv1dWithBias operation should be 3, but is ${o.shape.length} instead.`);
+    if (t.shape.length !== 3)
+      throw new l(`The kernel for a conv1dWithBias operation should be 3, but is ${t.shape.length} instead`);
+    if (i != null && i.shape.length !== 1)
+      throw new l(`The bias for a conv1dWithBias operation should be 1, but is ${i.shape.length} instead`);
+    if (n === "channelsFirst" && (o = d(o, [0, 2, 1])), s === "causal")
+      throw new w("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
+    let a = gt(o, t, e, s === "same" ? "same" : "valid", "NWC", r);
+    return i != null && (a = S(a, i)), a;
+  });
+}
+function j(o, t, i, e = [1, 1], s = "valid", n, r, a = null) {
+  return c(() => {
+    if (n == null && (n = K()), b(n), o.rank !== 3 && o.rank !== 4)
+      throw new l(`conv2dWithBiasActivation expects input to be of rank 3 or 4, but received ${o.rank}.`);
+    if (t.rank !== 3 && t.rank !== 4)
+      throw new l(`conv2dWithBiasActivation expects kernel to be of rank 3 or 4, but received ${o.rank}.`);
+    let h = bt(o, n);
+    if (s === "causal")
+      throw new w("The support for CAUSAL padding mode in conv1dWithBias is not implemented yet.");
+    return h = mt({
+      x: h,
+      filter: t,
+      strides: e,
+      pad: s === "same" ? "same" : "valid",
+      dilations: r,
+      dataFormat: "NHWC",
+      bias: i,
+      activation: a
+    }), n === "channelsFirst" && (h = d(h, [0, 3, 1, 2])), h;
+  });
+}
+function vt(o, t, i, e = [1, 1, 1], s = "valid", n, r) {
+  return c(() => {
+    if (n == null && (n = K()), b(n), o.rank !== 4 && o.rank !== 5)
+      throw new l(`conv3dWithBias expects input to be of rank 4 or 5, but received ${o.rank}.`);
+    if (t.rank !== 4 && t.rank !== 5)
+      throw new l(`conv3dWithBias expects kernel to be of rank 4 or 5, but received ${o.rank}.`);
+    let a = wt(o, n);
+    if (s === "causal")
+      throw new w("The support for CAUSAL padding mode in conv3dWithBias is not implemented yet.");
+    return a = kt(a, t, e, s === "same" ? "same" : "valid", "NDHWC", r), i != null && (a = S(a, i)), n === "channelsFirst" && (a = d(a, [0, 4, 1, 2, 3])), a;
+  });
+}
+class P extends Z {
+  constructor(t, i) {
+    if (super(i), this.bias = null, this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_BIAS_INITIALIZER = "zeros", P.verifyArgs(i), this.rank = t, q(this.rank, "rank"), this.rank !== 1 && this.rank !== 2 && this.rank !== 3)
+      throw new w(`Convolution layer for rank other than 1, 2, or 3 (${this.rank}) is not implemented yet.`);
+    if (this.kernelSize = J(i.kernelSize, t, "kernelSize"), this.strides = J(i.strides == null ? 1 : i.strides, t, "strides"), this.padding = i.padding == null ? "valid" : i.padding, lt(this.padding), this.dataFormat = i.dataFormat == null ? "channelsLast" : i.dataFormat, b(this.dataFormat), this.activation = rt(i.activation), this.useBias = i.useBias == null ? !0 : i.useBias, this.biasInitializer = x(i.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.biasConstraint = L(i.biasConstraint), this.biasRegularizer = A(i.biasRegularizer), this.activityRegularizer = A(i.activityRegularizer), this.dilationRate = J(i.dilationRate == null ? 1 : i.dilationRate, t, "dilationRate"), this.rank === 1 && Array.isArray(this.dilationRate) && this.dilationRate.length !== 1)
+      throw new l(`dilationRate must be a number or an array of a single number for 1D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+    if (this.rank === 2) {
+      if (typeof this.dilationRate == "number")
+        this.dilationRate = [this.dilationRate, this.dilationRate];
+      else if (this.dilationRate.length !== 2)
+        throw new l(`dilationRate must be a number or array of two numbers for 2D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+    } else if (this.rank === 3) {
+      if (typeof this.dilationRate == "number")
+        this.dilationRate = [this.dilationRate, this.dilationRate, this.dilationRate];
+      else if (this.dilationRate.length !== 3)
+        throw new l(`dilationRate must be a number or array of three numbers for 3D convolution, but received ${JSON.stringify(this.dilationRate)}`);
+    }
+  }
+  static verifyArgs(t) {
+    if (dt("kernelSize" in t, "required key 'kernelSize' not in config"), typeof t.kernelSize != "number" && !M(t.kernelSize, "number", 1, 3))
+      throw new l(`BaseConv expects config.kernelSize to be number or number[] with length 1, 2, or 3, but received ${JSON.stringify(t.kernelSize)}.`);
+  }
+  getConfig() {
+    const t = {
+      kernelSize: this.kernelSize,
+      strides: this.strides,
+      padding: this.padding,
+      dataFormat: this.dataFormat,
+      dilationRate: this.dilationRate,
+      activation: at(this.activation),
+      useBias: this.useBias,
+      biasInitializer: B(this.biasInitializer),
+      biasRegularizer: F(this.biasRegularizer),
+      activityRegularizer: F(this.activityRegularizer),
+      biasConstraint: E(this.biasConstraint)
+    }, i = super.getConfig();
+    return Object.assign(t, i), t;
+  }
+}
+class v extends P {
+  constructor(t, i) {
+    super(t, i), this.kernel = null, v.verifyArgs(i), this.filters = i.filters, q(this.filters, "filters"), this.kernelInitializer = x(i.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.kernelConstraint = L(i.kernelConstraint), this.kernelRegularizer = A(i.kernelRegularizer);
+  }
+  build(t) {
+    t = k(t);
+    const i = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
+    if (t[i] == null)
+      throw new l(`The channel dimension of the input should be defined. Found ${t[i]}`);
+    const e = t[i], s = this.kernelSize.concat([e, this.filters]);
+    this.kernel = this.addWeight("kernel", s, null, this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], null, this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [{ ndim: this.rank + 2, axes: { [i]: e } }], this.built = !0;
+  }
+  call(t, i) {
+    return c(() => {
+      t = z(t);
+      let e;
+      const s = this.bias == null ? null : this.bias.read(), n = ct(this.activation.getClassName());
+      if (n != null && this.rank === 2)
+        e = j(t, this.kernel.read(), s, this.strides, this.padding, this.dataFormat, this.dilationRate, n);
+      else {
+        if (this.rank === 1)
+          e = zt(t, this.kernel.read(), s, this.strides[0], this.padding, this.dataFormat, this.dilationRate[0]);
+        else if (this.rank === 2)
+          e = j(t, this.kernel.read(), s, this.strides, this.padding, this.dataFormat, this.dilationRate);
+        else if (this.rank === 3)
+          e = vt(t, this.kernel.read(), s, this.strides, this.padding, this.dataFormat, this.dilationRate);
+        else
+          throw new w("convolutions greater than 3D are not implemented yet.");
+        this.activation != null && (e = this.activation.apply(e));
+      }
+      return e;
+    });
+  }
+  computeOutputShape(t) {
+    t = k(t);
+    const i = [], e = this.dataFormat === "channelsLast" ? t.slice(1, t.length - 1) : t.slice(2);
+    for (let n = 0; n < e.length; ++n) {
+      const r = ht(e[n], this.kernelSize[n], this.padding, this.strides[n], typeof this.dilationRate == "number" ? this.dilationRate : this.dilationRate[n]);
+      i.push(r);
+    }
+    let s = [t[0]];
+    return this.dataFormat === "channelsLast" ? (s = s.concat(i), s.push(this.filters)) : (s.push(this.filters), s = s.concat(i)), s;
+  }
+  getConfig() {
+    const t = {
+      filters: this.filters,
+      kernelInitializer: B(this.kernelInitializer),
+      kernelRegularizer: F(this.kernelRegularizer),
+      kernelConstraint: E(this.kernelConstraint)
+    }, i = super.getConfig();
+    return Object.assign(t, i), t;
+  }
+  static verifyArgs(t) {
+    if (!("filters" in t) || typeof t.filters != "number" || t.filters < 1)
+      throw new l(`Convolution layer expected config.filters to be a 'number' > 0 but got ${JSON.stringify(t.filters)}`);
+  }
+}
+class D extends v {
+  constructor(t) {
+    super(2, t), D.verifyArgs(t);
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.rank, t;
+  }
+  static verifyArgs(t) {
+    if (typeof t.kernelSize != "number" && !M(t.kernelSize, "number", 1, 2))
+      throw new l(`Conv2D expects config.kernelSize to be number or number[] with length 1 or 2, but received ${JSON.stringify(t.kernelSize)}.`);
+  }
+}
+D.className = "Conv2D";
+f(D);
+class N extends v {
+  constructor(t) {
+    super(3, t), N.verifyArgs(t);
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.rank, t;
+  }
+  static verifyArgs(t) {
+    if (typeof t.kernelSize != "number" && !(Array.isArray(t.kernelSize) && (t.kernelSize.length === 1 || t.kernelSize.length === 3)))
+      throw new l(`Conv3D expects config.kernelSize to be number or [number, number, number], but received ${JSON.stringify(t.kernelSize)}.`);
+  }
+}
+N.className = "Conv3D";
+f(N);
+class V extends D {
+  constructor(t) {
+    if (super(t), this.inputSpec = [new y({ ndim: 4 })], this.padding !== "same" && this.padding !== "valid")
+      throw new l(`Conv2DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
+  }
+  build(t) {
+    if (t = k(t), t.length !== 4)
+      throw new l("Input should have rank 4; Received input shape: " + JSON.stringify(t));
+    const i = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
+    if (t[i] == null)
+      throw new l("The channel dimension of the inputs should be defined. Found `None`.");
+    const e = t[i], s = this.kernelSize.concat([this.filters, e]);
+    this.kernel = this.addWeight("kernel", s, "float32", this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], "float32", this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [new y({ ndim: 4, axes: { [i]: e } })], this.built = !0;
+  }
+  call(t, i) {
+    return c(() => {
+      let e = z(t);
+      if (e.shape.length !== 4)
+        throw new l(`Conv2DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${e.shape.length}`);
+      const s = e.shape, n = s[0];
+      let r, a;
+      this.dataFormat === "channelsFirst" ? (r = 2, a = 3) : (r = 1, a = 2);
+      const h = s[r], g = s[a], C = this.kernelSize[0], I = this.kernelSize[1], R = this.strides[0], $ = this.strides[1], U = u(h, R, C, this.padding), H = u(g, $, I, this.padding), _ = [n, U, H, this.filters];
+      this.dataFormat !== "channelsLast" && (e = d(e, [0, 2, 3, 1]));
+      let p = ut(e, this.kernel.read(), _, this.strides, this.padding);
+      return this.dataFormat !== "channelsLast" && (p = d(p, [0, 3, 1, 2])), this.bias != null && (p = S(p, this.bias.read(), this.dataFormat)), this.activation != null && (p = this.activation.apply(p)), p;
+    });
+  }
+  computeOutputShape(t) {
+    t = k(t);
+    const i = t.slice();
+    let e, s, n;
+    this.dataFormat === "channelsFirst" ? (e = 1, s = 2, n = 3) : (e = 3, s = 1, n = 2);
+    const r = this.kernelSize[0], a = this.kernelSize[1], h = this.strides[0], g = this.strides[1];
+    return i[e] = this.filters, i[s] = u(i[s], h, r, this.padding), i[n] = u(i[n], g, a, this.padding), i;
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.dilationRate, t;
+  }
+}
+V.className = "Conv2DTranspose";
+f(V);
+class G extends N {
+  constructor(t) {
+    if (super(t), this.inputSpec = [new y({ ndim: 5 })], this.padding !== "same" && this.padding !== "valid")
+      throw new l(`Conv3DTranspose currently supports only padding modes 'same' and 'valid', but received padding mode ${this.padding}`);
+  }
+  build(t) {
+    if (t = k(t), t.length !== 5)
+      throw new l("Input should have rank 5; Received input shape: " + JSON.stringify(t));
+    const i = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
+    if (t[i] == null)
+      throw new l("The channel dimension of the inputs should be defined. Found `None`.");
+    const e = t[i], s = this.kernelSize.concat([this.filters, e]);
+    this.kernel = this.addWeight("kernel", s, "float32", this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.useBias && (this.bias = this.addWeight("bias", [this.filters], "float32", this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint)), this.inputSpec = [new y({ ndim: 5, axes: { [i]: e } })], this.built = !0;
+  }
+  call(t, i) {
+    return c(() => {
+      let e = z(t);
+      if (e.shape.length !== 5)
+        throw new l(`Conv3DTranspose.call() expects input tensor to be rank-4, but received a tensor of rank-${e.shape.length}`);
+      const s = e.shape, n = s[0];
+      let r, a, h;
+      this.dataFormat === "channelsFirst" ? (h = 2, r = 3, a = 4) : (h = 1, r = 2, a = 3);
+      const g = s[h], C = s[r], I = s[a], R = this.kernelSize[0], $ = this.kernelSize[1], U = this.kernelSize[2], H = this.strides[0], _ = this.strides[1], p = this.strides[2], it = u(g, H, R, this.padding), et = u(C, _, $, this.padding), st = u(I, p, U, this.padding), nt = [n, it, et, st, this.filters];
+      this.dataFormat !== "channelsLast" && (e = d(e, [0, 2, 3, 4, 1]));
+      let m = pt(e, this.kernel.read(), nt, this.strides, this.padding);
+      return this.dataFormat !== "channelsLast" && (m = d(m, [0, 4, 1, 2, 3])), this.bias !== null && (m = S(m, this.bias.read(), this.dataFormat)), this.activation !== null && (m = this.activation.apply(m)), m;
+    });
+  }
+  computeOutputShape(t) {
+    t = k(t);
+    const i = t.slice();
+    let e, s, n, r;
+    this.dataFormat === "channelsFirst" ? (e = 1, s = 2, n = 3, r = 4) : (e = 4, s = 1, n = 2, r = 3);
+    const a = this.kernelSize[0], h = this.kernelSize[1], g = this.kernelSize[2], C = this.strides[0], I = this.strides[1], R = this.strides[2];
+    return i[e] = this.filters, i[s] = u(i[s], C, a, this.padding), i[n] = u(i[n], I, h, this.padding), i[r] = u(i[r], R, g, this.padding), i;
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.dilationRate, t;
+  }
+}
+G.className = "Conv3DTranspose";
+f(G);
+class Q extends v {
+  constructor(t, i) {
+    if (super(t, i), this.DEFAULT_DEPTHWISE_INITIALIZER = "glorotUniform", this.DEFAULT_POINTWISE_INITIALIZER = "glorotUniform", this.depthwiseKernel = null, this.pointwiseKernel = null, i.filters == null)
+      throw new l("The `filters` configuration field is required by SeparableConv, but is unspecified.");
+    if (i.kernelInitializer != null || i.kernelRegularizer != null || i.kernelConstraint != null)
+      throw new l("Fields kernelInitializer, kernelRegularizer and kernelConstraint are invalid for SeparableConv2D. Use depthwiseInitializer, depthwiseRegularizer, depthwiseConstraint, pointwiseInitializer, pointwiseRegularizer and pointwiseConstraint instead.");
+    if (i.padding != null && i.padding !== "same" && i.padding !== "valid")
+      throw new l(`SeparableConv${this.rank}D supports only padding modes: 'same' and 'valid', but received ${JSON.stringify(i.padding)}`);
+    this.depthMultiplier = i.depthMultiplier == null ? 1 : i.depthMultiplier, this.depthwiseInitializer = x(i.depthwiseInitializer || this.DEFAULT_DEPTHWISE_INITIALIZER), this.depthwiseRegularizer = A(i.depthwiseRegularizer), this.depthwiseConstraint = L(i.depthwiseConstraint), this.pointwiseInitializer = x(i.depthwiseInitializer || this.DEFAULT_POINTWISE_INITIALIZER), this.pointwiseRegularizer = A(i.pointwiseRegularizer), this.pointwiseConstraint = L(i.pointwiseConstraint);
+  }
+  build(t) {
+    if (t = k(t), t.length < this.rank + 2)
+      throw new l(`Inputs to SeparableConv${this.rank}D should have rank ${this.rank + 2}, but received input shape: ${JSON.stringify(t)}`);
+    const i = this.dataFormat === "channelsFirst" ? 1 : t.length - 1;
+    if (t[i] == null || t[i] < 0)
+      throw new l(`The channel dimension of the inputs should be defined, but found ${JSON.stringify(t[i])}`);
+    const e = t[i], s = this.kernelSize.concat([e, this.depthMultiplier]), n = [];
+    for (let a = 0; a < this.rank; ++a)
+      n.push(1);
+    n.push(e * this.depthMultiplier, this.filters);
+    const r = !0;
+    this.depthwiseKernel = this.addWeight("depthwise_kernel", s, "float32", this.depthwiseInitializer, this.depthwiseRegularizer, r, this.depthwiseConstraint), this.pointwiseKernel = this.addWeight("pointwise_kernel", n, "float32", this.pointwiseInitializer, this.pointwiseRegularizer, r, this.pointwiseConstraint), this.useBias ? this.bias = this.addWeight("bias", [this.filters], "float32", this.biasInitializer, this.biasRegularizer, r, this.biasConstraint) : this.bias = null, this.inputSpec = [new y({ ndim: this.rank + 2, axes: { [i]: e } })], this.built = !0;
+  }
+  call(t, i) {
+    return c(() => {
+      t = z(t);
+      let e;
+      if (this.rank === 1)
+        throw new w("1D separable convolution is not implemented yet.");
+      return this.rank === 2 && (this.dataFormat === "channelsFirst" && (t = d(t, [0, 2, 3, 1])), e = ft(t, this.depthwiseKernel.read(), this.pointwiseKernel.read(), this.strides, this.padding, this.dilationRate, "NHWC")), this.useBias && (e = S(e, this.bias.read(), this.dataFormat)), this.activation != null && (e = this.activation.apply(e)), this.dataFormat === "channelsFirst" && (e = d(e, [0, 3, 1, 2])), e;
+    });
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.rank, delete t.kernelInitializer, delete t.kernelRegularizer, delete t.kernelConstraint, t.depthwiseInitializer = B(this.depthwiseInitializer), t.pointwiseInitializer = B(this.pointwiseInitializer), t.depthwiseRegularizer = F(this.depthwiseRegularizer), t.pointwiseRegularizer = F(this.pointwiseRegularizer), t.depthwiseConstraint = E(this.depthwiseConstraint), t.pointwiseConstraint = E(this.pointwiseConstraint), t;
+  }
+}
+Q.className = "SeparableConv";
+class X extends Q {
+  constructor(t) {
+    super(2, t);
+  }
+}
+X.className = "SeparableConv2D";
+f(X);
+class O extends v {
+  constructor(t) {
+    super(1, t), O.verifyArgs(t), this.inputSpec = [{ ndim: 3 }];
+  }
+  getConfig() {
+    const t = super.getConfig();
+    return delete t.rank, delete t.dataFormat, t;
+  }
+  static verifyArgs(t) {
+    if (typeof t.kernelSize != "number" && !M(t.kernelSize, "number", 1, 1))
+      throw new l(`Conv1D expects config.kernelSize to be number or number[] with length 1, but received ${JSON.stringify(t.kernelSize)}.`);
+  }
+}
+O.className = "Conv1D";
+f(O);
+class Y extends Z {
+  constructor(t) {
+    super(t), typeof t.cropping == "number" ? this.cropping = [[t.cropping, t.cropping], [t.cropping, t.cropping]] : typeof t.cropping[0] == "number" ? this.cropping = [
+      [t.cropping[0], t.cropping[0]],
+      [t.cropping[1], t.cropping[1]]
+    ] : this.cropping = t.cropping, this.dataFormat = t.dataFormat === void 0 ? "channelsLast" : t.dataFormat, this.inputSpec = [{ ndim: 4 }];
+  }
+  computeOutputShape(t) {
+    return this.dataFormat === "channelsFirst" ? [
+      t[0],
+      t[1],
+      t[2] - this.cropping[0][0] - this.cropping[0][1],
+      t[3] - this.cropping[1][0] - this.cropping[1][1]
+    ] : [
+      t[0],
+      t[1] - this.cropping[0][0] - this.cropping[0][1],
+      t[2] - this.cropping[1][0] - this.cropping[1][1],
+      t[3]
+    ];
+  }
+  call(t, i) {
+    return c(() => {
+      if (t = z(t), this.dataFormat === "channelsLast") {
+        const e = T(t, this.cropping[0][0], t.shape[1] - this.cropping[0][0] - this.cropping[0][1], 2);
+        return T(e, this.cropping[1][0], t.shape[2] - this.cropping[1][1] - this.cropping[1][0], 3);
+      } else {
+        const e = T(t, this.cropping[0][0], t.shape[2] - this.cropping[0][0] - this.cropping[0][1], 3);
+        return T(e, this.cropping[1][0], t.shape[3] - this.cropping[1][1] - this.cropping[1][0], 4);
+      }
+    });
+  }
+  getConfig() {
+    const t = { cropping: this.cropping, dataFormat: this.dataFormat }, i = super.getConfig();
+    return Object.assign(t, i), t;
+  }
+}
+Y.className = "Cropping2D";
+f(Y);
+class tt extends Z {
+  constructor(t) {
+    super(t), this.DEFAULT_SIZE = [2, 2], this.inputSpec = [{ ndim: 4 }], this.size = t.size == null ? this.DEFAULT_SIZE : t.size, this.dataFormat = t.dataFormat == null ? "channelsLast" : t.dataFormat, b(this.dataFormat), this.interpolation = t.interpolation == null ? "nearest" : t.interpolation, ot(this.interpolation);
+  }
+  computeOutputShape(t) {
+    if (this.dataFormat === "channelsFirst") {
+      const i = t[2] == null ? null : this.size[0] * t[2], e = t[3] == null ? null : this.size[1] * t[3];
+      return [t[0], t[1], i, e];
+    } else {
+      const i = t[1] == null ? null : this.size[0] * t[1], e = t[2] == null ? null : this.size[1] * t[2];
+      return [t[0], i, e, t[3]];
+    }
+  }
+  call(t, i) {
+    return c(() => {
+      let e = z(t);
+      const s = e.shape;
+      if (this.dataFormat === "channelsFirst") {
+        e = d(e, [0, 2, 3, 1]);
+        const n = this.size[0] * s[2], r = this.size[1] * s[3], a = this.interpolation === "nearest" ? W.resizeNearestNeighbor(e, [n, r]) : W.resizeBilinear(e, [n, r]);
+        return d(a, [0, 3, 1, 2]);
+      } else {
+        const n = this.size[0] * s[1], r = this.size[1] * s[2];
+        return this.interpolation === "nearest" ? W.resizeNearestNeighbor(e, [n, r]) : W.resizeBilinear(e, [n, r]);
+      }
+    });
+  }
+  getConfig() {
+    const t = {
+      size: this.size,
+      dataFormat: this.dataFormat,
+      interpolation: this.interpolation
+    }, i = super.getConfig();
+    return Object.assign(t, i), t;
+  }
+}
+tt.className = "UpSampling2D";
+f(tt);
+export {
+  P as BaseConv,
+  v as Conv,
+  O as Conv1D,
+  D as Conv2D,
+  V as Conv2DTranspose,
+  N as Conv3D,
+  G as Conv3DTranspose,
+  Y as Cropping2D,
+  Q as SeparableConv,
+  X as SeparableConv2D,
+  tt as UpSampling2D,
+  zt as conv1dWithBias,
+  j as conv2dWithBiasActivation,
+  vt as conv3dWithBias,
+  bt as preprocessConv2DInput,
+  wt as preprocessConv3DInput
+};
+//# sourceMappingURL=convolutional.js.map