@genai-fi/nanogpt 0.1.0 → 0.1.2

package/dist/NanoGPTModel.d.ts

@@ -1,7 +1,6 @@
 import { default as TF } from '@tensorflow/tfjs';
 import { GPTConfig } from './config';
 export interface TrainingLogEntry {
-    epoch: number;
     loss: number;
     valLoss?: number;
     step: number;

package/dist/TeachableLLM.d.ts

@@ -6,17 +6,21 @@ import { default as Generator, IGenerateOptions } from './Generator';
 import { default as Trainer, ITrainerOptions } from './Trainer';
 import { default as EE } from 'eventemitter3';
 type TeachableLLMStatus = 'warmup' | 'ready' | 'training' | 'loading' | 'busy' | 'error';
-export default class TeachableLLM extends EE<'status' | 'error'> {
-    readonly config: GPTConfig;
-    readonly model: NanoGPT;
+export default class TeachableLLM extends EE<'status' | 'error' | 'trainStep'> {
+    private _config?;
+    private _model?;
     readonly tf: typeof TF;
-    readonly tokeniser: ITokeniser;
+    private _tokeniser?;
     private _status;
-    constructor(tf: typeof TF, tokeniser: ITokeniser, model: NanoGPT);
+    constructor(tf: typeof TF, tokeniser?: ITokeniser, model?: NanoGPT);
+    get config(): GPTConfig;
+    get model(): NanoGPT;
+    get tokeniser(): ITokeniser;
     get status(): TeachableLLMStatus;
+    get ready(): boolean;
     private setStatus;
     saveModel(): Promise<Blob>;
-    static loadModel(tf: typeof TF, data: Blob | Buffer | string): Promise<TeachableLLM>;
+    static loadModel(tf: typeof TF, data: Blob | Buffer | string): TeachableLLM;
     static create(tf: typeof TF, config?: Partial<GPTConfig>): TeachableLLM;
     getNumParams(): number;
     trainer(): Trainer;

package/dist/TeachableLLM.js

@@ -1,58 +1,96 @@
-import a from "./NanoGPTModel.js";
-import { defaultConfig as m } from "./config.js";
-import { saveModel as u } from "./utilities/save.js";
-import { loadModel as h } from "./utilities/load.js";
-import c from "./Generator.js";
-import d from "./Trainer.js";
-import { E as l } from "./index-SOhdqzHq.js";
-import { dummyPassAsync as f } from "./utilities/dummy.js";
+import m from "./NanoGPTModel.js";
+import { defaultConfig as d } from "./config.js";
+import { saveModel as l } from "./utilities/save.js";
+import { loadModel as u } from "./utilities/load.js";
+import _ from "./Generator.js";
+import c from "./Trainer.js";
+import { E as f } from "./index-SOhdqzHq.js";
+import { dummyPassAsync as a } from "./utilities/dummy.js";
 import g from "./tokeniser/CharTokeniser.js";
-class n extends l {
-  config;
-  model;
+class n extends f {
+  _config;
+  _model;
   tf;
-  tokeniser;
+  _tokeniser;
   _status = "loading";
-  constructor(t, e, r) {
-    super(), this.tf = t, this.config = r.config, this.tokeniser = e, this.model = r;
+  constructor(t, r, e) {
+    super(), this.tf = t, this._config = e?.config, this._tokeniser = r, this._model = e;
+  }
+  get config() {
+    if (!this._config)
+      throw new Error("Model configuration is not initialized.");
+    return this._config;
+  }
+  get model() {
+    if (!this._model)
+      throw new Error("Model is not initialized.");
+    return this._model;
+  }
+  get tokeniser() {
+    if (!this._tokeniser)
+      throw new Error("Tokeniser is not initialized.");
+    return this._tokeniser;
   }
   get status() {
     return this._status;
   }
+  get ready() {
+    return this._status === "ready" && !!this._model && !!this._tokeniser;
+  }
   setStatus(t) {
     this._status !== t && (this._status = t, this.emit("status", t));
   }
   saveModel() {
-    return u(this.model, this.tokeniser);
+    if (!this._model || !this._tokeniser)
+      throw new Error("Model or tokeniser is not initialized.");
+    return l(this._model, this._tokeniser);
   }
-  static async loadModel(t, e) {
-    const { model: r, tokeniser: o } = await h(t, e), s = new n(t, o, r);
-    return s.setStatus("warmup"), f(r).then(() => {
-      s.setStatus("ready");
+  static loadModel(t, r) {
+    const e = new n(t);
+    return u(t, r).then(({ model: i, tokeniser: s }) => {
+      e._model = i, e._tokeniser = s, e._config = i.config, e.setStatus("warmup"), a(i).then(() => {
+        e.setStatus("ready");
+      }).catch((o) => {
+        e.setStatus("error"), e.emit("error", o);
+      });
     }).catch((i) => {
-      s.setStatus("error"), s.emit("error", i);
-    }), s;
+      e.setStatus("error"), e.emit("error", i);
+    }), e;
   }
-  static create(t, e = {}) {
-    const r = { ...m, ...e }, o = new g(r.vocabSize), s = new a(t, r);
-    return new n(t, o, s);
+  static create(t, r = {}) {
+    const e = { ...d, ...r }, i = new g(e.vocabSize), s = new m(t, e), o = new n(t, i, s);
+    return o.setStatus("warmup"), a(s).then(() => {
+      o.setStatus("ready");
+    }).catch((h) => {
+      o.setStatus("error"), o.emit("error", h);
+    }), o;
   }
   getNumParams() {
-    return this.model.getNumParams();
+    if (!this._model)
+      throw new Error("Model is not initialized.");
+    return this._model.getNumParams();
   }
   trainer() {
-    const t = new d(this.model, this.tokeniser);
-    return t.on("start", () => this.setStatus("training")), t.on("stop", () => this.setStatus("ready")), t;
+    if (!this._model || !this._tokeniser)
+      throw new Error("Model or tokeniser is not initialized.");
+    const t = new c(this._model, this._tokeniser);
+    return t.on("start", () => this.setStatus("training")), t.on("stop", () => this.setStatus("ready")), t.on("log", async (r) => {
+      const e = this.listeners("trainStep");
+      for (const i of e)
+        await i(r);
+    }), t;
   }
-  train(t, e) {
-    return this.trainer().train(t, e);
+  train(t, r) {
+    return this.trainer().train(t, r);
   }
   generator() {
-    const t = new c(this.model, this.tokeniser);
+    if (!this._model || !this._tokeniser)
+      throw new Error("Model or tokeniser is not initialized.");
+    const t = new _(this._model, this._tokeniser);
     return t.on("start", () => this.setStatus("busy")), t.on("stop", () => this.setStatus("ready")), t;
   }
-  generateText(t, e) {
-    return this.generator().generate(t, e);
+  generateText(t, r) {
+    return this.generator().generate(t, r);
   }
 }
 export {

package/dist/Trainer.d.ts

@@ -2,7 +2,6 @@ import { default as NanoGPT } from './NanoGPTModel';
 import { ITokeniser } from './tokeniser/type';
 import { default as EE } from 'eventemitter3';
 export interface ITrainerOptions {
-    epochs?: number;
     batchSize?: number;
     learningRate?: number;
     maxSteps?: number;

package/dist/Trainer.js

@@ -1,34 +1,34 @@
-import { E as s } from "./index-SOhdqzHq.js";
-import n from "./training/FullTrainer.js";
-class o extends s {
+import { E as l } from "./index-SOhdqzHq.js";
+import o from "./training/FullTrainer.js";
+class m extends l {
   trainer;
   constructor(a, t) {
-    super(), this.trainer = new n(a.tf, a, t, 1e-3);
+    super(), this.trainer = new o(a.tf, a, t, 1e-3);
   }
   stop() {
   }
   async train(a, t) {
-    const { trainDataset: e, validationDataset: r } = await this.trainer.createTrainValidationSplit(
+    const { trainDataset: r, validationDataset: e } = await this.trainer.createTrainValidationSplit(
       a,
       t?.batchSize || 32,
       t?.validationSplit || 0.1
     );
     this.emit("start"), await this.trainer.trainOnDataset(
-      e,
+      r,
       {
-        epochs: t?.epochs || 2,
         prompt: t?.prompt,
-        stepsPerEpoch: t?.maxSteps || 100,
         logInterval: t?.logInterval || 10,
         desiredLoss: t?.desiredLoss || 0.01,
         onStep: async (i) => {
-          this.emit("log", i);
+          const s = this.listeners("log");
+          for (const n of s)
+            await n(i);
         }
       },
-      r
+      e
     ), this.emit("stop");
   }
 }
 export {
-  o as default
+  m as default
 };

package/dist/training/FullTrainer.js

@@ -1,77 +1,65 @@
-import { generateText as g } from "../utilities/generate.js";
-import T from "./Trainer.js";
-const b = {
-  epochs: 1,
-  stepsPerEpoch: 1e6,
+import { generateText as L } from "../utilities/generate.js";
+import f from "./Trainer.js";
+const w = {
   desiredLoss: 0.01,
   logInterval: 1
 };
-class S extends T {
-  constructor(a, r, t, i = 3e-4) {
-    super(a, r, t, i);
+class g extends f {
+  constructor(r, i, o, n = 3e-4) {
+    super(r, i, o, n);
   }
   // Train for multiple epochs using Dataset API - FIXED memory leaks
-  async trainOnDataset(a, r, t) {
-    const { epochs: i, stepsPerEpoch: n, desiredLoss: c, logInterval: L, onStep: h, onEpoch: o, prompt: l } = {
-      ...b,
-      ...r
+  async trainOnDataset(r, i, o) {
+    const { desiredLoss: n, logInterval: h, onStep: l, prompt: c } = {
+      ...w,
+      ...i
     }, s = {
-      epoch: 0,
       pass: 0,
       depth: 1,
       step: 0,
       stepSinceDepthChange: 0,
       lastLoss: 1e6,
-      epochLoss: 0,
       totalSteps: 0,
       losses: [],
       validationLosses: []
     };
     this.dummyPass(), this.model.trainable = !0;
-    const m = Date.now();
-    for (s.epoch = 0; s.epoch < i; s.epoch++) {
-      s.step = 0, s.epochLoss = 0, s.pass = 0, s.depth = 1, s.stepSinceDepthChange = 0;
-      const u = await a.iterator();
-      try {
-        for (; !(n && s.step >= n || s.lastLoss < c); ) {
-          const e = await u.next();
-          if (e.done) break;
-          const f = e.value, w = this.trainBatch(s, f), p = {
-            epoch: s.epoch,
-            loss: s.lastLoss,
-            step: s.step,
-            time: Date.now() - m,
-            batchSize: f.xs.shape[0]
-          };
-          if (this.model.log.push(p), s.step % L === 0 && (await w, h)) {
-            if (l) {
-              const v = await g(this.tokenizer, this.model, l, 100, {
+    const d = Date.now(), m = await r.iterator();
+    try {
+      for (; !(s.lastLoss < n); ) {
+        const e = await m.next();
+        if (e.done) break;
+        const p = e.value, u = this.trainBatch(s, p), a = {
+          loss: s.lastLoss,
+          step: s.step,
+          time: Date.now() - d,
+          batchSize: p.xs.shape[0]
+        };
+        if (this.model.log.push(a), s.step % h === 0) {
+          if (await u, o)
+            try {
+              const t = await this.evaluateOnDataset(o, 5);
+              s.validationLosses.push(t), a.valLoss = t;
+            } catch (t) {
+              console.error("Validation error:", t);
+            }
+          if (l) {
+            if (c) {
+              const t = await L(this.tokenizer, this.model, c, 100, {
                 temperature: 0.8
               });
-              p.example = v;
+              a.example = t;
             }
-            await h(p);
+            await l(a);
           }
         }
-      } catch (e) {
-        throw console.error("Training error:", e), this.tf.dispose(), e;
       }
-      const d = s.epochLoss / s.step;
-      if (t)
-        try {
-          const e = await this.evaluateOnDataset(t, 5);
-          s.validationLosses.push(e), o && await o(s.epoch, d, e);
-        } catch (e) {
-          console.error("Validation error:", e);
-        }
-      else
-        o && o(s.epoch, d);
-      if (this.tf.dispose(), s.lastLoss < c)
-        break;
+    } catch (e) {
+      throw console.error("Training error:", e), this.tf.dispose(), e;
     }
-    return { losses: s.losses, validationLosses: s.validationLosses };
+    return this.tf.dispose(), { losses: s.losses, validationLosses: s.validationLosses };
   }
 }
 export {
-  S as default
+  g as default
 };

package/dist/training/LayerTrainer.js

@@ -1,111 +1,90 @@
-import { generateText as v } from "../utilities/generate.js";
-import T from "./Trainer.js";
-import { schedule as k } from "./lwSchedule.js";
-const x = {
-  epochs: 1,
-  stepsPerEpoch: 1e6,
+import { generateText as d } from "../utilities/generate.js";
+import S from "./Trainer.js";
+import { schedule as u } from "./lwSchedule.js";
+const w = {
   desiredLoss: 0.01,
   logInterval: 1,
   stepsPerLayer: 400,
   maxPasses: 3
 };
-class D extends T {
+class b extends S {
   trainingPattern = [];
   startPass = 0;
   startLayer = 0;
-  constructor(o, e, t, h = 3e-4) {
-    if (super(o, e, t, h), this.trainingPattern = k[e.config.nLayer - 1] || [], e.log.length > 0) {
-      const r = e.log[e.log.length - 1];
-      r.pass !== void 0 && r.layer !== void 0 && (this.startPass = r.pass, this.startLayer = r.layer, console.log(`Resuming training from pass ${this.startPass}, layer ${this.startLayer}`));
+  constructor(r, a, e, p = 3e-4) {
+    if (super(r, a, e, p), this.trainingPattern = u[a.config.nLayer - 1] || [], a.log.length > 0) {
+      const i = a.log[a.log.length - 1];
+      i.pass !== void 0 && i.layer !== void 0 && (this.startPass = i.pass, this.startLayer = i.layer, console.log(`Resuming training from pass ${this.startPass}, layer ${this.startLayer}`));
     }
   }
-  applyTrainingPattern(o) {
-    const e = o < this.trainingPattern.length ? o : this.trainingPattern.length - 1, t = this.trainingPattern[e];
-    this.model.setSkipMask(t.skip), this.model.setTrainableMask(t.trainable), this.resetOptimizer(t.adam), console.log("Applied training pattern:", e, t);
+  applyTrainingPattern(r) {
+    const a = r < this.trainingPattern.length ? r : this.trainingPattern.length - 1, e = this.trainingPattern[a];
+    this.model.setSkipMask(e.skip), this.model.setTrainableMask(e.trainable), this.resetOptimizer(e.adam), console.log("Applied training pattern:", a, e);
   }
   // Train for multiple epochs using Dataset API - FIXED memory leaks
-  async trainOnDataset(o, e, t) {
-    const {
-      epochs: h,
-      stepsPerEpoch: r,
-      desiredLoss: c,
-      logInterval: P,
-      stepsPerLayer: d,
-      onLayerChange: n,
-      onPassComplete: g,
-      onStep: y,
-      onEpoch: p,
-      prompt: L
-    } = {
-      ...x,
-      ...e
-    }, s = {
-      epoch: 0,
+  async trainOnDataset(r, a, e) {
+    const { desiredLoss: p, logInterval: i, stepsPerLayer: L, onLayerChange: l, onPassComplete: h, onStep: c, prompt: g } = {
+      ...w,
+      ...a
+    }, t = {
       pass: 0,
       layerStep: 0,
       step: 0,
       stepSinceLayerChange: 0,
       lastLoss: 1e6,
-      epochLoss: 0,
       totalSteps: 0,
       losses: [],
       validationLosses: []
     };
     this.dummyPass();
-    const S = Date.now();
-    for (s.epoch = 0; s.epoch < h; s.epoch++) {
-      s.step = 0, s.epochLoss = 0, s.pass = this.startPass, s.layerStep = this.startLayer + this.startPass * this.model.config.nLayer, s.stepSinceLayerChange = 0, this.startPass = 0, this.startLayer = 0;
-      const u = await o.iterator();
-      this.applyTrainingPattern(s.layerStep % this.trainingPattern.length);
-      try {
-        for (; !(r && s.step >= r || s.lastLoss < c); ) {
-          const a = await u.next();
-          if (a.done) break;
-          const m = a.value, w = this.trainBatch(s, m);
-          s.stepSinceLayerChange++;
-          const l = {
-            epoch: s.epoch,
-            loss: s.lastLoss,
-            step: s.step,
-            time: Date.now() - S,
-            batchSize: m.xs.shape[0],
-            pass: s.pass,
-            layer: s.layerStep % this.model.config.nLayer
-          };
-          if (this.model.log.push(l), s.step % P === 0 && (await w, y)) {
-            if (L) {
-              const i = await v(this.tokenizer, this.model, L, 100, {
+    const f = Date.now();
+    this.startPass = 0, this.startLayer = 0;
+    const m = await r.iterator();
+    this.applyTrainingPattern(t.layerStep % this.trainingPattern.length);
+    try {
+      for (; !(t.lastLoss < p); ) {
+        const n = await m.next();
+        if (n.done) break;
+        const y = n.value, P = this.trainBatch(t, y);
+        t.stepSinceLayerChange++;
+        const o = {
+          loss: t.lastLoss,
+          step: t.step,
+          time: Date.now() - f,
+          batchSize: y.xs.shape[0],
+          pass: t.pass,
+          layer: t.layerStep % this.model.config.nLayer
+        };
+        if (this.model.log.push(o), t.step % i === 0) {
+          if (await P, e)
+            try {
+              const s = await this.evaluateOnDataset(e, 5);
+              t.validationLosses.push(s), o.valLoss = s;
+            } catch (s) {
+              console.error("Validation error:", s);
+            }
+          if (c) {
+            if (g) {
+              const s = await d(this.tokenizer, this.model, g, 100, {
                 temperature: 0.8,
                 topK: 10
               });
-              l.example = i;
+              o.example = s;
             }
-            await y(l);
-          }
-          if (s.stepSinceLayerChange >= d) {
-            let i;
-            t && (i = await this.evaluateOnDataset(t, 5), s.validationLosses.push(i), l.valLoss = i), s.layerStep++, s.layerStep % this.model.config.nLayer === 0 ? (n && await n(s.layerStep, s.pass, i), g && await g(s.pass), s.pass++) : n && await n(s.layerStep, s.pass, i), s.stepSinceLayerChange = 0, this.applyTrainingPattern(s.layerStep % this.trainingPattern.length);
+            await c(o);
           }
         }
-      } catch (a) {
-        throw console.error("Training error:", a), this.tf.dispose(), a;
-      }
-      const f = s.epochLoss / s.step;
-      if (t)
-        try {
-          const a = await this.evaluateOnDataset(t, 5);
-          s.validationLosses.push(a), p && await p(s.epoch, f, a);
-        } catch (a) {
-          console.error("Validation error:", a);
+        if (t.stepSinceLayerChange >= L) {
+          let s;
+          e && (s = await this.evaluateOnDataset(e, 5), t.validationLosses.push(s), o.valLoss = s), t.layerStep++, t.layerStep % this.model.config.nLayer === 0 ? (l && await l(t.layerStep, t.pass, s), h && await h(t.pass), t.pass++) : l && await l(t.layerStep, t.pass, s), t.stepSinceLayerChange = 0, this.applyTrainingPattern(t.layerStep % this.trainingPattern.length);
         }
-      else
-        p && p(s.epoch, f);
-      if (this.tf.dispose(), s.lastLoss < c)
-        break;
+      }
+    } catch (n) {
+      throw console.error("Training error:", n), this.tf.dispose(), n;
     }
-    return { losses: s.losses, validationLosses: s.validationLosses };
+    return this.tf.dispose(), { losses: t.losses, validationLosses: t.validationLosses };
   }
 }
 export {
-  D as default
+  b as default
 };

package/dist/training/Trainer.d.ts

@@ -4,10 +4,8 @@ import { default as NanoGPT, TrainingLogEntry } from '../NanoGPTModel';
 import { default as TF } from '@tensorflow/tfjs';
 import { default as AdamExt } from './AdamExt';
 export interface TrainingState {
-    epoch: number;
     step: number;
     lastLoss: number;
-    epochLoss: number;
     totalSteps: number;
     losses: number[];
     validationLosses: number[];
@@ -19,12 +17,9 @@ export interface AdamConfig {
     epsilon: number;
 }
 export interface TrainingOptions {
-    epochs: number;
-    stepsPerEpoch: number;
     desiredLoss: number;
     logInterval: number;
     prompt?: string;
-    onEpoch?: (e: number, loss: number, valLoss?: number) => Promise<void> | void;
     onStep?: (log: TrainingLogEntry) => Promise<void> | void;
 }
 export default abstract class GPTTrainer {

package/dist/training/Trainer.js

@@ -57,7 +57,7 @@ class y {
   async trainBatch(t, e) {
     try {
       const s = this.trainStep(e, !1, !1);
-      return e.xs.dispose(), e.ys.dispose(), t.step++, t.totalSteps++, s.array().then((a) => (t.lastLoss = a, t.losses.push(t.lastLoss), t.epochLoss += t.lastLoss, s.dispose(), t.lastLoss));
+      return e.xs.dispose(), e.ys.dispose(), t.step++, t.totalSteps++, s.array().then((a) => (t.lastLoss = a, t.losses.push(t.lastLoss), s.dispose(), t.lastLoss));
     } catch (s) {
       throw console.error(`Error processing batch at step ${t.step}:`, s), this.tf.dispose(), s;
     }

package/dist/utilities/load.js

@@ -1,5 +1,5 @@
-import { z as F } from "../jszip.min-BLbRbbKt.js";
-import { importWeights as b } from "./weights.js";
+import { z as u } from "../jszip.min-BLbRbbKt.js";
+import { importWeights as F } from "./weights.js";
 import k from "../tokeniser/CharTokeniser.js";
 import j from "../NanoGPTModel.js";
 import { dummyPassAsync as z } from "./dummy.js";
@@ -10,7 +10,7 @@ async function A(o) {
   return e.arrayBuffer();
 }
 async function T(o, e) {
-  const m = typeof e == "string" ? await A(e) : e, n = await F.loadAsync(m), s = /* @__PURE__ */ new Map(), c = await n.file("manifest.json")?.async("string");
+  const m = typeof e == "string" ? await A(e) : e, n = await u.loadAsync(m), s = /* @__PURE__ */ new Map(), c = await n.file("manifest.json")?.async("string");
   if (!c)
     throw new Error("Manifest file not found in the zip archive");
   const f = JSON.parse(c);
@@ -19,20 +19,21 @@ async function T(o, e) {
   const l = await n.file("tokeniser.json")?.async("string");
   if (!l)
     throw new Error("Tokeniser file not found in the zip archive");
-  const g = JSON.parse(l), y = new k(g.vocab), w = /* @__PURE__ */ new Map();
+  const g = JSON.parse(l), y = new k(g.vocab), p = /* @__PURE__ */ new Map();
   for (const t of Object.keys(n.files))
     if (t.endsWith(".bin")) {
       const r = t.replace(".bin", ""), h = await n.file(t).async("arraybuffer"), d = new Float32Array(h), i = s.get(r) || { spec: [], data: new Float32Array() };
       i.data = d, s.set(r, i);
-      const u = await b(i, o);
-      w.set(r, u);
+      const b = await F(i, o);
+      p.set(r, b);
     }
+  o.disposeVariables();
   const a = new j(o, f.config);
-  await z(a), a.loadWeights(w);
-  const p = await n.file("log.json")?.async("string");
-  if (p)
+  await z(a), a.loadWeights(p);
+  const w = await n.file("log.json")?.async("string");
+  if (w)
     try {
-      const t = JSON.parse(p);
+      const t = JSON.parse(w);
       a.log = t;
     } catch (t) {
       throw console.error("Error parsing training log:", t), new Error(`Failed to parse training log: ${t}`);

package/dist/utilities/waitForModel.d.ts

@@ -0,0 +1,2 @@
+import { TeachableLLM } from '../main';
+export default function waitForModel(model: TeachableLLM): Promise<void>;

package/dist/utilities/waitForModel.js

@@ -0,0 +1,12 @@
+function n(r) {
+  return new Promise((t, a) => {
+    r.ready ? t() : (r.on("status", (e) => {
+      e === "ready" && t();
+    }), r.on("error", (e) => {
+      a(e);
+    }));
+  });
+}
+export {
+  n as default
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@genai-fi/nanogpt",
-    "version": "0.1.0",
+    "version": "0.1.2",
     "type": "module",
     "main": "dist/main.js",
     "types": "dist/main.d.ts",
@@ -23,7 +23,7 @@
         "test": "vitest",
         "ci:test": "vitest --coverage --reporter=junit --outputFile=junit.xml",
         "coverage": "vitest run --coverage",
-        "train": "tsx scripts/train.ts --epochs 2 --batch 64",
+        "train": "tsx scripts/train.ts --batch 64",
         "generate": "tsx scripts/generate.ts",
         "evaluate": "tsx scripts/evaluate.ts",
         "debug": "tsx scripts/debug.ts"