@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

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

@@ -0,0 +1,682 @@
+import "../../../tfjs-core/dist/index.js";
+import { getActivation as x, serializeActivation as W } from "../activations.js";
+import { expandDims as At, tile as it, dot as E, biasAdd as P, concatAlongFirstAxis as st, inTrainPhase as gt, dropout as Rt } from "../backend/tfjs_backend.js";
+import { nameScope as Ct } from "../common.js";
+import { getConstraint as g, serializeConstraint as R } from "../constraints.js";
+import { Layer as ut, InputSpec as $, SymbolicTensor as St } from "../engine/topology.js";
+import { ValueError as m, NotImplementedError as kt, AttributeError as Nt } from "../errors.js";
+import { getInitializer as C, serializeInitializer as S, Initializer as Tt, Ones as Dt } from "../initializers.js";
+import { getRegularizer as k, serializeRegularizer as I } from "../regularizers.js";
+import { assertPositiveInteger as H } from "../utils/generic_utils.js";
+import { range as ct, min as U, max as w } from "../utils/math_utils.js";
+import { isArrayOfShapes as q, getExactlyOneShape as X, getExactlyOneTensor as yt } from "../utils/types_utils.js";
+import { batchGetValue as Et, batchSetValue as _t } from "../variables.js";
+import { deserialize as ht } from "./serialization.js";
+import { registerClass as _ } from "../../../tfjs-core/dist/serialization.js";
+import { tidy as d, dispose as N, keep as G } from "../../../tfjs-core/dist/globals.js";
+import { arraysEqual as rt } from "../../../tfjs-core/dist/util_base.js";
+import { zeros as O } from "../../../tfjs-core/dist/ops/zeros.js";
+import { sum as Mt } from "../../../tfjs-core/dist/ops/sum.js";
+import { onesLike as L } from "../../../tfjs-core/dist/ops/ones_like.js";
+import { mul as f } from "../../../tfjs-core/dist/ops/mul.js";
+import { add as b } from "../../../tfjs-core/dist/ops/add.js";
+import { split as K } from "../../../tfjs-core/dist/ops/split.js";
+import { neg as Lt } from "../../../tfjs-core/dist/ops/neg.js";
+import { transpose as nt } from "../../../tfjs-core/dist/ops/transpose.js";
+import { cast as lt } from "../../../tfjs-core/dist/ops/cast.js";
+import { expandDims as vt } from "../../../tfjs-core/dist/ops/expand_dims.js";
+import { reverse as ot } from "../../../tfjs-core/dist/ops/reverse.js";
+import { unstack as at } from "../../../tfjs-core/dist/ops/unstack.js";
+import { sub as Ft } from "../../../tfjs-core/dist/ops/sub.js";
+import { stack as Ut } from "../../../tfjs-core/dist/ops/stack.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 wt(o, t, e, s) {
+  if (Array.isArray(o)) {
+    if (t != null || e != null)
+      throw new m("When inputs is an array, neither initialState or constants should be provided");
+    s != null && (e = o.slice(o.length - s, o.length), o = o.slice(0, o.length - s)), o.length > 1 && (t = o.slice(1, o.length)), o = o[0];
+  }
+  function i(r) {
+    return r == null || Array.isArray(r) ? r : [r];
+  }
+  return t = i(t), e = i(e), { inputs: o, initialState: t, constants: e };
+}
+function Bt(o, t, e, s = !1, i, r, n = !1, l = !1) {
+  return d(() => {
+    const u = t.shape.length;
+    if (u < 3)
+      throw new m(`Input should be at least 3D, but is ${u}D.`);
+    const c = [1, 0].concat(ct(2, u));
+    t = nt(t, c), n && console.warn("Backend rnn(): the unroll = true option is not applicable to the imperative deeplearn.js backend."), i != null && (i = lt(lt(i, "bool"), "float32"), i.rank === u - 1 && (i = vt(i, -1)), i = nt(i, c)), s && (t = ot(t, 0), i != null && (i = ot(i, 0)));
+    const h = [];
+    let p, a = e;
+    const T = t.shape[0], D = at(t);
+    let y;
+    i != null && (y = at(i));
+    for (let z = 0; z < T; ++z) {
+      const j = D[z], F = d(() => o(j, a));
+      if (i == null)
+        p = F[0], a = F[1];
+      else {
+        const Z = d(() => {
+          const M = y[z], et = Ft(L(M), M), mt = b(f(F[0], M), f(a[0], et)), It = a.map((zt, bt) => b(f(F[1][bt], M), f(zt, et)));
+          return { output: mt, newStates: It };
+        });
+        p = Z.output, a = Z.newStates;
+      }
+      l && h.push(p);
+    }
+    let A;
+    return l && (A = Ut(h, 1)), [p, A, a];
+  });
+}
+class v extends ut {
+  constructor(t) {
+    super(t);
+    let e;
+    if (t.cell == null)
+      throw new m("cell property is missing for the constructor of RNN.");
+    if (Array.isArray(t.cell) ? e = new tt({ cells: t.cell }) : e = t.cell, e.stateSize == null)
+      throw new m("The RNN cell should have an attribute `stateSize` (tuple of integers, one integer per RNN state).");
+    this.cell = e, this.returnSequences = t.returnSequences == null ? !1 : t.returnSequences, this.returnState = t.returnState == null ? !1 : t.returnState, this.goBackwards = t.goBackwards == null ? !1 : t.goBackwards, this._stateful = t.stateful == null ? !1 : t.stateful, this.unroll = t.unroll == null ? !1 : t.unroll, this.supportsMasking = !0, this.inputSpec = [new $({ ndim: 3 })], this.stateSpec = null, this.states_ = null, this.numConstants = null, this.keptStates = [];
+  }
+  // Porting Note: This is the equivalent of `RNN.states` property getter in
+  //   PyKeras.
+  getStates() {
+    if (this.states_ == null) {
+      const t = Array.isArray(this.cell.stateSize) ? this.cell.stateSize.length : 1;
+      return ct(0, t).map((e) => null);
+    } else
+      return this.states_;
+  }
+  // Porting Note: This is the equivalent of the `RNN.states` property setter in
+  //   PyKeras.
+  setStates(t) {
+    this.states_ = t;
+  }
+  computeOutputShape(t) {
+    q(t) && (t = t[0]), t = t;
+    let e = this.cell.stateSize;
+    Array.isArray(e) || (e = [e]);
+    const s = e[0];
+    let i;
+    if (this.returnSequences ? i = [t[0], t[1], s] : i = [t[0], s], this.returnState) {
+      const r = [];
+      for (const n of e)
+        r.push([t[0], n]);
+      return [i].concat(r);
+    } else
+      return i;
+  }
+  computeMask(t, e) {
+    return d(() => {
+      Array.isArray(e) && (e = e[0]);
+      const s = this.returnSequences ? e : null;
+      if (this.returnState) {
+        const i = this.states.map((r) => null);
+        return [s].concat(i);
+      } else
+        return s;
+    });
+  }
+  /**
+   * Get the current state tensors of the RNN.
+   *
+   * If the state hasn't been set, return an array of `null`s of the correct
+   * length.
+   */
+  get states() {
+    if (this.states_ == null) {
+      const t = Array.isArray(this.cell.stateSize) ? this.cell.stateSize.length : 1, e = [];
+      for (let s = 0; s < t; ++s)
+        e.push(null);
+      return e;
+    } else
+      return this.states_;
+  }
+  set states(t) {
+    this.states_ = t;
+  }
+  build(t) {
+    if (this.numConstants != null)
+      throw new kt("Constants support is not implemented in RNN yet.");
+    q(t) && (t = t[0]), t = t;
+    const e = this.stateful ? t[0] : null, s = t.slice(2);
+    this.inputSpec[0] = new $({ shape: [e, null, ...s] });
+    const i = [t[0]].concat(t.slice(2));
+    this.cell.build(i);
+    let r;
+    if (Array.isArray(this.cell.stateSize) ? r = this.cell.stateSize : r = [this.cell.stateSize], this.stateSpec != null) {
+      if (!rt(this.stateSpec.map((n) => n.shape[n.shape.length - 1]), r))
+        throw new m(`An initialState was passed that is not compatible with cell.stateSize. Received stateSpec=${this.stateSpec}; However cell.stateSize is ${this.cell.stateSize}`);
+    } else
+      this.stateSpec = r.map((n) => new $({ shape: [null, n] }));
+    this.stateful && this.resetStates();
+  }
+  /**
+   * Reset the state tensors of the RNN.
+   *
+   * If the `states` argument is `undefined` or `null`, will set the
+   * state tensor(s) of the RNN to all-zero tensors of the appropriate
+   * shape(s).
+   *
+   * If `states` is provided, will set the state tensors of the RNN to its
+   * value.
+   *
+   * @param states Optional externally-provided initial states.
+   * @param training Whether this call is done during training. For stateful
+   *   RNNs, this affects whether the old states are kept or discarded. In
+   *   particular, if `training` is `true`, the old states will be kept so
+   *   that subsequent backpropgataion through time (BPTT) may work properly.
+   *   Else, the old states will be discarded.
+   */
+  resetStates(t, e = !1) {
+    d(() => {
+      if (!this.stateful)
+        throw new Nt("Cannot call resetStates() on an RNN Layer that is not stateful.");
+      const s = this.inputSpec[0].shape[0];
+      if (s == null)
+        throw new m("If an RNN is stateful, it needs to know its batch size. Specify the batch size of your input tensors: \n- If using a Sequential model, specify the batch size by passing a `batchInputShape` option to your first layer.\n- If using the functional API, specify the batch size by passing a `batchShape` option to your Input layer.");
+      if (this.states_ == null)
+        Array.isArray(this.cell.stateSize) ? this.states_ = this.cell.stateSize.map((i) => O([s, i])) : this.states_ = [O([s, this.cell.stateSize])];
+      else if (t == null)
+        N(this.states_), this.keptStates != null && (N(this.keptStates), this.keptStates = []), Array.isArray(this.cell.stateSize) ? this.states_ = this.cell.stateSize.map((i) => O([s, i])) : this.states_[0] = O([s, this.cell.stateSize]);
+      else {
+        if (Array.isArray(t) || (t = [t]), t.length !== this.states_.length)
+          throw new m(`Layer ${this.name} expects ${this.states_.length} state(s), but it received ${t.length} state value(s). Input received: ${t}`);
+        e === !0 ? this.keptStates.push(this.states_.slice()) : N(this.states_);
+        for (let i = 0; i < this.states_.length; ++i) {
+          const r = t[i], n = Array.isArray(this.cell.stateSize) ? this.cell.stateSize[i] : this.cell.stateSize, l = [s, n];
+          if (!rt(r.shape, l))
+            throw new m(`State ${i} is incompatible with layer ${this.name}: expected shape=${l}, received shape=${r.shape}`);
+          this.states_[i] = r;
+        }
+      }
+      this.states_ = this.states_.map((i) => G(i.clone()));
+    });
+  }
+  apply(t, e) {
+    let s = e == null ? null : e.initialState, i = e == null ? null : e.constants;
+    e == null && (e = {});
+    const r = wt(t, s, i, this.numConstants);
+    t = r.inputs, s = r.initialState, i = r.constants;
+    let n = [], l = [];
+    if (s != null) {
+      e.initialState = s, n = n.concat(s), this.stateSpec = [];
+      for (const c of s)
+        this.stateSpec.push(new $({ shape: c.shape }));
+      l = l.concat(this.stateSpec);
+    }
+    if (i != null && (e.constants = i, n = n.concat(i), this.numConstants = i.length), n[0] instanceof St) {
+      const c = [t].concat(n), h = this.inputSpec.concat(l), p = this.inputSpec;
+      this.inputSpec = h;
+      const a = super.apply(c, e);
+      return this.inputSpec = p, a;
+    } else
+      return super.apply(t, e);
+  }
+  // tslint:disable-next-line:no-any
+  call(t, e) {
+    return d(() => {
+      const s = e == null ? null : e.mask, i = e == null ? null : e.training;
+      let r = e == null ? null : e.initialState;
+      t = yt(t), r == null && (this.stateful ? r = this.states_ : r = this.getInitialState(t));
+      const n = Array.isArray(this.cell.stateSize) ? this.cell.stateSize.length : 1;
+      if (r.length !== n)
+        throw new m(`RNN Layer has ${n} state(s) but was passed ${r.length} initial state(s).`);
+      this.unroll && console.warn("Ignoring unroll = true for RNN layer, due to imperative backend.");
+      const l = { training: i }, c = Bt((D, y) => {
+        const A = this.cell.call([D].concat(y), l);
+        return [A[0], A.slice(1)];
+      }, t, r, this.goBackwards, s, null, this.unroll, this.returnSequences), h = c[0], p = c[1], a = c[2];
+      this.stateful && this.resetStates(a, i);
+      const T = this.returnSequences ? p : h;
+      return this.returnState ? [T].concat(a) : T;
+    });
+  }
+  getInitialState(t) {
+    return d(() => {
+      let e = O(t.shape);
+      return e = Mt(e, [1, 2]), e = At(e), Array.isArray(this.cell.stateSize) ? this.cell.stateSize.map((s) => s > 1 ? it(e, [1, s]) : e) : this.cell.stateSize > 1 ? [it(e, [1, this.cell.stateSize])] : [e];
+    });
+  }
+  get trainableWeights() {
+    return this.trainable ? this.cell.trainableWeights : [];
+  }
+  get nonTrainableWeights() {
+    return this.trainable ? this.cell.nonTrainableWeights : this.cell.weights;
+  }
+  setFastWeightInitDuringBuild(t) {
+    super.setFastWeightInitDuringBuild(t), this.cell != null && this.cell.setFastWeightInitDuringBuild(t);
+  }
+  getConfig() {
+    const t = super.getConfig(), e = {
+      returnSequences: this.returnSequences,
+      returnState: this.returnState,
+      goBackwards: this.goBackwards,
+      stateful: this.stateful,
+      unroll: this.unroll
+    };
+    this.numConstants != null && (e.numConstants = this.numConstants);
+    const s = this.cell.getConfig();
+    return this.getClassName() === v.className && (e.cell = {
+      className: this.cell.getClassName(),
+      config: s
+    }), Object.assign(Object.assign(Object.assign({}, s), t), e);
+  }
+  /** @nocollapse */
+  static fromConfig(t, e, s = {}) {
+    const i = e.cell, r = ht(i, s);
+    return new t(Object.assign(e, { cell: r }));
+  }
+}
+v.className = "RNN";
+_(v);
+class V extends ut {
+}
+class J extends V {
+  constructor(t) {
+    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, H(this.units, "units"), this.activation = x(t.activation == null ? this.DEFAULT_ACTIVATION : t.activation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = C(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = C(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = C(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = k(t.kernelRegularizer), this.recurrentRegularizer = k(t.recurrentRegularizer), this.biasRegularizer = k(t.biasRegularizer), this.kernelConstraint = g(t.kernelConstraint), this.recurrentConstraint = g(t.recurrentConstraint), this.biasConstraint = g(t.biasConstraint), this.dropout = U([1, w([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = U([
+      1,
+      w([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+    ]), this.dropoutFunc = t.dropoutFunc, this.stateSize = this.units, this.dropoutMask = null, this.recurrentDropoutMask = null;
+  }
+  build(t) {
+    t = X(t), this.kernel = this.addWeight("kernel", [t[t.length - 1], this.units], null, this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.recurrentKernel = this.addWeight("recurrent_kernel", [this.units, this.units], null, this.recurrentInitializer, this.recurrentRegularizer, !0, this.recurrentConstraint), this.useBias ? this.bias = this.addWeight("bias", [this.units], null, this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint) : this.bias = null, this.built = !0;
+  }
+  // Porting Note: PyKeras' equivalent of this method takes two tensor inputs:
+  //   `inputs` and `states`. Here, the two tensors are combined into an
+  //   `Tensor[]` Array as the first input argument.
+  //   Similarly, PyKeras' equivalent of this method returns two values:
+  //    `output` and `[output]`. Here the two are combined into one length-2
+  //    `Tensor[]`, consisting of `output` repeated.
+  call(t, e) {
+    return d(() => {
+      if (t = t, t.length !== 2)
+        throw new m(`SimpleRNNCell expects 2 input Tensors, got ${t.length}.`);
+      let s = t[1];
+      t = t[0];
+      const i = e.training == null ? !1 : e.training;
+      0 < this.dropout && this.dropout < 1 && this.dropoutMask == null && (this.dropoutMask = B({
+        ones: () => L(t),
+        rate: this.dropout,
+        training: i,
+        dropoutFunc: this.dropoutFunc
+      })), 0 < this.recurrentDropout && this.recurrentDropout < 1 && this.recurrentDropoutMask == null && (this.recurrentDropoutMask = B({
+        ones: () => L(s),
+        rate: this.recurrentDropout,
+        training: i,
+        dropoutFunc: this.dropoutFunc
+      }));
+      let r;
+      const n = this.dropoutMask, l = this.recurrentDropoutMask;
+      n != null ? r = E(f(t, n), this.kernel.read()) : r = E(t, this.kernel.read()), this.bias != null && (r = P(r, this.bias.read())), l != null && (s = f(s, l));
+      let u = b(r, E(s, this.recurrentKernel.read()));
+      return this.activation != null && (u = this.activation.apply(u)), [u, u];
+    });
+  }
+  getConfig() {
+    const t = super.getConfig(), e = {
+      units: this.units,
+      activation: W(this.activation),
+      useBias: this.useBias,
+      kernelInitializer: S(this.kernelInitializer),
+      recurrentInitializer: S(this.recurrentInitializer),
+      biasInitializer: S(this.biasInitializer),
+      kernelRegularizer: I(this.kernelRegularizer),
+      recurrentRegularizer: I(this.recurrentRegularizer),
+      biasRegularizer: I(this.biasRegularizer),
+      activityRegularizer: I(this.activityRegularizer),
+      kernelConstraint: R(this.kernelConstraint),
+      recurrentConstraint: R(this.recurrentConstraint),
+      biasConstraint: R(this.biasConstraint),
+      dropout: this.dropout,
+      recurrentDropout: this.recurrentDropout
+    };
+    return Object.assign(Object.assign({}, t), e);
+  }
+}
+J.className = "SimpleRNNCell";
+_(J);
+class pt extends v {
+  constructor(t) {
+    t.cell = new J(t), super(t);
+  }
+  call(t, e) {
+    return d(() => {
+      this.cell.dropoutMask != null && (N(this.cell.dropoutMask), this.cell.dropoutMask = null), this.cell.recurrentDropoutMask != null && (N(this.cell.recurrentDropoutMask), this.cell.recurrentDropoutMask = null);
+      const s = e == null ? null : e.mask, i = e == null ? null : e.training, r = e == null ? null : e.initialState;
+      return super.call(t, { mask: s, training: i, initialState: r });
+    });
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return new t(e);
+  }
+}
+pt.className = "SimpleRNN";
+_(pt);
+class Q extends V {
+  constructor(t) {
+    if (super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_RECURRENT_ACTIVATION = "hardSigmoid", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", t.resetAfter)
+      throw new m("GRUCell does not support reset_after parameter set to true.");
+    this.units = t.units, H(this.units, "units"), this.activation = x(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = x(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = C(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = C(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = C(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.kernelRegularizer = k(t.kernelRegularizer), this.recurrentRegularizer = k(t.recurrentRegularizer), this.biasRegularizer = k(t.biasRegularizer), this.kernelConstraint = g(t.kernelConstraint), this.recurrentConstraint = g(t.recurrentConstraint), this.biasConstraint = g(t.biasConstraint), this.dropout = U([1, w([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = U([
+      1,
+      w([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+    ]), this.dropoutFunc = t.dropoutFunc, this.implementation = t.implementation, this.stateSize = this.units, this.dropoutMask = null, this.recurrentDropoutMask = null;
+  }
+  build(t) {
+    t = X(t);
+    const e = t[t.length - 1];
+    this.kernel = this.addWeight("kernel", [e, this.units * 3], null, this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.recurrentKernel = this.addWeight("recurrent_kernel", [this.units, this.units * 3], null, this.recurrentInitializer, this.recurrentRegularizer, !0, this.recurrentConstraint), this.useBias ? this.bias = this.addWeight("bias", [this.units * 3], null, this.biasInitializer, this.biasRegularizer, !0, this.biasConstraint) : this.bias = null, this.built = !0;
+  }
+  call(t, e) {
+    return d(() => {
+      if (t = t, t.length !== 2)
+        throw new m(`GRUCell expects 2 input Tensors (inputs, h, c), got ${t.length}.`);
+      const s = e.training == null ? !1 : e.training;
+      let i = t[1];
+      t = t[0], 0 < this.dropout && this.dropout < 1 && this.dropoutMask == null && (this.dropoutMask = B({
+        ones: () => L(t),
+        rate: this.dropout,
+        training: s,
+        count: 3,
+        dropoutFunc: this.dropoutFunc
+      })), 0 < this.recurrentDropout && this.recurrentDropout < 1 && this.recurrentDropoutMask == null && (this.recurrentDropoutMask = B({
+        ones: () => L(i),
+        rate: this.recurrentDropout,
+        training: s,
+        count: 3,
+        dropoutFunc: this.dropoutFunc
+      }));
+      const r = this.dropoutMask, n = this.recurrentDropoutMask;
+      let l, u, c;
+      0 < this.dropout && this.dropout < 1 && (t = f(t, r[0]));
+      let h = E(t, this.kernel.read());
+      this.useBias && (h = P(h, this.bias.read())), 0 < this.recurrentDropout && this.recurrentDropout < 1 && (i = f(i, n[0]));
+      const p = this.recurrentKernel.read(), [a, T] = K(p, [2 * this.units, this.units], p.rank - 1), D = E(i, a), [y, A, z] = K(h, 3, h.rank - 1), [j, F] = K(D, 2, D.rank - 1);
+      l = this.recurrentActivation.apply(b(y, j)), u = this.recurrentActivation.apply(b(A, F));
+      const Z = E(f(u, i), T);
+      c = this.activation.apply(b(z, Z));
+      const M = b(f(l, i), f(b(1, Lt(l)), c));
+      return [M, M];
+    });
+  }
+  getConfig() {
+    const t = super.getConfig(), e = {
+      units: this.units,
+      activation: W(this.activation),
+      recurrentActivation: W(this.recurrentActivation),
+      useBias: this.useBias,
+      kernelInitializer: S(this.kernelInitializer),
+      recurrentInitializer: S(this.recurrentInitializer),
+      biasInitializer: S(this.biasInitializer),
+      kernelRegularizer: I(this.kernelRegularizer),
+      recurrentRegularizer: I(this.recurrentRegularizer),
+      biasRegularizer: I(this.biasRegularizer),
+      activityRegularizer: I(this.activityRegularizer),
+      kernelConstraint: R(this.kernelConstraint),
+      recurrentConstraint: R(this.recurrentConstraint),
+      biasConstraint: R(this.biasConstraint),
+      dropout: this.dropout,
+      recurrentDropout: this.recurrentDropout,
+      implementation: this.implementation,
+      resetAfter: !1
+    };
+    return Object.assign(Object.assign({}, t), e);
+  }
+}
+Q.className = "GRUCell";
+_(Q);
+class ft extends v {
+  constructor(t) {
+    t.implementation === 0 && console.warn("`implementation=0` has been deprecated, and now defaults to `implementation=1`. Please update your layer call."), t.cell = new Q(t), super(t);
+  }
+  call(t, e) {
+    return d(() => {
+      this.cell.dropoutMask != null && (N(this.cell.dropoutMask), this.cell.dropoutMask = null), this.cell.recurrentDropoutMask != null && (N(this.cell.recurrentDropoutMask), this.cell.recurrentDropoutMask = null);
+      const s = e == null ? null : e.mask, i = e == null ? null : e.training, r = e == null ? null : e.initialState;
+      return super.call(t, { mask: s, training: i, initialState: r });
+    });
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return e.implmentation === 0 && (e.implementation = 1), new t(e);
+  }
+}
+ft.className = "GRU";
+_(ft);
+class Y extends V {
+  constructor(t) {
+    super(t), this.DEFAULT_ACTIVATION = "tanh", this.DEFAULT_RECURRENT_ACTIVATION = "hardSigmoid", this.DEFAULT_KERNEL_INITIALIZER = "glorotNormal", this.DEFAULT_RECURRENT_INITIALIZER = "orthogonal", this.DEFAULT_BIAS_INITIALIZER = "zeros", this.units = t.units, H(this.units, "units"), this.activation = x(t.activation === void 0 ? this.DEFAULT_ACTIVATION : t.activation), this.recurrentActivation = x(t.recurrentActivation === void 0 ? this.DEFAULT_RECURRENT_ACTIVATION : t.recurrentActivation), this.useBias = t.useBias == null ? !0 : t.useBias, this.kernelInitializer = C(t.kernelInitializer || this.DEFAULT_KERNEL_INITIALIZER), this.recurrentInitializer = C(t.recurrentInitializer || this.DEFAULT_RECURRENT_INITIALIZER), this.biasInitializer = C(t.biasInitializer || this.DEFAULT_BIAS_INITIALIZER), this.unitForgetBias = t.unitForgetBias, this.kernelRegularizer = k(t.kernelRegularizer), this.recurrentRegularizer = k(t.recurrentRegularizer), this.biasRegularizer = k(t.biasRegularizer), this.kernelConstraint = g(t.kernelConstraint), this.recurrentConstraint = g(t.recurrentConstraint), this.biasConstraint = g(t.biasConstraint), this.dropout = U([1, w([0, t.dropout == null ? 0 : t.dropout])]), this.recurrentDropout = U([
+      1,
+      w([0, t.recurrentDropout == null ? 0 : t.recurrentDropout])
+    ]), this.dropoutFunc = t.dropoutFunc, this.implementation = t.implementation, this.stateSize = [this.units, this.units], this.dropoutMask = null, this.recurrentDropoutMask = null;
+  }
+  build(t) {
+    var e;
+    t = X(t);
+    const s = t[t.length - 1];
+    this.kernel = this.addWeight("kernel", [s, this.units * 4], null, this.kernelInitializer, this.kernelRegularizer, !0, this.kernelConstraint), this.recurrentKernel = this.addWeight("recurrent_kernel", [this.units, this.units * 4], null, this.recurrentInitializer, this.recurrentRegularizer, !0, this.recurrentConstraint);
+    let i;
+    if (this.useBias) {
+      if (this.unitForgetBias) {
+        const r = this.biasInitializer, n = this.units;
+        i = new (e = class extends Tt {
+          apply(u, c) {
+            const h = r.apply([n]), p = new Dt().apply([n]), a = r.apply([n * 2]);
+            return st(st(h, p), a);
+          }
+        }, /** @nocollapse */
+        e.className = "CustomInit", e)();
+      } else
+        i = this.biasInitializer;
+      this.bias = this.addWeight("bias", [this.units * 4], null, i, this.biasRegularizer, !0, this.biasConstraint);
+    } else
+      this.bias = null;
+    this.built = !0;
+  }
+  call(t, e) {
+    return d(() => {
+      const s = e.training == null ? !1 : e.training;
+      if (t = t, t.length !== 3)
+        throw new m(`LSTMCell expects 3 input Tensors (inputs, h, c), got ${t.length}.`);
+      let i = t[1];
+      const r = t[2];
+      t = t[0], 0 < this.dropout && this.dropout < 1 && this.dropoutMask == null && (this.dropoutMask = B({
+        ones: () => L(t),
+        rate: this.dropout,
+        training: s,
+        count: 4,
+        dropoutFunc: this.dropoutFunc
+      })), 0 < this.recurrentDropout && this.recurrentDropout < 1 && this.recurrentDropoutMask == null && (this.recurrentDropoutMask = B({
+        ones: () => L(i),
+        rate: this.recurrentDropout,
+        training: s,
+        count: 4,
+        dropoutFunc: this.dropoutFunc
+      }));
+      const n = this.dropoutMask, l = this.recurrentDropoutMask;
+      let u, c, h, p;
+      0 < this.dropout && this.dropout < 1 && (t = f(t, n[0]));
+      let a = E(t, this.kernel.read());
+      0 < this.recurrentDropout && this.recurrentDropout < 1 && (i = f(i, l[0])), a = b(a, E(i, this.recurrentKernel.read())), this.useBias && (a = P(a, this.bias.read()));
+      const [T, D, y, A] = K(a, 4, a.rank - 1);
+      u = this.recurrentActivation.apply(T), c = this.recurrentActivation.apply(D), h = b(f(c, r), f(u, this.activation.apply(y))), p = this.recurrentActivation.apply(A);
+      const z = f(p, this.activation.apply(h));
+      return [z, z, h];
+    });
+  }
+  getConfig() {
+    const t = super.getConfig(), e = {
+      units: this.units,
+      activation: W(this.activation),
+      recurrentActivation: W(this.recurrentActivation),
+      useBias: this.useBias,
+      kernelInitializer: S(this.kernelInitializer),
+      recurrentInitializer: S(this.recurrentInitializer),
+      biasInitializer: S(this.biasInitializer),
+      unitForgetBias: this.unitForgetBias,
+      kernelRegularizer: I(this.kernelRegularizer),
+      recurrentRegularizer: I(this.recurrentRegularizer),
+      biasRegularizer: I(this.biasRegularizer),
+      activityRegularizer: I(this.activityRegularizer),
+      kernelConstraint: R(this.kernelConstraint),
+      recurrentConstraint: R(this.recurrentConstraint),
+      biasConstraint: R(this.biasConstraint),
+      dropout: this.dropout,
+      recurrentDropout: this.recurrentDropout,
+      implementation: this.implementation
+    };
+    return Object.assign(Object.assign({}, t), e);
+  }
+}
+Y.className = "LSTMCell";
+_(Y);
+class dt extends v {
+  constructor(t) {
+    t.implementation === 0 && console.warn("`implementation=0` has been deprecated, and now defaults to `implementation=1`. Please update your layer call."), t.cell = new Y(t), super(t);
+  }
+  call(t, e) {
+    return d(() => {
+      this.cell.dropoutMask != null && (N(this.cell.dropoutMask), this.cell.dropoutMask = null), this.cell.recurrentDropoutMask != null && (N(this.cell.recurrentDropoutMask), this.cell.recurrentDropoutMask = null);
+      const s = e == null ? null : e.mask, i = e == null ? null : e.training, r = e == null ? null : e.initialState;
+      return super.call(t, { mask: s, training: i, initialState: r });
+    });
+  }
+  /** @nocollapse */
+  static fromConfig(t, e) {
+    return e.implmentation === 0 && (e.implementation = 1), new t(e);
+  }
+}
+dt.className = "LSTM";
+_(dt);
+class tt extends V {
+  constructor(t) {
+    super(t), this.cells = t.cells;
+  }
+  get stateSize() {
+    const t = [];
+    for (const e of this.cells.slice().reverse())
+      Array.isArray(e.stateSize) ? t.push(...e.stateSize) : t.push(e.stateSize);
+    return t;
+  }
+  call(t, e) {
+    return d(() => {
+      t = t;
+      let s = t.slice(1);
+      const i = [];
+      for (const l of this.cells.slice().reverse())
+        Array.isArray(l.stateSize) ? i.push(s.splice(0, l.stateSize.length)) : i.push(s.splice(0, 1));
+      i.reverse();
+      const r = [];
+      let n;
+      for (let l = 0; l < this.cells.length; ++l) {
+        const u = this.cells[l];
+        s = i[l], l === 0 ? n = [t[0]].concat(s) : n = [n[0]].concat(s), n = u.call(n, e), r.push(n.slice(1));
+      }
+      s = [];
+      for (const l of r.slice().reverse())
+        s.push(...l);
+      return [n[0]].concat(s);
+    });
+  }
+  build(t) {
+    q(t) && (t = t[0]), t = t;
+    let e;
+    this.cells.forEach((s, i) => {
+      Ct(`RNNCell_${i}`, () => {
+        s.build(t), Array.isArray(s.stateSize) ? e = s.stateSize[0] : e = s.stateSize, t = [t[0], e];
+      });
+    }), this.built = !0;
+  }
+  getConfig() {
+    const t = super.getConfig(), e = (r) => ({
+      className: r.getClassName(),
+      config: r.getConfig()
+    }), i = { cells: this.cells.map(e) };
+    return Object.assign(Object.assign({}, t), i);
+  }
+  /** @nocollapse */
+  static fromConfig(t, e, s = {}) {
+    const i = [];
+    for (const r of e.cells)
+      i.push(ht(r, s));
+    return new t({ cells: i });
+  }
+  get trainableWeights() {
+    if (!this.trainable)
+      return [];
+    const t = [];
+    for (const e of this.cells)
+      t.push(...e.trainableWeights);
+    return t;
+  }
+  get nonTrainableWeights() {
+    const t = [];
+    for (const e of this.cells)
+      t.push(...e.nonTrainableWeights);
+    if (!this.trainable) {
+      const e = [];
+      for (const s of this.cells)
+        e.push(...s.trainableWeights);
+      return e.concat(t);
+    }
+    return t;
+  }
+  /**
+   * Retrieve the weights of a the model.
+   *
+   * @returns A flat `Array` of `tf.Tensor`s.
+   */
+  getWeights() {
+    const t = [];
+    for (const e of this.cells)
+      t.push(...e.weights);
+    return Et(t);
+  }
+  /**
+   * Set the weights of the model.
+   *
+   * @param weights An `Array` of `tf.Tensor`s with shapes and types matching
+   *     the output of `getWeights()`.
+   */
+  setWeights(t) {
+    const e = [];
+    for (const s of this.cells) {
+      const i = s.weights.length, r = t.splice(i);
+      for (let n = 0; n < s.weights.length; ++n)
+        e.push([s.weights[n], r[n]]);
+    }
+    _t(e);
+  }
+}
+tt.className = "StackedRNNCells";
+_(tt);
+function B(o) {
+  const { ones: t, rate: e, training: s = !1, count: i = 1, dropoutFunc: r } = o, n = () => r != null ? r(t(), e) : Rt(t(), e), l = () => gt(n, t, s);
+  return !i || i <= 1 ? G(l().clone()) : Array(i).fill(void 0).map(l).map((c) => G(c.clone()));
+}
+export {
+  ft as GRU,
+  Q as GRUCell,
+  dt as LSTM,
+  Y as LSTMCell,
+  v as RNN,
+  V as RNNCell,
+  pt as SimpleRNN,
+  J as SimpleRNNCell,
+  tt as StackedRNNCells,
+  B as generateDropoutMask,
+  Bt as rnn,
+  wt as standardizeArgs
+};
+//# sourceMappingURL=recurrent.js.map