@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-layers/dist/engine/container.js

@@ -0,0 +1,640 @@
+import "../../../tfjs-core/dist/index.js";
+import { getUid as z } from "../backend/state.js";
+import { ValueError as T, RuntimeError as K, NotImplementedError as R } from "../errors.js";
+import { deserialize as G } from "../layers/serialization.js";
+import { unique as A, assert as C, reverseNumberCompare as S, pyListRepeat as W, singletonOrArray as M, toList as D, isObjectEmpty as J } from "../utils/generic_utils.js";
+import { convertTsToPythonic as U } from "../utils/serialization_utils.js";
+import { normalizeShapeList as j } from "../utils/types_utils.js";
+import { batchSetValue as q } from "../variables.js";
+import { version as H } from "../version.js";
+import { FeedDict as Q, execute as X } from "./executor.js";
+import { InputLayer as Y } from "./input_layer.js";
+import { Layer as Z, Node as P } from "./topology.js";
+import { tidy as v } from "../../../tfjs-core/dist/globals.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.
+ * =============================================================================
+ */
+const ee = (_) => {
+  const t = Object.keys(_);
+  if (t.length === 0)
+    return !1;
+  const s = t[0].split("/");
+  return !isNaN(parseInt(s[s.length - 1], 10));
+};
+class $ extends Z {
+  constructor(t) {
+    if (super({}), this.containerNodes = /* @__PURE__ */ new Set(), this.name = t.name, this.name == null) {
+      const e = this.getClassName().toLowerCase();
+      this.name = z(e);
+    }
+    if (this.supportsMasking = !1, this.trainable_ = !0, Array.isArray(t.inputs) ? this.inputs = t.inputs.slice() : this.inputs = [t.inputs], Array.isArray(t.outputs) ? this.outputs = t.outputs.slice() : this.outputs = [t.outputs], A(this.inputs).length !== this.inputs.length)
+      throw new T(`The list of inputs passed to the model is redundant. All inputs should only appear once. Found: ${this.inputs.map((e) => e.name)}`);
+    A(this.outputs).length !== this.outputs.length && console.warn(`The list of outputs passed to the model is redundant. All outputs should only appear once. Found: ${this.outputs.map((e) => e.name)}`), this.inputLayers = [], this.inputLayersNodeIndices = [], this.inputLayersTensorIndices = [], this.outputLayers = [], this.outputLayersNodeIndices = [], this.outputLayersTensorIndices = [], this.layers = [], this.internalContainerRefs = [];
+    for (const e of this.outputs) {
+      const i = e.sourceLayer, n = e.nodeIndex, c = e.tensorIndex;
+      this.outputLayers.push(i), this.outputLayersNodeIndices.push(n), this.outputLayersTensorIndices.push(c);
+    }
+    for (const e of this.inputs) {
+      const i = e.sourceLayer, n = e.nodeIndex, c = e.tensorIndex;
+      C(n === 0, "input layer has >1 nodes"), C(c === 0, "input layer has >1 tensors"), this.inputLayers.push(i), this.inputLayersNodeIndices.push(n), this.inputLayersTensorIndices.push(c);
+    }
+    this.inputNames = [], this.outputNames = [], this.feedInputShapes = [], this.feedInputNames = [], this.feedOutputNames = [];
+    for (let e = 0; e < this.inputLayers.length; e++) {
+      const i = this.inputLayers[e];
+      if (!(i instanceof Y))
+        throw new TypeError(`Input layers to a LayersModel must be InputLayer objects. Received inputs: ${t.inputs}. Input ${e} (0-based) originates from layer type ${i.getClassName()}.`);
+      this.inputNames.push(i.name), this.feedInputShapes.push(i.batchInputShape), this.feedInputNames.push(i.name);
+    }
+    for (const e of this.outputLayers)
+      this.outputNames.push(e.name);
+    this.internalInputShapes = this.inputs.map((e) => e.shape), this.internalOutputShapes = this.outputs.map((e) => e.shape);
+    const s = {}, o = {}, y = {}, m = {}, r = {}, a = [], u = (e, i, n, c, w, x) => {
+      (c == null || w == null || x == null) && (c = e.sourceLayer, w = e.nodeIndex, x = e.tensorIndex);
+      const L = c.inboundNodes[w];
+      if (n.indexOf(L) !== -1)
+        throw new K(`The tensor ${e.name} at layer "${c.name}" is part of a cycle.`);
+      if (i.indexOf(L) !== -1)
+        return;
+      this.containerNodes.add($.nodeKey(c, w)), c.id in r || (r[c.id] = Object.keys(r).length), n.indexOf(L) === -1 && n.push(L);
+      const O = L.inboundLayers.length;
+      for (let k = 0; k < O; k++) {
+        const F = L.inputTensors[k], E = L.inboundLayers[k], B = L.nodeIndices[k], V = L.tensorIndices[k];
+        u(F, i, n, E, B, V);
+      }
+      for (i.push(L); n.indexOf(L) >= 0; )
+        n.splice(n.indexOf(L), 1);
+      a.push(L);
+    }, d = [], l = [];
+    for (const e of this.outputs)
+      u(e, d, l);
+    const g = a.slice().reverse();
+    for (const e of g) {
+      o[e.id] = e, e.id in s || (s[e.id] = 0);
+      let i = s[e.id];
+      const n = y[e.outboundLayer.id] == null ? 0 : y[e.outboundLayer.id];
+      i = Math.max(i, n), y[e.outboundLayer.id] = i, m[e.outboundLayer.id] = e.outboundLayer, s[e.id] = i;
+      for (let c = 0; c < e.inboundLayers.length; c++) {
+        const w = e.inboundLayers[c], x = e.nodeIndices[c], L = w.inboundNodes[x], O = s[L.id] == null ? 0 : s[L.id];
+        s[L.id] = Math.max(i + 1, O), o[L.id] = L;
+      }
+    }
+    const b = {};
+    for (const e in s) {
+      const i = s[e];
+      i in b || (b[i] = []), b[i].push(o[e]);
+    }
+    const I = {};
+    for (const e in y) {
+      const i = y[e];
+      i in I || (I[i] = []), I[i].push(m[e]);
+    }
+    let N = Object.keys(I).map((e) => parseInt(e, 10)).sort(S);
+    this.layers = [];
+    for (const e of N) {
+      const i = I[e];
+      i.sort((n, c) => {
+        const w = r[n.id], x = r[c.id];
+        return w < x ? -1 : w > x ? 1 : 0;
+      });
+      for (const n of i)
+        n instanceof $ && this.internalContainerRefs.push(n), this.layers.push(n);
+    }
+    this.layersByDepth = I, N = Object.keys(b).map((e) => parseInt(e, 10)).sort(S);
+    const f = this.inputs.slice(), h = [];
+    for (const e of N)
+      for (const i of b[e]) {
+        const n = i.outboundLayer;
+        if (n != null) {
+          for (const c of i.inputTensors)
+            if (f.indexOf(c) === -1)
+              throw new K(`Graph disconnected: cannot obtain value for tensor ${c} at layer "${n.name}". The following previous layers were accessed without issue: ${h}`);
+          for (const c of i.outputTensors)
+            f.push(c);
+          h.push(n.name);
+        }
+      }
+    this.nodesByDepth = b;
+    const p = this.layers.map((e) => e.name);
+    for (const e of p) {
+      const i = p.filter((n) => n === e).length;
+      if (i !== 1)
+        throw new K(`The name "${e}" is used ${i} times in the model. All layer names should be unique. Layer names: ` + JSON.stringify(p));
+    }
+    this.outboundNodes = [], this.inboundNodes = [], new P({
+      outboundLayer: this,
+      inboundLayers: [],
+      nodeIndices: [],
+      tensorIndices: [],
+      inputTensors: this.inputs,
+      outputTensors: this.outputs,
+      inputMasks: this.inputs.map((e) => null),
+      outputMasks: this.outputs.map((e) => null),
+      inputShapes: this.inputs.map((e) => e.shape),
+      outputShapes: this.outputs.map((e) => e.shape)
+    }), this.built = !0, this._refCount = 1;
+  }
+  assertNotDisposed() {
+    if (this._refCount === 0)
+      throw new Error(`Container '${this.name}' is already disposed.`);
+  }
+  /**
+   * Attempt to dispose a LayersModel's weights.
+   *
+   * This method decrease the reference count of the LayersModel object by 1.
+   *
+   * A LayersModel is reference-counted. Its reference count is incremented by 1
+   * when it is first constructed and when it is used as a Layer of another
+   * LayersModel.
+   *
+   * If the reference count of a LayersModel becomes 0, the `dispose` method of
+   * all its constituent `Layer`s will be called.
+   *
+   * Note: If the reference count is greater than 0 after the decrement, the
+   * `dispose` method of its constituent `Layer`s will *not* be called.
+   *
+   * After a LayersModel is disposed, it cannot be used in calls such as
+   * 'predict`, `evaluate` or `fit` anymore.
+   *
+   * @returns A DisposeResult Object with the following fields:
+   *   - refCountAfterDispose: The reference count of the LayersModel after this
+   *     `dispose()` call.
+   *   - numDisposedVariables: Number of `tf.Variable`s (i.e., weights) disposed
+   *     during this `dispose()` call.
+   * @throws {Error} If the layer is not built yet, or if the LayersModel has
+   *   already been disposed.
+   */
+  dispose() {
+    this.assertNotDisposed();
+    const t = { refCountAfterDispose: null, numDisposedVariables: 0 };
+    if (--this._refCount === 0) {
+      for (const s of this.layers)
+        t.numDisposedVariables += s.dispose().numDisposedVariables;
+      for (const s of this.internalContainerRefs)
+        t.numDisposedVariables += s.dispose().numDisposedVariables;
+    }
+    return t.refCountAfterDispose = this._refCount, t;
+  }
+  get trainable() {
+    return this.trainable_;
+  }
+  set trainable(t) {
+    this.layers.forEach((s) => {
+      s._trainableWeights.forEach((o) => o.trainable = t);
+    }), this.trainable_ = t;
+  }
+  get trainableWeights() {
+    if (this._trainableWeights.length > 0)
+      throw new T("Container instance unexpectedly contains _trainableWeights.The trainable weights of a Container are a union of the trainable weights of its consituent Layers. Its own _trainableWeights must remain an empty Array.");
+    if (!this.trainable)
+      return [];
+    let t = [];
+    for (const s of this.layers)
+      t = t.concat(s.trainableWeights);
+    return t;
+  }
+  get nonTrainableWeights() {
+    const t = [];
+    for (const s of this.layers)
+      t.push(...s.nonTrainableWeights);
+    if (!this.trainable) {
+      const s = [];
+      for (const o of this.layers)
+        s.push(...o.trainableWeights);
+      return s.concat(t);
+    }
+    return t;
+  }
+  get weights() {
+    return this.trainableWeights.concat(this.nonTrainableWeights);
+  }
+  /**
+   * Loads all layer weights from a JSON object.
+   *
+   * Porting Note: HDF5 weight files cannot be directly loaded in JavaScript /
+   *   TypeScript. The utility script at `scripts/pykeras.py` offers means
+   *   to convert them into JSON strings compatible with this method.
+   * Porting Note: TensorFlow.js Layers supports only loading by name currently.
+   *
+   * @param weights A JSON mapping weight names to weight values as nested
+   *   arrays of numbers, or a `NamedTensorMap`, i.e., a JSON mapping weight
+   *   names to `tf.Tensor` objects.
+   * @param strict Require that the provided weights exactly match those
+   *   required by the container.  Default: `true`.  Passing `false` means that
+   *   extra weights and missing weights will be silently ignored.
+   */
+  loadWeights(t, s = !0) {
+    const o = {};
+    let y = 0;
+    const m = ee(t);
+    m && this.parseWeights(t);
+    for (const a of this.layers)
+      for (const [u, d] of a.weights.entries()) {
+        const l = m ? `${d.name.split("/").slice(0, -1).join("/") + "/"}${u}` : d.originalName;
+        if (o[l] != null)
+          throw new T(`Duplicate weight name: ${l}`);
+        o[l] = d, y++;
+      }
+    const r = [];
+    for (const a in t) {
+      let u = a;
+      if (o[a] == null) {
+        const d = a.split("/");
+        u = d.slice(0, -2).concat([d[d.length - 1]]).join("/");
+      }
+      if (o[u] != null)
+        r.push([o[u], t[a]]);
+      else if (s)
+        throw new T(`Provided weight data has no target variable: ${a}`);
+      delete o[u];
+    }
+    if (s) {
+      const a = [];
+      for (const u in o)
+        a.push(u);
+      if (a.length > 0)
+        throw new T(`${a.length} of ${y} weights are not set: ${a}`);
+    }
+    q(r);
+  }
+  parseWeights(t) {
+    for (const s in Object.keys(t)) {
+      const o = s.split("/"), y = ["vars", "layer_checkpoint_dependencies"], m = o.map((r) => r.startsWith("_") ? r.slice(1) : r).filter((r) => !y.includes(r)).join("/");
+      m !== s && (t[m] = t[s], delete t[s]);
+    }
+  }
+  /**
+   * Util shared between different serialization methods.
+   * @returns LayersModel config with Keras version information added.
+   */
+  updatedConfig() {
+    const t = this.getConfig(), s = {};
+    return s.className = this.getClassName(), s.config = t, s.kerasVersion = `tfjs-layers ${H}`, s.backend = "TensorFlow.js", s;
+  }
+  /**
+   * Returns a JSON string containing the network configuration.
+   *
+   * To load a network from a JSON save file, use
+   * models.modelFromJSON(jsonString);
+   * @param extraJsonArgs Unused in tfjs-layers, maintained for PyKeras
+   * @param returnString Whether the return value should be stringified
+   *    (default: `true`).
+   * @returns a JSON string if `returnString` (default), or a JSON object if
+   *   `!returnString`.
+   */
+  // tslint:disable-next-line:no-any
+  toJSON(t, s = !0) {
+    const o = U(this.updatedConfig());
+    return s ? JSON.stringify(o) : o;
+  }
+  /**
+   * Call the model on new inputs.
+   *
+   * In this case `call` just reapplies all ops in the graph to the new inputs
+   * (e.g. build a new computational graph from the provided inputs).
+   *
+   * @param inputs A tensor or list of tensors.
+   * @param mask A mask or list of masks. A mask can be either a tensor or null
+   *   (no mask).
+   *
+   * @return A tensor if there is a single output, or a list of tensors if there
+   *   are more than one outputs.
+   */
+  call(t, s) {
+    return v(() => {
+      t = D(t);
+      const o = new Q();
+      for (let y = 0; y < this.inputs.length; ++y)
+        o.add(this.inputs[y], t[y]);
+      return X(this.outputs, o, s);
+    });
+  }
+  /**
+   * Computes an output mask tensor.
+   *
+   * @param inputs Tensor or list of tensors.
+   * @param mask Tensor or list of tensors.
+   *
+   * @return null or a tensor (or list of tensors, one per output tensor of the
+   * layer).
+   */
+  computeMask(t, s) {
+    return v(() => {
+      t = D(t);
+      let o;
+      return s == null ? o = W(null, t.length) : o = D(s), this.runInternalGraph(t, o)[1];
+    });
+  }
+  /**
+   * Computes the output shape of the layer.
+   *
+   * Assumes that the layer will be built to match that input shape provided.
+   *
+   * @param inputShape A shape (tuple of integers) or a list of shape tuples
+   *   (one per output tensor of the layer). Shape tuples can include null for
+   *   free dimensions, instead of an integer.
+   */
+  computeOutputShape(t) {
+    const s = j(t);
+    if (s.length !== this.inputLayers.length)
+      throw new T(`Invalid inputShape argument ${t}: model has ${this.inputLayers.length} tensor inputs.`);
+    const o = {};
+    for (let a = 0; a < s.length; a++) {
+      const u = this.inputLayers[a], d = s[a], l = u.name + "_0_0";
+      o[l] = d;
+    }
+    const y = Object.keys(this.nodesByDepth).map((a) => parseInt(a, 10)).sort(S);
+    if (y.length > 1)
+      for (const a of y) {
+        const u = this.nodesByDepth[a];
+        for (const d of u) {
+          const l = d.outboundLayer;
+          if (this.inputLayers.map((f) => f.id).indexOf(l.id) !== -1)
+            continue;
+          const g = [];
+          for (let f = 0; f < d.inboundLayers.length; f++) {
+            const h = d.inboundLayers[f], p = d.nodeIndices[f], e = d.tensorIndices[f], i = `${h.name}_${p}_${e}`, n = o[i];
+            g.push(n);
+          }
+          const b = l.computeOutputShape(M(g)), I = j(b), N = l.inboundNodes.indexOf(d);
+          for (let f = 0; f < I.length; f++) {
+            const h = `${l.name}_${N}_${f}`;
+            o[h] = I[f];
+          }
+        }
+      }
+    const m = [], r = [];
+    for (let a = 0; a < this.outputLayers.length; a++) {
+      const u = this.outputLayers[a], d = this.outputLayersNodeIndices[a], l = this.outputLayersTensorIndices[a], g = `${u.name}_${d}_${l}`;
+      r.push(g);
+    }
+    for (let a = 0; a < r.length; a++) {
+      const u = r[a];
+      C(u in o), m.push(o[u]);
+    }
+    return M(m);
+  }
+  /**
+   * Computes output tensors for new inputs.
+   *
+   * Note:
+   *   - Expects `inputs` to be a list (potentially with 1 element).
+   *
+   * @param inputs List of tensors
+   * @param masks List of masks (tensors or null).
+   * @return Three lists: outputTensors, outputMasks, outputShapes
+   */
+  runInternalGraph(t, s) {
+    s == null && (s = W(null, t.length));
+    const o = {};
+    for (let u = 0; u < this.inputs.length; ++u) {
+      const d = this.inputs[u], l = t[u], g = s[u];
+      o[d.id] = [l, g];
+    }
+    const y = Object.keys(this.nodesByDepth).map((u) => parseInt(u, 10)).sort(S);
+    for (const u of y) {
+      const d = this.nodesByDepth[u];
+      for (const l of d) {
+        const g = l.outboundLayer, b = l.inputTensors, I = l.outputTensors, N = new Array();
+        for (const f of b)
+          f.id in o && N.push(o[f.id]);
+        if (N.length === b.length) {
+          let f = {}, h, p, e, i;
+          if (l.callArgs != null && (f = l.callArgs), N.length === 1) {
+            const [n, c] = N[0];
+            f.mask == null && (f.mask = c), e = D(g.call(n, f)), i = D(g.computeMask(n, c)), h = [n], p = [c];
+          } else
+            h = N.map((n) => n[0]), p = N.map((n) => n[1]), f.mask == null && (f.mask = p), e = D(g.call(h, f)), i = D(g.computeMask(h, p));
+          if (g.activityRegularizer)
+            throw new R("LayersModel invocation with concrete Tensor value(s) in the presence of activity regularizer(s) is not supported yet.");
+          for (let n = 0; n < I.length; ++n) {
+            const c = I[n], w = e[n], x = i[n];
+            o[c.id] = [w, x];
+          }
+        }
+      }
+    }
+    const m = [], r = [], a = [];
+    for (const u of this.outputs) {
+      C(u.id in o, `Could not compute output ${u.name} : ${u.id}`);
+      const [d, l] = o[u.id];
+      a.push(d.shape), m.push(d), r.push(l);
+    }
+    return [m, r, a];
+  }
+  /**
+   * Builds a map of internal node keys to node ordering.
+   * Used in serializaion a node orderings may change as unused nodes are
+   * dropped. Porting Note:  This helper method was pulled out of getConfig to
+   * improve readability.
+   * @param layers An array of Layers in the model.
+   * @returns Map of Node Keys to index order within the layer.
+   */
+  buildNodeConversionMap(t) {
+    const s = {};
+    let o;
+    for (const y of this.layers) {
+      o = y instanceof $ ? 1 : 0;
+      for (let m = 0; m < y.inboundNodes.length; m++) {
+        const r = $.nodeKey(y, m);
+        this.containerNodes.has(r) && (s[r] = o, o += 1);
+      }
+    }
+    return s;
+  }
+  getLayer(t, s) {
+    if (s != null)
+      return this.findLayer(s);
+    if (t == null)
+      throw new T("Provide either a layer name or layer index");
+    if (typeof t == "number")
+      return this.findLayer(t);
+    for (const o of this.layers)
+      if (o.name === t)
+        return o;
+    throw new T(`No such layer: ${t}`);
+  }
+  findLayer(t) {
+    if (this.layers.length <= t)
+      throw new T(`Was asked to retrieve layer at index ${t}, but model only has ${this.layers.length} layer(s).`);
+    return this.layers[t];
+  }
+  /**
+   * Retrieves the Container's current loss values.
+   *
+   * Used for regularizers during training.
+   */
+  calculateLosses() {
+    return v(() => {
+      const t = [];
+      for (const s of this.layers)
+        for (let o = 0; o < s.inboundNodes.length; ++o) {
+          const y = $.nodeKey(s, o);
+          this.containerNodes.has(y) && t.push(...s.calculateLosses());
+        }
+      return t;
+    });
+  }
+  getConfig() {
+    const t = { name: this.name }, s = this.buildNodeConversionMap(this.layers), o = [];
+    for (const r of this.layers) {
+      const a = r.getClassName(), u = r.getConfig(), d = [];
+      for (let g = 0; g < r.inboundNodes.length; g++) {
+        const b = r.inboundNodes[g], I = $.nodeKey(r, g);
+        let N = {};
+        if (this.containerNodes.has(I)) {
+          if (b.callArgs)
+            try {
+              JSON.stringify(b.callArgs), N = b.callArgs;
+            } catch {
+              console.warn(`Layer ${r.name} was passed non-serializable keyword arguments: ${b.callArgs}. They will not be included in the serialized model (and thus will be missing at deserialization time).`), N = {};
+            }
+          if (b.inboundLayers.length > 0) {
+            const f = [];
+            for (let h = 0; h < b.inboundLayers.length; h++) {
+              const p = b.inboundLayers[h], e = b.nodeIndices[h], i = b.tensorIndices[h], n = $.nodeKey(p, e);
+              let c = s[n];
+              c == null && (c = 0), f.push([p.name, c, i, N]);
+            }
+            d.push(f);
+          }
+        }
+      }
+      const l = {};
+      l.name = r.name, l.className = a, l.config = u, l.inboundNodes = d, o.push(l);
+    }
+    t.layers = o;
+    const y = [];
+    for (let r = 0; r < this.inputLayers.length; r++) {
+      const a = this.inputLayers[r], u = this.inputLayersNodeIndices[r], d = $.nodeKey(a, u);
+      if (!this.containerNodes.has(d))
+        continue;
+      let l = s[d];
+      l == null && (l = 0);
+      const g = this.inputLayersTensorIndices[r];
+      y.push([a.name, l, g]);
+    }
+    t.inputLayers = y;
+    const m = [];
+    for (let r = 0; r < this.outputLayers.length; r++) {
+      const a = this.outputLayers[r], u = this.outputLayersNodeIndices[r], d = $.nodeKey(a, u);
+      if (!this.containerNodes.has(d))
+        continue;
+      let l = s[d];
+      l == null && (l = 0);
+      const g = this.outputLayersTensorIndices[r];
+      m.push([a.name, l, g]);
+    }
+    return t.outputLayers = m, t;
+  }
+  /**
+   * Instantiates a LayersModel from its config (output of `get_config()`).
+   * @param cls the class to create
+   * @param config LayersModel config dictionary.
+   * @param customObjects An optional dictionary of custom objects.
+   * @param fastWeightInit Optional flag to use fast weight initialization
+   *   during deserialization. This is applicable to cases in which
+   *   the initialization will be immediately overwritten by loaded weight
+   *   values. Default: `false`.
+   * @returns A LayersModel instance.
+   * @throws ValueError: In case of improperly formatted config dict.
+   */
+  /** @nocollapse */
+  static fromConfig(t, s, o = {}, y = !1) {
+    const m = {}, r = {};
+    function a(h, p) {
+      h.name in r ? r[h.name].push(p) : r[h.name] = [p];
+    }
+    function u(h, p) {
+      const e = [];
+      let i;
+      for (const n of p) {
+        const c = n[0], w = n[1], x = n[2];
+        if (i = n[3] == null ? {} : n[3], !(c in m)) {
+          a(h, p);
+          return;
+        }
+        const L = m[c];
+        if (L.inboundNodes.length <= w) {
+          a(h, p);
+          return;
+        }
+        const O = L.inboundNodes[w];
+        e.push(O.outputTensors[x]);
+      }
+      e.length > 0 && h.apply(M(e), i);
+    }
+    function d(h) {
+      const p = h.name, e = G(h, s.customObjects != null ? s.customObjects : {});
+      e.setFastWeightInitDuringBuild(y), m[p] = e, h.inboundNodes.forEach((n) => {
+        if (!(n instanceof Array))
+          throw new T(`Corrupted configuration, expected array for nodeData: ${n}`);
+        a(e, n);
+      });
+    }
+    const l = s.name, g = s.layers;
+    for (const h of g)
+      d(h);
+    for (; !J(r); )
+      for (const h of g) {
+        const p = m[h.name];
+        if (p.name in r) {
+          const e = r[p.name];
+          delete r[p.name];
+          for (const i of e)
+            u(p, i);
+        }
+      }
+    const b = [], I = [], N = s.inputLayers;
+    for (const h of N) {
+      const p = h[0], e = h[1], i = h[2];
+      C(p in m);
+      const c = m[p].inboundNodes[e].outputTensors;
+      b.push(c[i]);
+    }
+    const f = s.outputLayers;
+    for (const h of f) {
+      const p = h[0], e = h[1], i = h[2];
+      C(p in m);
+      const c = m[p].inboundNodes[e].outputTensors;
+      I.push(c[i]);
+    }
+    return new t({ inputs: b, outputs: I, name: l });
+  }
+  /**
+   * Determine whether the container is stateful.
+   *
+   * Porting Note: this is the equivalent of the stateful @property of
+   *   the Container class in PyKeras.
+   */
+  get stateful() {
+    if (this._stateful)
+      throw new T("Container instance unexpectedly has _stateful = true. The statefulness of a Container is determined by the Layers it contains. Its _stateful property must remain the default false.");
+    for (const t of this.layers)
+      if (t.stateful)
+        return !0;
+    return !1;
+  }
+  /**
+   * Reset the state of all stateful constituent layers (if any).
+   *
+   * Examples of stateful layers include RNN layers whose `stateful` property
+   * is set as `true`.
+   */
+  resetStates() {
+    v(() => {
+      this.layers.forEach((t) => {
+        t.stateful && t.resetStates();
+      });
+    });
+  }
+}
+export {
+  $ as Container
+};
+//# sourceMappingURL=container.js.map