@genai-fi/nanogpt 0.10.2 → 0.10.3

package/dist/utilities/packed.js

@@ -1,750 +1,15 @@
-import { g as $ } from "../index-D5v913EJ.js";
-import { p as K } from "../index-xuotMAFm.js";
-import { w, o as W, p as N, K as H, I as P, q as A, s as z, t as X, v as Y, x as Z, A as J } from "../tensor_util-DfwaWayG.js";
-import { b as Q, E as L, a as p, o as ee, q as te, r as se, t as C, V as ne, u as G, T as B, v as R, m as re, s as ie, w as ae, f as oe, x as ce } from "../tensor-CzmOBsdf.js";
-import { PackableTensor as j, PackableVariable as de } from "../patches/PackedTensor.js";
-function be() {
-  return y.backendName === "webgpu";
+import { e as n } from "../index-DOvlwCh-.js";
+function o() {
+  return n().backendName === "webgpu";
 }
-function x(i) {
-  return i.packed !== void 0;
+function r(e) {
+  return e.dtype === "packedF16";
 }
-function T(i) {
-  return x(i) && i.packed;
-}
-function O(i) {
-  if (x(i)) {
-    if (i.dtype !== "int32")
-      throw new Error("packTensor: only int32 tensors can be packed.");
-    return i.packed = !0, i;
-  } else
-    throw console.error("Tensor:", i), new Error("Tensor is not packable");
-}
-function we(i) {
-  if (x(i)) {
-    if (i.dtype !== "float32")
-      throw new Error("unpackTensor: only float32 tensors can be unpacked.");
-    i.packed = !1;
-  }
-  return i;
-}
-function he(i, e, t, s) {
-  for (let n = e.length - 1; n >= 0; n--) {
-    const r = e[n], c = [];
-    if (r.outputs.forEach((o) => {
-      const a = i[o.id];
-      a != null ? c.push(a) : c.push(null);
-    }), r.gradient == null)
-      throw new Error(`Cannot compute gradient: gradient function not found for ${r.kernelName}.`);
-    const d = r.gradient(c);
-    for (const o in r.inputs) {
-      if (!(o in d))
-        throw new Error(
-          `Cannot backprop through input ${o}. Available gradients found: ${Object.keys(d)}.`
-        );
-      const a = t(() => d[o]()), h = T(a);
-      if (a.dtype !== "float32" && (!h || a.dtype !== "int32"))
-        throw new Error(
-          `Error in gradient for op ${r.kernelName}. The gradient of input ${o} must have 'float32' dtype, but has '${a.dtype}'`
-        );
-      const u = r.inputs[o];
-      if (!Q(a.shape, u.shape))
-        throw new Error(
-          `Error in gradient for op ${r.kernelName}. The gradient of input '${o}' has shape '${a.shape}', which does not match the shape of the input '${u.shape}'`
-        );
-      if (i[u.id] == null)
-        i[u.id] = a;
-      else {
-        const l = i[u.id];
-        i[u.id] = s(l, a), l.dispose();
-      }
-    }
-  }
-}
-let S;
-function U() {
-  if (S == null) {
-    let i;
-    if (typeof window < "u")
-      i = window;
-    else if (typeof $ < "u")
-      i = $;
-    else if (typeof K < "u")
-      i = K;
-    else if (typeof self < "u")
-      i = self;
-    else
-      throw new Error("Could not find a global object");
-    S = i;
-  }
-  return S;
-}
-const E = {
-  engine: null
-}, D = U();
-if (D._tfengine)
-  throw new Error("TensorFlow engine already initialized before patching.");
-Object.defineProperty(D, "_tfengine", {
-  get: () => {
-    if (E.engine == null) {
-      const i = new L(D);
-      E.engine = new I(i);
-    }
-    return E.engine;
-  }
-});
-function F(i) {
-  return i.kernelName != null;
-}
-class _ {
-  // Public since optimizers will use it.
-  registeredVariables = {};
-  nextTapeNodeId = 0;
-  numBytes = 0;
-  numTensors = 0;
-  numStringTensors = 0;
-  numDataBuffers = 0;
-  activeTape;
-  // Number of nested tf.grad() statements when computing higher-order
-  // gradients. E.g. `1` for first-order gradients and `2` for second-order
-  // gradients. Used to track if the tape should be removed after a backprop.
-  gradientDepth = 0;
-  // Number of nested kernel calls. When kernel depth is greater than 1, we turn
-  // off the tape.
-  kernelDepth = 0;
-  // Keep Tensors that parallel the tapes.
-  activeScope;
-  scopeStack = [];
-  /**
-   * Keeps track of the number of data moves during a kernel execution. We
-   * maintain a stack since kernels can call other kernels, recursively.
-   */
-  numDataMovesStack = [];
-  nextScopeId = 0;
-  tensorInfo = /* @__PURE__ */ new WeakMap();
-  profiling = !1;
-  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 I {
-  constructor(e) {
-    this.ENV = e, this.state = new _(), console.log("GenAI Patched Engine Initialized");
-  }
-  version = "GENAI_PATCHED_ENGINE";
-  state;
-  backendName;
-  registry = {};
-  registryFactory = {};
-  profiler;
-  backendInstance = null;
-  pendingBackendInit;
-  pendingBackendInitId = 0;
-  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 s = e[t];
-      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: 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, s = 1) {
-    return e in this.registryFactory ? (w(`${e} backend was already registered. Reusing existing backend factory.`), !1) : (this.registryFactory[e] = { factory: t, priority: s }, console.log("Registered backend", e), !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: s } = this.initializeBackend(e);
-      if (!(s ? await t : t))
-        return !1;
-    }
-    return this.backendInstance = this.registry[e], this.setupRegisteredKernels(), this.profiler = new W(this.backendInstance), !0;
-  }
-  setupRegisteredKernels() {
-    N(this.backendName).forEach((t) => {
-      t.setupFunc != null && t.setupFunc(this.backendInstance);
-    });
-  }
-  disposeRegisteredKernels(e) {
-    N(e).forEach((s) => {
-      s.disposeFunc != null && s.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 s = t.factory();
-      if (s && !(s instanceof H) && typeof s.then == "function") {
-        const n = ++this.pendingBackendInitId, r = s.then((c) => n < this.pendingBackendInitId ? !1 : (this.registry[e] = c, this.pendingBackendInit = null, !0)).catch((c) => (n < this.pendingBackendInitId || (this.pendingBackendInit = null, w(`Initialization of backend ${e} failed`), w(c.stack || c.message)), !1));
-        return this.pendingBackendInit = r, { success: r, asyncInit: !0 };
-      } else
-        return this.registry[e] = s, { success: !0, asyncInit: !1 };
-    } catch (s) {
-      return w(`Initialization of backend ${e} failed`), w(s.stack || s.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 s = e[t], { 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(e, t) {
-    const s = this.state.tensorInfo.get(t);
-    s || console.warn("Tried to move data that does not exist", this.state, t);
-    const n = s.backend, r = this.readSync(t), c = n.refCount(t);
-    n.disposeData(t, !0), s.backend = e, e.move(t, r, s.shape, s.dtype, c), this.shouldCheckForMemLeaks() && this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
-  }
-  tidy(e, t) {
-    let s = 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");
-      s = e;
-    }
-    let n;
-    return this.scopedRun(
-      () => this.startScope(s),
-      () => this.endScope(n),
-      () => (n = t(), n instanceof Promise && console.error("Cannot return a Promise inside of tidy."), n)
-    );
-  }
-  scopedRun(e, t, s) {
-    e();
-    try {
-      const n = s();
-      return t(), n;
-    } catch (n) {
-      throw t(), n;
-    }
-  }
-  static nextTensorId = 0;
-  nextTensorId() {
-    return I.nextTensorId++;
-  }
-  static nextVariableId = 0;
-  nextVariableId() {
-    return I.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 s = T(e) ? O(y.runKernel(P, { x: e })) : y.runKernel(P, { x: e }), n = { x: e }, r = (d) => ({
-      x: () => {
-        const o = "float32", a = { x: d }, h = { dtype: o }, u = T(e), l = y.runKernel(
-          Z,
-          a,
-          // tslint:disable-next-line: no-unnecessary-type-assertion
-          h
-        );
-        return u && O(l), l;
-      }
-    }), c = [];
-    return this.addTapeNode(this.state.activeScope.name, n, [s], r, c, {}), s;
-  }
-  /**
-   * 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, s) {
-    if (this.backendName == null && this.backend, !(A(e, this.backendName) != null))
-      throw new Error(`Kernel '${e}' not registered for backend '${this.backendName}'`);
-    return this.runKernelFunc({ kernelName: e, inputs: t, attrs: s });
-  }
-  shouldCheckForMemLeaks() {
-    return this.ENV.getBool("IS_TEST");
-  }
-  checkKernelForMemLeak(e, t, s) {
-    const n = this.backend.numDataIds();
-    let r = 0;
-    s.forEach((o) => {
-      r += o.dtype === "complex64" ? 3 : 1;
-    });
-    const c = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1], d = n - t - r - c;
-    if (d > 0)
-      throw new Error(
-        `Backend '${this.backendName}' has an internal memory leak (${d} 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, s = [];
-    const n = this.isTapeOn(), r = this.state.numBytes, c = this.state.numTensors;
-    this.shouldCheckForMemLeaks() && this.state.numDataMovesStack.push(0);
-    let d;
-    this.backendName == null && this.backend;
-    let o;
-    const a = F(e) ? e.kernelName : this.state.activeScope != null ? this.state.activeScope.name : "";
-    if (F(e)) {
-      const { kernelName: f, inputs: v, attrs: m } = e;
-      this.backendName == null && this.backend;
-      const k = A(f, this.backendName);
-      p(
-        k != null,
-        () => `Cannot find registered kernel '${f}' for backend '${this.backendName}'`
-      ), d = () => {
-        const q = this.backend.numDataIds();
-        o = k.kernelFunc({ inputs: v, attrs: m, backend: this.backend });
-        const M = Array.isArray(o) ? o : [o];
-        this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(f, q, M);
-        const V = M.map((b) => b.rank != null ? b : this.makeTensorFromTensorInfo(b));
-        if (n) {
-          const b = this.getTensorsForGradient(f, v, V);
-          s = this.saveTensorsForBackwardMode(b ?? []);
-        }
-        return V;
-      };
-    } else {
-      const { forwardFunc: f } = e, v = (m) => {
-        n && (s = m.map((k) => this.keep(this.clone(k))));
-      };
-      d = () => {
-        const m = this.backend.numDataIds();
-        o = this.tidy(() => f(this.backend, v));
-        const k = Array.isArray(o) ? o : [o];
-        return this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(a, m, k), k;
-      };
-    }
-    const { inputs: h, attrs: u } = e, l = F(e) ? null : e.backwardsFunc;
-    let g;
-    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 = d() : (g = this.profiler.profileKernel(a, h, () => d()), this.ENV.getBool("DEBUG") && this.profiler.logKernelProfile(g), t = g.outputs);
-      }
-    ), n && this.addTapeNode(
-      a,
-      h,
-      t,
-      l,
-      s,
-      u ?? {}
-    ), this.state.profiling && this.state.activeProfile.kernels.push({
-      name: a,
-      bytesAdded: this.state.numBytes - r,
-      totalBytesSnapshot: this.state.numBytes,
-      tensorsAdded: this.state.numTensors - c,
-      totalTensorsSnapshot: this.state.numTensors,
-      inputShapes: Object.keys(h).map(
-        (f) => h[f] != null ? h[f].shape : null
-      ),
-      outputShapes: t.map((f) => f.shape),
-      kernelTimeMs: g.timeMs,
-      extraInfo: g.extraInfo
-    }), Array.isArray(o) ? 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((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(e, t, s) {
-    const n = z(e);
-    if (n != null) {
-      const r = n.inputsToSave || [], c = n.outputsToSave || [];
-      let d;
-      n.saveAllInputs ? (p(Array.isArray(t), () => "saveAllInputs is true, expected inputs to be an array."), d = Object.keys(t).map((a) => t[a])) : d = r.map((a) => t[a]);
-      const o = s.filter((a, h) => c[h]);
-      return d.concat(o);
-    }
-    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, s, n) {
-    if (e == null)
-      throw new Error("Values passed to engine.makeTensor() are null");
-    s = s || "float32", n = n || this.backend;
-    let r = e;
-    s === "string" && ee(e[0]) && (r = e.map((o) => te(o)));
-    const c = n.write(r, t, s), d = new j(t, s, c, this.nextTensorId());
-    if (this.trackTensor(d, n), s === "string") {
-      const o = this.state.tensorInfo.get(c), a = se(r);
-      this.state.numBytes += a - o.bytes, o.bytes = a;
-    }
-    return d;
-  }
-  /**
-   * 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, s, n) {
-    s = s || "float32";
-    const r = { dataId: e, shape: t, 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(e, t) {
-    const { dataId: s, shape: n, dtype: r } = e, c = new j(n, r, s, this.nextTensorId());
-    if (c.packed = e.packed || !1, c.packed && r !== "int32")
-      throw new Error("Only int32 tensors can be packed.");
-    return this.trackTensor(c, t ?? this.backend), c;
-  }
-  makeVariable(e, t = !0, s, n) {
-    s = s || this.nextVariableId().toString(), n != null && n !== e.dtype && (e = e.cast(n));
-    const r = new de(e, t, 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(e, t) {
-    this.state.numTensors++, e.dtype === "string" && this.state.numStringTensors++;
-    let s = 0;
-    e.dtype !== "complex64" && e.dtype !== "string" && (s = e.size * C(e.dtype)), this.state.numBytes += s, 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: s
-    })), e instanceof ne || 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 s = e.size * C(e.dtype);
-      this.state.numBytes -= s;
-    }
-    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, s = 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((n) => n.totalBytesSnapshot)
-    ), this.state.activeProfile.newBytes = this.state.numBytes - t, 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(e, t, s, n, r, c) {
-    const d = { id: this.state.nextTapeNodeId++, kernelName: e, inputs: t, outputs: s, saved: r }, o = z(e);
-    o != null && (n = o.gradFunc), n != null && (d.gradient = (a) => (a = a.map((h, u) => {
-      if (h == null) {
-        const l = s[u], g = oe(l.size, l.dtype);
-        return this.makeTensor(g, l.shape, l.dtype);
-      }
-      return h;
-    }), n(a.length > 1 ? a : a[0], r, c))), this.state.activeTape.push(d);
-  }
-  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 = X(e), s = new Set(t.map((r) => r.id));
-    for (let r = 0; r < this.state.activeScope.track.length; r++) {
-      const c = this.state.activeScope.track[r];
-      !c.kept && !s.has(c.id) && c.dispose();
-    }
-    const n = this.state.scopeStack.pop();
-    this.state.activeScope = this.state.scopeStack.length === 0 ? null : this.state.scopeStack[this.state.scopeStack.length - 1], t.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(e, t, s, n = !1) {
-    if (p(t.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", e)
-    );
-    p(r instanceof B, () => "The result y returned by f() must be a tensor.");
-    const c = Y(this.state.activeTape, t, r);
-    if (!n && c.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 d = {};
-      d[r.id] = s ?? le(r.shape), he(
-        d,
-        c,
-        // Pass the tidy function to avoid circular dep with `tape.ts`.
-        (a) => this.tidy(a),
-        // Pass an add function to avoide a circular dep with `tape.ts`.
-        fe
-      );
-      const o = t.map((a) => d[a.id]);
-      return this.state.gradientDepth === 0 && (this.state.activeTape.forEach((a) => {
-        if (a.saved !== void 0)
-          for (const h of a.saved)
-            h.dispose();
-      }), this.state.activeTape = null), { value: r, grads: o };
-    });
-  }
-  customGrad(e) {
-    return p(G(e), () => "The f passed in customGrad(f) must be a function."), (...t) => {
-      p(
-        t.every((d) => d instanceof B),
-        () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors"
-      );
-      let s;
-      const n = {};
-      t.forEach((d, o) => {
-        n[o] = d;
-      });
-      const r = (d, o) => (s = e(...t, o), p(
-        s.value instanceof B,
-        () => "The function f passed in customGrad(f) must return an object where `obj.value` is a tensor"
-      ), p(
-        G(s.gradFunc),
-        () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function."
-      ), s.value), c = (d, o) => {
-        const a = s.gradFunc(d, o), h = Array.isArray(a) ? a : [a];
-        p(
-          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(...)."
-        ), p(
-          h.every((l) => l instanceof B),
-          () => "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 u = {};
-        return h.forEach((l, g) => {
-          u[g] = () => l;
-        }), u;
-      };
-      return this.runKernelFunc({
-        forwardFunc: r,
-        backwardsFunc: c,
-        inputs: n
-      });
-    };
-  }
-  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 = R(), s = await this.backend.time(e);
-    return s.wallMs = R() - t, 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(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 _();
-    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;
-  }
-}
-function le(i) {
-  const e = re(ie(i), "float32");
-  return y.makeTensor(e, i, "float32");
-}
-function ue() {
-  const i = U();
-  if (i._tfengine == null) {
-    const e = new L(i);
-    i._tfengine = new I(e);
-  }
-  return ae(i._tfengine.ENV), ce(() => i._tfengine), i._tfengine;
-}
-const y = ue();
-function fe(i, e) {
-  const t = T(i) || T(e), s = { a: i, b: e };
-  return y.runKernel(t ? "Add16" : J, s);
+function a(e) {
+  return r(e);
 }
 export {
-  I as E,
-  y as a,
-  he as b,
-  fe as c,
-  ue as g,
-  x as isPackableTensor,
-  T as isPackedTensor,
-  O as packTensor,
-  be as packingSupported,
-  we as unpackTensor
+  r as isPackableTensor,
+  a as isPackedTensor,
+  o as packingSupported
 };