@genai-fi/nanogpt 0.9.0 → 0.10.0

package/dist/index-ZyQhjEPo.js

@@ -0,0 +1,2157 @@
+import { w as J, o as je, p as ge, K as qe, I as Ee, q as pe, s as ye, t as Te, v as Ve, a3 as He, x as Ae, A as Me, a4 as Ne, a5 as xe, m as G, a6 as Xe, $ as Je, a7 as Ye, a8 as Ze, a9 as Qe, aa as et, ab as tt, ac as nt, ad as st, ae as rt, af as at } from "./tensor_util-DV-FP5Q3.js";
+import { o as it, E as ot, q as ct, y as lt, a as g, r as ut, t as ht, T as R, u as dt, V as re, v as ae, w as Y, x as be, f as ft, m as mt, s as Z, e as B, M as gt, N as ue, D, O as Fe, B as De, P as pt, d as he, Q as yt, R as bt, S as wt, U as St, j as Ce } from "./tensor-DdQUJZlz.js";
+import { p as Q } from "./index-xuotMAFm.js";
+import { B as ee } from "./index-Cp39cXWe.js";
+function ne(s) {
+  return s.kernelName != null;
+}
+class we {
+  constructor() {
+    this.registeredVariables = {}, this.nextTapeNodeId = 0, this.numBytes = 0, this.numTensors = 0, this.numStringTensors = 0, this.numDataBuffers = 0, this.gradientDepth = 0, this.kernelDepth = 0, this.scopeStack = [], this.numDataMovesStack = [], this.nextScopeId = 0, this.tensorInfo = /* @__PURE__ */ new WeakMap(), this.profiling = !1, this.activeProfile = {
+      newBytes: 0,
+      newTensors: 0,
+      peakBytes: 0,
+      kernels: [],
+      result: null,
+      get kernelNames() {
+        return Array.from(new Set(this.kernels.map((e) => e.name)));
+      }
+    };
+  }
+  dispose() {
+    for (const e in this.registeredVariables)
+      this.registeredVariables[e].dispose();
+  }
+}
+class q {
+  constructor(e) {
+    this.ENV = e, this.registry = {}, this.registryFactory = {}, this.pendingBackendInitId = 0, this.state = new we();
+  }
+  async ready() {
+    if (this.pendingBackendInit != null)
+      return this.pendingBackendInit.then(() => {
+      });
+    if (this.backendInstance != null)
+      return;
+    const e = this.getSortedBackends();
+    for (let t = 0; t < e.length; t++) {
+      const n = e[t];
+      if (await this.initializeBackend(n).success) {
+        await this.setBackend(n);
+        return;
+      }
+    }
+    throw new Error("Could not initialize any backends, all backend initializations failed.");
+  }
+  get backend() {
+    if (this.pendingBackendInit != null)
+      throw new Error(`Backend '${this.backendName}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
+    if (this.backendInstance == null) {
+      const { name: e, asyncInit: t } = this.initializeBackendsAndReturnBest();
+      if (t)
+        throw new Error(`The highest priority backend '${e}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
+      this.setBackend(e);
+    }
+    return this.backendInstance;
+  }
+  backendNames() {
+    return Object.keys(this.registryFactory);
+  }
+  findBackend(e) {
+    if (!(e in this.registry))
+      if (e in this.registryFactory) {
+        const { asyncInit: t } = this.initializeBackend(e);
+        if (t)
+          return null;
+      } else
+        return null;
+    return this.registry[e];
+  }
+  findBackendFactory(e) {
+    return e in this.registryFactory ? this.registryFactory[e].factory : null;
+  }
+  registerBackend(e, t, n = 1) {
+    return e in this.registryFactory ? (J(`${e} backend was already registered. Reusing existing backend factory.`), !1) : (this.registryFactory[e] = { factory: t, priority: n }, !0);
+  }
+  async setBackend(e) {
+    if (this.registryFactory[e] == null)
+      throw new Error(`Backend name '${e}' not found in registry`);
+    if (this.backendName = e, this.registry[e] == null) {
+      this.backendInstance = null;
+      const { success: t, asyncInit: n } = this.initializeBackend(e);
+      if (!(n ? await t : t))
+        return !1;
+    }
+    return this.backendInstance = this.registry[e], this.setupRegisteredKernels(), this.profiler = new je(this.backendInstance), !0;
+  }
+  setupRegisteredKernels() {
+    ge(this.backendName).forEach((t) => {
+      t.setupFunc != null && t.setupFunc(this.backendInstance);
+    });
+  }
+  disposeRegisteredKernels(e) {
+    ge(e).forEach((n) => {
+      n.disposeFunc != null && n.disposeFunc(this.registry[e]);
+    });
+  }
+  /**
+   * Initializes a backend by looking up the backend name in the factory
+   * registry and calling the factory method. Returns a boolean representing
+   * whether the initialization of the backend succeeded. Throws an error if
+   * there is no backend in the factory registry.
+   */
+  initializeBackend(e) {
+    const t = this.registryFactory[e];
+    if (t == null)
+      throw new Error(`Cannot initialize backend ${e}, no registration found.`);
+    try {
+      const n = t.factory();
+      if (n && !(n instanceof qe) && typeof n.then == "function") {
+        const r = ++this.pendingBackendInitId, a = n.then((i) => r < this.pendingBackendInitId ? !1 : (this.registry[e] = i, this.pendingBackendInit = null, !0)).catch((i) => (r < this.pendingBackendInitId || (this.pendingBackendInit = null, J(`Initialization of backend ${e} failed`), J(i.stack || i.message)), !1));
+        return this.pendingBackendInit = a, { success: a, asyncInit: !0 };
+      } else
+        return this.registry[e] = n, { success: !0, asyncInit: !1 };
+    } catch (n) {
+      return J(`Initialization of backend ${e} failed`), J(n.stack || n.message), { success: !1, asyncInit: !1 };
+    }
+  }
+  removeBackend(e) {
+    if (!(e in this.registryFactory))
+      throw new Error(`${e} backend not found in registry`);
+    this.backendName === e && this.pendingBackendInit != null && this.pendingBackendInitId++, e in this.registry && (this.disposeRegisteredKernels(e), this.registry[e].dispose(), delete this.registry[e]), delete this.registryFactory[e], this.backendName === e && (this.pendingBackendInit = null, this.backendName = null, this.backendInstance = null);
+  }
+  getSortedBackends() {
+    if (Object.keys(this.registryFactory).length === 0)
+      throw new Error("No backend found in registry.");
+    return Object.keys(this.registryFactory).sort((e, t) => this.registryFactory[t].priority - this.registryFactory[e].priority);
+  }
+  initializeBackendsAndReturnBest() {
+    const e = this.getSortedBackends();
+    for (let t = 0; t < e.length; t++) {
+      const n = e[t], { success: r, asyncInit: a } = this.initializeBackend(n);
+      if (a || r)
+        return { name: n, asyncInit: a };
+    }
+    throw new Error("Could not initialize any backends, all backend initializations failed.");
+  }
+  moveData(e, t) {
+    const n = this.state.tensorInfo.get(t), r = n.backend, a = this.readSync(t), i = r.refCount(t);
+    r.disposeData(t, !0), n.backend = e, e.move(t, a, n.shape, n.dtype, i), this.shouldCheckForMemLeaks() && this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
+  }
+  tidy(e, t) {
+    let n = null;
+    if (t == null) {
+      if (typeof e != "function")
+        throw new Error("Please provide a function to tidy()");
+      t = e;
+    } else {
+      if (typeof e != "string" && !(e instanceof String))
+        throw new Error("When calling with two arguments, the first argument to tidy() must be a string");
+      if (typeof t != "function")
+        throw new Error("When calling with two arguments, the 2nd argument to tidy() must be a function");
+      n = e;
+    }
+    let r;
+    return this.scopedRun(() => this.startScope(n), () => this.endScope(r), () => (r = t(), r instanceof Promise && console.error("Cannot return a Promise inside of tidy."), r));
+  }
+  scopedRun(e, t, n) {
+    e();
+    try {
+      const r = n();
+      return t(), r;
+    } catch (r) {
+      throw t(), r;
+    }
+  }
+  nextTensorId() {
+    return q.nextTensorId++;
+  }
+  nextVariableId() {
+    return q.nextVariableId++;
+  }
+  /**
+   * This method is called instead of the public-facing tensor.clone() when
+   * saving a tensor for backwards pass. It makes sure to add the clone
+   * operation to the tape regardless of being called inside a kernel
+   * execution.
+   */
+  clone(e) {
+    const t = u.runKernel(Ee, { x: e }), n = { x: e }, r = (i) => ({
+      x: () => {
+        const o = "float32", c = { x: i }, l = { dtype: o };
+        return u.runKernel(
+          Ae,
+          c,
+          // tslint:disable-next-line: no-unnecessary-type-assertion
+          l
+        );
+      }
+    }), a = [];
+    return this.addTapeNode(this.state.activeScope.name, n, [t], r, a, {}), t;
+  }
+  /**
+   * Execute a kernel with the given name and return the output tensor.
+   *
+   * @param kernelName The name of the kernel to execute.
+   * @param inputs A map of input names to tensors.
+   * @param attrs A map of attribute names to their values. An attribute is a
+   *     primitive (non-tensor) input to the kernel.
+   * @param inputsToSave A list of tensors, inputs to save for the backprop
+   *     computation.
+   * @param outputsToSave A list of booleans, specifying which output to save
+   *     for the backprop computation. These are booleans since the output
+   * tensors are not visible to the user.
+   */
+  runKernel(e, t, n) {
+    if (this.backendName == null && this.backend, !(pe(e, this.backendName) != null))
+      throw new Error(`Kernel '${e}' not registered for backend '${this.backendName}'`);
+    return this.runKernelFunc({ kernelName: e, inputs: t, attrs: n });
+  }
+  shouldCheckForMemLeaks() {
+    return this.ENV.getBool("IS_TEST");
+  }
+  checkKernelForMemLeak(e, t, n) {
+    const r = this.backend.numDataIds();
+    let a = 0;
+    n.forEach((c) => {
+      a += c.dtype === "complex64" ? 3 : 1;
+    });
+    const i = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1], o = r - t - a - i;
+    if (o > 0)
+      throw new Error(`Backend '${this.backendName}' has an internal memory leak (${o} data ids) after running '${e}'`);
+  }
+  /**
+   * Internal helper method to execute a kernel Func
+   *
+   * Use `runKernel` to execute kernels from outside of engine.
+   */
+  runKernelFunc(e) {
+    let t, n = [];
+    const r = this.isTapeOn(), a = this.state.numBytes, i = this.state.numTensors;
+    this.shouldCheckForMemLeaks() && this.state.numDataMovesStack.push(0);
+    let o;
+    this.backendName == null && this.backend;
+    let c;
+    const l = ne(e) ? e.kernelName : this.state.activeScope != null ? this.state.activeScope.name : "";
+    if (ne(e)) {
+      const { kernelName: b, inputs: w, attrs: I } = e;
+      this.backendName == null && this.backend;
+      const T = pe(b, this.backendName);
+      g(T != null, () => `Cannot find registered kernel '${b}' for backend '${this.backendName}'`), o = () => {
+        const te = this.backend.numDataIds();
+        c = T.kernelFunc({ inputs: w, attrs: I, backend: this.backend });
+        const fe = Array.isArray(c) ? c : [c];
+        this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(b, te, fe);
+        const me = fe.map((X) => X.rank != null ? X : this.makeTensorFromTensorInfo(X));
+        if (r) {
+          const X = this.getTensorsForGradient(b, w, me);
+          n = this.saveTensorsForBackwardMode(X);
+        }
+        return me;
+      };
+    } else {
+      const { forwardFunc: b } = e, w = (I) => {
+        r && (n = I.map((T) => this.keep(this.clone(T))));
+      };
+      o = () => {
+        const I = this.backend.numDataIds();
+        c = this.tidy(() => b(this.backend, w));
+        const T = Array.isArray(c) ? c : [c];
+        return this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(l, I, T), T;
+      };
+    }
+    const { inputs: h, attrs: m } = e, d = ne(e) ? null : e.backwardsFunc;
+    let p;
+    return this.scopedRun(
+      // Stop recording to a tape when running a kernel.
+      () => this.state.kernelDepth++,
+      () => this.state.kernelDepth--,
+      () => {
+        !this.ENV.getBool("DEBUG") && !this.state.profiling ? t = o() : (p = this.profiler.profileKernel(l, h, () => o()), this.ENV.getBool("DEBUG") && this.profiler.logKernelProfile(p), t = p.outputs);
+      }
+    ), r && this.addTapeNode(l, h, t, d, n, m), this.state.profiling && this.state.activeProfile.kernels.push({
+      name: l,
+      bytesAdded: this.state.numBytes - a,
+      totalBytesSnapshot: this.state.numBytes,
+      tensorsAdded: this.state.numTensors - i,
+      totalTensorsSnapshot: this.state.numTensors,
+      inputShapes: Object.keys(h).map((b) => h[b] != null ? h[b].shape : null),
+      outputShapes: t.map((b) => b.shape),
+      kernelTimeMs: p.timeMs,
+      extraInfo: p.extraInfo
+    }), Array.isArray(c) ? t : t[0];
+  }
+  /**
+   * Saves tensors used in forward mode for use in backward mode.
+   *
+   * @param tensors the list of tensors to save.
+   */
+  saveTensorsForBackwardMode(e) {
+    return e.map((n) => this.keep(this.clone(n)));
+  }
+  /**
+   * Returns a list of tensors to save for a given gradient calculation.
+   *
+   * @param kernelName name of kernel to look up gradient for.
+   * @param inputs a map of input tensors.
+   * @param outputs an array of output tensors from forward mode of kernel.
+   */
+  getTensorsForGradient(e, t, n) {
+    const r = ye(e);
+    if (r != null) {
+      const a = r.inputsToSave || [], i = r.outputsToSave || [];
+      let o;
+      r.saveAllInputs ? (g(Array.isArray(t), () => "saveAllInputs is true, expected inputs to be an array."), o = Object.keys(t).map((l) => t[l])) : o = a.map((l) => t[l]);
+      const c = n.filter((l, h) => i[h]);
+      return o.concat(c);
+    }
+    return [];
+  }
+  /**
+   * Internal method used by public APIs for tensor creation. Makes a new
+   * tensor with the provided shape, dtype and values. It always
+   * creates a new data id and writes the values to the underlying backend.
+   */
+  makeTensor(e, t, n, r) {
+    if (e == null)
+      throw new Error("Values passed to engine.makeTensor() are null");
+    n = n || "float32", r = r || this.backend;
+    let a = e;
+    n === "string" && ut(e[0]) && (a = e.map((c) => ht(c)));
+    const i = r.write(a, t, n), o = new R(t, n, i, this.nextTensorId());
+    if (this.trackTensor(o, r), n === "string") {
+      const c = this.state.tensorInfo.get(i), l = dt(a);
+      this.state.numBytes += l - c.bytes, c.bytes = l;
+    }
+    return o;
+  }
+  /**
+   * Internal method used by backends. Makes a new tensor
+   * that is a wrapper around an existing data id. It doesn't create
+   * a new data id, only increments the ref count used in memory tracking.
+   * @deprecated
+   */
+  makeTensorFromDataId(e, t, n, r) {
+    n = n || "float32";
+    const a = { dataId: e, shape: t, dtype: n };
+    return this.makeTensorFromTensorInfo(a, r);
+  }
+  /**
+   * Internal method used by backends. Makes a new tensor that is a wrapper
+   * around an existing data id in TensorInfo. It doesn't create a new data id,
+   * only increments the ref count used in memory tracking.
+   */
+  makeTensorFromTensorInfo(e, t) {
+    const { dataId: n, shape: r, dtype: a } = e, i = new R(r, a, n, this.nextTensorId());
+    return this.trackTensor(i, t), i;
+  }
+  makeVariable(e, t = !0, n, r) {
+    n = n || this.nextVariableId().toString(), r != null && r !== e.dtype && (e = e.cast(r));
+    const a = new re(e, t, n, this.nextTensorId());
+    if (this.state.registeredVariables[a.name] != null)
+      throw new Error(`Variable with name ${a.name} was already registered`);
+    return this.state.registeredVariables[a.name] = a, this.incRef(a, this.backend), a;
+  }
+  trackTensor(e, t) {
+    this.state.numTensors++, e.dtype === "string" && this.state.numStringTensors++;
+    let n = 0;
+    e.dtype !== "complex64" && e.dtype !== "string" && (n = e.size * ae(e.dtype)), this.state.numBytes += n, this.state.tensorInfo.has(e.dataId) || (this.state.numDataBuffers++, this.state.tensorInfo.set(e.dataId, {
+      backend: t || this.backend,
+      dtype: e.dtype,
+      shape: e.shape,
+      bytes: n
+    })), e instanceof re || this.track(e);
+  }
+  // Track the tensor by dataId and increase the refCount for the dataId in the
+  // backend.
+  // TODO(pyu10055): This is currently used by makeVariable method, to increase
+  // refCount on the backend for the dataId. It can potentially be replaced with
+  // Identity op indead of calling backend directly.
+  incRef(e, t) {
+    this.trackTensor(e, t), this.backend.incRef(e.dataId);
+  }
+  removeDataId(e, t) {
+    this.state.tensorInfo.has(e) && this.state.tensorInfo.get(e).backend === t && (this.state.tensorInfo.delete(e), this.state.numDataBuffers--);
+  }
+  disposeTensor(e) {
+    if (!this.state.tensorInfo.has(e.dataId))
+      return;
+    const t = this.state.tensorInfo.get(e.dataId);
+    if (this.state.numTensors--, e.dtype === "string" && (this.state.numStringTensors--, this.state.numBytes -= t.bytes), e.dtype !== "complex64" && e.dtype !== "string") {
+      const n = e.size * ae(e.dtype);
+      this.state.numBytes -= n;
+    }
+    t.backend.disposeData(e.dataId) && this.removeDataId(e.dataId, t.backend);
+  }
+  disposeVariables() {
+    for (const e in this.state.registeredVariables) {
+      const t = this.state.registeredVariables[e];
+      this.disposeVariable(t);
+    }
+  }
+  disposeVariable(e) {
+    this.disposeTensor(e), this.state.registeredVariables[e.name] != null && delete this.state.registeredVariables[e.name];
+  }
+  memory() {
+    const e = this.backend.memory();
+    return e.numTensors = this.state.numTensors, e.numDataBuffers = this.state.numDataBuffers, e.numBytes = this.state.numBytes, this.state.numStringTensors > 0 && (e.unreliable = !0, e.reasons == null && (e.reasons = []), e.reasons.push("Memory usage by string tensors is approximate (2 bytes per character)")), e;
+  }
+  async profile(e) {
+    this.state.profiling = !0;
+    const t = this.state.numBytes, n = this.state.numTensors;
+    this.state.activeProfile.kernels = [], this.state.activeProfile.result = await e(), this.state.profiling = !1, this.state.activeProfile.peakBytes = Math.max(...this.state.activeProfile.kernels.map((r) => r.totalBytesSnapshot)), this.state.activeProfile.newBytes = this.state.numBytes - t, this.state.activeProfile.newTensors = this.state.numTensors - n;
+    for (const r of this.state.activeProfile.kernels)
+      r.kernelTimeMs = await r.kernelTimeMs, r.extraInfo = await r.extraInfo;
+    return this.state.activeProfile;
+  }
+  isTapeOn() {
+    return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
+  }
+  addTapeNode(e, t, n, r, a, i) {
+    const o = { id: this.state.nextTapeNodeId++, kernelName: e, inputs: t, outputs: n, saved: a }, c = ye(e);
+    c != null && (r = c.gradFunc), r != null && (o.gradient = (l) => (l = l.map((h, m) => {
+      if (h == null) {
+        const d = n[m], p = ft(d.size, d.dtype);
+        return this.makeTensor(p, d.shape, d.dtype);
+      }
+      return h;
+    }), r(l.length > 1 ? l : l[0], a, i))), this.state.activeTape.push(o);
+  }
+  keep(e) {
+    return e.kept = !0, e;
+  }
+  startTape() {
+    this.state.gradientDepth === 0 && (this.state.activeTape = []), this.state.gradientDepth++;
+  }
+  endTape() {
+    this.state.gradientDepth--;
+  }
+  /**
+   * Start a scope. Use this with endScope() to achieve the same functionality
+   * as scope() without the need for a function closure.
+   */
+  startScope(e) {
+    const t = {
+      track: [],
+      name: "unnamed scope",
+      id: this.state.nextScopeId++
+    };
+    e && (t.name = e), this.state.scopeStack.push(t), this.state.activeScope = t;
+  }
+  /**
+   * End a scope. Use this with startScope() to achieve the same functionality
+   * as scope() without the need for a function closure.
+   */
+  endScope(e) {
+    const t = Te(e), n = new Set(t.map((a) => a.id));
+    for (let a = 0; a < this.state.activeScope.track.length; a++) {
+      const i = this.state.activeScope.track[a];
+      !i.kept && !n.has(i.id) && i.dispose();
+    }
+    const r = this.state.scopeStack.pop();
+    this.state.activeScope = this.state.scopeStack.length === 0 ? null : this.state.scopeStack[this.state.scopeStack.length - 1], t.forEach((a) => {
+      !a.kept && a.scopeId === r.id && this.track(a);
+    });
+  }
+  /**
+   * Returns gradients of `f` with respect to each of the `xs`. The gradients
+   * returned are of the same length as `xs`, but some might be null if `f`
+   * was not a function of that `x`. It also takes optional dy to multiply the
+   * gradient, which defaults to `1`.
+   */
+  gradients(e, t, n, r = !1) {
+    if (g(t.length > 0, () => "gradients() received an empty list of xs."), n != null && n.dtype !== "float32")
+      throw new Error(`dy must have 'float32' dtype, but has '${n.dtype}'`);
+    const a = this.scopedRun(() => this.startTape(), () => this.endTape(), () => this.tidy("forward", e));
+    g(a instanceof R, () => "The result y returned by f() must be a tensor.");
+    const i = Ve(this.state.activeTape, t, a);
+    if (!r && i.length === 0 && t.length > 0)
+      throw new Error("Cannot compute gradient of y=f(x) with respect to x. Make sure that the f you passed encloses all operations that lead from x to y.");
+    return this.tidy("backward", () => {
+      const o = {};
+      o[a.id] = n ?? kt(a.shape), He(
+        o,
+        i,
+        // Pass the tidy function to avoid circular dep with `tape.ts`.
+        (l) => this.tidy(l),
+        // Pass an add function to avoide a circular dep with `tape.ts`.
+        It
+      );
+      const c = t.map((l) => o[l.id]);
+      return this.state.gradientDepth === 0 && (this.state.activeTape.forEach((l) => {
+        for (const h of l.saved)
+          h.dispose();
+      }), this.state.activeTape = null), { value: a, grads: c };
+    });
+  }
+  customGrad(e) {
+    return g(Y(e), () => "The f passed in customGrad(f) must be a function."), (...t) => {
+      g(t.every((o) => o instanceof R), () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors");
+      let n;
+      const r = {};
+      t.forEach((o, c) => {
+        r[c] = o;
+      });
+      const a = (o, c) => (n = e(...t, c), g(n.value instanceof R, () => "The function f passed in customGrad(f) must return an object where `obj.value` is a tensor"), g(Y(n.gradFunc), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function."), n.value), i = (o, c) => {
+        const l = n.gradFunc(o, c), h = Array.isArray(l) ? l : [l];
+        g(h.length === t.length, () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns the same number of tensors as inputs passed to f(...)."), g(h.every((d) => d instanceof R), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns a list of only tensors.");
+        const m = {};
+        return h.forEach((d, p) => {
+          m[p] = () => d;
+        }), m;
+      };
+      return this.runKernelFunc({
+        forwardFunc: a,
+        backwardsFunc: i,
+        inputs: r
+      });
+    };
+  }
+  readSync(e) {
+    return this.state.tensorInfo.get(e).backend.readSync(e);
+  }
+  read(e) {
+    return this.state.tensorInfo.get(e).backend.read(e);
+  }
+  readToGPU(e, t) {
+    return this.state.tensorInfo.get(e).backend.readToGPU(e, t);
+  }
+  async time(e) {
+    const t = be(), n = await this.backend.time(e);
+    return n.wallMs = be() - t, n;
+  }
+  /**
+   * Tracks a Tensor in the current scope to be automatically cleaned up
+   * when the current scope ends, and returns the value.
+   *
+   * @param result The Tensor to track in the current scope.
+   */
+  track(e) {
+    return this.state.activeScope != null && (e.scopeId = this.state.activeScope.id, this.state.activeScope.track.push(e)), e;
+  }
+  get registeredVariables() {
+    return this.state.registeredVariables;
+  }
+  /**
+   * Resets the engine state. Removes all backends but does not remove
+   * registered backend factories.
+   */
+  reset() {
+    this.pendingBackendInitId++, this.state.dispose(), this.ENV.reset(), this.state = new we();
+    for (const e in this.registry)
+      this.disposeRegisteredKernels(e), this.registry[e].dispose(), delete this.registry[e];
+    this.backendName = null, this.backendInstance = null, this.pendingBackendInit = null;
+  }
+}
+q.nextTensorId = 0;
+q.nextVariableId = 0;
+function kt(s) {
+  const e = mt(Z(s), "float32");
+  return u.makeTensor(e, s, "float32");
+}
+function Re() {
+  const s = it();
+  if (s._tfengine == null) {
+    const e = new ot(s);
+    s._tfengine = new q(e);
+  }
+  return ct(s._tfengine.ENV), lt(() => s._tfengine), s._tfengine;
+}
+const u = Re();
+function It(s, e) {
+  const t = { a: s, b: e };
+  return u.runKernel(Me, t);
+}
+function vt() {
+  return typeof navigator < "u" && navigator != null;
+}
+function $n(s) {
+  if (s || vt()) {
+    if (s || (s = navigator), s.product === "ReactNative")
+      return !0;
+    const e = s.userAgent || s.vendor || // tslint:disable-next-line:no-any
+    (typeof window < "u" ? window.opera : "");
+    if (!e) {
+      const t = s;
+      return t.userAgentData && t.userAgentData.mobile;
+    }
+    return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(e) || // tslint:disable-next-line:max-line-length
+    /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(e.substr(0, 4));
+  }
+  return !1;
+}
+function Bt() {
+  return typeof window < "u" && window.document != null || //@ts-ignore
+  typeof WorkerGlobalScope < "u";
+}
+const E = B();
+E.registerFlag("DEBUG", () => !1, (s) => {
+  s && console.warn("Debugging mode is ON. The output of every math call will be downloaded to CPU and checked for NaNs. This significantly impacts performance.");
+});
+E.registerFlag("IS_BROWSER", () => Bt());
+E.registerFlag("IS_NODE", () => typeof Q < "u" && typeof Q.versions < "u" && typeof Q.versions.node < "u");
+E.registerFlag("IS_CHROME", () => typeof navigator < "u" && navigator != null && navigator.userAgent != null && /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor));
+E.registerFlag("IS_SAFARI", () => typeof navigator < "u" && navigator != null && navigator.userAgent != null && /Safari/.test(navigator.userAgent) && /Apple/.test(navigator.vendor));
+E.registerFlag("PROD", () => !1);
+E.registerFlag("TENSORLIKE_CHECK_SHAPE_CONSISTENCY", () => E.getBool("DEBUG"));
+E.registerFlag("DEPRECATION_WARNINGS_ENABLED", () => !0);
+E.registerFlag("IS_TEST", () => !1);
+E.registerFlag("CHECK_COMPUTATION_FOR_ERRORS", () => E.getBool("DEBUG"));
+E.registerFlag("WRAP_TO_IMAGEBITMAP", () => !1);
+E.registerFlag("CANVAS2D_WILL_READ_FREQUENTLY_FOR_GPU", () => !1);
+E.registerFlag("USE_SETTIMEOUTCUSTOM", () => !1);
+function Et(s, e) {
+  let t = s;
+  if (D(s))
+    return e === "string" ? [] : [s.length];
+  if (Ne(s)) {
+    const r = s.channels || "RGBA";
+    return [s.height, s.width * r.length];
+  } else if (xe(s))
+    return [s.buffer.size / (e == null ? 4 : ae(e))];
+  if (!Array.isArray(s))
+    return [];
+  const n = [];
+  for (; Array.isArray(t) || D(t) && e !== "string"; )
+    n.push(t.length), t = t[0];
+  return Array.isArray(s) && B().getBool("TENSORLIKE_CHECK_SHAPE_CONSISTENCY") && $e(s, n, []), n;
+}
+function $e(s, e, t) {
+  if (t = t || [], !Array.isArray(s) && !D(s)) {
+    g(e.length === 0, () => `Element arr[${t.join("][")}] is a primitive, but should be an array/TypedArray of ${e[0]} elements`);
+    return;
+  }
+  g(e.length > 0, () => `Element arr[${t.join("][")}] should be a primitive, but is an array of ${s.length} elements`), g(s.length === e[0], () => `Element arr[${t.join("][")}] should have ${e[0]} elements, but has ${s.length} elements`);
+  const n = e.slice(1);
+  for (let r = 0; r < s.length; ++r)
+    $e(s[r], n, t.concat(r));
+}
+function Se(s, e, t, n) {
+  if (s !== "string_or_numeric") {
+    if (s == null)
+      throw new Error("Expected dtype cannot be null.");
+    if (s !== "numeric" && s !== e || s === "numeric" && e === "string")
+      throw new Error(`Argument '${t}' passed to '${n}' must be ${s} tensor, but got ${e} tensor`);
+  }
+}
+function S(s, e, t, n = "numeric") {
+  if (s instanceof gt())
+    return Se(n, s.dtype, e, t), s;
+  let r = ue(s);
+  if (r !== "string" && ["bool", "int32", "float32"].indexOf(n) >= 0 && (r = n), Se(n, r, e, t), s == null || !D(s) && !Array.isArray(s) && typeof s != "number" && typeof s != "boolean" && typeof s != "string") {
+    const c = s == null ? "null" : s.constructor.name;
+    throw new Error(`Argument '${e}' passed to '${t}' must be a Tensor or TensorLike, but got '${c}'`);
+  }
+  const a = Et(s, r);
+  !D(s) && !Array.isArray(s) && (s = [s]);
+  const o = r !== "string" ? Fe(s, r) : De(s, [], !0);
+  return u.makeTensor(o, a, r);
+}
+function Tt(s, e, t, n = "numeric") {
+  if (!Array.isArray(s))
+    throw new Error(`Argument ${e} passed to ${t} must be a \`Tensor[]\` or \`TensorLike[]\``);
+  return s.map((a, i) => S(a, `${e}[${i}]`, t, n));
+}
+const At = "__op";
+function M(s) {
+  const e = Object.keys(s);
+  if (e.length !== 1)
+    throw new Error(`Please provide an object with a single key (operation name) mapping to a function. Got an object with ${e.length} keys.`);
+  let t = e[0];
+  const n = s[t];
+  t.endsWith("_") && (t = t.substring(0, t.length - 1)), t = t + At;
+  const r = (...a) => {
+    u.startScope(t);
+    try {
+      const i = n(...a);
+      return pt(i) && console.error("Cannot return a Promise inside of tidy."), u.endScope(i), i;
+    } catch (i) {
+      throw u.endScope(null), i;
+    }
+  };
+  return Object.defineProperty(r, "name", { value: t, configurable: !0 }), r;
+}
+function Mt(s, e, t, n) {
+  if (n == null)
+    n = ue(s);
+  else if (n === "complex64")
+    throw new Error("Cannot construct a complex64 tensor directly. Please use tf.complex(real, imag).");
+  if (xe(s) || Ne(s)) {
+    if (n !== "float32" && n !== "int32")
+      throw new Error(`Creating tensor from GPU data only supports 'float32'|'int32' dtype, while the dtype is ${n}.`);
+    return u.backend.createTensorFromGPUData(s, e || t, n);
+  }
+  if (!D(s) && !Array.isArray(s) && typeof s != "number" && typeof s != "boolean" && typeof s != "string")
+    throw new Error("values passed to tensor(values) must be a number/boolean/string or an array of numbers/booleans/strings, or a TypedArray");
+  if (e != null) {
+    he(e);
+    const r = Z(e), a = Z(t);
+    g(r === a, () => `Based on the provided shape, [${e}], the tensor should have ${r} values but has ${a}`);
+    for (let i = 0; i < t.length; ++i) {
+      const o = t[i], c = i === t.length - 1 ? o !== Z(e.slice(i)) : !0;
+      g(t[i] === e[i] || !c, () => `Error creating a new Tensor. Inferred shape (${t}) does not match the provided shape (${e}). `);
+    }
+  }
+  return !D(s) && !Array.isArray(s) && (s = [s]), e = e || t, s = n !== "string" ? Fe(s, n) : De(s, [], !0), u.makeTensor(s, e, n);
+}
+class H {
+  /**
+   * Concatenate a number of ArrayBuffers into one.
+   *
+   * @param buffers An array of ArrayBuffers to concatenate, or a single
+   *     ArrayBuffer.
+   * @returns Result of concatenating `buffers` in order.
+   */
+  static join(e) {
+    return new H(e).slice();
+  }
+  constructor(e) {
+    if (this.shards = [], this.previousShardIndex = 0, e == null || (e instanceof Array || (e = [e]), e = e.map((n) => D(n) ? n.buffer : n), e.length === 0))
+      return;
+    this.bufferUniformSize = e[0].byteLength;
+    let t = 0;
+    for (let n = 0; n < e.length; n++) {
+      const r = e[n];
+      n !== e.length - 1 && r.byteLength !== this.bufferUniformSize && (this.bufferUniformSize = void 0);
+      const a = t + r.byteLength;
+      this.shards.push({ buffer: r, start: t, end: a }), t = a;
+    }
+    this.shards.length === 0 && (this.byteLength = 0), this.byteLength = this.shards[this.shards.length - 1].end;
+  }
+  slice(e = 0, t = this.byteLength) {
+    if (this.shards.length === 0)
+      return new ArrayBuffer(0);
+    if (e = isNaN(Number(e)) ? 0 : e, t = isNaN(Number(t)) ? 0 : t, e = Math.max(0, e), t = Math.min(this.byteLength, t), t <= e)
+      return new ArrayBuffer(0);
+    const n = this.findShardForByte(e);
+    if (n === -1)
+      throw new Error(`Could not find start shard for byte ${e}`);
+    const r = t - e, a = new ArrayBuffer(r), i = new Uint8Array(a);
+    let o = 0;
+    for (let c = n; c < this.shards.length; c++) {
+      const l = this.shards[c], m = e + o - l.start, d = o, b = Math.min(t, l.end) - l.start, w = new Uint8Array(l.buffer, m, b - m);
+      if (i.set(w, d), o += w.length, t < l.end)
+        break;
+    }
+    return a;
+  }
+  /**
+   * Get the index of the shard that contains the byte at `byteIndex`.
+   */
+  findShardForByte(e) {
+    if (this.shards.length === 0 || e < 0 || e >= this.byteLength)
+      return -1;
+    if (this.bufferUniformSize != null)
+      return this.previousShardIndex = Math.floor(e / this.bufferUniformSize), this.previousShardIndex;
+    function t(r) {
+      return e < r.start ? -1 : e >= r.end ? 1 : 0;
+    }
+    if (t(this.shards[this.previousShardIndex]) === 0)
+      return this.previousShardIndex;
+    const n = Nt(this.shards, t);
+    return n === -1 ? -1 : (this.previousShardIndex = n, this.previousShardIndex);
+  }
+}
+function Nt(s, e) {
+  let t = 0, n = s.length;
+  for (; t <= n; ) {
+    const r = Math.floor((n - t) / 2) + t, a = e(s[r]);
+    if (a === 0)
+      return r;
+    a < 0 ? n = r : t = r + 1;
+  }
+  return -1;
+}
+function _n() {
+  u.disposeVariables();
+}
+function On() {
+  return u;
+}
+function Ln() {
+  return u.memory();
+}
+function k(s, e) {
+  return u.tidy(s, e);
+}
+function A(s) {
+  Te(s).forEach((t) => t.dispose());
+}
+function xt(s) {
+  return u.keep(s);
+}
+function zn(s) {
+  return u.setBackend(s);
+}
+function Pn() {
+  return u.ready();
+}
+function Un() {
+  return u.backendName;
+}
+function Gn(s, e, t = 1) {
+  return u.registerBackend(s, e, t);
+}
+function Wn() {
+  return u.backend;
+}
+const ke = 4;
+async function Kn(s, e) {
+  const t = [], n = [], r = Array.isArray(s) ? s.map((i) => i.name) : Object.keys(s);
+  for (let i = 0; i < r.length; ++i) {
+    const o = r[i], c = Array.isArray(s) ? s[i].tensor : s[o];
+    if (c.dtype !== "float32" && c.dtype !== "int32" && c.dtype !== "bool" && c.dtype !== "string" && c.dtype !== "complex64")
+      throw new Error(`Unsupported dtype in weight '${o}': ${c.dtype}`);
+    const l = { name: o, shape: c.shape, dtype: c.dtype };
+    if (c.dtype === "string") {
+      const h = new Promise(async (m) => {
+        const d = await c.bytes(), p = d.reduce((I, T) => I + T.length, 0) + ke * d.length, b = new Uint8Array(p);
+        let w = 0;
+        for (let I = 0; I < d.length; I++) {
+          const T = d[I], te = new Uint8Array(new Uint32Array([T.length]).buffer);
+          b.set(te, w), w += ke, b.set(T, w), w += T.length;
+        }
+        m(b);
+      });
+      n.push(h);
+    } else
+      n.push(c.data());
+    e != null && (l.group = e), t.push(l);
+  }
+  const a = await Promise.all(n);
+  return { data: Ft(a), specs: t };
+}
+function Ft(s) {
+  if (s === null)
+    throw new Error(`Invalid input value: ${JSON.stringify(s)}`);
+  let e = 0;
+  const t = [];
+  s.forEach((a) => {
+    if (e += a.byteLength, t.push(a.byteLength === a.buffer.byteLength ? a : new a.constructor(a)), !(a instanceof Float32Array || a instanceof Int32Array || a instanceof Uint8Array))
+      throw new Error(`Unsupported TypedArray subtype: ${a.constructor.name}`);
+  });
+  const n = new Uint8Array(e);
+  let r = 0;
+  return t.forEach((a) => {
+    n.set(new Uint8Array(a.buffer), r), r += a.byteLength;
+  }), n.buffer;
+}
+const de = typeof ee < "u" && (typeof Blob > "u" || typeof atob > "u" || typeof btoa > "u");
+function Ie(s) {
+  return de ? ee.byteLength(s, "utf8") : new Blob([s]).size;
+}
+function Dt(s) {
+  if (de)
+    return ee.from(s).toString("base64");
+  const e = new Uint8Array(s);
+  let t = "";
+  for (let n = 0, r = e.length; n < r; n++)
+    t += String.fromCharCode(e[n]);
+  return btoa(t);
+}
+function Ct(s) {
+  if (de) {
+    const n = ee.from(s, "base64");
+    return n.buffer.slice(n.byteOffset, n.byteOffset + n.byteLength);
+  }
+  const e = atob(s), t = new Uint8Array(e.length);
+  for (let n = 0; n < e.length; ++n)
+    t.set([e.charCodeAt(n)], n);
+  return t.buffer;
+}
+function jn(s) {
+  return H.join(s);
+}
+function qn(s, e) {
+  const t = {
+    modelTopology: s.modelTopology,
+    format: s.format,
+    generatedBy: s.generatedBy,
+    convertedBy: s.convertedBy,
+    weightsManifest: e
+  };
+  return s.signature != null && (t.signature = s.signature), s.userDefinedMetadata != null && (t.userDefinedMetadata = s.userDefinedMetadata), s.modelInitializer != null && (t.modelInitializer = s.modelInitializer), s.initializerSignature != null && (t.initializerSignature = s.initializerSignature), s.trainingConfig != null && (t.trainingConfig = s.trainingConfig), t;
+}
+function Rt(s, e, t) {
+  const n = {
+    modelTopology: s.modelTopology,
+    format: s.format,
+    generatedBy: s.generatedBy,
+    convertedBy: s.convertedBy
+  };
+  if (s.trainingConfig != null && (n.trainingConfig = s.trainingConfig), s.weightsManifest != null) {
+    if (!e)
+      throw new Error("modelJSON has weightsManifest but weightSpecs is null");
+    if (!t)
+      throw new Error("modelJSON has weightsManifest but weightData is null");
+    n.weightSpecs = e, n.weightData = t;
+  }
+  return s.signature != null && (n.signature = s.signature), s.userDefinedMetadata != null && (n.userDefinedMetadata = s.userDefinedMetadata), s.modelInitializer != null && (n.modelInitializer = s.modelInitializer), s.initializerSignature != null && (n.initializerSignature = s.initializerSignature), n;
+}
+async function Vn(s, e) {
+  let t, n;
+  return s.weightsManifest != null && ([t, n] = await e(s.weightsManifest)), Rt(s, t, n);
+}
+function _e(s) {
+  if (s.modelTopology instanceof ArrayBuffer)
+    throw new Error("Expected JSON model topology, received ArrayBuffer.");
+  return {
+    dateSaved: /* @__PURE__ */ new Date(),
+    modelTopologyType: "JSON",
+    modelTopologyBytes: s.modelTopology == null ? 0 : Ie(JSON.stringify(s.modelTopology)),
+    weightSpecsBytes: s.weightSpecs == null ? 0 : Ie(JSON.stringify(s.weightSpecs)),
+    weightDataBytes: s.weightData == null ? 0 : new H(s.weightData).byteLength
+  };
+}
+function Hn(s) {
+  const e = [];
+  for (const t of s)
+    e.push(...t.weights);
+  return e;
+}
+class v {
+  constructor() {
+    this.saveRouters = [], this.loadRouters = [];
+  }
+  static getInstance() {
+    return v.instance == null && (v.instance = new v()), v.instance;
+  }
+  /**
+   * Register a save-handler router.
+   *
+   * @param saveRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `save` method defined or `null`.
+   */
+  static registerSaveRouter(e) {
+    v.getInstance().saveRouters.push(e);
+  }
+  /**
+   * Register a load-handler router.
+   *
+   * @param loadRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `load` method defined or `null`.
+   */
+  static registerLoadRouter(e) {
+    v.getInstance().loadRouters.push(e);
+  }
+  /**
+   * Look up IOHandler for saving, given a URL-like string.
+   *
+   * @param url
+   * @returns If only one match is found, an instance of IOHandler with the
+   * `save` method defined. If no match is found, `null`.
+   * @throws Error, if more than one match is found.
+   */
+  static getSaveHandlers(e) {
+    return v.getHandlers(e, "save");
+  }
+  /**
+   * Look up IOHandler for loading, given a URL-like string.
+   *
+   * @param url
+   * @param loadOptions Optional, custom load options.
+   * @returns All valid handlers for `url`, given the currently registered
+   *   handler routers.
+   */
+  static getLoadHandlers(e, t) {
+    return v.getHandlers(e, "load", t);
+  }
+  static getHandlers(e, t, n) {
+    const r = [];
+    return (t === "load" ? v.getInstance().loadRouters : v.getInstance().saveRouters).forEach((i) => {
+      const o = i(e, n);
+      o !== null && r.push(o);
+    }), r;
+  }
+}
+const Xn = (s) => v.getSaveHandlers(s);
+const ie = "tensorflowjs", oe = 1, O = "models_store", $ = "model_info_store";
+function Oe() {
+  if (!B().getBool("IS_BROWSER"))
+    throw new Error("Failed to obtain IndexedDB factory because the current environmentis not a web browser.");
+  const s = typeof window > "u" ? self : window, e = s.indexedDB || s.mozIndexedDB || s.webkitIndexedDB || s.msIndexedDB || s.shimIndexedDB;
+  if (e == null)
+    throw new Error("The current browser does not appear to support IndexedDB.");
+  return e;
+}
+function ce(s) {
+  const e = s.result;
+  e.createObjectStore(O, { keyPath: "modelPath" }), e.createObjectStore($, { keyPath: "modelPath" });
+}
+class z {
+  constructor(e) {
+    if (this.indexedDB = Oe(), e == null || !e)
+      throw new Error("For IndexedDB, modelPath must not be null, undefined or empty.");
+    this.modelPath = e;
+  }
+  async save(e) {
+    if (e.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserLocalStorage.save() does not support saving model topology in binary formats yet.");
+    return this.databaseAction(this.modelPath, e);
+  }
+  async load() {
+    return this.databaseAction(this.modelPath);
+  }
+  /**
+   * Perform database action to put model artifacts into or read model artifacts
+   * from IndexedDB object store.
+   *
+   * Whether the action is put or get depends on whether `modelArtifacts` is
+   * specified. If it is specified, the action will be put; otherwise the action
+   * will be get.
+   *
+   * @param modelPath A unique string path for the model.
+   * @param modelArtifacts If specified, it will be the model artifacts to be
+   *   stored in IndexedDB.
+   * @returns A `Promise` of `SaveResult`, if the action is put, or a `Promise`
+   *   of `ModelArtifacts`, if the action is get.
+   */
+  databaseAction(e, t) {
+    return new Promise((n, r) => {
+      const a = this.indexedDB.open(ie, oe);
+      a.onupgradeneeded = () => ce(a), a.onsuccess = () => {
+        const i = a.result;
+        if (t == null) {
+          const o = i.transaction(O, "readonly"), l = o.objectStore(O).get(this.modelPath);
+          l.onsuccess = () => {
+            if (l.result == null)
+              return i.close(), r(new Error(`Cannot find model with path '${this.modelPath}' in IndexedDB.`));
+            n(l.result.modelArtifacts);
+          }, l.onerror = (h) => (i.close(), r(l.error)), o.oncomplete = () => i.close();
+        } else {
+          t.weightData = H.join(t.weightData);
+          const o = _e(t), c = i.transaction($, "readwrite");
+          let l = c.objectStore($), h;
+          try {
+            h = l.put({ modelPath: this.modelPath, modelArtifactsInfo: o });
+          } catch (d) {
+            return r(d);
+          }
+          let m;
+          h.onsuccess = () => {
+            m = i.transaction(O, "readwrite");
+            const d = m.objectStore(O);
+            let p;
+            try {
+              p = d.put({
+                modelPath: this.modelPath,
+                modelArtifacts: t,
+                modelArtifactsInfo: o
+              });
+            } catch (b) {
+              return r(b);
+            }
+            p.onsuccess = () => n({ modelArtifactsInfo: o }), p.onerror = (b) => {
+              l = c.objectStore($);
+              const w = l.delete(this.modelPath);
+              w.onsuccess = () => (i.close(), r(p.error)), w.onerror = (I) => (i.close(), r(p.error));
+            };
+          }, h.onerror = (d) => (i.close(), r(h.error)), c.oncomplete = () => {
+            m == null ? i.close() : m.oncomplete = () => i.close();
+          };
+        }
+      }, a.onerror = (i) => r(a.error);
+    });
+  }
+}
+z.URL_SCHEME = "indexeddb://";
+const Le = (s) => B().getBool("IS_BROWSER") && !Array.isArray(s) && s.startsWith(z.URL_SCHEME) ? $t(s.slice(z.URL_SCHEME.length)) : null;
+v.registerSaveRouter(Le);
+v.registerLoadRouter(Le);
+function $t(s) {
+  return new z(s);
+}
+function _t(s) {
+  return s.startsWith(z.URL_SCHEME) ? s.slice(z.URL_SCHEME.length) : s;
+}
+class Ot {
+  constructor() {
+    this.indexedDB = Oe();
+  }
+  async listModels() {
+    return new Promise((e, t) => {
+      const n = this.indexedDB.open(ie, oe);
+      n.onupgradeneeded = () => ce(n), n.onsuccess = () => {
+        const r = n.result, a = r.transaction($, "readonly"), o = a.objectStore($).getAll();
+        o.onsuccess = () => {
+          const c = {};
+          for (const l of o.result)
+            c[l.modelPath] = l.modelArtifactsInfo;
+          e(c);
+        }, o.onerror = (c) => (r.close(), t(o.error)), a.oncomplete = () => r.close();
+      }, n.onerror = (r) => t(n.error);
+    });
+  }
+  async removeModel(e) {
+    return e = _t(e), new Promise((t, n) => {
+      const r = this.indexedDB.open(ie, oe);
+      r.onupgradeneeded = () => ce(r), r.onsuccess = () => {
+        const a = r.result, i = a.transaction($, "readwrite"), o = i.objectStore($), c = o.get(e);
+        let l;
+        c.onsuccess = () => {
+          if (c.result == null)
+            return a.close(), n(new Error(`Cannot find model with path '${e}' in IndexedDB.`));
+          {
+            const h = o.delete(e), m = () => {
+              l = a.transaction(O, "readwrite");
+              const p = l.objectStore(O).delete(e);
+              p.onsuccess = () => t(c.result.modelArtifactsInfo), p.onerror = (b) => n(c.error);
+            };
+            h.onsuccess = m, h.onerror = (d) => (m(), a.close(), n(c.error));
+          }
+        }, c.onerror = (h) => (a.close(), n(c.error)), i.oncomplete = () => {
+          l == null ? a.close() : l.oncomplete = () => a.close();
+        };
+      }, r.onerror = (a) => n(r.error);
+    });
+  }
+}
+const C = "/", K = "tensorflowjs_models", ze = "info", Lt = "model_topology", zt = "weight_specs", Pt = "weight_data", Ut = "model_metadata";
+function Pe(s) {
+  return {
+    info: [K, s, ze].join(C),
+    topology: [K, s, Lt].join(C),
+    weightSpecs: [K, s, zt].join(C),
+    weightData: [K, s, Pt].join(C),
+    modelMetadata: [K, s, Ut].join(C)
+  };
+}
+function Ue(s) {
+  for (const e of Object.values(s))
+    window.localStorage.removeItem(e);
+}
+function Gt(s) {
+  const e = s.split(C);
+  if (e.length < 3)
+    throw new Error(`Invalid key format: ${s}`);
+  return e.slice(1, e.length - 1).join(C);
+}
+function Wt(s) {
+  return s.startsWith(P.URL_SCHEME) ? s.slice(P.URL_SCHEME.length) : s;
+}
+class P {
+  constructor(e) {
+    if (!B().getBool("IS_BROWSER") || typeof window > "u" || typeof window.localStorage > "u")
+      throw new Error("The current environment does not support local storage.");
+    if (this.LS = window.localStorage, e == null || !e)
+      throw new Error("For local storage, modelPath must not be null, undefined or empty.");
+    this.modelPath = e, this.keys = Pe(this.modelPath);
+  }
+  /**
+   * Save model artifacts to browser local storage.
+   *
+   * See the documentation to `browserLocalStorage` for details on the saved
+   * artifacts.
+   *
+   * @param modelArtifacts The model artifacts to be stored.
+   * @returns An instance of SaveResult.
+   */
+  async save(e) {
+    if (e.modelTopology instanceof ArrayBuffer)
+      throw new Error("BrowserLocalStorage.save() does not support saving model topology in binary formats yet.");
+    {
+      const t = JSON.stringify(e.modelTopology), n = JSON.stringify(e.weightSpecs), r = _e(e), a = H.join(e.weightData);
+      try {
+        this.LS.setItem(this.keys.info, JSON.stringify(r)), this.LS.setItem(this.keys.topology, t), this.LS.setItem(this.keys.weightSpecs, n), this.LS.setItem(this.keys.weightData, Dt(a));
+        const i = {
+          format: e.format,
+          generatedBy: e.generatedBy,
+          convertedBy: e.convertedBy,
+          signature: e.signature != null ? e.signature : void 0,
+          userDefinedMetadata: e.userDefinedMetadata != null ? e.userDefinedMetadata : void 0,
+          modelInitializer: e.modelInitializer != null ? e.modelInitializer : void 0,
+          initializerSignature: e.initializerSignature != null ? e.initializerSignature : void 0,
+          trainingConfig: e.trainingConfig != null ? e.trainingConfig : void 0
+        };
+        return this.LS.setItem(this.keys.modelMetadata, JSON.stringify(i)), { modelArtifactsInfo: r };
+      } catch {
+        throw Ue(this.keys), new Error(`Failed to save model '${this.modelPath}' to local storage: size quota being exceeded is a possible cause of this failure: modelTopologyBytes=${r.modelTopologyBytes}, weightSpecsBytes=${r.weightSpecsBytes}, weightDataBytes=${r.weightDataBytes}.`);
+      }
+    }
+  }
+  /**
+   * Load a model from local storage.
+   *
+   * See the documentation to `browserLocalStorage` for details on the saved
+   * artifacts.
+   *
+   * @returns The loaded model (if loading succeeds).
+   */
+  async load() {
+    const e = JSON.parse(this.LS.getItem(this.keys.info));
+    if (e == null)
+      throw new Error(`In local storage, there is no model with name '${this.modelPath}'`);
+    if (e.modelTopologyType !== "JSON")
+      throw new Error("BrowserLocalStorage does not support loading non-JSON model topology yet.");
+    const t = {}, n = JSON.parse(this.LS.getItem(this.keys.topology));
+    if (n == null)
+      throw new Error(`In local storage, the topology of model '${this.modelPath}' is missing.`);
+    t.modelTopology = n;
+    const r = JSON.parse(this.LS.getItem(this.keys.weightSpecs));
+    if (r == null)
+      throw new Error(`In local storage, the weight specs of model '${this.modelPath}' are missing.`);
+    t.weightSpecs = r;
+    const a = this.LS.getItem(this.keys.modelMetadata);
+    if (a != null) {
+      const o = JSON.parse(a);
+      t.format = o.format, t.generatedBy = o.generatedBy, t.convertedBy = o.convertedBy, o.signature != null && (t.signature = o.signature), o.userDefinedMetadata != null && (t.userDefinedMetadata = o.userDefinedMetadata), o.modelInitializer != null && (t.modelInitializer = o.modelInitializer), o.initializerSignature != null && (t.initializerSignature = o.initializerSignature), o.trainingConfig != null && (t.trainingConfig = o.trainingConfig);
+    }
+    const i = this.LS.getItem(this.keys.weightData);
+    if (i == null)
+      throw new Error(`In local storage, the binary weight values of model '${this.modelPath}' are missing.`);
+    return t.weightData = Ct(i), t;
+  }
+}
+P.URL_SCHEME = "localstorage://";
+const Ge = (s) => B().getBool("IS_BROWSER") && !Array.isArray(s) && s.startsWith(P.URL_SCHEME) ? Kt(s.slice(P.URL_SCHEME.length)) : null;
+v.registerSaveRouter(Ge);
+v.registerLoadRouter(Ge);
+function Kt(s) {
+  return new P(s);
+}
+class jt {
+  constructor() {
+    g(B().getBool("IS_BROWSER"), () => "Current environment is not a web browser"), g(typeof window > "u" || typeof window.localStorage < "u", () => "Current browser does not appear to support localStorage"), this.LS = window.localStorage;
+  }
+  async listModels() {
+    const e = {}, t = K + C, n = C + ze;
+    for (let r = 0; r < this.LS.length; ++r) {
+      const a = this.LS.key(r);
+      if (a.startsWith(t) && a.endsWith(n)) {
+        const i = Gt(a);
+        e[i] = JSON.parse(this.LS.getItem(a));
+      }
+    }
+    return e;
+  }
+  async removeModel(e) {
+    e = Wt(e);
+    const t = Pe(e);
+    if (this.LS.getItem(t.info) == null)
+      throw new Error(`Cannot find model at path '${e}'`);
+    const n = JSON.parse(this.LS.getItem(t.info));
+    return Ue(t), n;
+  }
+}
+const ve = "://";
+class N {
+  constructor() {
+    this.managers = {};
+  }
+  static getInstance() {
+    return N.instance == null && (N.instance = new N()), N.instance;
+  }
+  /**
+   * Register a save-handler router.
+   *
+   * @param saveRouter A function that maps a URL-like string onto an instance
+   * of `IOHandler` with the `save` method defined or `null`.
+   */
+  static registerManager(e, t) {
+    g(e != null, () => "scheme must not be undefined or null."), e.endsWith(ve) && (e = e.slice(0, e.indexOf(ve))), g(e.length > 0, () => "scheme must not be an empty string.");
+    const n = N.getInstance();
+    g(n.managers[e] == null, () => `A model store manager is already registered for scheme '${e}'.`), n.managers[e] = t;
+  }
+  static getManager(e) {
+    const t = N.getInstance().managers[e];
+    if (t == null)
+      throw new Error(`Cannot find model manager for scheme '${e}'`);
+    return t;
+  }
+  static getSchemes() {
+    return Object.keys(N.getInstance().managers);
+  }
+}
+class qt {
+  constructor() {
+    this.messageName = "setTimeoutCustom", this.functionRefs = [], this.handledMessageCount = 0, this.hasEventListener = !1;
+  }
+  fetch(e, t) {
+    return fetch(e, t);
+  }
+  now() {
+    return performance.now();
+  }
+  encode(e, t) {
+    if (t !== "utf-8" && t !== "utf8")
+      throw new Error(`Browser's encoder only supports utf-8, but got ${t}`);
+    return this.textEncoder == null && (this.textEncoder = new TextEncoder()), this.textEncoder.encode(e);
+  }
+  decode(e, t) {
+    return new TextDecoder(t).decode(e);
+  }
+  // If the setTimeout nesting level is greater than 5 and timeout is less
+  // than 4ms, timeout will be clamped to 4ms, which hurts the perf.
+  // Interleaving window.postMessage and setTimeout will trick the browser and
+  // avoid the clamp.
+  setTimeoutCustom(e, t) {
+    if (typeof window > "u" || !B().getBool("USE_SETTIMEOUTCUSTOM")) {
+      setTimeout(e, t);
+      return;
+    }
+    this.functionRefs.push(e), setTimeout(() => {
+      window.postMessage({ name: this.messageName, index: this.functionRefs.length - 1 }, "*");
+    }, t), this.hasEventListener || (this.hasEventListener = !0, window.addEventListener("message", (n) => {
+      if (n.source === window && n.data.name === this.messageName) {
+        n.stopPropagation();
+        const r = this.functionRefs[n.data.index];
+        r(), this.handledMessageCount++, this.handledMessageCount === this.functionRefs.length && (this.functionRefs = [], this.handledMessageCount = 0);
+      }
+    }, !0));
+  }
+  isTypedArray(e) {
+    return yt(e);
+  }
+}
+if (B().get("IS_BROWSER")) {
+  B().setPlatform("browser", new qt());
+  try {
+    N.registerManager(P.URL_SCHEME, new jt());
+  } catch {
+  }
+  try {
+    N.registerManager(z.URL_SCHEME, new Ot());
+  } catch {
+  }
+}
+const Vt = {
+  // tslint:disable-next-line:no-require-imports
+  importFetch: () => require("node-fetch")
+};
+let se;
+class Ht {
+  constructor() {
+    this.util = require("util"), this.textEncoder = new this.util.TextEncoder();
+  }
+  fetch(e, t) {
+    return B().global.fetch != null ? B().global.fetch(e, t) : (se == null && (se = Vt.importFetch()), se(e, t));
+  }
+  now() {
+    const e = Q.hrtime();
+    return e[0] * 1e3 + e[1] / 1e6;
+  }
+  encode(e, t) {
+    if (t !== "utf-8" && t !== "utf8")
+      throw new Error(`Node built-in encoder only supports utf-8, but got ${t}`);
+    return this.textEncoder.encode(e);
+  }
+  decode(e, t) {
+    return e.length === 0 ? "" : new this.util.TextDecoder(t).decode(e);
+  }
+  isTypedArray(e) {
+    return this.util.types.isFloat32Array(e) || this.util.types.isInt32Array(e) || this.util.types.isUint8Array(e) || this.util.types.isUint8ClampedArray(e);
+  }
+}
+B().get("IS_NODE") && !B().get("IS_BROWSER") && B().setPlatform("node", new Ht());
+function Xt(s, e = "float32", t) {
+  return e = e || "float32", he(s), new bt(s, e, t);
+}
+function Jt(s, e) {
+  const t = S(s, "x", "cast");
+  if (!wt(e))
+    throw new Error(`Failed to cast to unknown dtype ${e}`);
+  if (e === "string" && t.dtype !== "string" || e !== "string" && t.dtype === "string")
+    throw new Error("Only strings can be casted to strings");
+  const n = { x: t }, r = { dtype: e };
+  return u.runKernel(Ae, n, r);
+}
+const le = /* @__PURE__ */ M({ cast_: Jt });
+function Yt(s) {
+  const t = { x: S(s, "x", "clone", "string_or_numeric") };
+  return u.runKernel(Ee, t);
+}
+const Zt = /* @__PURE__ */ M({ clone_: Yt });
+function Qt(s, e = !1) {
+  console.log(s.toString(e));
+}
+Re();
+const en = {
+  buffer: Xt,
+  cast: le,
+  clone: Zt,
+  print: Qt
+};
+St(en);
+function tn(s, e) {
+  let t = S(s, "a", "add"), n = S(e, "b", "add");
+  [t, n] = G(t, n);
+  const r = { a: t, b: n };
+  return u.runKernel(Me, r);
+}
+const y = /* @__PURE__ */ M({ add_: tn });
+function nn(s, e) {
+  let t = S(s, "a", "floorDiv"), n = S(e, "b", "floorDiv");
+  [t, n] = G(t, n);
+  const r = { a: t, b: n };
+  return u.runKernel(Xe, r);
+}
+const sn = /* @__PURE__ */ M({ floorDiv_: nn });
+function rn(s, e) {
+  let t = S(s, "a", "div"), n = S(e, "b", "div");
+  if ([t, n] = G(t, n), t.dtype === "int32" && n.dtype === "int32")
+    return sn(t, n);
+  const r = { a: t, b: n }, a = {};
+  return u.runKernel(Je, r, a);
+}
+const x = /* @__PURE__ */ M({ div_: rn });
+function an(s, e) {
+  let t = S(s, "a", "mul"), n = S(e, "b", "mul");
+  [t, n] = G(t, n);
+  const r = { a: t, b: n };
+  return u.runKernel(Ye, r);
+}
+const f = /* @__PURE__ */ M({ mul_: an });
+function on(s) {
+  const e = S(s, "x", "abs");
+  if (e.dtype === "complex64") {
+    const t = { x: e };
+    return u.runKernel(Ze, t);
+  } else {
+    const t = { x: e };
+    return u.runKernel(Qe, t);
+  }
+}
+const cn = /* @__PURE__ */ M({ abs_: on });
+function ln(s, e, t) {
+  he(s), t = t || ue(e);
+  const n = { shape: s, value: e, dtype: t };
+  return u.runKernel(et, {}, n);
+}
+function Jn(s, e) {
+  const t = s.length, n = [];
+  for (let r = 0; r < t; r++) {
+    const a = t - 1 - r, i = s[a] || 1;
+    (e[e.length - 1 - r] || 1) > 1 && i === 1 && n.unshift(a);
+  }
+  return n;
+}
+function Yn(s, e) {
+  const t = [];
+  for (let n = 0; n < e.length; n++) {
+    const r = s[s.length - n - 1], a = e.length - n - 1, i = e[a];
+    (r == null || r === 1 && i > 1) && t.unshift(a);
+  }
+  return t;
+}
+function un(s, e) {
+  const t = Math.max(s.length, e.length), n = new Array(t);
+  for (let r = 0; r < t; r++) {
+    let a = s[s.length - r - 1];
+    a == null && (a = 1);
+    let i = e[e.length - r - 1];
+    if (i == null && (i = 1), a === 1)
+      n[t - r - 1] = i;
+    else if (i === 1)
+      n[t - r - 1] = a;
+    else if (a !== i) {
+      const o = `Operands could not be broadcast together with shapes ${s} and ${e}.`;
+      throw Error(o);
+    } else
+      n[t - r - 1] = a;
+  }
+  return n;
+}
+function hn(s) {
+  const t = { x: S(s, "x", "zerosLike") };
+  return u.runKernel(tt, t);
+}
+const F = /* @__PURE__ */ M({ zerosLike_: hn });
+function dn(s, e) {
+  let t = S(s, "base", "pow"), n = S(e, "exp", "pow");
+  [t, n] = G(t, n);
+  const r = { a: t, b: n };
+  return u.runKernel(nt, r);
+}
+const Be = /* @__PURE__ */ M({ pow_: dn });
+function U(s, e) {
+  if ((D(s) && e !== "string" || Array.isArray(s)) && e !== "complex64")
+    throw new Error("Error creating a new Scalar: value must be a primitive (number|boolean|string)");
+  if (e === "string" && D(s) && !(s instanceof Uint8Array))
+    throw new Error("When making a scalar from encoded string, the value must be `Uint8Array`.");
+  return Mt(s, [], [], e);
+}
+function fn(s) {
+  const t = { x: S(s, "x", "sqrt", "float32") };
+  return u.runKernel(st, t);
+}
+const V = /* @__PURE__ */ M({ sqrt_: fn });
+function mn(s) {
+  const e = S(s, "x", "square"), t = {};
+  return u.runKernel("Square", { x: e }, t);
+}
+const L = /* @__PURE__ */ M({ square_: mn });
+function Zn(s) {
+  return g(Y(s), () => "The f passed in grads(f) must be a function"), (e, t) => {
+    g(Array.isArray(e), () => "The args passed in grads(f)(args) must be an array of `Tensor`s or `TensorLike`s");
+    const n = Tt(e, "args", "tf.grads", "string_or_numeric"), r = t != null ? S(t, "dy", "tf.grads") : null;
+    return u.tidy(() => {
+      const { value: a, grads: i } = u.gradients(() => s(...n), n, r);
+      return r != null && Ce(a.shape, r.shape, "The shape of dy passed in grads(f)([x1,...], dy) must match the shape returned by f([x1,...])"), We(i), i;
+    });
+  };
+}
+function Qn(s) {
+  return g(Y(s), () => "The f passed in valueAndGrads(f) must be a function"), (e, t) => {
+    g(Array.isArray(e) && e.every((r) => r instanceof R), () => "The args passed in valueAndGrads(f)(args) must be array of tensors"), g(t == null || t instanceof R, () => "The dy passed in valueAndGrads(f)(args, dy) must be a tensor");
+    const n = u.gradients(() => s(...e), e, t);
+    return t != null && Ce(n.value.shape, t.shape, "The shape of dy passed in valueAndGrads(f)([x1,...], dy) must match the shape returned by f([x1,...])"), We(n.grads), n;
+  };
+}
+function gn(s, e) {
+  g(Y(s), () => "The f passed in variableGrads(f) must be a function"), g(e == null || Array.isArray(e) && e.every((l) => l instanceof re), () => "The varList passed in variableGrads(f, varList) must be an array of variables");
+  const t = e != null;
+  if (!t) {
+    e = [];
+    for (const l in u.registeredVariables)
+      e.push(u.registeredVariables[l]);
+  }
+  const n = t ? e.filter((l) => !l.trainable) : null, r = e.length;
+  e = e.filter((l) => l.trainable), g(e.length > 0, () => `variableGrads() expects at least one of the input variables to be trainable, but none of the ${r} variables is trainable.`);
+  const a = !0, { value: i, grads: o } = u.gradients(s, e, null, a);
+  g(o.some((l) => l != null), () => "Cannot find a connection between any variable and the result of the loss function y=f(x). Please make sure the operations that use variables are inside the function f passed to minimize()."), g(i.rank === 0, () => `The f passed in variableGrads(f) must return a scalar, but it returned a rank-${i.rank} tensor`);
+  const c = {};
+  return e.forEach((l, h) => {
+    o[h] != null && (c[l.name] = o[h]);
+  }), n?.forEach((l) => c[l.name] = null), { value: i, grads: c };
+}
+function es(s) {
+  return u.customGrad(s);
+}
+function We(s) {
+  if (s.filter((t) => t == null).length > 0)
+    throw new Error(`Cannot compute gradient of y=f(x) with respect to x. Make sure that
+    the f you passed encloses all operations that lead from x to y.`);
+}
+function pn(s, e) {
+  let t = S(s, "a", "sub"), n = S(e, "b", "sub");
+  [t, n] = G(t, n);
+  const r = { a: t, b: n };
+  return u.runKernel(rt, r);
+}
+const j = /* @__PURE__ */ M({ sub_: pn });
+function yn(s, e) {
+  let t = S(s, "a", "maximum"), n = S(e, "b", "maximum");
+  [t, n] = G(t, n), t.dtype === "bool" && (t = le(t, "int32"), n = le(n, "int32")), un(t.shape, n.shape);
+  const r = { a: t, b: n };
+  return u.runKernel(at, r);
+}
+const bn = /* @__PURE__ */ M({ maximum_: yn });
+const wn = /* @__PURE__ */ new Map(), Sn = /* @__PURE__ */ new Map();
+class kn {
+  /**
+   * Return the class name for this class to use in serialization contexts.
+   *
+   * Generally speaking this will be the same thing that constructor.name
+   * would have returned.  However, the class name needs to be robust
+   * against minification for serialization/deserialization to work properly.
+   *
+   * There's also places such as initializers.VarianceScaling, where
+   * implementation details between different languages led to different
+   * class hierarchies and a non-leaf node is used for serialization purposes.
+   */
+  getClassName() {
+    return this.constructor.className;
+  }
+  /**
+   * Creates an instance of T from a ConfigDict.
+   *
+   * This works for most descendants of serializable.  A few need to
+   * provide special handling.
+   * @param cls A Constructor for the class to instantiate.
+   * @param config The Configuration for the object.
+   */
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t);
+  }
+}
+class _ {
+  constructor() {
+    this.classNameMap = {};
+  }
+  /**
+   * Returns the singleton instance of the map.
+   */
+  static getMap() {
+    return _.instance == null && (_.instance = new _()), _.instance;
+  }
+  /**
+   * Registers the class as serializable.
+   */
+  static register(e) {
+    _.getMap().classNameMap[e.className] = [e, e.fromConfig];
+  }
+}
+function In(s, e, t) {
+  g(s.className != null, () => "Class being registered does not have the static className property defined."), g(typeof s.className == "string", () => "className is required to be a string, but got type " + typeof s.className), g(s.className.length > 0, () => "Class being registered has an empty-string as its className, which is disallowed."), typeof e > "u" && (e = "Custom"), typeof t > "u" && (t = s.className);
+  const n = t, r = e + ">" + n;
+  return _.register(s), wn.set(r, s), Sn.set(s, r), s;
+}
+class W extends kn {
+  /**
+   * Executes `f()` and minimizes the scalar output of `f()` by computing
+   * gradients of y with respect to the list of trainable variables provided by
+   * `varList`. If no list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to minimize.
+   * @param returnCost Whether to return the scalar cost value produced by
+   * executing `f()`.
+   * @param varList An optional list of variables to update. If specified, only
+   * the trainable variables in varList will be updated by minimize. Defaults to
+   * all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  minimize(e, t = !1, n) {
+    const { value: r, grads: a } = this.computeGradients(e, n);
+    if (n != null) {
+      const i = n.map((o) => ({ name: o.name, tensor: a[o.name] }));
+      this.applyGradients(i);
+    } else
+      this.applyGradients(a);
+    return A(a), t ? r : (r.dispose(), null);
+  }
+  /**
+   * The number of iterations that this optimizer instance has been invoked for.
+   */
+  get iterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), this.iterations_;
+  }
+  incrementIterations() {
+    this.iterations_ = this.iterations + 1;
+  }
+  /**
+   * Executes f() and computes the gradient of the scalar output of f() with
+   * respect to the list of trainable variables provided by `varList`. If no
+   * list is provided, it defaults to all trainable variables.
+   *
+   * @param f The function to execute and whose output to use for computing
+   * gradients with respect to variables.
+   * @param varList An optional list of variables to compute gradients with
+   * respect to. If specified, only the trainable variables in varList will have
+   * gradients computed with respect to. Defaults to all trainable variables.
+   *
+   * @doc {heading: 'Training', subheading: 'Optimizers'}
+   */
+  computeGradients(e, t) {
+    return gn(e, t);
+  }
+  /**
+   * Dispose the variables (if any) owned by this optimizer instance.
+   */
+  dispose() {
+    this.iterations_ != null && A(this.iterations_);
+  }
+  async saveIterations() {
+    return this.iterations_ == null && (this.iterations_ = 0), {
+      name: "iter",
+      // TODO(cais): Use 'int64' type when available.
+      tensor: U(this.iterations_, "int32")
+    };
+  }
+  async getWeights() {
+    throw new Error("getWeights() is not implemented for this optimizer yet.");
+  }
+  async setWeights(e) {
+    throw new Error(`setWeights() is not implemented for this optimizer class ${this.getClassName()}`);
+  }
+  /**
+   * Extract the first element of the weight values and set it
+   * as the iterations counter variable of this instance of optimizer.
+   *
+   * @param weightValues
+   * @returns Weight values with the first element consumed and excluded.
+   */
+  async extractIterations(e) {
+    return this.iterations_ = (await e[0].tensor.data())[0], e.slice(1);
+  }
+}
+Object.defineProperty(W, Symbol.hasInstance, {
+  value: (s) => s.minimize != null && s.computeGradients != null && s.applyGradients != null
+});
+class vn extends W {
+  /** @nocollapse */
+  static get className() {
+    return "Adadelta";
+  }
+  constructor(e, t, n = null) {
+    super(), this.learningRate = e, this.rho = t, this.epsilon = n, this.accumulatedGrads = [], this.accumulatedUpdates = [], n == null && (this.epsilon = u.backend.epsilon());
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e)).forEach((n, r) => {
+      const a = u.registeredVariables[n], i = !1;
+      this.accumulatedGrads[r] == null && (this.accumulatedGrads[r] = {
+        originalName: `${n}/accum_grad`,
+        variable: k(() => F(a).variable(i))
+      }), this.accumulatedUpdates[r] == null && (this.accumulatedUpdates[r] = {
+        originalName: `${n}/accum_var`,
+        variable: k(() => F(a).variable(i))
+      });
+      const o = Array.isArray(e) ? e[r].tensor : e[n];
+      if (o == null)
+        return;
+      const c = this.accumulatedGrads[r].variable, l = this.accumulatedUpdates[r].variable;
+      k(() => {
+        const h = y(f(c, this.rho), f(L(o), 1 - this.rho)), m = f(x(V(y(l, this.epsilon)), V(y(c, this.epsilon))), o), d = y(f(l, this.rho), f(L(m), 1 - this.rho));
+        c.assign(h), l.assign(d);
+        const p = y(f(m, -this.learningRate), a);
+        a.assign(p);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedUpdates != null && (A(this.accumulatedGrads.map((e) => e.variable)), A(this.accumulatedUpdates.map((e) => e.variable)));
+  }
+  async getWeights() {
+    const e = [...this.accumulatedGrads, ...this.accumulatedUpdates];
+    return [await this.saveIterations()].concat(e.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e);
+    const t = e.length / 2, n = !1;
+    this.accumulatedGrads = e.slice(0, t).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    })), this.accumulatedUpdates = e.slice(t, t * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      rho: this.rho,
+      epsilon: this.epsilon
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.rho, t.epsilon);
+  }
+}
+class Bn extends W {
+  /** @nocollapse */
+  static get className() {
+    return "Adagrad";
+  }
+  constructor(e, t = 0.1) {
+    super(), this.learningRate = e, this.initialAccumulatorValue = t, this.accumulatedGrads = [];
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e)).forEach((n, r) => {
+      const a = u.registeredVariables[n];
+      this.accumulatedGrads[r] == null && (this.accumulatedGrads[r] = {
+        originalName: `${n}/accumulator`,
+        variable: k(() => ln(a.shape, this.initialAccumulatorValue).variable(!1))
+      });
+      const i = Array.isArray(e) ? e[r].tensor : e[n];
+      if (i == null)
+        return;
+      const o = this.accumulatedGrads[r].variable;
+      k(() => {
+        const c = y(o, L(i));
+        o.assign(c);
+        const l = y(f(x(i, V(y(c, u.backend.epsilon()))), -this.learningRate), a);
+        a.assign(l);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedGrads != null && A(this.accumulatedGrads.map((e) => e.variable));
+  }
+  async getWeights() {
+    return [await this.saveIterations()].concat(this.accumulatedGrads.map((e) => ({ name: e.originalName, tensor: e.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e);
+    const t = !1;
+    this.accumulatedGrads = e.map((n) => ({ originalName: n.name, variable: n.tensor.variable(t) }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      initialAccumulatorValue: this.initialAccumulatorValue
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.initialAccumulatorValue);
+  }
+}
+class En extends W {
+  /** @nocollapse */
+  static get className() {
+    return "Adam";
+  }
+  constructor(e, t, n, r = null) {
+    super(), this.learningRate = e, this.beta1 = t, this.beta2 = n, this.epsilon = r, this.accumulatedFirstMoment = [], this.accumulatedSecondMoment = [], k(() => {
+      this.accBeta1 = U(t).variable(), this.accBeta2 = U(n).variable();
+    }), r == null && (this.epsilon = u.backend.epsilon());
+  }
+  applyGradients(e) {
+    const t = Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e);
+    k(() => {
+      const n = j(1, this.accBeta1), r = j(1, this.accBeta2);
+      t.forEach((a, i) => {
+        const o = u.registeredVariables[a], c = !1;
+        this.accumulatedFirstMoment[i] == null && (this.accumulatedFirstMoment[i] = {
+          originalName: `${a}/m`,
+          variable: k(() => F(o).variable(c))
+        }), this.accumulatedSecondMoment[i] == null && (this.accumulatedSecondMoment[i] = {
+          originalName: `${a}/v`,
+          variable: k(() => F(o).variable(c))
+        });
+        const l = Array.isArray(e) ? e[i].tensor : e[a];
+        if (l == null)
+          return;
+        const h = this.accumulatedFirstMoment[i].variable, m = this.accumulatedSecondMoment[i].variable, d = y(f(h, this.beta1), f(l, 1 - this.beta1)), p = y(f(m, this.beta2), f(L(l), 1 - this.beta2)), b = x(d, n), w = x(p, r);
+        h.assign(d), m.assign(p);
+        const I = y(f(x(b, y(V(w), this.epsilon)), -this.learningRate), o);
+        o.assign(I);
+      }), this.accBeta1.assign(f(this.accBeta1, this.beta1)), this.accBeta2.assign(f(this.accBeta2, this.beta2));
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accBeta1.dispose(), this.accBeta2.dispose(), this.accumulatedFirstMoment != null && A(this.accumulatedFirstMoment.map((e) => e.variable)), this.accumulatedSecondMoment != null && A(this.accumulatedSecondMoment.map((e) => e.variable));
+  }
+  async getWeights() {
+    const e = [...this.accumulatedFirstMoment, ...this.accumulatedSecondMoment];
+    return [await this.saveIterations()].concat(e.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e), k(() => {
+      this.accBeta1.assign(Be(this.beta1, this.iterations_ + 1)), this.accBeta2.assign(Be(this.beta2, this.iterations_ + 1));
+    });
+    const t = e.length / 2, n = !1;
+    this.accumulatedFirstMoment = e.slice(0, t).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    })), this.accumulatedSecondMoment = e.slice(t, t * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      beta1: this.beta1,
+      beta2: this.beta2,
+      epsilon: this.epsilon
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.beta1, t.beta2, t.epsilon);
+  }
+}
+class Tn extends W {
+  /** @nocollapse */
+  static get className() {
+    return "Adamax";
+  }
+  constructor(e, t, n, r = null, a = 0) {
+    super(), this.learningRate = e, this.beta1 = t, this.beta2 = n, this.epsilon = r, this.decay = a, this.accumulatedFirstMoment = [], this.accumulatedWeightedInfNorm = [], k(() => {
+      this.iteration = U(0).variable(), this.accBeta1 = U(t).variable();
+    }), r == null && (this.epsilon = u.backend.epsilon());
+  }
+  applyGradients(e) {
+    const t = Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e);
+    k(() => {
+      const n = j(1, this.accBeta1), r = x(-this.learningRate, y(f(this.iteration, this.decay), 1));
+      t.forEach((a, i) => {
+        const o = u.registeredVariables[a], c = !1;
+        this.accumulatedFirstMoment[i] == null && (this.accumulatedFirstMoment[i] = {
+          originalName: `${a}/m`,
+          variable: F(o).variable(c)
+        }), this.accumulatedWeightedInfNorm[i] == null && (this.accumulatedWeightedInfNorm[i] = {
+          originalName: `${a}/v`,
+          variable: F(o).variable(c)
+        });
+        const l = Array.isArray(e) ? e[i].tensor : e[a];
+        if (l == null)
+          return;
+        const h = this.accumulatedFirstMoment[i].variable, m = this.accumulatedWeightedInfNorm[i].variable, d = y(f(h, this.beta1), f(l, 1 - this.beta1)), p = f(m, this.beta2), b = cn(l), w = bn(p, b);
+        h.assign(d), m.assign(w);
+        const I = y(f(x(r, n), x(d, y(w, this.epsilon))), o);
+        o.assign(I);
+      }), this.iteration.assign(y(this.iteration, 1)), this.accBeta1.assign(f(this.accBeta1, this.beta1));
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accBeta1.dispose(), this.iteration.dispose(), this.accumulatedFirstMoment != null && A(this.accumulatedFirstMoment.map((e) => e.variable)), this.accumulatedWeightedInfNorm != null && A(this.accumulatedWeightedInfNorm.map((e) => e.variable));
+  }
+  async getWeights() {
+    throw new Error("getWeights() is not implemented for Adamax yet.");
+  }
+  async setWeights(e) {
+    throw new Error("setWeights() is not implemented for Adamax yet.");
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      beta1: this.beta1,
+      beta2: this.beta2,
+      epsilon: this.epsilon,
+      decay: this.decay
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.beta1, t.beta2, t.epsilon, t.decay);
+  }
+}
+class Ke extends W {
+  /** @nocollapse */
+  static get className() {
+    return "SGD";
+  }
+  constructor(e) {
+    super(), this.learningRate = e, this.setLearningRate(e);
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e)).forEach((n, r) => {
+      const a = Array.isArray(e) ? e[r].tensor : e[n];
+      if (a == null)
+        return;
+      const i = u.registeredVariables[n];
+      k(() => {
+        const o = y(f(this.c, a), i);
+        i.assign(o);
+      });
+    }), this.incrementIterations();
+  }
+  /**
+   * Sets the learning rate of the optimizer.
+   */
+  setLearningRate(e) {
+    this.learningRate = e, this.c != null && this.c.dispose(), this.c = xt(U(-e));
+  }
+  dispose() {
+    this.c.dispose();
+  }
+  async getWeights() {
+    return [await this.saveIterations()];
+  }
+  async setWeights(e) {
+    if (e = await this.extractIterations(e), e.length !== 0)
+      throw new Error("SGD optimizer does not have settable weights.");
+  }
+  getConfig() {
+    return { learningRate: this.learningRate };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate);
+  }
+}
+class An extends Ke {
+  /** @nocollapse */
+  // Name matters for Python compatibility.
+  static get className() {
+    return "Momentum";
+  }
+  constructor(e, t, n = !1) {
+    super(e), this.learningRate = e, this.momentum = t, this.useNesterov = n, this.accumulations = [], this.m = U(this.momentum);
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e)).forEach((n, r) => {
+      const a = u.registeredVariables[n];
+      this.accumulations[r] == null && (this.accumulations[r] = {
+        originalName: `${n}/momentum`,
+        variable: k(() => F(a).variable(!1))
+      });
+      const i = this.accumulations[r].variable, o = Array.isArray(e) ? e[r].tensor : e[n];
+      o != null && k(() => {
+        let c;
+        const l = y(f(this.m, i), o);
+        this.useNesterov ? c = y(f(this.c, y(o, f(l, this.m))), a) : c = y(f(this.c, l), a), i.assign(l), a.assign(c);
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.m.dispose(), this.accumulations != null && A(this.accumulations.map((e) => e.variable));
+  }
+  /**
+   * Sets the momentum of the optimizer.
+   *
+   * @param momentum
+   */
+  setMomentum(e) {
+    this.momentum = e;
+  }
+  async getWeights() {
+    return [await this.saveIterations()].concat(this.accumulations.map((e) => ({ name: e.originalName, tensor: e.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e);
+    const t = !1;
+    this.accumulations = e.map((n) => ({ originalName: n.name, variable: n.tensor.variable(t) }));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      momentum: this.momentum,
+      useNesterov: this.useNesterov
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.momentum, t.useNesterov);
+  }
+}
+class Mn extends W {
+  /** @nocollapse */
+  static get className() {
+    return "RMSProp";
+  }
+  constructor(e, t = 0.9, n = 0, r = null, a = !1) {
+    if (super(), this.learningRate = e, this.decay = t, this.momentum = n, this.epsilon = r, this.accumulatedMeanSquares = [], this.accumulatedMoments = [], this.accumulatedMeanGrads = [], this.centered = a, r == null && (this.epsilon = u.backend.epsilon()), e == null)
+      throw new Error("learningRate for RMSPropOptimizer must be defined.");
+  }
+  applyGradients(e) {
+    (Array.isArray(e) ? e.map((n) => n.name) : Object.keys(e)).forEach((n, r) => {
+      const a = u.registeredVariables[n], i = !1;
+      this.accumulatedMeanSquares[r] == null && (this.accumulatedMeanSquares[r] = {
+        originalName: `${n}/rms`,
+        variable: k(() => F(a).variable(i))
+      }), this.accumulatedMoments[r] == null && (this.accumulatedMoments[r] = {
+        originalName: `${n}/momentum`,
+        variable: k(() => F(a).variable(i))
+      }), this.accumulatedMeanGrads[r] == null && this.centered && (this.accumulatedMeanGrads[r] = {
+        originalName: `${n}/mg`,
+        variable: k(() => F(a).variable(i))
+      });
+      const o = Array.isArray(e) ? e[r].tensor : e[n];
+      if (o == null)
+        return;
+      const c = this.accumulatedMeanSquares[r].variable, l = this.accumulatedMoments[r].variable;
+      k(() => {
+        const h = y(f(c, this.decay), f(L(o), 1 - this.decay));
+        if (this.centered) {
+          const m = this.accumulatedMeanGrads[r].variable, d = y(f(m, this.decay), f(o, 1 - this.decay)), p = x(f(o, this.learningRate), V(j(h, y(L(d), this.epsilon)))), b = y(f(l, this.momentum), p);
+          c.assign(h), m.assign(d), l.assign(b);
+          const w = j(a, b);
+          a.assign(w);
+        } else {
+          const m = y(f(c, this.decay), f(L(o), 1 - this.decay)), d = y(f(l, this.momentum), x(f(o, this.learningRate), V(y(m, this.epsilon))));
+          c.assign(m), l.assign(d);
+          const p = j(a, d);
+          a.assign(p);
+        }
+      });
+    }), this.incrementIterations();
+  }
+  dispose() {
+    this.accumulatedMeanSquares != null && A(this.accumulatedMeanSquares.map((e) => e.variable)), this.accumulatedMeanGrads != null && this.centered && A(this.accumulatedMeanGrads.map((e) => e.variable)), this.accumulatedMoments != null && A(this.accumulatedMoments.map((e) => e.variable));
+  }
+  async getWeights() {
+    const e = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];
+    return this.centered && e.push(...this.accumulatedMeanGrads), [await this.saveIterations()].concat(e.map((t) => ({ name: t.originalName, tensor: t.variable })));
+  }
+  async setWeights(e) {
+    e = await this.extractIterations(e);
+    const t = this.centered ? e.length / 3 : e.length / 2, n = !1;
+    this.accumulatedMeanSquares = e.slice(0, t).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    })), this.accumulatedMoments = e.slice(t, t * 2).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    })), this.centered && (this.accumulatedMeanGrads = e.slice(t * 2, t * 3).map((r) => ({
+      originalName: r.name,
+      variable: r.tensor.variable(n)
+    })));
+  }
+  getConfig() {
+    return {
+      learningRate: this.learningRate,
+      decay: this.decay,
+      momentum: this.momentum,
+      epsilon: this.epsilon,
+      centered: this.centered
+    };
+  }
+  /** @nocollapse */
+  static fromConfig(e, t) {
+    return new e(t.learningRate, t.decay, t.momentum, t.epsilon, t.centered);
+  }
+}
+const Nn = [
+  vn,
+  Bn,
+  En,
+  Tn,
+  An,
+  Mn,
+  Ke
+];
+function xn() {
+  for (const s of Nn)
+    In(s);
+}
+xn();
+export {
+  bn as $,
+  M as A,
+  S as B,
+  Tt as C,
+  Zt as D,
+  u as E,
+  Zn as F,
+  le as G,
+  _n as H,
+  It as I,
+  Xt as J,
+  v as K,
+  H as L,
+  qn as M,
+  _e as N,
+  W as O,
+  Vn as P,
+  Hn as Q,
+  Wn as R,
+  cn as S,
+  L as T,
+  Ke as U,
+  An as V,
+  Mn as W,
+  En as X,
+  vn as Y,
+  Tn as Z,
+  Bn as _,
+  Ln as a,
+  In as a0,
+  kn as a1,
+  _ as a2,
+  Xn as a3,
+  Kn as a4,
+  jn as a5,
+  sn as a6,
+  $n as a7,
+  Bt as a8,
+  U as b,
+  j as c,
+  A as d,
+  On as e,
+  Gn as f,
+  Un as g,
+  Jn as h,
+  ln as i,
+  un as j,
+  xt as k,
+  x as l,
+  f as m,
+  y as n,
+  V as o,
+  Be as p,
+  Yn as q,
+  Pn as r,
+  zn as s,
+  k as t,
+  Qn as u,
+  gn as v,
+  es as w,
+  Et as x,
+  Mt as y,
+  F as z
+};