@genai-fi/nanogpt 0.18.0 → 0.19.0

package/dist/training/sparseCrossEntropy.js

@@ -1,69 +1,69 @@
-import { gatherSub as j } from "../ops/gatherSub.js";
+import { gatherSub as $ } from "../ops/gatherSub.js";
 import { scatterSub as T } from "../ops/scatterSub.js";
-import { t as H, a1 as G, h as A, m as x, d as U, a2 as D, b as q, a3 as F } from "../index-DSGwv2Yx.js";
-import { m as J, l as K, a as E, n as N, w as O } from "../not_equal-CkQKkKZy.js";
-import { s as m } from "../sum-D39FeU5h.js";
-import { s as Q } from "../softmax-BLGJqdwx.js";
-function R(e, h, t, g, v, a = 0) {
-  return H(() => {
-    const S = e.shape[e.shape.length - 1], i = v || e.shape.slice(0, -1), l = i.reduce((n, p) => n * p, 1), f = e.shape.length > 2 ? e.reshape([l, S]) : e, b = h.shape.length > 1 ? h.reshape([l]).cast("int32") : h.cast("int32"), u = J(f, -1, !0), o = G(f, u), r = K(o, -1), d = j(r, b, o);
+import { t as F, a1 as G, j as A, m as x, i as U, a2 as D, a as j, a3 as q } from "../index-CUXkjxiT.js";
+import { m as J, l as K, a as E, n as N, w as O } from "../not_equal-hurPF26l.js";
+import { s as m } from "../sum-BpiwSWvg.js";
+import { s as Q } from "../softmax-D4q1LJN7.js";
+function R(e, l, a, g, v, t = 0) {
+  return F(() => {
+    const S = e.shape[e.shape.length - 1], i = v || e.shape.slice(0, -1), f = i.reduce((c, d) => c * d, 1), h = e.shape.length > 2 ? e.reshape([f, S]) : e, y = l.shape.length > 1 ? l.reshape([f]).cast("int32") : l.cast("int32"), u = J(h, -1, !0), o = G(h, u), n = K(o, -1), p = $(n, y, o);
     let s;
-    if (a > 0) {
-      const n = G(r, E(o, -1));
-      s = A(x(d, 1 - a), x(n, a));
+    if (t > 0) {
+      const c = G(n, E(o, -1));
+      s = A(x(p, 1 - t), x(c, t));
     } else
-      s = d;
-    if (t)
-      if (s = x(s, t), g) {
-        const n = m(t.reshape(i), -1);
-        s = U(m(s.reshape(i), -1), n);
+      s = p;
+    if (a)
+      if (s = x(s, a), g) {
+        const c = m(a.reshape(i), -1);
+        s = U(m(s.reshape(i), -1), c);
       } else {
-        const n = m(t);
-        s = U(m(s), n);
+        const c = m(a);
+        s = U(m(s), c);
       }
     else
       g ? s = E(s.reshape(i), -1) : s = E(s);
     return s;
   });
 }
-function ts(e, h, t = 0) {
+function as(e, l, a = 0) {
   return D(
     // @ts-expect-error Invalid params
-    (a, S, i) => {
-      const l = a.shape[a.shape.length - 1], f = a.shape.slice(0, -1), b = f.reduce((p, c) => p * c, 1), u = a.reshape([b, l]), o = S.reshape([b]).cast("int32");
-      let r, d = null;
+    (t, S, i) => {
+      const f = t.shape[t.shape.length - 1], h = t.shape.slice(0, -1), y = h.reduce((d, r) => d * r, 1), u = t.reshape([y, f]), o = S.reshape([y]).cast("int32");
+      let n, p = null;
       if (e) {
-        const p = q(-100, "int32"), c = N(o, p);
-        d = c.cast("float32"), r = O(c, o, F(o));
+        const d = j(65535, "int32"), r = N(o, d);
+        p = r.cast("float32"), n = O(r, o, q(o)), d.dispose(), r.dispose();
       } else
-        r = o;
+        n = o;
       const s = R(
         u,
-        r,
-        d || void 0,
+        n,
+        p || void 0,
+        l,
         h,
-        f,
-        t
+        a
       );
-      return i(d ? [u, r, d] : [u, r]), u.dispose(), o.dispose(), { value: s, gradFunc: (p, c) => H(() => {
-        const C = c[0], z = c[1], y = e ? c[2] : void 0, w = Q(C), P = y ? m(y) : q(C.shape[0], "float32"), I = p.div(P).broadcastTo([C.shape[0]]), M = y && e ? x(I, y) : I;
+      return i(p ? [u, n, p] : [u, n]), u.dispose(), o.dispose(), { value: s, gradFunc: (d, r) => F(() => {
+        const C = r[0], z = r[1], b = e ? r[2] : void 0, w = Q(C), H = b ? m(b) : j(C.shape[0], "float32"), I = d.div(H).broadcastTo([C.shape[0]]), M = b && e ? x(I, b) : I;
         let L;
-        if (t > 0) {
-          const W = t / l, $ = G(w, W);
+        if (a > 0) {
+          const V = a / f, W = G(w, V);
           L = T(
-            $,
+            W,
             z,
-            x(M, 1 - t)
+            x(M, 1 - a)
           );
         } else
           L = T(w, z, M);
-        const V = F(S);
-        return [L.reshape(a.shape), V];
+        const P = q(S);
+        return [L.reshape(t.shape), P];
       }) };
     }
   );
 }
 export {
-  ts as createSoftmaxCrossEntropyWithGrad,
+  as as createSoftmaxCrossEntropyWithGrad,
   R as sparseSoftmaxCrossEntropy
 };

package/dist/training/tasks/ConversationTask.d.ts

@@ -9,6 +9,10 @@ export default class ConversationTask extends Task {
     hasMoreConversations(): boolean;
     nextConversation(): Conversation[] | null;
     nextTokens(tokeniser: ITokeniser): number[] | null;
+    nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
     shuffle(): void;
     estimateTokens(tokeniser: ITokeniser): Promise<number>;
 }

package/dist/training/tasks/ConversationTask.js

@@ -1,6 +1,6 @@
 import { Task as t } from "./Task.js";
-import { shuffle as s } from "../DatasetBuilder.js";
-class a extends t {
+import { shuffle as i } from "../DatasetBuilder.js";
+class f extends t {
   rawConvo;
   shuffledIndices = null;
   index = 0;
@@ -19,9 +19,9 @@ class a extends t {
     const n = this.rawConvo[this.shuffledIndices ? this.shuffledIndices[this.index] : this.index];
     return this.index++, n;
   }
-  nextTokens(n) {
+  nextTokens(n, s) {
     const e = this.nextConversation();
-    return e ? n.encodeConversation(e) : null;
+    return e ? n.encodeConversation(e, !1, s) : null;
   }
   shuffle() {
     if (!this.shuffledIndices) {
@@ -29,12 +29,12 @@ class a extends t {
       for (let n = 0; n < this.rawConvo.length; n++)
         this.shuffledIndices[n] = n;
     }
-    s(this.shuffledIndices), this.index = 0;
+    i(this.shuffledIndices), this.index = 0;
   }
   async estimateTokens(n) {
-    return (await n.encodeConversation(this.rawConvo[0])).length * this.length;
+    return n.encodeConversation(this.rawConvo[0]).length * this.length;
   }
 }
 export {
-  a as default
+  f as default
 };

package/dist/training/tasks/PretrainingTask.d.ts

@@ -8,6 +8,10 @@ export default class PretrainingTask extends Task {
     hasMoreConversations(): boolean;
     nextConversation(): Conversation[] | null;
     nextTokens(tokeniser: ITokeniser): number[] | null;
+    nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
     shuffle(): void;
     estimateTokens(tokeniser: ITokeniser): Promise<number>;
 }

package/dist/training/tasks/PretrainingTask.js

@@ -1,5 +1,5 @@
-import { Task as n } from "./Task.js";
-class r extends n {
+import { Task as r } from "./Task.js";
+class h extends r {
   rawText;
   index = 0;
   get length() {
@@ -20,24 +20,28 @@ class r extends n {
     };
     return this.index++, [t];
   }
-  nextTokens(t) {
+  nextTokens(t, n) {
     if (this.index >= this.rawText.length)
       return null;
     const e = t.encodeSequence(this.rawText[this.index]);
-    return this.index++, e;
+    if (this.index++, n) {
+      const s = new Array(e.length).fill(!0);
+      return { tokens: e, mask: s };
+    }
+    return e;
   }
   shuffle() {
     this.index = 0;
   }
   async estimateTokens(t) {
-    return (await t.encodeConversation([
+    return t.encodeConversation([
       {
         role: "assistant",
         content: this.rawText[0]
       }
-    ])).length * this.length;
+    ]).length * this.length;
   }
 }
 export {
-  r as default
+  h as default
 };

package/dist/training/tasks/StartSentenceTask.d.ts

@@ -8,6 +8,10 @@ export default class StartSentenceTask extends Task {
     hasMoreConversations(): boolean;
     nextConversation(): Conversation[] | null;
     nextTokens(tokeniser: ITokeniser): number[] | null;
+    nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
     shuffle(): void;
     private conversationFromString;
     estimateTokens(tokeniser: ITokeniser): Promise<number>;

package/dist/training/tasks/StartSentenceTask.js

@@ -1,5 +1,5 @@
-import { Task as e } from "./Task.js";
-class a extends e {
+import { Task as r } from "./Task.js";
+class a extends r {
   rawText;
   index = 0;
   get length() {
@@ -17,9 +17,9 @@ class a extends e {
     const t = this.rawText[this.index];
     return this.index++, this.conversationFromString(t);
   }
-  nextTokens(t) {
-    const n = this.nextConversation();
-    return n ? t.encodeConversation(n) : null;
+  nextTokens(t, n) {
+    const e = this.nextConversation();
+    return e ? t.encodeConversation(e, !1, n) : null;
   }
   shuffle() {
     this.index = 0;

package/dist/training/tasks/Task.d.ts

@@ -4,7 +4,19 @@ export declare abstract class Task {
     abstract hasMoreConversations(): boolean;
     abstract nextConversation(): Conversation[] | null;
     abstract nextTokens(tokeniser: ITokeniser): number[] | null;
+    abstract nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
+    abstract nextTokens(tokeniser: ITokeniser, masking?: boolean): number[] | {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
     abstract estimateTokens(tokeniser: ITokeniser): Promise<number>;
     abstract shuffle(): void;
 }
 export declare function tokensFromTasks(tasks: Task[], tokenizer: ITokeniser, cb?: (tokens: number) => void): Promise<Uint16Array>;
+export declare function tokensFromTasks(tasks: Task[], tokenizer: ITokeniser, cb?: (tokens: number) => void, masking?: boolean): Promise<{
+    tokens: Uint16Array;
+    mask: Uint8Array;
+}>;

package/dist/training/tasks/Task.js

@@ -1,44 +1,68 @@
-import { yieldIfNeeded as g } from "../../utilities/yielder.js";
-class y {
+import { yieldIfNeeded as k } from "../../utilities/yielder.js";
+class w {
 }
-function u(i, f, h, t, n) {
-  for (const s of i) {
-    const o = s.nextTokens(h);
-    if (o) {
-      t.total += o.length;
-      const c = f[f.length - 1];
-      if (t.offset + o.length > c.length) {
-        const r = c.length - t.offset;
-        c.set(o.slice(0, r), t.offset);
-        const l = new Uint16Array(Math.floor(n * 0.1) + 100);
-        l.set(o.slice(r), 0), f.push(l), t.offset = o.length - r;
+function m(y, i, u, o, g, n) {
+  for (const a of y) {
+    const e = a.nextTokens(u, n ? !0 : void 0);
+    if (e) {
+      const f = Array.isArray(e) ? e : e.tokens;
+      o.total += f.length;
+      const c = i[i.length - 1], l = n ? n[n.length - 1] : null;
+      if (o.offset + f.length > c.length) {
+        const s = c.length - o.offset;
+        c.set(f.slice(0, s), o.offset);
+        const t = new Uint16Array(Math.floor(g * 0.1) + 100);
+        if (t.set(f.slice(s), 0), i.push(t), n && l && !Array.isArray(e)) {
+          l.set(
+            e.mask.slice(0, s).map((h) => h ? 1 : 0),
+            o.offset
+          );
+          const r = new Uint8Array(t.length);
+          r.set(
+            e.mask.slice(s).map((h) => h ? 1 : 0),
+            0
+          ), n.push(r);
+        }
+        o.offset = f.length - s;
       } else
-        c.set(o, t.offset), t.offset += o.length;
+        c.set(f, o.offset), l && !Array.isArray(e) && l.set(
+          e.mask.map((s) => s ? 1 : 0),
+          o.offset
+        ), o.offset += f.length;
     }
   }
 }
-async function d(i, f, h) {
-  const t = Math.min(
-    (await Promise.all(i.map((e) => e.estimateTokens(f)))).reduce((e, a) => e + a, 0),
-    f.vocabSize * 1e4
-  ), n = [new Uint16Array(t)], s = {
+async function p(y, i, u, o) {
+  const g = Math.min(
+    (await Promise.all(y.map((t) => t.estimateTokens(i)))).reduce((t, r) => t + r, 0),
+    i.vocabSize * 1e4
+  ), n = [new Uint16Array(g)], a = o ? [new Uint8Array(g)] : null, e = {
     offset: 0,
     total: 0
   };
-  let o = performance.now();
-  for (; s.offset < t && (u(i, n, f, s, t), !i.every((e) => !e.hasMoreConversations())); )
-    o = await g(o, h, s.total);
+  let f = performance.now();
+  for (; e.offset < g && (m(y, n, i, e, g, a || void 0), !y.every((t) => !t.hasMoreConversations())); )
+    f = await k(f, u, e.total);
   if (n.length === 1)
-    return n[0].subarray(0, s.offset);
-  const c = n.reduce((e, a) => e + a.length, 0) - (n[n.length - 1].length - s.offset), r = new Uint16Array(c);
-  let l = 0;
-  for (let e = 0; e < n.length; e++) {
-    const a = n[e];
-    e === n.length - 1 ? (r.set(a.subarray(0, s.offset), l), l += s.offset) : (r.set(a, l), l += a.length);
+    return a ? { tokens: n[0].subarray(0, e.offset), mask: a[0].subarray(0, e.offset) } : n[0].subarray(0, e.offset);
+  const c = n.reduce((t, r) => t + r.length, 0) - (n[n.length - 1].length - e.offset), l = new Uint16Array(c);
+  let s = 0;
+  for (let t = 0; t < n.length; t++) {
+    const r = n[t];
+    t === n.length - 1 ? (l.set(r.subarray(0, e.offset), s), s += e.offset) : (l.set(r, s), s += r.length);
   }
-  return r;
+  if (a) {
+    const t = new Uint8Array(c);
+    s = 0;
+    for (let r = 0; r < a.length; r++) {
+      const h = a[r];
+      r === a.length - 1 ? (t.set(h.subarray(0, e.offset), s), s += e.offset) : (t.set(h, s), s += h.length);
+    }
+    return { tokens: l, mask: t };
+  }
+  return l;
 }
 export {
-  y as Task,
-  d as tokensFromTasks
+  w as Task,
+  p as tokensFromTasks
 };

package/dist/training/types.d.ts

@@ -61,6 +61,7 @@ export interface TrainingOptions extends Partial<AdamWOptimizerConfig> {
     labelSmoothing?: number;
     dropout?: number;
     layerDrop?: number;
+    debug?: boolean;
     onStep?: (log: TrainingLogEntry) => void;
 }
 export interface TrainingState {

package/dist/training/validation.d.ts

@@ -2,7 +2,7 @@ import { ITokeniser, Task } from '../main';
 import { Tensor } from '@tensorflow/tfjs-core';
 import { Dataset } from '@tensorflow/tfjs-data';
 import { DatasetBuilder, DatasetState } from './DatasetBuilder';
-export declare function createTrainValidationSplit(tasks: Task[] | Uint16Array, tokeniser: ITokeniser, datasetBuilder: DatasetBuilder, batchSize: number, validationSplit?: number): Promise<{
+export declare function createTrainValidationSplit(tasks: Task[] | Uint16Array, tokeniser: ITokeniser, datasetBuilder: DatasetBuilder, batchSize: number, validationSplit?: number, masking?: boolean): Promise<{
     trainDataset: Dataset<{
         xs: Tensor;
         ys: Tensor;

package/dist/training/validation.js

@@ -1,22 +1,22 @@
-import "../index-DSGwv2Yx.js";
-import "../random_width-B_fVXhGx.js";
-import "../zeros_like-rOHr54NY.js";
+import "../index-CUXkjxiT.js";
+import "../random_width-DN5ZtQkM.js";
+import "../zeros_like-CWjDdwr-.js";
 import "../Generator.js";
 import "../index-Cp39cXWe.js";
-import "../dataset-DlqAN81i.js";
+import "../dataset-CGGp1z9P.js";
 import "../ops/cpu/attentionMask.js";
 import "../ops/webgl/attentionMask.js";
 import "../ops/grads/attentionMask.js";
 import "../ops/cpu/rope.js";
 import "../ops/webgl/rope.js";
-import "../rope-CC5RjmKU.js";
+import "../rope-DcrZM_e6.js";
 import "../ops/cpu/appendCache.js";
 import "../ops/webgl/appendCache.js";
 import "../ops/grads/softmax16.js";
-import "../matMul16-BIT70Vya.js";
+import "../matMul16-BcVC_E62.js";
 import "../ops/webgl/matMul16.js";
 import "../ops/cpu/matMul16.js";
-import "../pack16-WlOSOuZA.js";
+import "../pack16-bqltoUlR.js";
 import "../ops/transpose16.js";
 import "../ops/reshape16.js";
 import "../ops/cpu/qkv.js";
@@ -38,46 +38,47 @@ import "../ops/cpu/gatherSub.js";
 import "../ops/webgl/gatherSub.js";
 import "../ops/cpu/scatterSub.js";
 import "../ops/webgl/scatterSub.js";
-import { PAGE_FACTOR as m, shuffle as h } from "./DatasetBuilder.js";
-import { tokensFromTasks as k } from "./tasks/Task.js";
+import { PAGE_FACTOR as a, shuffle as k } from "./DatasetBuilder.js";
 import "../papaparse.min-C0cScC2i.js";
+import { tokensFromTasks as y } from "./tasks/Task.js";
 import "../ops/cpu/matMulGelu.js";
-import "../matMulGelu-CsZnh18H.js";
+import "../matMulGelu-JNLZqKQp.js";
 import "../ops/grads/matMulGelu.js";
 import "../ops/cpu/gelu.js";
 import "../ops/webgl/gelu.js";
-import "../gelu-DpTCC3eB.js";
+import "../gelu-B220X1Go.js";
 import "../ops/webgl/log.js";
 import "../checks/normRMS.js";
 import "../checks/normRMSGrad.js";
-async function dt(p, g, o, s, l = 0.1) {
-  const i = p instanceof Uint16Array ? p : await k(p, g), r = /* @__PURE__ */ new Set();
-  if (l > 0) {
-    const t = Math.floor(i.length / (o.blockSize * m)), n = Math.max(1, Math.floor(t * l));
-    for (; r.size < n; ) {
-      const d = Math.floor(Math.random() * t);
-      r.add(d);
+async function Mt(n, x, o, l, c = 0.1, d) {
+  const r = n instanceof Uint16Array ? n : await y(n, x, void 0, d), i = r instanceof Uint16Array ? r : r.tokens, f = r instanceof Uint16Array ? void 0 : r.mask, m = /* @__PURE__ */ new Set();
+  if (c > 0) {
+    const t = Math.floor(i.length / (o.blockSize * a)), s = Math.max(1, Math.floor(t * c));
+    for (; m.size < s; ) {
+      const M = Math.floor(Math.random() * t);
+      m.add(M);
     }
   }
-  const a = new Uint32Array(
-    i.length - r.size * o.blockSize * m
-  ), e = new Uint32Array(r.size * o.blockSize * m);
-  let c = 0, f = 0;
+  const p = new Uint32Array(
+    i.length - m.size * o.blockSize * a
+  ), e = new Uint32Array(m.size * o.blockSize * a);
+  let h = 0, g = 0;
   for (let t = 0; t < i.length; t++) {
-    const n = Math.floor(t / (o.blockSize * m));
-    r.has(n) ? f < e.length && (e[f++] = t) : c < a.length && (a[c++] = t);
+    const s = Math.floor(t / (o.blockSize * a));
+    m.has(s) ? g < e.length && (e[g++] = t) : h < p.length && (p[h++] = t);
   }
-  const { dataset: x, state: w } = await o.createTextDataset(
+  const { dataset: v, state: w } = await o.createTextDataset(
     i,
-    s,
-    h(a)
-  ), { dataset: z, state: M } = await o.createTextDataset(
+    l,
+    k(p),
+    f || void 0
+  ), { dataset: z, state: A } = await o.createTextDataset(
     i,
-    s,
-    h(e)
+    l,
+    k(e)
   );
-  return { trainDataset: x, validationDataset: z, size: i.length, validationState: M, trainState: w };
+  return { trainDataset: v, validationDataset: z, size: i.length, validationState: A, trainState: w };
 }
 export {
-  dt as createTrainValidationSplit
+  Mt as createTrainValidationSplit
 };

package/dist/{transpose-Qxz-4os3.js → transpose-9kRxIXWR.js}

@@ -1,5 +1,5 @@
-import { o as u, n as i, E as o, ao as $, ap as g, aq as m, v as l, t as x, ar as p } from "./index-DSGwv2Yx.js";
-import { c as k } from "./complex-3DpPEG9B.js";
+import { o as u, q as i, E as o, ao as $, ap as g, aq as x, x as l, t as m, ar as p } from "./index-CUXkjxiT.js";
+import { c as k } from "./complex-DI35Q-gW.js";
 function K(r) {
   const e = { input: i(r, "input", "imag") };
   return o.runKernel($, e);
@@ -12,25 +12,25 @@ function E(r) {
 const _ = /* @__PURE__ */ u({ neg_: E });
 function b(r) {
   const e = { input: i(r, "input", "real") };
-  return o.runKernel(m, e);
+  return o.runKernel(x, e);
 }
 const d = /* @__PURE__ */ u({ real_: b });
-function v(r, t, e) {
+function N(r, t, e) {
   const n = i(r, "x", "transpose");
   if (t == null && (t = n.shape.map((s, a) => a).reverse()), l(n.rank === t.length, () => `Error in transpose: rank of input ${n.rank} must match length of perm ${t}.`), t.forEach((s) => {
     l(s >= 0 && s < n.rank, () => `All entries in 'perm' must be between 0 and ${n.rank - 1} but got ${t}`);
   }), n.rank <= 1)
     return n.clone();
   const f = { x: n }, c = { perm: t };
-  return n.dtype === "complex64" ? x(() => {
+  return n.dtype === "complex64" ? m(() => {
     let s = d(n), a = h(n);
     return s = o.runKernel(p, { x: s }, c), a = o.runKernel(p, { x: a }, c), e && (a = _(a)), k(s, a);
   }) : o.runKernel(p, f, c);
 }
-const y = /* @__PURE__ */ u({ transpose_: v });
+const v = /* @__PURE__ */ u({ transpose_: N });
 export {
   h as i,
   _ as n,
   d as r,
-  y as t
+  v as t
 };

package/dist/{unsorted_segment_sum-BfFVV9Zm.js → unsorted_segment_sum-DJvk5xnh.js}

@@ -1,8 +1,8 @@
-import { o as h, n as c, E as d, bm as T, bn as q, bo as H, v as l, bp as P, J as _, bq as y, br as I, bs as W, bt as B, bu as A, bv as G, bw as L, bx as O, by as z, bz as F, z as M, _ as j, bA as J, bB as U, bC as V, a2 as Q, a1 as N, m as X, bD as Y, bE as Z, bF as R, bG as nn, bH as tn, bI as sn, bJ as en, bK as rn, bL as on, bM as an, bN as un, aE as cn, bO as ln } from "./index-DSGwv2Yx.js";
-import { k as C, c as g, m as D } from "./step-DQY6_ABw.js";
-import { r as b } from "./reshape-BIN71H3p.js";
-import { m as pn, b as hn, e as w } from "./not_equal-CkQKkKZy.js";
-import { s as K } from "./sum-D39FeU5h.js";
+import { o as h, q as c, E as d, bm as T, bn as q, bo as H, x as l, bp as P, L as _, bq as y, br as B, bs as I, bt as W, bu as A, bv as L, bw as G, bx as O, by as z, bz as F, B as M, _ as j, bA as J, bB as U, bC as V, a2 as Q, a1 as N, m as X, bD as Y, bE as Z, bF as R, bG as nn, bH as tn, bI as sn, bJ as en, bK as rn, bL as on, bM as an, bN as un, aE as cn, bO as ln } from "./index-CUXkjxiT.js";
+import { k as C, c as g, m as D } from "./step-BTxPtq1r.js";
+import { r as b } from "./reshape-BDOuCSNW.js";
+import { m as pn, b as hn, e as w } from "./not_equal-hurPF26l.js";
+import { s as K } from "./sum-BpiwSWvg.js";
 function fn(s, n = null, t = !1) {
   const i = { x: c(s, "x", "all", "bool") }, o = { axis: n, keepDims: t };
   return d.runKernel(T, i, o);
@@ -37,7 +37,7 @@ function xn(s, n, t) {
   const e = c(s, "x", "batchToSpaceND"), i = n.reduce((r, a) => r * a);
   l(e.rank >= 1 + n.length, () => `input rank is ${e.rank} but should be > than blockShape.length ${n.length}`), l(t.length === n.length, () => `crops.length is ${t.length} but should be equal to blockShape.length  ${n.length}`), l(e.shape[0] % i === 0, () => `input tensor batch is ${e.shape[0]} but is not divisible by the product of the elements of blockShape ${n.join(" * ")} === ${i}`);
   const o = { x: e }, p = { blockShape: n, crops: t };
-  return d.runKernel(I, o, p);
+  return d.runKernel(B, o, p);
 }
 const ot = /* @__PURE__ */ h({ batchToSpaceND_: xn });
 function kn(s) {
@@ -57,7 +57,7 @@ function vn(s, n, t, e, i, o) {
     offset: m,
     mean: r,
     variance: a
-  }, k = { varianceEpsilon: o }, $ = d.runKernel(W, x, k);
+  }, k = { varianceEpsilon: o }, $ = d.runKernel(I, x, k);
   return b($, p.shape);
 }
 const at = /* @__PURE__ */ h({ batchNorm_: vn });
@@ -67,7 +67,7 @@ function gn(s, n, t, e, i = "NHWC", o = [1, 1], p) {
   r.rank === 3 && (m = !0, u = b(r, [1, r.shape[0], r.shape[1], r.shape[2]])), l(u.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${u.rank}.`), l(a.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ${a.rank}.`), g("conv2d", e, p);
   const f = i === "NHWC" ? u.shape[3] : u.shape[1];
   l(f === a.shape[2], () => `Error in conv2d: depth of input (${f}) must match input depth for filter ${a.shape[2]}.`), l(C(t, o), () => `Error in conv2D: Either strides or dilations must be 1. Got strides ${t} and dilations '${o}'`), l(D(o), () => "Error in conv2D: Dilated rates should be larger than 0."), l(D(t), () => "Error in conv2D: Strides should be larger than 0.");
-  const x = { x: u, filter: a }, k = { strides: t, pad: e, dataFormat: i, dilations: o, dimRoundingMode: p }, $ = d.runKernel(B, x, k);
+  const x = { x: u, filter: a }, k = { strides: t, pad: e, dataFormat: i, dilations: o, dimRoundingMode: p }, $ = d.runKernel(W, x, k);
   return m ? b($, [$.shape[1], $.shape[2], $.shape[3]]) : $;
 }
 const S = /* @__PURE__ */ h({ conv2d_: gn });
@@ -96,12 +96,12 @@ function Nn(s, n, t, e, i, o) {
 const ut = /* @__PURE__ */ h({ conv2dTranspose_: Nn });
 function _n(s) {
   const t = { x: c(s, "x", "cos", "float32") };
-  return d.runKernel(G, t);
+  return d.runKernel(L, t);
 }
 const ct = /* @__PURE__ */ h({ cos_: _n });
 function wn(s) {
   const t = { x: c(s, "x", "cosh", "float32") };
-  return d.runKernel(L, t);
+  return d.runKernel(G, t);
 }
 const lt = /* @__PURE__ */ h({ cosh_: wn });
 function Kn(s, n = 0, t = !1, e = !1) {
@@ -143,7 +143,7 @@ function yn(s) {
   return d.runKernel(V, t);
 }
 const mt = /* @__PURE__ */ h({ softplus_: yn });
-function In(s, n = -1) {
+function Bn(s, n = -1) {
   const t = c(s, "logits", "logSoftmax");
   if (n === -1 && (n = t.rank - 1), n !== t.rank - 1)
     throw Error(`Log Softmax along a non-last dimension is not yet supported. Logits was rank ${t.rank} and axis was ${n}`);
@@ -155,20 +155,20 @@ function In(s, n = -1) {
     } };
   })(t);
 }
-const $t = /* @__PURE__ */ h({ logSoftmax_: In });
-function Wn(s) {
+const $t = /* @__PURE__ */ h({ logSoftmax_: Bn });
+function In(s) {
   const t = { x: c(s, "x", "logicalNot", "bool") };
   return d.runKernel(Y, t);
 }
-const bt = /* @__PURE__ */ h({ logicalNot_: Wn });
-function Bn(s, n, t, e, i) {
+const bt = /* @__PURE__ */ h({ logicalNot_: In });
+function Wn(s, n, t, e, i) {
   const o = c(s, "x", "maxPool"), p = 1;
   let r = o, a = !1;
   o.rank === 3 && (a = !0, r = b(o, [1, o.shape[0], o.shape[1], o.shape[2]])), l(r.rank === 4, () => `Error in maxPool: input must be rank 4 but got rank ${r.rank}.`), l(C(t, p), () => `Error in maxPool: Either strides or dilations must be 1. Got strides ${t} and dilations '${p}'`), g("maxPool", e, i);
   const u = { x: r }, m = { filterSize: n, strides: t, pad: e, dimRoundingMode: i }, f = d.runKernel(Z, u, m);
   return a ? b(f, [f.shape[1], f.shape[2], f.shape[3]]) : f;
 }
-const xt = /* @__PURE__ */ h({ maxPool_: Bn });
+const xt = /* @__PURE__ */ h({ maxPool_: Wn });
 function An(s, n, t = 1, e = 0, i = "int32") {
   if (n < 2)
     throw new Error(`Error in oneHot: depth must be >=2, but it is ${n}`);
@@ -176,19 +176,19 @@ function An(s, n, t = 1, e = 0, i = "int32") {
   return d.runKernel(R, p, r);
 }
 const kt = /* @__PURE__ */ h({ oneHot_: An });
-function Gn(s) {
+function Ln(s) {
   const t = { x: c(s, "x", "onesLike") };
   return d.runKernel(nn, t);
 }
-const vt = /* @__PURE__ */ h({ onesLike_: Gn });
-function Ln(s, n, t = 0) {
+const vt = /* @__PURE__ */ h({ onesLike_: Ln });
+function Gn(s, n, t = 0) {
   const e = c(s, "x", "pad");
   if (e.rank === 0)
     throw new Error("pad(scalar) is not defined. Pass non-scalar to pad");
   const i = { paddings: n, constantValue: t }, o = { x: e };
   return d.runKernel(tn, o, i);
 }
-const gt = /* @__PURE__ */ h({ pad_: Ln });
+const gt = /* @__PURE__ */ h({ pad_: Gn });
 function On(s, n, t) {
   const e = c(s, "x", "spaceToBatchND");
   l(e.rank >= 1 + n.length, () => `input rank ${e.rank} should be > than [blockShape] ${n.length}`), l(t.length === n.length, () => `paddings.shape[0] ${t.length} must be equal to [blockShape] ${n.length}`), l(e.shape.reduce((p, r, a) => a > 0 && a <= n.length ? p && (r + t[a - 1][0] + t[a - 1][1]) % n[a - 1] === 0 : p, !0), () => `input spatial dimensions ${e.shape.slice(1)} with paddings ${t.toString()} must be divisible by blockShapes ${n.toString()}`);