@cuemath/leap 4.1.1-gg4 → 4.1.1-j2

package/dist/node_modules/@tensorflow/tfjs-core/dist/engine.js

@@ -0,0 +1,595 @@
+import { KernelBackend as C } from "./backends/backend.js";
+import { Environment as N, setEnvironmentGlobal as R } from "./environment.js";
+import { getGlobalNamespace as $ } from "./global_util.js";
+import { Identity as P, Cast as j, Add as L } from "./kernel_names.js";
+import { getKernelsForBackend as E, getKernel as D, getGradient as M } from "./kernel_registry.js";
+import { warn as I } from "./log.js";
+import { Profiler as O } from "./profiler.js";
+import { getFilteredNodesXToY as _, backpropagateGradients as U } from "./tape.js";
+import { setTensorTracker as W, Tensor as m, Variable as x } from "./tensor.js";
+import { getTensorsInContainer as X } from "./tensor_util.js";
+import { encodeString as Y, now as V } from "./util.js";
+import { assert as f, isString as Z, bytesFromStringArray as q, bytesPerElement as K, isFunction as A, makeOnesTypedArray as H, sizeFromShape as J, makeZerosTypedArray as Q } from "./util_base.js";
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function v(d) {
+  return d.kernelName != null;
+}
+class z {
+  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((t) => t.name)));
+      }
+    };
+  }
+  dispose() {
+    for (const t in this.registeredVariables)
+      this.registeredVariables[t].dispose();
+  }
+}
+class y {
+  constructor(t) {
+    this.ENV = t, this.registry = {}, this.registryFactory = {}, this.pendingBackendInitId = 0, this.state = new z();
+  }
+  async ready() {
+    if (this.pendingBackendInit != null)
+      return this.pendingBackendInit.then(() => {
+      });
+    if (this.backendInstance != null)
+      return;
+    const t = this.getSortedBackends();
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e];
+      if (await this.initializeBackend(s).success) {
+        await this.setBackend(s);
+        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: t, asyncInit: e } = this.initializeBackendsAndReturnBest();
+      if (e)
+        throw new Error(`The highest priority backend '${t}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
+      this.setBackend(t);
+    }
+    return this.backendInstance;
+  }
+  backendNames() {
+    return Object.keys(this.registryFactory);
+  }
+  findBackend(t) {
+    if (!(t in this.registry))
+      if (t in this.registryFactory) {
+        const { asyncInit: e } = this.initializeBackend(t);
+        if (e)
+          return null;
+      } else
+        return null;
+    return this.registry[t];
+  }
+  findBackendFactory(t) {
+    return t in this.registryFactory ? this.registryFactory[t].factory : null;
+  }
+  registerBackend(t, e, s = 1) {
+    return t in this.registryFactory ? (I(`${t} backend was already registered. Reusing existing backend factory.`), !1) : (this.registryFactory[t] = { factory: e, priority: s }, !0);
+  }
+  async setBackend(t) {
+    if (this.registryFactory[t] == null)
+      throw new Error(`Backend name '${t}' not found in registry`);
+    if (this.backendName = t, this.registry[t] == null) {
+      this.backendInstance = null;
+      const { success: e, asyncInit: s } = this.initializeBackend(t);
+      if (!(s ? await e : e))
+        return !1;
+    }
+    return this.backendInstance = this.registry[t], this.setupRegisteredKernels(), this.profiler = new O(this.backendInstance), !0;
+  }
+  setupRegisteredKernels() {
+    E(this.backendName).forEach((e) => {
+      e.setupFunc != null && e.setupFunc(this.backendInstance);
+    });
+  }
+  disposeRegisteredKernels(t) {
+    E(t).forEach((s) => {
+      s.disposeFunc != null && s.disposeFunc(this.registry[t]);
+    });
+  }
+  /**
+   * 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(t) {
+    const e = this.registryFactory[t];
+    if (e == null)
+      throw new Error(`Cannot initialize backend ${t}, no registration found.`);
+    try {
+      const s = e.factory();
+      if (s && !(s instanceof C) && typeof s.then == "function") {
+        const n = ++this.pendingBackendInitId, r = s.then((i) => n < this.pendingBackendInitId ? !1 : (this.registry[t] = i, this.pendingBackendInit = null, !0)).catch((i) => (n < this.pendingBackendInitId || (this.pendingBackendInit = null, I(`Initialization of backend ${t} failed`), I(i.stack || i.message)), !1));
+        return this.pendingBackendInit = r, { success: r, asyncInit: !0 };
+      } else
+        return this.registry[t] = s, { success: !0, asyncInit: !1 };
+    } catch (s) {
+      return I(`Initialization of backend ${t} failed`), I(s.stack || s.message), { success: !1, asyncInit: !1 };
+    }
+  }
+  removeBackend(t) {
+    if (!(t in this.registryFactory))
+      throw new Error(`${t} backend not found in registry`);
+    this.backendName === t && this.pendingBackendInit != null && this.pendingBackendInitId++, t in this.registry && (this.disposeRegisteredKernels(t), this.registry[t].dispose(), delete this.registry[t]), delete this.registryFactory[t], this.backendName === t && (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((t, e) => this.registryFactory[e].priority - this.registryFactory[t].priority);
+  }
+  initializeBackendsAndReturnBest() {
+    const t = this.getSortedBackends();
+    for (let e = 0; e < t.length; e++) {
+      const s = t[e], { success: n, asyncInit: r } = this.initializeBackend(s);
+      if (r || n)
+        return { name: s, asyncInit: r };
+    }
+    throw new Error("Could not initialize any backends, all backend initializations failed.");
+  }
+  moveData(t, e) {
+    const s = this.state.tensorInfo.get(e), n = s.backend, r = this.readSync(e), i = n.refCount(e);
+    n.disposeData(e, !0), s.backend = t, t.move(e, r, s.shape, s.dtype, i), this.shouldCheckForMemLeaks() && this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
+  }
+  tidy(t, e) {
+    let s = null;
+    if (e == null) {
+      if (typeof t != "function")
+        throw new Error("Please provide a function to tidy()");
+      e = t;
+    } else {
+      if (typeof t != "string" && !(t instanceof String))
+        throw new Error("When calling with two arguments, the first argument to tidy() must be a string");
+      if (typeof e != "function")
+        throw new Error("When calling with two arguments, the 2nd argument to tidy() must be a function");
+      s = t;
+    }
+    let n;
+    return this.scopedRun(() => this.startScope(s), () => this.endScope(n), () => (n = e(), n instanceof Promise && console.error("Cannot return a Promise inside of tidy."), n));
+  }
+  scopedRun(t, e, s) {
+    t();
+    try {
+      const n = s();
+      return e(), n;
+    } catch (n) {
+      throw e(), n;
+    }
+  }
+  nextTensorId() {
+    return y.nextTensorId++;
+  }
+  nextVariableId() {
+    return y.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(t) {
+    const e = B.runKernel(P, { x: t }), s = { x: t }, n = (i) => ({
+      x: () => {
+        const o = "float32", a = { x: i }, c = { dtype: o };
+        return B.runKernel(
+          j,
+          a,
+          // tslint:disable-next-line: no-unnecessary-type-assertion
+          c
+        );
+      }
+    }), r = [];
+    return this.addTapeNode(this.state.activeScope.name, s, [e], n, r, {}), e;
+  }
+  /**
+   * 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(t, e, s) {
+    if (this.backendName == null && this.backend, !(D(t, this.backendName) != null))
+      throw new Error(`Kernel '${t}' not registered for backend '${this.backendName}'`);
+    return this.runKernelFunc({ kernelName: t, inputs: e, attrs: s });
+  }
+  shouldCheckForMemLeaks() {
+    return this.ENV.getBool("IS_TEST");
+  }
+  checkKernelForMemLeak(t, e, s) {
+    const n = this.backend.numDataIds();
+    let r = 0;
+    s.forEach((a) => {
+      r += a.dtype === "complex64" ? 3 : 1;
+    });
+    const i = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1], o = n - e - r - i;
+    if (o > 0)
+      throw new Error(`Backend '${this.backendName}' has an internal memory leak (${o} data ids) after running '${t}'`);
+  }
+  /**
+   * Internal helper method to execute a kernel Func
+   *
+   * Use `runKernel` to execute kernels from outside of engine.
+   */
+  runKernelFunc(t) {
+    let e, s = [];
+    const n = this.isTapeOn(), r = this.state.numBytes, i = this.state.numTensors;
+    this.shouldCheckForMemLeaks() && this.state.numDataMovesStack.push(0);
+    let o;
+    this.backendName == null && this.backend;
+    let a;
+    const c = v(t) ? t.kernelName : this.state.activeScope != null ? this.state.activeScope.name : "";
+    if (v(t)) {
+      const { kernelName: u, inputs: w, attrs: b } = t;
+      this.backendName == null && this.backend;
+      const g = D(u, this.backendName);
+      f(g != null, () => `Cannot find registered kernel '${u}' for backend '${this.backendName}'`), o = () => {
+        const G = this.backend.numDataIds();
+        a = g.kernelFunc({ inputs: w, attrs: b, backend: this.backend });
+        const S = Array.isArray(a) ? a : [a];
+        this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(u, G, S);
+        const F = S.map((T) => T.rank != null ? T : this.makeTensorFromTensorInfo(T));
+        if (n) {
+          const T = this.getTensorsForGradient(u, w, F);
+          s = this.saveTensorsForBackwardMode(T);
+        }
+        return F;
+      };
+    } else {
+      const { forwardFunc: u } = t, w = (b) => {
+        n && (s = b.map((g) => this.keep(this.clone(g))));
+      };
+      o = () => {
+        const b = this.backend.numDataIds();
+        a = this.tidy(() => u(this.backend, w));
+        const g = Array.isArray(a) ? a : [a];
+        return this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(c, b, g), g;
+      };
+    }
+    const { inputs: h, attrs: k } = t, l = v(t) ? null : t.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 ? e = o() : (p = this.profiler.profileKernel(c, h, () => o()), this.ENV.getBool("DEBUG") && this.profiler.logKernelProfile(p), e = p.outputs);
+      }
+    ), n && this.addTapeNode(c, h, e, l, s, k), this.state.profiling && this.state.activeProfile.kernels.push({
+      name: c,
+      bytesAdded: this.state.numBytes - r,
+      totalBytesSnapshot: this.state.numBytes,
+      tensorsAdded: this.state.numTensors - i,
+      totalTensorsSnapshot: this.state.numTensors,
+      inputShapes: Object.keys(h).map((u) => h[u] != null ? h[u].shape : null),
+      outputShapes: e.map((u) => u.shape),
+      kernelTimeMs: p.timeMs,
+      extraInfo: p.extraInfo
+    }), Array.isArray(a) ? e : e[0];
+  }
+  /**
+   * Saves tensors used in forward mode for use in backward mode.
+   *
+   * @param tensors the list of tensors to save.
+   */
+  saveTensorsForBackwardMode(t) {
+    return t.map((s) => this.keep(this.clone(s)));
+  }
+  /**
+   * 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(t, e, s) {
+    const n = M(t);
+    if (n != null) {
+      const r = n.inputsToSave || [], i = n.outputsToSave || [];
+      let o;
+      n.saveAllInputs ? (f(Array.isArray(e), () => "saveAllInputs is true, expected inputs to be an array."), o = Object.keys(e).map((c) => e[c])) : o = r.map((c) => e[c]);
+      const a = s.filter((c, h) => i[h]);
+      return o.concat(a);
+    }
+    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(t, e, s, n) {
+    if (t == null)
+      throw new Error("Values passed to engine.makeTensor() are null");
+    s = s || "float32", n = n || this.backend;
+    let r = t;
+    s === "string" && Z(t[0]) && (r = t.map((a) => Y(a)));
+    const i = n.write(r, e, s), o = new m(e, s, i, this.nextTensorId());
+    if (this.trackTensor(o, n), s === "string") {
+      const a = this.state.tensorInfo.get(i), c = q(r);
+      this.state.numBytes += c - a.bytes, a.bytes = c;
+    }
+    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(t, e, s, n) {
+    s = s || "float32";
+    const r = { dataId: t, shape: e, dtype: s };
+    return this.makeTensorFromTensorInfo(r, n);
+  }
+  /**
+   * 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(t, e) {
+    const { dataId: s, shape: n, dtype: r } = t, i = new m(n, r, s, this.nextTensorId());
+    return this.trackTensor(i, e), i;
+  }
+  makeVariable(t, e = !0, s, n) {
+    s = s || this.nextVariableId().toString(), n != null && n !== t.dtype && (t = t.cast(n));
+    const r = new x(t, e, s, this.nextTensorId());
+    if (this.state.registeredVariables[r.name] != null)
+      throw new Error(`Variable with name ${r.name} was already registered`);
+    return this.state.registeredVariables[r.name] = r, this.incRef(r, this.backend), r;
+  }
+  trackTensor(t, e) {
+    this.state.numTensors++, t.dtype === "string" && this.state.numStringTensors++;
+    let s = 0;
+    t.dtype !== "complex64" && t.dtype !== "string" && (s = t.size * K(t.dtype)), this.state.numBytes += s, this.state.tensorInfo.has(t.dataId) || (this.state.numDataBuffers++, this.state.tensorInfo.set(t.dataId, {
+      backend: e || this.backend,
+      dtype: t.dtype,
+      shape: t.shape,
+      bytes: s
+    })), t instanceof x || this.track(t);
+  }
+  // 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(t, e) {
+    this.trackTensor(t, e), this.backend.incRef(t.dataId);
+  }
+  removeDataId(t, e) {
+    this.state.tensorInfo.has(t) && this.state.tensorInfo.get(t).backend === e && (this.state.tensorInfo.delete(t), this.state.numDataBuffers--);
+  }
+  disposeTensor(t) {
+    if (!this.state.tensorInfo.has(t.dataId))
+      return;
+    const e = this.state.tensorInfo.get(t.dataId);
+    if (this.state.numTensors--, t.dtype === "string" && (this.state.numStringTensors--, this.state.numBytes -= e.bytes), t.dtype !== "complex64" && t.dtype !== "string") {
+      const s = t.size * K(t.dtype);
+      this.state.numBytes -= s;
+    }
+    e.backend.disposeData(t.dataId) && this.removeDataId(t.dataId, e.backend);
+  }
+  disposeVariables() {
+    for (const t in this.state.registeredVariables) {
+      const e = this.state.registeredVariables[t];
+      this.disposeVariable(e);
+    }
+  }
+  disposeVariable(t) {
+    this.disposeTensor(t), this.state.registeredVariables[t.name] != null && delete this.state.registeredVariables[t.name];
+  }
+  memory() {
+    const t = this.backend.memory();
+    return t.numTensors = this.state.numTensors, t.numDataBuffers = this.state.numDataBuffers, t.numBytes = this.state.numBytes, this.state.numStringTensors > 0 && (t.unreliable = !0, t.reasons == null && (t.reasons = []), t.reasons.push("Memory usage by string tensors is approximate (2 bytes per character)")), t;
+  }
+  async profile(t) {
+    this.state.profiling = !0;
+    const e = this.state.numBytes, s = this.state.numTensors;
+    this.state.activeProfile.kernels = [], this.state.activeProfile.result = await t(), this.state.profiling = !1, this.state.activeProfile.peakBytes = Math.max(...this.state.activeProfile.kernels.map((n) => n.totalBytesSnapshot)), this.state.activeProfile.newBytes = this.state.numBytes - e, this.state.activeProfile.newTensors = this.state.numTensors - s;
+    for (const n of this.state.activeProfile.kernels)
+      n.kernelTimeMs = await n.kernelTimeMs, n.extraInfo = await n.extraInfo;
+    return this.state.activeProfile;
+  }
+  isTapeOn() {
+    return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
+  }
+  addTapeNode(t, e, s, n, r, i) {
+    const o = { id: this.state.nextTapeNodeId++, kernelName: t, inputs: e, outputs: s, saved: r }, a = M(t);
+    a != null && (n = a.gradFunc), n != null && (o.gradient = (c) => (c = c.map((h, k) => {
+      if (h == null) {
+        const l = s[k], p = Q(l.size, l.dtype);
+        return this.makeTensor(p, l.shape, l.dtype);
+      }
+      return h;
+    }), n(c.length > 1 ? c : c[0], r, i))), this.state.activeTape.push(o);
+  }
+  keep(t) {
+    return t.kept = !0, t;
+  }
+  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(t) {
+    const e = {
+      track: [],
+      name: "unnamed scope",
+      id: this.state.nextScopeId++
+    };
+    t && (e.name = t), this.state.scopeStack.push(e), this.state.activeScope = e;
+  }
+  /**
+   * End a scope. Use this with startScope() to achieve the same functionality
+   * as scope() without the need for a function closure.
+   */
+  endScope(t) {
+    const e = X(t), s = new Set(e.map((r) => r.id));
+    for (let r = 0; r < this.state.activeScope.track.length; r++) {
+      const i = this.state.activeScope.track[r];
+      !i.kept && !s.has(i.id) && i.dispose();
+    }
+    const n = this.state.scopeStack.pop();
+    this.state.activeScope = this.state.scopeStack.length === 0 ? null : this.state.scopeStack[this.state.scopeStack.length - 1], e.forEach((r) => {
+      !r.kept && r.scopeId === n.id && this.track(r);
+    });
+  }
+  /**
+   * 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(t, e, s, n = !1) {
+    if (f(e.length > 0, () => "gradients() received an empty list of xs."), s != null && s.dtype !== "float32")
+      throw new Error(`dy must have 'float32' dtype, but has '${s.dtype}'`);
+    const r = this.scopedRun(() => this.startTape(), () => this.endTape(), () => this.tidy("forward", t));
+    f(r instanceof m, () => "The result y returned by f() must be a tensor.");
+    const i = _(this.state.activeTape, e, r);
+    if (!n && i.length === 0 && e.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[r.id] = s ?? tt(r.shape), U(
+        o,
+        i,
+        // Pass the tidy function to avoid circular dep with `tape.ts`.
+        (c) => this.tidy(c),
+        // Pass an add function to avoide a circular dep with `tape.ts`.
+        st
+      );
+      const a = e.map((c) => o[c.id]);
+      return this.state.gradientDepth === 0 && (this.state.activeTape.forEach((c) => {
+        for (const h of c.saved)
+          h.dispose();
+      }), this.state.activeTape = null), { value: r, grads: a };
+    });
+  }
+  customGrad(t) {
+    return f(A(t), () => "The f passed in customGrad(f) must be a function."), (...e) => {
+      f(e.every((o) => o instanceof m), () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors");
+      let s;
+      const n = {};
+      e.forEach((o, a) => {
+        n[a] = o;
+      });
+      const r = (o, a) => (s = t(...e, a), f(s.value instanceof m, () => "The function f passed in customGrad(f) must return an object where `obj.value` is a tensor"), f(A(s.gradFunc), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function."), s.value), i = (o, a) => {
+        const c = s.gradFunc(o, a), h = Array.isArray(c) ? c : [c];
+        f(h.length === e.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(...)."), f(h.every((l) => l instanceof m), () => "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 k = {};
+        return h.forEach((l, p) => {
+          k[p] = () => l;
+        }), k;
+      };
+      return this.runKernelFunc({
+        forwardFunc: r,
+        backwardsFunc: i,
+        inputs: n
+      });
+    };
+  }
+  readSync(t) {
+    return this.state.tensorInfo.get(t).backend.readSync(t);
+  }
+  read(t) {
+    return this.state.tensorInfo.get(t).backend.read(t);
+  }
+  readToGPU(t, e) {
+    return this.state.tensorInfo.get(t).backend.readToGPU(t, e);
+  }
+  async time(t) {
+    const e = V(), s = await this.backend.time(t);
+    return s.wallMs = V() - e, s;
+  }
+  /**
+   * 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(t) {
+    return this.state.activeScope != null && (t.scopeId = this.state.activeScope.id, this.state.activeScope.track.push(t)), t;
+  }
+  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 z();
+    for (const t in this.registry)
+      this.disposeRegisteredKernels(t), this.registry[t].dispose(), delete this.registry[t];
+    this.backendName = null, this.backendInstance = null, this.pendingBackendInit = null;
+  }
+}
+y.nextTensorId = 0;
+y.nextVariableId = 0;
+function tt(d) {
+  const t = H(J(d), "float32");
+  return B.makeTensor(t, d, "float32");
+}
+function et() {
+  const d = $();
+  if (d._tfengine == null) {
+    const t = new N(d);
+    d._tfengine = new y(t);
+  }
+  return R(d._tfengine.ENV), W(() => d._tfengine), d._tfengine;
+}
+const B = et();
+function st(d, t) {
+  const e = { a: d, b: t };
+  return B.runKernel(L, e);
+}
+export {
+  B as ENGINE,
+  y as Engine,
+  st as add,
+  et as getOrMakeEngine
+};
+//# sourceMappingURL=engine.js.map