@genai-fi/nanogpt 0.1.0 → 0.1.1

package/dist/TeachableLLM.d.ts

@@ -7,16 +7,20 @@ 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;
+    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,60 +1,90 @@
 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 { defaultConfig as h } from "./config.js";
+import { saveModel as d } from "./utilities/save.js";
+import { loadModel as m } from "./utilities/load.js";
+import l from "./Generator.js";
+import u from "./Trainer.js";
+import { E as _ } from "./index-SOhdqzHq.js";
 import { dummyPassAsync as f } from "./utilities/dummy.js";
-import g from "./tokeniser/CharTokeniser.js";
-class n extends l {
-  config;
-  model;
+import c from "./tokeniser/CharTokeniser.js";
+class s extends _ {
+  _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 d(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 s(t);
+    return m(t, r).then(({ model: i, tokeniser: o }) => {
+      e._model = i, e._tokeniser = o, e._config = i.config, e.setStatus("warmup"), f(i).then(() => {
+        e.setStatus("ready");
+      }).catch((n) => {
+        e.setStatus("error"), e.emit("error", n);
+      });
     }).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 = { ...h, ...r }, i = new c(e.vocabSize), o = new a(t, e);
+    return new s(t, i, 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);
+    if (!this._model || !this._tokeniser)
+      throw new Error("Model or tokeniser is not initialized.");
+    const t = new u(this._model, this._tokeniser);
     return t.on("start", () => this.setStatus("training")), t.on("stop", () => this.setStatus("ready")), 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 l(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 {
-  n as default
+  s as default
 };

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.1",
     "type": "module",
     "main": "dist/main.js",
     "types": "dist/main.d.ts",