@genai-fi/nanogpt 0.9.0 → 0.9.1

package/dist/training/FullTrainer.js

@@ -1,15 +1,15 @@
-import y from "./Trainer.js";
-import v from "./Evaluator.js";
+import L from "./Trainer.js";
+import w from "./Evaluator.js";
 import { d as S } from "../index-BzFyqcy-.js";
-import w from "../utilities/profile.js";
-const f = {
+import f from "../utilities/profile.js";
+const y = {
   desiredLoss: 0.01,
   logInterval: 1,
   maxSteps: 1e3
 };
-class b extends y {
-  constructor(s, t, a = 3e-4) {
-    super(s, t, a);
+class x extends L {
+  constructor(s, e, a = 3e-4) {
+    super(s, e, a);
   }
   createEmptyState() {
     return {
@@ -23,52 +23,55 @@ class b extends y {
       ...this.lastState || {}
     };
   }
-  createLogEntry(s, t, a, n) {
+  createLogEntry(s, e, a, l) {
     return {
       loss: s.lastLoss,
       step: s.step,
-      time: Date.now() - t,
+      time: Date.now() - e,
       batchSize: a,
-      learningRate: n ? this.optimizer.lr : void 0
+      learningRate: l ? this.optimizer.lr : void 0
     };
   }
-  createProgress(s, t, a) {
+  createProgress(s, e, a) {
     return {
       duration: s.trainingDuration,
-      totalSamples: s.totalSteps * t.batchSize,
-      samplesPerSecond: s.totalSteps * t.batchSize / (s.trainingDuration / 1e3),
+      totalSamples: s.totalSteps * e.batchSize,
+      samplesPerSecond: s.totalSteps * e.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();
+  async stepDataset(s, e, a) {
+    const { logInterval: l } = {
+      ...y,
+      ...e
+    }, c = Date.now(), r = this.createEmptyState();
+    this.lastState = r, await this.dummyPass(), this.model.trainable = !0, e?.advancedMetrics && (this.model.getProfiler() || this.model.setProfiler(new f())), this.running = !0, r.logStartTime = c;
+    const d = a ? new w(this.model, a) : void 0, t = await s.iterator();
     try {
       for (; this.running; ) {
-        const i = await e.next();
+        const i = await t.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 m = i.value, o = this.trainBatch(r, m);
+        if (r.step % l === 0) {
+          const g = (await o.data())[0];
+          r.lastLoss = g;
           const u = Date.now();
-          if (r.trainingDuration += u - r.logStartTime, m)
+          r.trainingDuration += u - r.logStartTime;
+          const p = this.createLogEntry(r, c, m.xs.shape[0], e?.advancedMetrics);
+          if (this.model.trainingState = {
+            steps: r.totalSteps,
+            learningRate: this.optimizer.lr,
+            batchSize: m.xs.shape[0],
+            loss: r.lastLoss
+          }, d)
             try {
-              const h = await m.evaluate(5);
-              r.validationLosses.push(h), c.valLoss = h;
-            } catch (h) {
-              console.error("Validation error:", h);
+              const n = await d.evaluate(5);
+              r.validationLosses.push(n), p.valLoss = n;
+            } catch (n) {
+              console.error("Validation error:", n);
             }
-          const p = this.createProgress(r, c, t?.advancedMetrics);
-          return o.dispose(), this.stop(), { log: c, progress: p };
+          const v = this.createProgress(r, p, e?.advancedMetrics);
+          return o.dispose(), this.stop(), { log: p, progress: v };
         }
         o.dispose();
       }
@@ -78,42 +81,50 @@ class b extends y {
     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();
+  async trainOnDataset(s, e, a) {
+    const { logInterval: l, onStep: c, maxSteps: r } = {
+      ...y,
+      ...e
+    }, d = Date.now(), t = this.createEmptyState();
+    this.lastState = t, await this.dummyPass(), this.model.trainable = !0, e?.advancedMetrics && (this.model.getProfiler() || this.model.setProfiler(new f())), this.running = !0, t.logStartTime = d;
+    const i = a ? new w(this.model, a) : void 0, m = await s.iterator();
     try {
       for (; this.running; ) {
-        const o = await g.next();
+        const o = await m.next();
         if (o.done) break;
-        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)
+        const g = o.value, u = this.trainBatch(t, g);
+        if (t.step % l === 0) {
+          const p = (await u.data())[0];
+          t.lastLoss = p;
+          const v = Date.now();
+          t.trainingDuration += v - t.logStartTime;
+          const n = this.createLogEntry(t, d, g.xs.shape[0], e?.advancedMetrics);
+          if (this.model.trainingState = {
+            steps: t.totalSteps,
+            learningRate: this.optimizer.lr,
+            batchSize: g.xs.shape[0],
+            loss: t.lastLoss
+          }, i)
             try {
-              const d = await i.evaluate(5);
-              e.validationLosses.push(d), p.valLoss = d;
-            } catch (d) {
-              console.error("Validation error:", d);
+              const h = await i.evaluate(5);
+              t.validationLosses.push(h), n.valLoss = h;
+            } catch (h) {
+              console.error("Validation error:", h);
             }
-          if (l) {
-            const d = this.createProgress(e, p, t?.advancedMetrics);
-            await l(p, d);
+          if (c) {
+            const h = this.createProgress(t, n, e?.advancedMetrics);
+            await c(n, h);
           }
-          e.logStartTime = Date.now();
+          t.logStartTime = Date.now();
         }
-        u.dispose(), e.step >= r && this.stop();
+        u.dispose(), t.step >= r && this.stop();
       }
     } catch (o) {
       throw console.error("Training error:", o), S(), o;
     }
-    return S(), this.running = !1, { losses: e.losses, validationLosses: e.validationLosses };
+    return S(), this.running = !1, { losses: t.losses, validationLosses: t.validationLosses };
   }
 }
 export {
-  b as default
+  x as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@genai-fi/nanogpt",
-    "version": "0.9.0",
+    "version": "0.9.1",
     "type": "module",
     "main": "dist/main.js",
     "types": "dist/main.d.ts",