@genai-fi/nanogpt 0.7.2 → 0.8.0

package/dist/training/FullTrainer.d.ts

@@ -1,10 +1,23 @@
 import { ITokeniser } from '../tokeniser/type';
-import { default as NanoGPT } from '../NanoGPTModel';
-import { default as GPTTrainer, TrainingOptions } from './Trainer';
+import { default as GPTTrainer, TrainingLogEntry, TrainingOptions, TrainingProgress } from './Trainer';
 import { Tensor } from '@tensorflow/tfjs-core';
 import { Dataset } from '@tensorflow/tfjs-data';
+import { default as Model, ModelForwardAttributes } from '../models/model';
 export default class FullTrainer extends GPTTrainer {
-    constructor(model: NanoGPT, tokenizer: ITokeniser, learningRate?: number);
+    constructor(model: Model<ModelForwardAttributes>, tokenizer: ITokeniser, learningRate?: number);
+    private createEmptyState;
+    private createLogEntry;
+    private createProgress;
+    stepDataset(dataset: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>, options: Partial<TrainingOptions>, validationDataset?: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>): Promise<{
+        log: TrainingLogEntry;
+        progress: TrainingProgress;
+    }>;
     trainOnDataset(dataset: Dataset<{
         xs: Tensor;
         ys: Tensor;

package/dist/training/FullTrainer.js

@@ -1,81 +1,119 @@
-import { generateText as w } from "../utilities/generate.js";
-import T from "./Trainer.js";
-import L from "./Evaluator.js";
-import { d as h } from "../index-BoWRt-10.js";
-import x from "../utilities/profile.js";
-const y = {
+import y from "./Trainer.js";
+import v from "./Evaluator.js";
+import { d as S } from "../index-CUQrfsw_.js";
+import w from "../utilities/profile.js";
+const f = {
   desiredLoss: 0.01,
   logInterval: 1,
   maxSteps: 1e3
 };
-class E extends T {
-  constructor(i, e, r = 3e-4) {
-    super(i, e, r);
+class b extends y {
+  constructor(s, t, a = 3e-4) {
+    super(s, t, a);
   }
-  // Train for multiple epochs using Dataset API - FIXED memory leaks
-  async trainOnDataset(i, e, r) {
-    const { logInterval: g, onStep: l, prompt: c, maxSteps: u } = {
-      ...y,
-      ...e
-    }, n = Date.now(), t = {
+  createEmptyState() {
+    return {
       step: 0,
       lastLoss: 1e6,
       totalSteps: 0,
       losses: [],
       validationLosses: [],
-      logStartTime: n,
+      logStartTime: 0,
       trainingDuration: 0,
       ...this.lastState || {}
     };
-    this.lastState = t, await this.dummyPass(), this.model.trainable = !0, e?.advancedMetrics && (this.model.getProfiler() || (this.model.config.layerConfig.profiler = new x())), this.running = !0, t.logStartTime = n;
-    const m = r ? new L(this.model, r) : void 0, f = await i.iterator();
+  }
+  createLogEntry(s, t, a, n) {
+    return {
+      loss: s.lastLoss,
+      step: s.step,
+      time: Date.now() - t,
+      batchSize: a,
+      learningRate: n ? this.optimizer.lr : void 0
+    };
+  }
+  createProgress(s, t, a) {
+    return {
+      duration: s.trainingDuration,
+      totalSamples: s.totalSteps * t.batchSize,
+      samplesPerSecond: s.totalSteps * t.batchSize / (s.trainingDuration / 1e3),
+      memory: a ? this.model.getProfiler()?.getPeakMemory() || 0 : void 0
+    };
+  }
+  async stepDataset(s, t, a) {
+    const { logInterval: n } = {
+      ...f,
+      ...t
+    }, l = Date.now(), r = this.createEmptyState();
+    this.lastState = r, await this.dummyPass(), this.model.trainable = !0, t?.advancedMetrics && (this.model.getProfiler() || this.model.setProfiler(new w())), this.running = !0, r.logStartTime = l;
+    const m = a ? new v(this.model, a) : void 0, e = await s.iterator();
+    try {
+      for (; this.running; ) {
+        const i = await e.next();
+        if (i.done) break;
+        const g = i.value, o = this.trainBatch(r, g), c = this.createLogEntry(r, l, g.xs.shape[0], t?.advancedMetrics);
+        if (this.model.trainingState = {
+          steps: r.totalSteps,
+          learningRate: this.optimizer.lr,
+          batchSize: g.xs.shape[0],
+          loss: r.lastLoss
+        }, r.step % n === 0) {
+          await o.data();
+          const u = Date.now();
+          if (r.trainingDuration += u - r.logStartTime, m)
+            try {
+              const h = await m.evaluate(5);
+              r.validationLosses.push(h), c.valLoss = h;
+            } catch (h) {
+              console.error("Validation error:", h);
+            }
+          const p = this.createProgress(r, c, t?.advancedMetrics);
+          return o.dispose(), this.stop(), { log: c, progress: p };
+        }
+        o.dispose();
+      }
+    } catch (i) {
+      throw console.error("Training error:", i), S(), i;
+    }
+    throw S(), this.running = !1, new Error("No log returned before training stopped.");
+  }
+  // Train for multiple epochs using Dataset API - FIXED memory leaks
+  async trainOnDataset(s, t, a) {
+    const { logInterval: n, onStep: l, maxSteps: r } = {
+      ...f,
+      ...t
+    }, m = Date.now(), e = this.createEmptyState();
+    this.lastState = e, await this.dummyPass(), this.model.trainable = !0, t?.advancedMetrics && (this.model.getProfiler() || this.model.setProfiler(new w())), this.running = !0, e.logStartTime = m;
+    const i = a ? new v(this.model, a) : void 0, g = await s.iterator();
     try {
       for (; this.running; ) {
-        const o = await f.next();
+        const o = await g.next();
         if (o.done) break;
-        const d = o.value, p = this.trainBatch(t, d), s = {
-          loss: t.lastLoss,
-          step: t.step,
-          time: Date.now() - n,
-          batchSize: d.xs.shape[0],
-          learningRate: e?.advancedMetrics ? this.optimizer.lr : void 0
-          //gradientNorm: options?.advancedMetrics ? await state.gradientNorm : undefined,
-        };
-        if (this.model.log.push(s), t.step % g === 0) {
-          await p.data();
-          const S = Date.now();
-          if (t.trainingDuration += S - t.logStartTime, m)
+        const c = o.value, u = this.trainBatch(e, c), p = this.createLogEntry(e, m, c.xs.shape[0], t?.advancedMetrics);
+        if (e.step % n === 0) {
+          await u.data();
+          const h = Date.now();
+          if (e.trainingDuration += h - e.logStartTime, i)
             try {
-              const a = await m.evaluate(5);
-              t.validationLosses.push(a), s.valLoss = a;
-            } catch (a) {
-              console.error("Validation error:", a);
+              const d = await i.evaluate(5);
+              e.validationLosses.push(d), p.valLoss = d;
+            } catch (d) {
+              console.error("Validation error:", d);
             }
           if (l) {
-            if (c) {
-              const v = await w(this.tokenizer, this.model, c, 100, {
-                temperature: 0.8
-              });
-              s.example = v;
-            }
-            const a = {
-              duration: t.trainingDuration,
-              totalSamples: t.totalSteps * s.batchSize,
-              samplesPerSecond: t.totalSteps * s.batchSize / (t.trainingDuration / 1e3),
-              memory: e.advancedMetrics ? this.model.getProfiler()?.getPeakMemory() || 0 : void 0
-            };
-            await l(s, a);
+            const d = this.createProgress(e, p, t?.advancedMetrics);
+            await l(p, d);
           }
-          t.logStartTime = Date.now();
+          e.logStartTime = Date.now();
         }
-        p.dispose(), t.step >= u && this.stop();
+        u.dispose(), e.step >= r && this.stop();
       }
     } catch (o) {
-      throw console.error("Training error:", o), h(), o;
+      throw console.error("Training error:", o), S(), o;
     }
-    return h(), this.running = !1, { losses: t.losses, validationLosses: t.validationLosses };
+    return S(), this.running = !1, { losses: e.losses, validationLosses: e.validationLosses };
   }
 }
 export {
-  E as default
+  b as default
 };

package/dist/training/Trainer.d.ts

@@ -1,10 +1,20 @@
 import { ITokeniser } from '../tokeniser/type';
 import { DatasetBuilder } from './DatasetBuilder';
-import { default as NanoGPT, TrainingLogEntry } from '../NanoGPTModel';
 import { default as AdamExt } from './AdamExt';
 import { TensorContainer } from '@tensorflow/tfjs-core/dist/tensor_types';
 import { Scalar, Tensor } from '@tensorflow/tfjs-core';
 import { Dataset } from '@tensorflow/tfjs-data';
+import { default as Model, ModelForwardAttributes } from '../models/model';
+export interface TrainingLogEntry {
+    loss: number;
+    valLoss?: number;
+    step: number;
+    time: number;
+    example?: string;
+    batchSize: number;
+    gradientNorm?: number;
+    learningRate?: number;
+}
 export interface TrainingState {
     step: number;
     lastLoss: number;
@@ -35,13 +45,15 @@ export interface TrainingOptions {
 }
 export default abstract class GPTTrainer {
     protected tokenizer: ITokeniser;
-    protected model: NanoGPT;
+    protected model: Model<ModelForwardAttributes>;
     protected optimizer: AdamExt;
     protected datasetBuilder: DatasetBuilder;
     protected learningRate: number;
     protected running: boolean;
     protected lastState?: TrainingState;
-    constructor(model: NanoGPT, tokenizer: ITokeniser, learningRate?: number);
+    protected _gradientCheckpointing: boolean;
+    constructor(model: Model<ModelForwardAttributes>, tokenizer: ITokeniser, learningRate?: number);
+    setGradientCheckpointing(enabled: boolean): void;
     setLearningRate(learningRate: number): void;
     reset(): void;
     stop(): void;
@@ -66,6 +78,16 @@ export default abstract class GPTTrainer {
         losses: number[];
         validationLosses: number[];
     }>;
+    abstract stepDataset(dataset: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>, options: Partial<TrainingOptions>, validationDataset?: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>): Promise<{
+        log: TrainingLogEntry;
+        progress: TrainingProgress;
+    }>;
     createTrainValidationSplit(textData: string[], batchSize?: number, validationSplit?: number): Promise<{
         trainDataset: Dataset<{
             xs: Tensor;

package/dist/training/Trainer.js

@@ -1,10 +1,10 @@
-import { DatasetBuilder as h, flattenTokens as p, PAGE_FACTOR as g } from "./DatasetBuilder.js";
+import { DatasetBuilder as m, flattenTokens as c, PAGE_FACTOR as g } from "./DatasetBuilder.js";
 import u from "./AdamExt.js";
-import { t as f, v as y, d as c } from "../index-BoWRt-10.js";
-import { z as m } from "../zeros--BdLQ3oG.js";
+import { t as f, v as y, d as p } from "../index-CUQrfsw_.js";
+import { z as h } from "../zeros-VZ72lWXM.js";
 class x {
-  constructor(t, e, a = 1e-3) {
-    this.tokenizer = e, this.model = t, this.learningRate = a, this.resetOptimizer(), this.datasetBuilder = new h(e, t.config.gpt.blockSize);
+  constructor(t, e, i = 1e-3) {
+    this.tokenizer = e, this.model = t, this.learningRate = i, this.resetOptimizer(), this.datasetBuilder = new m(e, t.config.blockSize);
   }
   model;
   optimizer;
@@ -12,6 +12,10 @@ class x {
   learningRate;
   running = !1;
   lastState;
+  _gradientCheckpointing = !1;
+  setGradientCheckpointing(t) {
+    this._gradientCheckpointing = t;
+  }
   setLearningRate(t) {
     this.learningRate = t, this.resetOptimizer({ learningRateFactor: 1, beta1: 0.9, beta2: 0.99, epsilon: 1e-8 });
   }
@@ -40,71 +44,59 @@ class x {
     );
     this.optimizer = e;
   }
-  /*private async maxGradNorm(grads: NamedVariableMap): Promise<number> {
-      let maxNorm = 0;
-      // Print all gradients
-      await Promise.all(
-          Object.keys(grads).map(async (varName) => {
-              const grad = grads[varName];
-              const temp = norm(grad);
-              const gradNorm = (await temp.data())[0];
-              temp.dispose();
-              if (gradNorm > maxNorm) {
-                  maxNorm = gradNorm;
-              }
-          })
-      );
-      return maxNorm;
-  }*/
-  trainStep(t, e, a = !1) {
+  trainStep(t, e, i = !1) {
     return f(() => {
       this.model.getProfiler()?.startMemory();
-      const { xs: s, ys: i } = e, o = () => {
-        const [l, d] = this.model.forward({ training: !0 }, s, i);
+      const { xs: a, ys: s } = e, n = () => {
+        const [l, d] = this.model.forward(
+          { training: !0, checkpointing: this._gradientCheckpointing },
+          a,
+          s
+        );
         return l.dispose(), d;
-      }, { value: n, grads: r } = y(o);
-      return a ? this.model.getProfiler()?.endMemory("Training") : (this.optimizer.applyGradients(r), this.model.getProfiler()?.endMemory("Training"), c(r)), n;
+      }, { value: o, grads: r } = y(n);
+      return i ? this.model.getProfiler()?.endMemory("Training") : (this.optimizer.applyGradients(r), this.model.getProfiler()?.endMemory("Training"), p(r)), o;
     });
   }
   async dummyPass() {
-    const t = m([1, this.model.config.gpt.blockSize], "int32"), e = m([1, this.model.config.gpt.blockSize], "int32");
+    const t = h([1, this.model.config.blockSize], "int32"), e = h([1, this.model.config.blockSize], "int32");
     try {
-      const a = this.trainStep({}, { xs: t, ys: e }, !0);
-      await a.data(), a.dispose();
-    } catch (a) {
-      console.error("Error during dummy pass:", a);
+      const i = this.trainStep({}, { xs: t, ys: e }, !0);
+      await i.data(), i.dispose();
+    } catch (i) {
+      console.error("Error during dummy pass:", i);
     } finally {
       t.dispose(), e.dispose();
     }
   }
   trainBatch(t, e) {
     try {
-      const a = this.trainStep(t, e, !1);
-      return e.xs.dispose(), e.ys.dispose(), t.step++, t.totalSteps++, a;
-    } catch (a) {
-      throw console.error(`Error processing batch at step ${t.step}:`, a), c(), a;
+      const i = this.trainStep(t, e, !1);
+      return e.xs.dispose(), e.ys.dispose(), t.step++, t.totalSteps++, i;
+    } catch (i) {
+      throw console.error(`Error processing batch at step ${t.step}:`, i), p(), i;
     }
   }
-  async createTrainValidationSplit(t, e = 32, a = 0.1) {
-    const s = await p(t, this.tokenizer), i = /* @__PURE__ */ new Set();
-    if (a > 0) {
-      const r = Math.floor(s.length / (this.datasetBuilder.blockSize * g)), l = Math.max(1, Math.floor(r * a));
-      for (; i.size < l; ) {
+  async createTrainValidationSplit(t, e = 32, i = 0.1) {
+    const a = await c(t, this.tokenizer), s = /* @__PURE__ */ new Set();
+    if (i > 0) {
+      const r = Math.floor(a.length / (this.datasetBuilder.blockSize * g)), l = Math.max(1, Math.floor(r * i));
+      for (; s.size < l; ) {
         const d = Math.floor(Math.random() * r);
-        i.add(d);
+        s.add(d);
       }
     }
-    const o = await this.datasetBuilder.createTextDataset(s, e, i, !1), n = await this.datasetBuilder.createTextDataset(
-      s,
+    const n = await this.datasetBuilder.createTextDataset(a, e, s, !1), o = await this.datasetBuilder.createTextDataset(
+      a,
       e,
-      i,
+      s,
       !0
     );
-    return { trainDataset: o, validationDataset: n };
+    return { trainDataset: n, validationDataset: o };
   }
   async createDataset(t, e = 32) {
-    const a = await p(t, this.tokenizer);
-    return await this.datasetBuilder.createTextDataset(a, e);
+    const i = await c(t, this.tokenizer);
+    return await this.datasetBuilder.createTextDataset(i, e);
   }
   dispose() {
     this.optimizer && this.optimizer.dispose();

package/dist/training/sparseCrossEntropy.js

@@ -1,28 +1,28 @@
 import { gatherSub as x } from "../ops/gatherSub.js";
 import { scatterSub as L } from "../ops/scatterSub.js";
-import { y, t as u, z as C, c as E } from "../index-BoWRt-10.js";
-import { s as G } from "../softmax-Bv_6lyMX.js";
-import { m as z } from "../max-Ddnnb5xe.js";
-import { l as v } from "../log_sum_exp-DbjkV734.js";
+import { I as C, t as u, K as E, c as G } from "../index-CUQrfsw_.js";
+import { s as y } from "../softmax-DLoZWYBx.js";
+import { m as z } from "../max-B3JOcNGb.js";
+import { l as v } from "../log_sum_exp-C142qZqY.js";
 function k(t, s) {
   return u(() => {
-    const n = t.shape[t.shape.length - 1], c = t.shape.slice(0, -1).reduce((o, e) => o * e, 1), h = t.shape.length > 2 ? t.reshape([c, n]) : t, p = s.shape.length > 1 ? s.reshape([c]).cast("int32") : s.cast("int32"), r = z(h, -1, !0), a = E(h, r), m = v(a, -1);
+    const n = t.shape[t.shape.length - 1], c = t.shape.slice(0, -1).reduce((o, e) => o * e, 1), h = t.shape.length > 2 ? t.reshape([c, n]) : t, p = s.shape.length > 1 ? s.reshape([c]).cast("int32") : s.cast("int32"), r = z(h, -1, !0), a = G(h, r), m = v(a, -1);
     return x(m, p, a);
   });
 }
-function A() {
-  return y(
+function q() {
+  return C(
     // @ts-expect-error Invalid params
     (s, n, d) => {
       const c = s.shape[s.shape.length - 1], p = s.shape.slice(0, -1).reduce((o, e) => o * e, 1), r = s.reshape([p, c]), a = n.reshape([p]).cast("int32"), m = k(r, a);
       return d([r, a]), r.dispose(), a.dispose(), { value: m, gradFunc: (o, e) => u(() => {
-        const S = e[0], f = e[1], b = G(S), l = L(b, f, o), g = C(n);
+        const S = e[0], f = e[1], b = y(S), l = L(b, f, o), g = E(n);
         return [l.reshape(s.shape), g];
       }) };
     }
   );
 }
 export {
-  A as createSoftmaxCrossEntropyWithGrad,
+  q as createSoftmaxCrossEntropyWithGrad,
   k as sparseSoftmaxCrossEntropy
 };

package/dist/utilities/dummy.d.ts

@@ -1,9 +1,9 @@
-import { default as NanoGPT } from '../NanoGPTModel';
-export declare function dummyPassAsync(model: NanoGPT): Promise<void>;
+import { default as Model, ModelForwardAttributes } from '../models/model';
+export declare function dummyPassAsync(model: Model<ModelForwardAttributes>): Promise<void>;
 export interface MemoryRequirements {
     perBatch: number;
     tapeSize: number;
     gradients: number;
 }
-export declare function dummyPassTrainAsync(model: NanoGPT): Promise<MemoryRequirements>;
-export declare function dummyPass(model: NanoGPT): void;
+export declare function dummyPassTrainAsync(model: Model<ModelForwardAttributes>): Promise<MemoryRequirements>;
+export declare function dummyPass(model: Model<ModelForwardAttributes>): void;

package/dist/utilities/dummy.js

@@ -1,31 +1,31 @@
-import { m as y, v as P, e as S } from "../index-BoWRt-10.js";
-import { z as i } from "../zeros--BdLQ3oG.js";
+import { m as y, v as P, e as S } from "../index-CUQrfsw_.js";
+import { z as i } from "../zeros-VZ72lWXM.js";
 async function w(s) {
-  const t = i([1, s.config.gpt.blockSize], "int32"), [e, n] = s.forward({ training: !1 }, t);
+  const t = i([1, s.config.blockSize], "int32"), [e, n] = s.forward({ training: !1 }, t);
   await e.data(), e.dispose(), n && n.dispose(), t.dispose();
 }
 async function k(s) {
   const t = y(), e = t.numBytesInGPUAllocated ?? t.numBytesAllocatedInGPU ?? t.numBytes;
   await w(s);
-  const n = i([1, s.config.gpt.blockSize], "int32"), r = i([1, s.config.gpt.blockSize], "int32"), o = {
+  const n = i([1, s.config.blockSize], "int32"), r = i([1, s.config.blockSize], "int32"), o = {
     perBatch: 0,
     tapeSize: 0,
     gradients: s.getNumParams() * 4
   }, f = () => {
-    const [c, l] = s.forward({ training: !0 }, n, r), p = S().state.activeTape;
-    let u = 0;
-    if (p)
-      for (const z of p)
-        u += z.saved?.reduce((B, I) => B + I.size * 4, 0) || 0;
-    return o.tapeSize = u, c.dispose(), l;
-  }, { value: m, grads: d } = P(f), a = y(), g = a.numBytesInGPUAllocated ?? a.numBytesAllocatedInGPU ?? a.numBytes;
-  o.perBatch = g - e - o.gradients, console.log("Dummy training memory requirements:", o), await m.data(), m.dispose();
+    const [c, g] = s.forward({ training: !0 }, n, r), u = S().state.activeTape;
+    let p = 0;
+    if (u)
+      for (const z of u)
+        p += z.saved?.reduce((B, I) => B + I.size * 4, 0) || 0;
+    return o.tapeSize = p, c.dispose(), g;
+  }, { value: m, grads: d } = P(f), a = y(), l = a.numBytesInGPUAllocated ?? a.numBytesAllocatedInGPU ?? a.numBytes;
+  o.perBatch = l - e - o.gradients, console.log("Dummy training memory requirements:", o), await m.data(), m.dispose();
   for (const c in d)
     d[c].dispose();
   return n.dispose(), r.dispose(), o;
 }
 function v(s) {
-  const t = i([1, s.config.gpt.blockSize], "int32"), [e, n] = s.forward({ training: !1 }, t);
+  const t = i([1, s.config.blockSize], "int32"), [e, n] = s.forward({ training: !1 }, t);
   e.dispose(), n && n.dispose(), t.dispose();
 }
 export {

package/dist/utilities/multinomialCPU.js

@@ -1,5 +1,5 @@
-import "../index-BoWRt-10.js";
-import { t as e } from "../tensor2d-wxPAnDQy.js";
+import "../index-CUQrfsw_.js";
+import { t as e } from "../tensor2d-BHy261cI.js";
 function l(n) {
   let r = 0;
   const i = Math.random();

package/dist/utilities/parameters.d.ts

@@ -1,4 +1,4 @@
-import { GPTConfig } from '../config';
+import { GPTConfig } from '../models/config';
 export declare function estimateParameterCount(config: GPTConfig): number;
 export declare function estimateMemoryUsage(config: GPTConfig): number;
 export declare function estimateTrainingMemoryUsage(config: GPTConfig, batchSize: number): number;

package/dist/utilities/performance.js

@@ -1,4 +1,4 @@
-import { t as s } from "../index-BoWRt-10.js";
+import { t as s } from "../index-CUQrfsw_.js";
 async function f(e, o = 10, r = !1) {
   for (let t = 0; t < 100; t++) {
     const a = r ? await e() : s(e);

package/dist/utilities/profile.js

@@ -1,4 +1,4 @@
-import { m as a } from "../index-BoWRt-10.js";
+import { m as a } from "../index-CUQrfsw_.js";
 const s = 1024 * 1024;
 class l {
   log = /* @__PURE__ */ new Map();

package/dist/utilities/safetensors.js

@@ -1,5 +1,5 @@
-import "../index-BoWRt-10.js";
-import { t as y } from "../tensor-JwS7ZYY6.js";
+import "../index-CUQrfsw_.js";
+import { t as y } from "../tensor-BAQdLqoU.js";
 function l(t) {
   if (t === "float32") return "F32";
   if (t === "int32") return "I32";

package/dist/utilities/weights.js

@@ -1,5 +1,5 @@
-import "../index-BoWRt-10.js";
-import { t as p } from "../tensor-JwS7ZYY6.js";
+import "../index-CUQrfsw_.js";
+import { t as p } from "../tensor-BAQdLqoU.js";
 function h(n) {
   const e = n.reduce((s, o) => s + o.length, 0), a = new Float32Array(e);
   let t = 0;

package/dist/{variable-BuddVFLa.js → variable-C9hihzDB.js}

@@ -1,4 +1,4 @@
-import { E as i } from "./index-BoWRt-10.js";
+import { E as i } from "./index-CUQrfsw_.js";
 /**
  * @license
  * Copyright 2018 Google LLC. All Rights Reserved.

package/dist/{webgpu_program-PFzf1hAQ.js → webgpu_program-dFEVbDPL.js}

@@ -1,4 +1,4 @@
-import { aa as k, ab as z, ac as E, a1 as j, l as A } from "./index-BoWRt-10.js";
+import { ad as k, ae as z, af as E, a2 as j, n as A } from "./index-CUQrfsw_.js";
 /**
  * @license
  * Copyright 2019 Google LLC. All Rights Reserved.

package/dist/{webgpu_util-D____QpY.js → webgpu_util-DLImlSc6.js}

@@ -1,4 +1,4 @@
-import { l as u } from "./index-BoWRt-10.js";
+import { n as u } from "./index-CUQrfsw_.js";
 /**
  * @license
  * Copyright 2019 Google LLC. All Rights Reserved.
@@ -15,57 +15,57 @@ import { l as u } from "./index-BoWRt-10.js";
  * limitations under the License.
  * =============================================================================
  */
-const e = (r) => {
+const e = (n) => {
   let t = 1;
-  for (let n = 0; n < r.length; n++)
-    t *= r[n];
+  for (let r = 0; r < n.length; r++)
+    t *= n[r];
   return t;
 };
-function m(r, t, n = [1, 1, 1], a = [1, 1, 1]) {
+function m(n, t, r = [1, 1, 1], a = [1, 1, 1]) {
   const [o, i, f] = [
-    Math.ceil(e(r.x.map((c) => t[c])) / (n[0] * a[0])),
-    r.y ? Math.ceil(e(r.y.map((c) => t[c])) / (n[1] * a[1])) : 1,
-    r.z ? Math.ceil(e(r.z.map((c) => t[c])) / (n[2] * a[2])) : 1
+    Math.ceil(e(n.x.map((c) => t[c])) / (r[0] * a[0])),
+    n.y ? Math.ceil(e(n.y.map((c) => t[c])) / (r[1] * a[1])) : 1,
+    n.z ? Math.ceil(e(n.z.map((c) => t[c])) / (r[2] * a[2])) : 1
   ];
   return [o, i, f];
 }
-function d(r, t, n, a = !1) {
+function d(n, t, r, a = !1) {
   const o = [8, 8, 1], i = [4, 4, 1];
-  return a || (r <= 8 && (i[1] = 1), t <= 16 && n <= 16 && (o[0] = 4)), { workgroupSize: o, elementsPerThread: i };
+  return a || (n <= 8 && (i[1] = 1), t <= 16 && r <= 16 && (o[0] = 4)), { workgroupSize: o, elementsPerThread: i };
 }
-function p(r, t, n = !1) {
-  if (n)
+function p(n, t, r = !1) {
+  if (r)
     return [8, 8, 1];
-  const a = e(r.x.map((i) => t[i])), o = e(r.y.map((i) => t[i]));
+  const a = e(n.x.map((i) => t[i])), o = e(n.y.map((i) => t[i]));
   return a <= 4 ? [4, 16, 1] : o <= 4 ? [16, 4, 1] : [16, 16, 1];
 }
-function M(r, t, n = !1) {
-  if (n)
+function M(n, t, r = !1) {
+  if (r)
     return [4, 4, 1];
-  const a = e(r.x.map((i) => t[i])), o = e(r.y.map((i) => t[i]));
+  const a = e(n.x.map((i) => t[i])), o = e(n.y.map((i) => t[i]));
   return a <= 4 ? [1, 2, 1] : o <= 4 ? [2, 1, 1] : [2, 2, 1];
 }
-function h(r) {
-  return { x: r.map((t, n) => n) };
+function h(n) {
+  return { x: n.map((t, r) => r) };
 }
-function x(r) {
-  if (r === "float32" || r === "int32" || r === "bool" || r === "string")
+function x(n) {
+  if (n === "float32" || n === "int32" || n === "bool" || n === "string")
     return 4;
-  if (r === "complex64")
+  if (n === "complex64")
     return 8;
-  throw new Error(`Unknown dtype ${r}`);
+  throw new Error(`Unknown dtype ${n}`);
 }
 function g() {
   return !!(typeof globalThis < "u" && globalThis.navigator && globalThis.navigator.gpu);
 }
-function b(r, t) {
-  Array.isArray(r) || (r = [r]), r.forEach((n) => {
-    n != null && u(n.dtype !== "complex64", () => `${t} does not support complex64 tensors in the WebGPU backend.`);
+function b(n, t) {
+  Array.isArray(n) || (n = [n]), n.forEach((r) => {
+    r != null && u(r.dtype !== "complex64", () => `${t} does not support complex64 tensors in the WebGPU backend.`);
   });
 }
 var s;
-(function(r) {
-  r[r.MatMulReduceProgram = 0] = "MatMulReduceProgram", r[r.MatMulSplitKProgram = 1] = "MatMulSplitKProgram", r[r.MatMulSmallOutputSizeProgram = 2] = "MatMulSmallOutputSizeProgram", r[r.MatMulPackedProgram = 3] = "MatMulPackedProgram", r[r.MatMulMax = 4] = "MatMulMax";
+(function(n) {
+  n[n.MatMulReduceProgram = 0] = "MatMulReduceProgram", n[n.MatMulSplitKProgram = 1] = "MatMulSplitKProgram", n[n.MatMulSmallOutputSizeProgram = 2] = "MatMulSmallOutputSizeProgram", n[n.MatMulPackedProgram = 3] = "MatMulPackedProgram", n[n.MatMulMax = 4] = "MatMulMax";
 })(s || (s = {}));
 export {
   x as G,

package/dist/{zeros--BdLQ3oG.js → zeros-VZ72lWXM.js}

@@ -1,4 +1,4 @@
-import { B as m, C as r, a2 as l, E as c, a6 as i, F as p, a7 as u, j as f } from "./index-BoWRt-10.js";
+import { B as m, C as r, a3 as l, E as c, a9 as i, L as p, aa as u, j as f } from "./index-CUQrfsw_.js";
 /**
  * @license
  * Copyright 2020 Google LLC. All Rights Reserved.