@genai-fi/nanogpt 0.2.11 → 0.3.0

package/dist/Generator.js

@@ -1,49 +1,52 @@
 import { E as u } from "./index-Dwqa6Zy2.js";
-class f extends u {
+import "./index-pWA4_lUh.js";
+import { t as d } from "./tensor2d-ZuQSh2D-.js";
+import { c as k } from "./concat-BIZS_td9.js";
+class w extends u {
   constructor(s, e) {
     super(), this.model = s, this.tokeniser = e;
   }
   active = !1;
   async tokenisePrompt(s) {
     const e = s ? await this.tokeniser.tokenise([s], !0) : [[this.tokeniser.eosToken]];
-    return this.model.tf.tensor2d(e, [1, e[0].length], "int32");
+    return d(e, [1, e[0].length], "int32");
   }
   async generateNoCache(s, e) {
-    let t = await this.tokenisePrompt(s), i = s || "";
-    const o = e?.maxLength ?? 1e3;
-    for (let a = 0; a < o && this.active; a++) {
+    let t = await this.tokenisePrompt(s), o = s || "";
+    const n = e?.maxLength ?? 1e3;
+    for (let a = 0; a < n && this.active; a++) {
       const {
-        output: n,
+        output: i,
         attention: c,
         probabilities: l
       } = this.model.generate(t, void 0, e), h = t;
-      t = this.model.tf.concat([t, n], 1), h.dispose();
-      const r = await this.processResponse(n, c, l);
-      if (n.dispose(), r === null)
+      t = k([t, i], 1), h.dispose();
+      const r = await this.processResponse(i, c, l);
+      if (i.dispose(), r === null)
         break;
-      i += r;
+      o += r;
     }
-    return t.dispose(), i;
+    return t.dispose(), o;
   }
   async processResponse(s, e, t) {
-    const i = (await s.array())[0][0];
-    if (i === this.tokeniser.eosToken)
+    const o = (await s.array())[0][0];
+    if (o === this.tokeniser.eosToken)
       return null;
-    const o = await this.tokeniser.decode([i]);
+    const n = await this.tokeniser.decode([o]);
     let a;
     e && (a = await e.array(), e.dispose());
-    let n;
-    return t && (n = await t.array(), t.dispose()), this.emit("tokens", [i], o, a, n), o;
+    let i;
+    return t && (i = await t.array(), t.dispose()), this.emit("tokens", [o], n, a, i), n;
   }
   async generateCache(s, e) {
-    let t = await this.tokenisePrompt(s), i = s || "";
-    const o = new Array(this.model.config.nLayer).fill(void 0), a = e?.maxLength ?? 1e3;
-    for (let n = 0; n < a && this.active; n++) {
+    let t = await this.tokenisePrompt(s), o = s || "";
+    const n = new Array(this.model.config.nLayer).fill(void 0), a = e?.maxLength ?? 1e3;
+    for (let i = 0; i < a && this.active; i++) {
       const {
         output: c,
         attention: l,
         probabilities: h
-      } = this.model.generate(t, o, {
+      } = this.model.generate(t, n, {
         ...e,
         usePadding: !1
       });
@@ -51,20 +54,22 @@ class f extends u {
       const r = await this.processResponse(c, l, h);
       if (r === null)
         break;
-      i += r;
+      o += r;
     }
-    return t.dispose(), i;
+    return n.forEach((i) => {
+      i && (i.k.dispose(), i.v.dispose());
+    }), t.dispose(), o;
   }
   async generate(s, e) {
     const t = s && s.length > this.model.config.blockSize ? s.slice(-this.model.config.blockSize) : s;
     this.active = !0, this.emit("start");
-    const o = await (this.model.config.useRope && !e?.noCache ? this.generateCache(t, e) : this.generateNoCache(t, e));
-    return this.active = !1, this.emit("stop"), o;
+    const n = await (this.model.config.useRope && !e?.noCache ? this.generateCache(t, e) : this.generateNoCache(t, e));
+    return this.active = !1, this.emit("stop"), n;
   }
   stop() {
     this.active = !1;
   }
 }
 export {
-  f as default
+  w as default
 };

package/dist/NanoGPTModel.d.ts

@@ -1,8 +1,8 @@
-import { default as TF } from '@tensorflow/tfjs';
 import { GPTConfig } from './config';
 import { KVCache } from './layers/CausalSelfAttention';
 import { default as MemoryProfiler } from './utilities/profile';
 import { default as BaseLayer } from './layers/BaseLayer';
+import { Tensor, Variable } from '@tensorflow/tfjs-core';
 export interface TrainingLogEntry {
     loss: number;
     valLoss?: number;
@@ -26,12 +26,11 @@ export default class NanoGPT extends BaseLayer {
     private blocks;
     private lnF;
     private ropeCache?;
-    readonly tf: typeof TF;
     log: TrainingLogEntry[];
-    constructor(tf: typeof TF, config?: Partial<GPTConfig>);
-    get variables(): TF.Variable[];
-    saveWeights(): Map<string, TF.Tensor[]>;
-    loadWeights(weights: Map<string, TF.Tensor[]>): void;
+    constructor(config?: Partial<GPTConfig>);
+    get variables(): Variable[];
+    saveWeights(): Map<string, Tensor[]>;
+    loadWeights(weights: Map<string, Tensor[]>): void;
     private inputPhase;
     setSkipMask(mask: boolean[]): void;
     setTrainableMask(mask: boolean[]): void;
@@ -40,15 +39,15 @@ export default class NanoGPT extends BaseLayer {
     private validateInput;
     private calculateLoss;
     private computeAttentionRollout;
-    forward(idx: TF.Tensor, targets?: TF.Tensor, training?: boolean, includeAttention?: boolean, cache?: (KVCache | undefined)[]): {
-        logits: TF.Tensor;
-        loss?: TF.Tensor;
-        attention?: TF.Tensor;
+    forward(idx: Tensor, targets?: Tensor, training?: boolean, includeAttention?: boolean, cache?: (KVCache | undefined)[]): {
+        logits: Tensor;
+        loss?: Tensor;
+        attention?: Tensor;
     };
-    generate(idx: TF.Tensor, cache?: (KVCache | undefined)[], options?: GenerateOptions): {
-        output: TF.Tensor;
-        attention?: TF.Tensor;
-        probabilities?: TF.Tensor;
+    generate(idx: Tensor, cache?: (KVCache | undefined)[], options?: GenerateOptions): {
+        output: Tensor;
+        attention?: Tensor;
+        probabilities?: Tensor;
     };
     getNumParams(): number;
     dispose(): void;

package/dist/NanoGPTModel.js

@@ -1,12 +1,98 @@
-import { defaultConfig as v } from "./config.js";
-import z from "./layers/TransformerBlock.js";
-import S from "./layers/TiedEmbedding.js";
-import _ from "./layers/RoPECache.js";
-import I from "./layers/RMSNorm.js";
-import { estimateParameterCount as F } from "./utilities/parameters.js";
-import { createSoftmaxCrossEntropyWithGrad as L } from "./training/sparseCrossEntropy.js";
-import P from "./layers/BaseLayer.js";
-class A extends P {
+import { defaultConfig as F } from "./config.js";
+import L from "./layers/TransformerBlock.js";
+import P from "./layers/TiedEmbedding.js";
+import C from "./layers/RoPECache.js";
+import q from "./layers/RMSNorm.js";
+import { estimateParameterCount as K } from "./utilities/parameters.js";
+import { createSoftmaxCrossEntropyWithGrad as N } from "./training/sparseCrossEntropy.js";
+import R from "./layers/BaseLayer.js";
+import { r as T, e as D, t as A, o as B, p as G } from "./random_width-PbCt7RXv.js";
+import { o as v, h as E, p as O, E as y, W as H, X as Q, Y as X, t as w, Z as j, f as _ } from "./index-pWA4_lUh.js";
+import { e as U, a as V } from "./exports_layers-7idKoYqh.js";
+import { r as I } from "./reshape-C8CR_Bad.js";
+import { r as Y } from "./range-CcDl05lo.js";
+import { g as Z } from "./gather-BPGW8RsB.js";
+import { s as J } from "./softmax-Be_lsqUc.js";
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function tt(m, t) {
+  let e = E(m, "a", "mod"), s = E(t, "b", "mod");
+  [e, s] = O(e, s);
+  const i = { a: e, b: s };
+  return y.runKernel(H, i);
+}
+const et = /* @__PURE__ */ v({ mod_: tt });
+/**
+ * @license
+ * Copyright 2020 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function ot(m, t, e, s = !1) {
+  const i = E(m, "logits", "multinomial"), o = i.size, n = i.rank;
+  if (o < 2)
+    throw new Error(`Error in multinomial: you need at least 2 outcomes, but got ${o}.`);
+  if (n > 2)
+    throw new Error(`Rank of probabilities must be 1 or 2, but is ${n}`);
+  e = e || Math.random();
+  const r = { logits: n === 1 ? I(i, [1, -1]) : i }, a = { numSamples: t, seed: e, normalized: s }, h = y.runKernel(Q, r, a);
+  return n === 1 ? I(h, [h.size]) : h;
+}
+const S = /* @__PURE__ */ v({ multinomial_: ot });
+/**
+ * @license
+ * Copyright 2018 Google LLC. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ * =============================================================================
+ */
+function st(m, t = 1, e = !0) {
+  const s = E(m, "x", "topk");
+  if (s.rank === 0)
+    throw new Error("topk() expects the input to be of rank 1 or higher");
+  const i = s.shape[s.shape.length - 1];
+  if (t < 0)
+    throw new Error(`'k' passed to topk() must be >= 0 but got ${t}`);
+  if (t > i)
+    throw new Error(`'k' passed to topk() must be <= the last dimension (${i}) but got ${t}`);
+  const o = { x: s }, n = { k: t, sorted: e }, [l, r] = y.runKernel(X, o, n);
+  return { values: l, indices: r };
+}
+const it = /* @__PURE__ */ v({ topk_: st });
+class Et extends R {
   config;
   wte;
   // Token embeddings
@@ -18,23 +104,22 @@ class A extends P {
   lnF;
   // Final layer norm
   ropeCache;
-  tf;
   log = [];
   // Training log
-  constructor(t, e = {}) {
-    super(), this.tf = t, this.config = { ...v, ...e }, this.wte = new S(t, {
+  constructor(t = {}) {
+    super(), this.config = { ...F, ...t }, this.wte = new P({
       vocabSize: this.config.vocabSize,
       embedDim: this.config.nEmbed,
       name: "token_embedding"
-    }), this.config.useRope === !1 ? this.wpe = this.tf.layers.embedding({
+    }), this.config.useRope === !1 ? this.wpe = U({
       inputDim: this.config.blockSize,
       outputDim: this.config.nEmbed,
       name: "positional_embedding",
-      embeddingsInitializer: this.tf.initializers.randomNormal({ mean: 0, stddev: 0.02 })
-    }) : this.ropeCache = new _(t, this.config), this.drop = this.tf.layers.dropout({ rate: this.config.dropout }), this.blocks = [];
-    for (let o = 0; o < this.config.nLayer; o++)
-      this.blocks.push(new z(this.tf, o, this.config, this.ropeCache));
-    this.lnF = new I(t, [this.config.nEmbed], 1e-8, "final_rms_norm");
+      embeddingsInitializer: T({ mean: 0, stddev: 0.02 })
+    }) : this.ropeCache = new C(this.config), this.drop = V({ rate: this.config.dropout }), this.blocks = [];
+    for (let e = 0; e < this.config.nLayer; e++)
+      this.blocks.push(new L(e, this.config, this.ropeCache));
+    this.lnF = new q([this.config.nEmbed], 1e-8, "final_rms_norm");
   }
   get variables() {
     return [
@@ -57,17 +142,14 @@ class A extends P {
       this.blocks[e].loadWeights(t);
     this.lnF.setWeights(t.get("final_rms_norm") || []);
   }
-  inputPhase(t, e, o = !1) {
-    return this.tf.tidy(() => {
+  inputPhase(t, e, s = !1) {
+    return w(() => {
       const i = this.wte.embed(t);
       if (this.config.useRope === !1) {
-        const [, s] = t.shape, l = this.config.blockSize, r = this.tf.range(0, s, 1, "int32"), n = this.tf.mod(
-          this.tf.add(r, this.tf.scalar(e, "int32")),
-          this.tf.scalar(l, "int32")
-        ), h = this.wpe.apply(n), c = i.add(h);
-        return this.drop.apply(c, { training: o });
+        const [, o] = t.shape, n = this.config.blockSize, l = Y(0, o, 1, "int32"), r = et(j(l, _(e, "int32")), _(n, "int32")), a = this.wpe.apply(r), h = i.add(a);
+        return this.drop.apply(h, { training: s });
       } else
-        return this.drop.apply(i, { training: o });
+        return this.drop.apply(i, { training: s });
     });
   }
   setSkipMask(t) {
@@ -103,97 +185,97 @@ class A extends P {
   }
   calculateLoss(t, e) {
     try {
-      return L()(t, e).mean();
-    } catch (o) {
-      throw console.error("Error computing loss:", o), new Error(`Loss computation failed: ${o}`);
+      return N()(t, e).mean();
+    } catch (s) {
+      throw console.error("Error computing loss:", s), new Error(`Loss computation failed: ${s}`);
     }
   }
   // Attention rollout per Abnar & Zuidema (2020)
   // Expects list of (B, T, T) attention matrices already averaged over heads.
   computeAttentionRollout(t) {
-    return this.tf.tidy(() => {
+    return w(() => {
       if (t.length === 0)
         throw new Error("No attentions for rollout");
-      const [e, o, i] = t[0].shape;
-      for (const s of t) {
-        const [l, r, n] = s.shape;
-        if (l !== e || r !== o || n !== i)
+      const [e, s, i] = t[0].shape;
+      for (const o of t) {
+        const [n, l, r] = o.shape;
+        if (n !== e || l !== s || r !== i)
           throw new Error(
-            `Inconsistent attention shapes in rollout: expected [${e},${o},${i}] got [${l},${r},${n}]`
+            `Inconsistent attention shapes in rollout: expected [${e},${s},${i}] got [${n},${l},${r}]`
           );
       }
-      if (o === i) {
-        const s = this.tf.eye(i, i).expandDims(0);
-        let l = s.tile([e, 1, 1]);
-        for (const r of t) {
-          const n = r.add(s);
-          l = n.div(n.sum(-1, !0)).matMul(l);
+      if (s === i) {
+        const o = D(i, i).expandDims(0);
+        let n = o.tile([e, 1, 1]);
+        for (const l of t) {
+          const r = l.add(o);
+          n = r.div(r.sum(-1, !0)).matMul(n);
         }
-        return l;
+        return n;
       }
-      if (o === 1) {
-        let s = null;
-        const l = this.tf.tensor1d([i - 1], "int32"), r = this.tf.oneHot(l, i).reshape([1, 1, i]).tile([e, 1, 1]);
-        l.dispose();
-        for (const n of t) {
-          let h = n.add(r);
-          h = h.div(h.sum(-1, !0)), s == null ? s = h : (s = s.mul(h), s = s.div(s.sum(-1, !0)));
+      if (s === 1) {
+        let o = null;
+        const n = A([i - 1], "int32"), l = B(n, i).reshape([1, 1, i]).tile([e, 1, 1]);
+        n.dispose();
+        for (const r of t) {
+          let a = r.add(l);
+          a = a.div(a.sum(-1, !0)), o == null ? o = a : (o = o.mul(a), o = o.div(o.sum(-1, !0)));
         }
-        return s;
+        return o;
       }
-      throw new Error(`Unsupported attention shapes for rollout: [B=${e}, Q=${o}, K=${i}]`);
+      throw new Error(`Unsupported attention shapes for rollout: [B=${e}, Q=${s}, K=${i}]`);
     });
   }
-  forward(t, e, o = !1, i = !1, s) {
-    return this.validateInput(t), this.tf.tidy(() => {
+  forward(t, e, s = !1, i = !1, o) {
+    return this.validateInput(t), w(() => {
       this.startMemory();
-      const l = s?.[0]?.length ?? 0;
-      let r = this.inputPhase(t, l, o);
-      const n = [];
-      if (s && s.length !== this.blocks.length)
-        throw console.error("Cache", s), new Error(`Cache length ${s.length} does not match number of blocks ${this.blocks.length}`);
-      for (let a = 0; a < this.blocks.length; a++) {
-        const d = r, g = this.blocks[a], {
-          output: m,
-          attention: b,
+      const n = o?.[0]?.length ?? 0;
+      let l = this.inputPhase(t, n, s);
+      const r = [];
+      if (o && o.length !== this.blocks.length)
+        throw console.error("Cache", o), new Error(`Cache length ${o.length} does not match number of blocks ${this.blocks.length}`);
+      for (let c = 0; c < this.blocks.length; c++) {
+        const u = l, d = this.blocks[c], {
+          output: b,
+          attention: k,
           cache: f
-        } = g.call(r, o, i, s ? s[a] : void 0);
-        r = m, d.dispose(), i && b && n.push(b), s && f ? (s[a]?.k.dispose(), s[a]?.v.dispose(), s[a] = f) : f && (f.k.dispose(), f.v.dispose());
+        } = d.call(l, s, i, o ? o[c] : void 0);
+        l = b, u.dispose(), i && k && r.push(k), o && f ? (o[c]?.k.dispose(), o[c]?.v.dispose(), o[c] = f) : f && (f.k.dispose(), f.v.dispose());
       }
-      let h;
-      i && n.length > 0 && (h = this.computeAttentionRollout(n)), r = this.lnF.apply(r);
-      const c = this.wte.project(r);
+      let a;
+      i && r.length > 0 && (a = this.computeAttentionRollout(r)), l = this.lnF.apply(l);
+      const h = this.wte.project(l);
       let p;
-      return e && (p = this.calculateLoss(c, e)), this.endMemory("Forward"), { logits: c, loss: p, attention: i ? h : void 0 };
+      return e && (p = this.calculateLoss(h, e)), this.endMemory("Forward"), { logits: h, loss: p, attention: i ? a : void 0 };
     });
   }
-  generate(t, e, o) {
-    const i = o?.temperature ?? 1, s = o?.topK, l = o?.usePadding ?? !1, r = o?.includeAttention ?? !1;
-    return this.tf.tidy(() => {
-      const n = t, h = n.shape[1], c = h <= this.config.blockSize ? n : n.slice(
-        [0, h - this.config.blockSize],
-        [n.shape[0], this.config.blockSize]
-      ), p = l ? this.config.blockSize - c.shape[1] : 0, a = p > 0 ? this.tf.pad(c, [
+  generate(t, e, s) {
+    const i = s?.temperature ?? 1, o = s?.topK, n = s?.usePadding ?? !1, l = s?.includeAttention ?? !1;
+    return w(() => {
+      const r = t, a = r.shape[1], h = a <= this.config.blockSize ? r : r.slice(
+        [0, a - this.config.blockSize],
+        [r.shape[0], this.config.blockSize]
+      ), p = n ? this.config.blockSize - h.shape[1] : 0, c = p > 0 ? G(h, [
         [0, 0],
         [0, p]
-      ]) : c, { logits: d, attention: g } = this.forward(a, void 0, !1, r, e), m = d.shape[1] - 1 - p, b = d.slice([0, m, 0], [d.shape[0], 1, d.shape[2]]), f = g ? g.slice([0, m, 0], [g.shape[0], 1, g.shape[2]]) : void 0, k = b.div(i);
-      let u;
-      if (s) {
-        const { values: y, indices: E } = this.tf.topk(k, s), $ = this.tf.multinomial(y.squeeze([1]), 1);
-        u = this.tf.gather(E.squeeze([1]), $, 1);
+      ]) : h, { logits: u, attention: d } = this.forward(c, void 0, !1, l, e), b = u.shape[1] - 1 - p, k = u.slice([0, b, 0], [u.shape[0], 1, u.shape[2]]), f = d ? d.slice([0, b, 0], [d.shape[0], 1, d.shape[2]]) : void 0, $ = k.div(i);
+      let g;
+      if (o) {
+        const { values: x, indices: M } = it($, o), W = S(x.squeeze([1]), 1);
+        g = Z(M.squeeze([1]), W, 1);
       } else
-        u = this.tf.multinomial(k.squeeze([1]), 1);
-      let w;
-      return o?.includeProbabilities && (w = this.tf.softmax(k.squeeze([1]))), u = u.reshape([1, 1]), { output: u, attention: f?.squeeze([1]), probabilities: w };
+        g = S($.squeeze([1]), 1);
+      let z;
+      return s?.includeProbabilities && (z = J($.squeeze([1]))), g = g.reshape([1, 1]), { output: g, attention: f?.squeeze([1]), probabilities: z };
     });
   }
   getNumParams() {
-    return F(this.config);
+    return K(this.config);
   }
   dispose() {
     this.wte.dispose(), this.wpe && this.wpe.dispose(), this.drop.dispose(), this.blocks.forEach((t) => t.dispose()), this.lnF.dispose();
   }
 }
 export {
-  A as default
+  Et as default
 };

package/dist/TeachableLLM.d.ts

@@ -1,4 +1,3 @@
-import { default as TF } from '@tensorflow/tfjs';
 import { GPTConfig } from './config';
 import { ITokeniser } from './tokeniser/type';
 import { default as NanoGPT } from './NanoGPTModel';
@@ -11,10 +10,9 @@ type TeachableLLMStatus = 'warmup' | 'awaitingTokens' | 'ready' | 'training' | '
 export default class TeachableLLM extends EE<'status' | 'error' | 'trainStep'> {
     private _config?;
     private _model?;
-    readonly tf: typeof TF;
     private _tokeniser?;
     private _status;
-    constructor(tf: typeof TF, tokeniser?: ITokeniser, model?: NanoGPT);
+    constructor(tokeniser?: ITokeniser, model?: NanoGPT);
     get config(): GPTConfig;
     get model(): NanoGPT;
     get tokeniser(): ITokeniser;
@@ -22,8 +20,8 @@ export default class TeachableLLM extends EE<'status' | 'error' | 'trainStep'> {
     get ready(): boolean;
     private setStatus;
     saveModel(options?: SaveOptions): Promise<Blob>;
-    static loadModel(tf: typeof TF, data: Blob | Buffer | string): TeachableLLM;
-    static create(tf: typeof TF, config?: Partial<GPTConfig>): TeachableLLM;
+    static loadModel(data: Blob | Buffer | string): TeachableLLM;
+    static create(tokeniserType: 'char' | 'bpe', config?: Partial<GPTConfig>): TeachableLLM;
     getProfiler(): MemoryProfiler | undefined;
     get enableProfiler(): boolean;
     set enableProfiler(value: boolean);

package/dist/TeachableLLM.js

@@ -1,29 +1,41 @@
-import { defaultConfig as h } from "./config.js";
-import m from "./NanoGPTModel.js";
+import { defaultConfig as l } from "./config.js";
+import h from "./NanoGPTModel.js";
 import { saveModel as d } from "./utilities/save.js";
 import { loadModel as f } from "./utilities/load.js";
 import u from "./Generator.js";
 import _ from "./Trainer.js";
-import { E as c } from "./index-Dwqa6Zy2.js";
-import { dummyPassAsync as l } from "./utilities/dummy.js";
-import g from "./tokeniser/CharTokeniser.js";
+import { E as p } from "./index-Dwqa6Zy2.js";
+import { dummyPassAsync as m } from "./utilities/dummy.js";
+import c from "./tokeniser/CharTokeniser.js";
+import g from "./tokeniser/bpe.js";
 import "./papaparse.min-C8l2Kvo1.js";
 import "./index-Tf7vU29b.js";
 import "./jszip.min-CjP2V1VV.js";
-import "./ops/scatterSub.js";
-import "./ops/gatherSub.js";
-import "./ops/attentionMask.js";
-import "./ops/qkv.js";
-import "./ops/rope.js";
-import p from "./utilities/profile.js";
-class a extends c {
+import "./index-pWA4_lUh.js";
+import "./ops/cpu/scatterSub.js";
+import "./ops/webgl/scatterSub.js";
+import "./ops/cpu/gatherSub.js";
+import "./ops/webgl/gatherSub.js";
+import "./ops/cpu/attentionMask.js";
+import "./ops/webgl/attentionMask.js";
+import "./ops/grads/attentionMask.js";
+import "./ops/cpu/qkv.js";
+import "./ops/webgl/qkv.js";
+import "./ops/grads/qkv.js";
+import "@tensorflow/tfjs";
+import "./ops/cpu/rope.js";
+import "./ops/webgl/rope.js";
+import "./ops/grads/rope.js";
+import "./ops/cpu/appendCache.js";
+import "./ops/webgl/appendCache.js";
+import w from "./utilities/profile.js";
+class a extends p {
   _config;
   _model;
-  tf;
   _tokeniser;
   _status = "loading";
-  constructor(t, r, e) {
-    super(), this.tf = t, this._config = e?.config, this._tokeniser = r, this._model = e;
+  constructor(t, e) {
+    super(), this._config = e?.config, this._tokeniser = t, this._model = e;
   }
   get config() {
     if (!this._config)
@@ -54,21 +66,21 @@ class a extends c {
       throw new Error("Model or tokeniser is not initialized.");
     return d(this._model, this._tokeniser, t);
   }
-  static loadModel(t, r) {
-    const e = new a(t);
-    return f(t, r).then(({ model: o, tokeniser: s }) => {
-      e._model = o, e._tokeniser = s, e._config = o.config, e.setStatus("warmup"), l(o).then(() => {
+  static loadModel(t) {
+    const e = new a();
+    return f(t).then(({ model: r, tokeniser: o }) => {
+      e._model = r, e._tokeniser = o, e._config = r.config, e.setStatus("warmup"), m(r).then(() => {
         e.setStatus("ready");
-      }).catch((i) => {
-        e.setStatus("error"), e.emit("error", i);
+      }).catch((s) => {
+        e.setStatus("error"), e.emit("error", s);
       });
-    }).catch((o) => {
-      e.setStatus("error"), e.emit("error", o);
+    }).catch((r) => {
+      e.setStatus("error"), e.emit("error", r);
     }), e;
   }
-  static create(t, r = {}) {
-    const e = { ...h, ...r }, o = new g(e.vocabSize), s = new m(t, e), i = new a(t, o, s);
-    return i.setStatus("warmup"), l(s).then(() => {
+  static create(t, e = {}) {
+    const r = { ...l, ...e }, o = t === "char" ? new c(r.vocabSize) : new g(r.vocabSize), s = new h(r), i = new a(o, s);
+    return i.setStatus("warmup"), m(s).then(() => {
       i.tokeniser.trained ? i.setStatus("ready") : (i.setStatus("awaitingTokens"), i.tokeniser.once("trainStatus", (n) => {
         n === "trained" && i.setStatus("ready");
       }));
@@ -86,7 +98,7 @@ class a extends c {
     if (t) {
       if (!this._model)
         throw new Error("Model is not initialized.");
-      this._model.getProfiler() || this._model.setProfiler(new p());
+      this._model.getProfiler() || this._model.setProfiler(new w());
     } else
       this._model && this._model.setProfiler(void 0);
   }
@@ -99,14 +111,14 @@ class a extends c {
     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("training")), t.on("stop", () => this.setStatus("ready")), t.on("log", async (r) => {
-      const e = this.listeners("trainStep");
-      for (const o of e)
-        await o(r);
+    return t.on("start", () => this.setStatus("training")), t.on("stop", () => this.setStatus("ready")), t.on("log", async (e) => {
+      const r = this.listeners("trainStep");
+      for (const o of r)
+        await o(e);
     }), t;
   }
-  train(t, r) {
-    return this.trainer().train(t, r);
+  train(t, e) {
+    return this.trainer().train(t, e);
   }
   generator() {
     if (!this._model || !this._tokeniser)
@@ -118,8 +130,8 @@ class a extends c {
       this.status === "busy" && this.setStatus("ready");
     }), t;
   }
-  generateText(t, r) {
-    return this.generator().generate(t, r);
+  generateText(t, e) {
+    return this.generator().generate(t, e);
   }
   dispose() {
     this._model?.dispose();