@genai-fi/nanogpt 0.10.1 → 0.10.2

package/dist/utilities/packed.js

@@ -1,68 +1,102 @@
-import { w as T, o as R, p as x, K as j, I as M, q as V, s as $, t as O, v as L, x as _, A as U } from "../tensor_util-DV-FP5Q3.js";
-import { b as q, o as W, E as H, q as X, a as p, r as Y, t as Z, u as J, v as K, V as Q, w as N, T as B, x as P, f as tt, m as et, s as st, y as nt } from "../tensor-DdQUJZlz.js";
-import { PackableTensor as A, PackableVariable as rt } from "../patches/PackedTensor.js";
-function lt() {
+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";
 }
-function E(o) {
-  return o.packed !== void 0;
+function x(i) {
+  return i.packed !== void 0;
 }
-function w(o) {
-  return E(o) && o.packed;
+function T(i) {
+  return x(i) && i.packed;
 }
-function z(o) {
-  if (E(o)) {
-    if (o.dtype !== "int32")
+function O(i) {
+  if (x(i)) {
+    if (i.dtype !== "int32")
       throw new Error("packTensor: only int32 tensors can be packed.");
-    return o.packed = !0, o;
+    return i.packed = !0, i;
   } else
-    throw console.error("Tensor:", o), new Error("Tensor is not packable");
+    throw console.error("Tensor:", i), new Error("Tensor is not packable");
 }
-function ft(o) {
-  if (E(o)) {
-    if (o.dtype !== "float32")
+function we(i) {
+  if (x(i)) {
+    if (i.dtype !== "float32")
       throw new Error("unpackTensor: only float32 tensors can be unpacked.");
-    o.packed = !1;
+    i.packed = !1;
   }
-  return o;
+  return i;
 }
-function it(o, t, e, s) {
-  for (let n = t.length - 1; n >= 0; n--) {
-    const r = t[n], c = [];
-    if (r.outputs.forEach((a) => {
-      const i = o[a.id];
-      i != null ? c.push(i) : c.push(null);
+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 h = r.gradient(c);
-    for (const a in r.inputs) {
-      if (!(a in h))
+    const d = r.gradient(c);
+    for (const o in r.inputs) {
+      if (!(o in d))
         throw new Error(
-          `Cannot backprop through input ${a}. Available gradients found: ${Object.keys(h)}.`
+          `Cannot backprop through input ${o}. Available gradients found: ${Object.keys(d)}.`
         );
-      const i = e(() => h[a]()), d = w(i);
-      if (i.dtype !== "float32" && (!d || i.dtype !== "int32"))
+      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 ${a} must have 'float32' dtype, but has '${i.dtype}'`
+          `Error in gradient for op ${r.kernelName}. The gradient of input ${o} must have 'float32' dtype, but has '${a.dtype}'`
         );
-      const l = r.inputs[a];
-      if (!q(i.shape, l.shape))
+      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 '${a}' has shape '${i.shape}', which does not match the shape of the input '${l.shape}'`
+          `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 (o[l.id] == null)
-        o[l.id] = i;
+      if (i[u.id] == null)
+        i[u.id] = a;
       else {
-        const u = o[l.id];
-        o[l.id] = s(u, i), u.dispose();
+        const l = i[u.id];
+        i[u.id] = s(l, a), l.dispose();
       }
     }
   }
 }
-function S(o) {
-  return o.kernelName != null;
+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;
 }
-class C {
+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;
@@ -96,17 +130,17 @@ class C {
     kernels: [],
     result: null,
     get kernelNames() {
-      return Array.from(new Set(this.kernels.map((t) => t.name)));
+      return Array.from(new Set(this.kernels.map((e) => e.name)));
     }
   };
   dispose() {
-    for (const t in this.registeredVariables)
-      this.registeredVariables[t].dispose();
+    for (const e in this.registeredVariables)
+      this.registeredVariables[e].dispose();
   }
 }
-class v {
-  constructor(t) {
-    this.ENV = t, this.state = new C(), console.log("GenAI Patched Engine Initialized");
+class I {
+  constructor(e) {
+    this.ENV = e, this.state = new _(), console.log("GenAI Patched Engine Initialized");
   }
   version = "GENAI_PATCHED_ENGINE";
   state;
@@ -123,9 +157,9 @@ class v {
       });
     if (this.backendInstance != null)
       return;
-    const t = this.getSortedBackends();
-    for (let e = 0; e < t.length; e++) {
-      const s = t[e];
+    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;
@@ -139,53 +173,53 @@ class v {
         `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)
+      const { name: e, asyncInit: t } = this.initializeBackendsAndReturnBest();
+      if (t)
         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`
+          `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(t);
+      this.setBackend(e);
     }
     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)
+  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[t];
+    return this.registry[e];
   }
-  findBackendFactory(t) {
-    return t in this.registryFactory ? this.registryFactory[t].factory : null;
+  findBackendFactory(e) {
+    return e in this.registryFactory ? this.registryFactory[e].factory : null;
   }
-  registerBackend(t, e, s = 1) {
-    return t in this.registryFactory ? (T(`${t} backend was already registered. Reusing existing backend factory.`), !1) : (this.registryFactory[t] = { factory: e, priority: s }, console.log("Registered backend", t), !0);
+  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(t) {
-    if (this.registryFactory[t] == null)
-      throw new Error(`Backend name '${t}' not found in registry`);
-    if (this.backendName = t, this.registry[t] == null) {
+  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: e, asyncInit: s } = this.initializeBackend(t);
-      if (!(s ? await e : e))
+      const { success: t, asyncInit: s } = this.initializeBackend(e);
+      if (!(s ? await t : t))
         return !1;
     }
-    return this.backendInstance = this.registry[t], this.setupRegisteredKernels(), this.profiler = new R(this.backendInstance), !0;
+    return this.backendInstance = this.registry[e], this.setupRegisteredKernels(), this.profiler = new W(this.backendInstance), !0;
   }
   setupRegisteredKernels() {
-    x(this.backendName).forEach((e) => {
-      e.setupFunc != null && e.setupFunc(this.backendInstance);
+    N(this.backendName).forEach((t) => {
+      t.setupFunc != null && t.setupFunc(this.backendInstance);
     });
   }
-  disposeRegisteredKernels(t) {
-    x(t).forEach((s) => {
-      s.disposeFunc != null && s.disposeFunc(this.registry[t]);
+  disposeRegisteredKernels(e) {
+    N(e).forEach((s) => {
+      s.disposeFunc != null && s.disposeFunc(this.registry[e]);
     });
   }
   /**
@@ -194,82 +228,82 @@ class v {
    * 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.`);
+  initializeBackend(e) {
+    const t = this.registryFactory[e];
+    if (t == null)
+      throw new Error(`Cannot initialize backend ${e}, no registration found.`);
     try {
-      const s = e.factory();
-      if (s && !(s instanceof j) && typeof s.then == "function") {
-        const n = ++this.pendingBackendInitId, r = s.then((c) => n < this.pendingBackendInitId ? !1 : (this.registry[t] = c, this.pendingBackendInit = null, !0)).catch((c) => (n < this.pendingBackendInitId || (this.pendingBackendInit = null, T(`Initialization of backend ${t} failed`), T(c.stack || c.message)), !1));
+      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[t] = s, { success: !0, asyncInit: !1 };
+        return this.registry[e] = s, { success: !0, asyncInit: !1 };
     } catch (s) {
-      return T(`Initialization of backend ${t} failed`), T(s.stack || s.message), { success: !1, asyncInit: !1 };
+      return w(`Initialization of backend ${e} failed`), w(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);
+  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((t, e) => this.registryFactory[e].priority - this.registryFactory[t].priority);
+    return Object.keys(this.registryFactory).sort((e, t) => this.registryFactory[t].priority - this.registryFactory[e].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);
+    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(t, e) {
-    const s = this.state.tensorInfo.get(e);
-    s || console.warn("Tried to move data that does not exist", this.state, e);
-    const n = s.backend, r = this.readSync(e), c = n.refCount(e);
-    n.disposeData(e, !0), s.backend = t, t.move(e, r, s.shape, s.dtype, c), this.shouldCheckForMemLeaks() && this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
+  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(t, e) {
+  tidy(e, t) {
     let s = null;
-    if (e == null) {
-      if (typeof t != "function")
+    if (t == null) {
+      if (typeof e != "function")
         throw new Error("Please provide a function to tidy()");
-      e = t;
+      t = e;
     } else {
-      if (typeof t != "string" && !(t instanceof String))
+      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 e != "function")
+      if (typeof t != "function")
         throw new Error("When calling with two arguments, the 2nd argument to tidy() must be a function");
-      s = t;
+      s = e;
     }
     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)
+      () => (n = t(), n instanceof Promise && console.error("Cannot return a Promise inside of tidy."), n)
     );
   }
-  scopedRun(t, e, s) {
-    t();
+  scopedRun(e, t, s) {
+    e();
     try {
       const n = s();
-      return e(), n;
+      return t(), n;
     } catch (n) {
-      throw e(), n;
+      throw t(), n;
     }
   }
   static nextTensorId = 0;
   nextTensorId() {
-    return v.nextTensorId++;
+    return I.nextTensorId++;
   }
   static nextVariableId = 0;
   nextVariableId() {
-    return v.nextVariableId++;
+    return I.nextVariableId++;
   }
   /**
    * This method is called instead of the public-facing tensor.clone() when
@@ -277,16 +311,16 @@ class v {
    * operation to the tape regardless of being called inside a kernel
    * execution.
    */
-  clone(t) {
-    const s = w(t) ? z(y.runKernel(M, { x: t })) : y.runKernel(M, { x: t }), n = { x: t }, r = (h) => ({
+  clone(e) {
+    const s = T(e) ? O(y.runKernel(P, { x: e })) : y.runKernel(P, { x: e }), n = { x: e }, r = (d) => ({
       x: () => {
-        const a = "float32", i = { x: h }, d = { dtype: a }, l = w(t), u = y.runKernel(
-          _,
-          i,
+        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
-          d
+          h
         );
-        return l && z(u), u;
+        return u && O(l), l;
       }
     }), c = [];
     return this.addTapeNode(this.state.activeScope.name, n, [s], r, c, {}), s;
@@ -304,24 +338,24 @@ class v {
    *     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, !(V(t, this.backendName) != null))
-      throw new Error(`Kernel '${t}' not registered for backend '${this.backendName}'`);
-    return this.runKernelFunc({ kernelName: t, inputs: e, attrs: s });
+  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(t, e, s) {
+  checkKernelForMemLeak(e, t, s) {
     const n = this.backend.numDataIds();
     let r = 0;
-    s.forEach((a) => {
-      r += a.dtype === "complex64" ? 3 : 1;
+    s.forEach((o) => {
+      r += o.dtype === "complex64" ? 3 : 1;
     });
-    const c = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1], h = n - e - r - c;
-    if (h > 0)
+    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 (${h} data ids) after running '${t}'`
+        `Backend '${this.backendName}' has an internal memory leak (${d} data ids) after running '${e}'`
       );
   }
   /**
@@ -329,81 +363,81 @@ class v {
    *
    * Use `runKernel` to execute kernels from outside of engine.
    */
-  runKernelFunc(t) {
-    let e, s = [];
+  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 h;
+    let d;
     this.backendName == null && this.backend;
-    let a;
-    const i = S(t) ? t.kernelName : this.state.activeScope != null ? this.state.activeScope.name : "";
-    if (S(t)) {
-      const { kernelName: f, inputs: I, attrs: m } = t;
+    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 g = V(f, this.backendName);
+      const k = A(f, this.backendName);
       p(
-        g != null,
+        k != null,
         () => `Cannot find registered kernel '${f}' for backend '${this.backendName}'`
-      ), h = () => {
-        const G = this.backend.numDataIds();
-        a = g.kernelFunc({ inputs: I, attrs: m, backend: this.backend });
-        const F = Array.isArray(a) ? a : [a];
-        this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(f, G, F);
-        const D = F.map((b) => b.rank != null ? b : this.makeTensorFromTensorInfo(b));
+      ), 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, I, D);
+          const b = this.getTensorsForGradient(f, v, V);
           s = this.saveTensorsForBackwardMode(b ?? []);
         }
-        return D;
+        return V;
       };
     } else {
-      const { forwardFunc: f } = t, I = (m) => {
-        n && (s = m.map((g) => this.keep(this.clone(g))));
+      const { forwardFunc: f } = e, v = (m) => {
+        n && (s = m.map((k) => this.keep(this.clone(k))));
       };
-      h = () => {
+      d = () => {
         const m = this.backend.numDataIds();
-        a = this.tidy(() => f(this.backend, I));
-        const g = Array.isArray(a) ? a : [a];
-        return this.shouldCheckForMemLeaks() && this.checkKernelForMemLeak(i, m, g), g;
+        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: d, attrs: l } = t, u = S(t) ? null : t.backwardsFunc;
-    let 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 ? e = h() : (k = this.profiler.profileKernel(i, d, () => h()), this.ENV.getBool("DEBUG") && this.profiler.logKernelProfile(k), e = k.outputs);
+        !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(
-      i,
-      d,
-      e,
-      u,
+      a,
+      h,
+      t,
+      l,
       s,
-      l ?? {}
+      u ?? {}
     ), this.state.profiling && this.state.activeProfile.kernels.push({
-      name: i,
+      name: a,
       bytesAdded: this.state.numBytes - r,
       totalBytesSnapshot: this.state.numBytes,
       tensorsAdded: this.state.numTensors - c,
       totalTensorsSnapshot: this.state.numTensors,
-      inputShapes: Object.keys(d).map(
-        (f) => d[f] != null ? d[f].shape : null
+      inputShapes: Object.keys(h).map(
+        (f) => h[f] != null ? h[f].shape : null
       ),
-      outputShapes: e.map((f) => f.shape),
-      kernelTimeMs: k.timeMs,
-      extraInfo: k.extraInfo
-    }), Array.isArray(a) ? e : e[0];
+      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(t) {
-    return t.map((s) => this.keep(this.clone(s)));
+  saveTensorsForBackwardMode(e) {
+    return e.map((s) => this.keep(this.clone(s)));
   }
   /**
    * Returns a list of tensors to save for a given gradient calculation.
@@ -412,14 +446,14 @@ class v {
    * @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 = $(t);
+  getTensorsForGradient(e, t, s) {
+    const n = z(e);
     if (n != null) {
       const r = n.inputsToSave || [], c = n.outputsToSave || [];
-      let h;
-      n.saveAllInputs ? (p(Array.isArray(e), () => "saveAllInputs is true, expected inputs to be an array."), h = Object.keys(e).map((i) => e[i])) : h = r.map((i) => e[i]);
-      const a = s.filter((i, d) => c[d]);
-      return h.concat(a);
+      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 [];
   }
@@ -428,18 +462,18 @@ class v {
    * 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)
+  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 = t;
-    s === "string" && Y(t[0]) && (r = t.map((a) => Z(a)));
-    const c = n.write(r, e, s), h = new A(e, s, c, this.nextTensorId());
-    if (this.trackTensor(h, n), s === "string") {
-      const a = this.state.tensorInfo.get(c), i = J(r);
-      this.state.numBytes += i - a.bytes, a.bytes = i;
+    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 h;
+    return d;
   }
   /**
    * Internal method used by backends. Makes a new tensor
@@ -447,9 +481,9 @@ class v {
    * a new data id, only increments the ref count used in memory tracking.
    * @deprecated
    */
-  makeTensorFromDataId(t, e, s, n) {
+  makeTensorFromDataId(e, t, s, n) {
     s = s || "float32";
-    const r = { dataId: t, shape: e, dtype: s };
+    const r = { dataId: e, shape: t, dtype: s };
     return this.makeTensorFromTensorInfo(r, n);
   }
   /**
@@ -457,69 +491,69 @@ class v {
    * 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, c = new A(n, r, s, this.nextTensorId());
-    if (c.packed = t.packed || !1, c.packed && r !== "int32")
+  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, e ?? this.backend), c;
+    return this.trackTensor(c, t ?? this.backend), c;
   }
-  makeVariable(t, e = !0, s, n) {
-    s = s || this.nextVariableId().toString(), n != null && n !== t.dtype && (t = t.cast(n));
-    const r = new rt(t, e, s, this.nextTensorId());
+  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(t, e) {
-    this.state.numTensors++, t.dtype === "string" && this.state.numStringTensors++;
+  trackTensor(e, t) {
+    this.state.numTensors++, e.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,
+    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
-    })), t instanceof Q || this.track(t);
+    })), 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(t, e) {
-    this.trackTensor(t, e), this.backend.incRef(t.dataId);
+  incRef(e, t) {
+    this.trackTensor(e, t), this.backend.incRef(e.dataId);
   }
-  removeDataId(t, e) {
-    this.state.tensorInfo.has(t) && this.state.tensorInfo.get(t).backend === e && (this.state.tensorInfo.delete(t), this.state.numDataBuffers--);
+  removeDataId(e, t) {
+    this.state.tensorInfo.has(e) && this.state.tensorInfo.get(e).backend === t && (this.state.tensorInfo.delete(e), this.state.numDataBuffers--);
   }
-  disposeTensor(t) {
-    if (!this.state.tensorInfo.has(t.dataId))
+  disposeTensor(e) {
+    if (!this.state.tensorInfo.has(e.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);
+    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;
     }
-    e.backend.disposeData(t.dataId) && this.removeDataId(t.dataId, e.backend);
+    t.backend.disposeData(e.dataId) && this.removeDataId(e.dataId, t.backend);
   }
   disposeVariables() {
-    for (const t in this.state.registeredVariables) {
-      const e = this.state.registeredVariables[t];
-      this.disposeVariable(e);
+    for (const e in this.state.registeredVariables) {
+      const t = this.state.registeredVariables[e];
+      this.disposeVariable(t);
     }
   }
-  disposeVariable(t) {
-    this.disposeTensor(t), this.state.registeredVariables[t.name] != null && delete this.state.registeredVariables[t.name];
+  disposeVariable(e) {
+    this.disposeTensor(e), this.state.registeredVariables[e.name] != null && delete this.state.registeredVariables[e.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;
+    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(t) {
+  async profile(e) {
     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(
+    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 - e, this.state.activeProfile.newTensors = this.state.numTensors - s;
+    ), 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;
@@ -527,18 +561,18 @@ class v {
   isTapeOn() {
     return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
   }
-  addTapeNode(t, e, s, n, r, c) {
-    const h = { id: this.state.nextTapeNodeId++, kernelName: t, inputs: e, outputs: s, saved: r }, a = $(t);
-    a != null && (n = a.gradFunc), n != null && (h.gradient = (i) => (i = i.map((d, l) => {
-      if (d == null) {
-        const u = s[l], k = tt(u.size, u.dtype);
-        return this.makeTensor(k, u.shape, u.dtype);
+  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 d;
-    }), n(i.length > 1 ? i : i[0], r, c))), this.state.activeTape.push(h);
+      return h;
+    }), n(a.length > 1 ? a : a[0], r, c))), this.state.activeTape.push(d);
   }
-  keep(t) {
-    return t.kept = !0, t;
+  keep(e) {
+    return e.kept = !0, e;
   }
   startTape() {
     this.state.gradientDepth === 0 && (this.state.activeTape = []), this.state.gradientDepth++;
@@ -550,26 +584,26 @@ class v {
    * 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 = {
+  startScope(e) {
+    const t = {
       track: [],
       name: "unnamed scope",
       id: this.state.nextScopeId++
     };
-    t && (e.name = t), this.state.scopeStack.push(e), this.state.activeScope = e;
+    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(t) {
-    const e = O(t), s = new Set(e.map((r) => r.id));
+  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], e.forEach((r) => {
+    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);
     });
   }
@@ -579,68 +613,68 @@ class v {
    * 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 (p(e.length > 0, () => "gradients() received an empty list of xs."), s != null && s.dtype !== "float32")
+  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", t)
+      () => this.tidy("forward", e)
     );
     p(r instanceof B, () => "The result y returned by f() must be a tensor.");
-    const c = L(this.state.activeTape, e, r);
-    if (!n && c.length === 0 && e.length > 0)
+    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 h = {};
-      h[r.id] = s ?? at(r.shape), it(
-        h,
+      const d = {};
+      d[r.id] = s ?? le(r.shape), he(
+        d,
         c,
         // Pass the tidy function to avoid circular dep with `tape.ts`.
-        (i) => this.tidy(i),
+        (a) => this.tidy(a),
         // Pass an add function to avoide a circular dep with `tape.ts`.
-        ct
+        fe
       );
-      const a = e.map((i) => h[i.id]);
-      return this.state.gradientDepth === 0 && (this.state.activeTape.forEach((i) => {
-        if (i.saved !== void 0)
-          for (const d of i.saved)
-            d.dispose();
-      }), this.state.activeTape = null), { value: r, grads: a };
+      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(t) {
-    return p(N(t), () => "The f passed in customGrad(f) must be a function."), (...e) => {
+  customGrad(e) {
+    return p(G(e), () => "The f passed in customGrad(f) must be a function."), (...t) => {
       p(
-        e.every((h) => h instanceof B),
+        t.every((d) => d instanceof B),
         () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors"
       );
       let s;
       const n = {};
-      e.forEach((h, a) => {
-        n[a] = h;
+      t.forEach((d, o) => {
+        n[o] = d;
       });
-      const r = (h, a) => (s = t(...e, a), p(
+      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(
-        N(s.gradFunc),
+        G(s.gradFunc),
         () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function."
-      ), s.value), c = (h, a) => {
-        const i = s.gradFunc(h, a), d = Array.isArray(i) ? i : [i];
+      ), s.value), c = (d, o) => {
+        const a = s.gradFunc(d, o), h = Array.isArray(a) ? a : [a];
         p(
-          d.length === e.length,
+          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(
-          d.every((u) => u instanceof B),
+          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 l = {};
-        return d.forEach((u, k) => {
-          l[k] = () => u;
-        }), l;
+        const u = {};
+        return h.forEach((l, g) => {
+          u[g] = () => l;
+        }), u;
       };
       return this.runKernelFunc({
         forwardFunc: r,
@@ -649,18 +683,18 @@ class v {
       });
     };
   }
-  readSync(t) {
-    return this.state.tensorInfo.get(t).backend.readSync(t);
+  readSync(e) {
+    return this.state.tensorInfo.get(e).backend.readSync(e);
   }
-  read(t) {
-    return this.state.tensorInfo.get(t).backend.read(t);
+  read(e) {
+    return this.state.tensorInfo.get(e).backend.read(e);
   }
-  readToGPU(t, e) {
-    return this.state.tensorInfo.get(t).backend.readToGPU(t, e);
+  readToGPU(e, t) {
+    return this.state.tensorInfo.get(e).backend.readToGPU(e, t);
   }
-  async time(t) {
-    const e = P(), s = await this.backend.time(t);
-    return s.wallMs = P() - e, s;
+  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
@@ -668,8 +702,8 @@ class v {
    *
    * @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;
+  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;
@@ -679,38 +713,38 @@ class v {
    * registered backend factories.
    */
   reset() {
-    this.pendingBackendInitId++, this.state.dispose(), this.ENV.reset(), this.state = new C();
-    for (const t in this.registry)
-      this.disposeRegisteredKernels(t), this.registry[t].dispose(), delete this.registry[t];
+    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 at(o) {
-  const t = et(st(o), "float32");
-  return y.makeTensor(t, o, "float32");
+function le(i) {
+  const e = re(ie(i), "float32");
+  return y.makeTensor(e, i, "float32");
 }
-function ot() {
-  const o = W();
-  if (o._tfengine == null) {
-    const t = new H(o);
-    o._tfengine = new v(t);
+function ue() {
+  const i = U();
+  if (i._tfengine == null) {
+    const e = new L(i);
+    i._tfengine = new I(e);
   }
-  return X(o._tfengine.ENV), nt(() => o._tfengine), o._tfengine;
+  return ae(i._tfengine.ENV), ce(() => i._tfengine), i._tfengine;
 }
-const y = ot();
-function ct(o, t) {
-  const e = w(o) || w(t), s = { a: o, b: t };
-  return y.runKernel(e ? "Add16" : U, s);
+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);
 }
 export {
-  v as E,
+  I as E,
   y as a,
-  it as b,
-  ct as c,
-  ot as g,
-  E as isPackableTensor,
-  w as isPackedTensor,
-  z as packTensor,
-  lt as packingSupported,
-  ft as unpackTensor
+  he as b,
+  fe as c,
+  ue as g,
+  x as isPackableTensor,
+  T as isPackedTensor,
+  O as packTensor,
+  be as packingSupported,
+  we as unpackTensor
 };