@genai-fi/nanogpt 0.20.0 → 0.20.2

package/dist/Generator.d.ts

@@ -0,0 +1,82 @@
+import { Conversation, ITokeniser } from './tokeniser/type';
+import { default as EE } from 'eventemitter3';
+import { default as Model, ModelForwardAttributes } from './models/model';
+import { GenerateOptions } from './inference/types';
+export declare function isConversation(data: unknown): data is Conversation[];
+export interface IGenerateOptions extends GenerateOptions {
+    maxLength?: number;
+    noCache?: boolean;
+    allowSpecial?: boolean;
+    nonConversational?: boolean;
+    continuation?: boolean;
+}
+export interface IGenerator extends EE<'start' | 'stop' | 'tokens' | 'reset'> {
+    generate(prompt: Conversation[], options?: IGenerateOptions): Promise<Conversation[]>;
+    generate(options?: IGenerateOptions): Promise<Conversation[]>;
+    step(prompt: Conversation[], options?: IGenerateOptions): Promise<Conversation[]>;
+    step(options?: IGenerateOptions): Promise<Conversation[]>;
+    stop(): void;
+    getConversation(): Conversation[];
+    getAttentionData(): number[][][][][];
+    getProbabilitiesData(): number[][][];
+    getEmbeddingsData(): {
+        name: string;
+        tensor: number[][];
+    }[][];
+    getTokens(): number[];
+    getLastLoss(): number | null;
+    getLastMultinomialRand(): number | null;
+    dispose(): void;
+    reset(): void;
+}
+/**
+ * Text generator using a NanoGPT model and a tokeniser.
+ * This uses the forward method of the model to generate text token by token, including options for temperature, top-k, and top-p sampling.
+ */
+export default class Generator extends EE<'start' | 'stop' | 'tokens' | 'reset'> implements IGenerator {
+    private readonly model;
+    private readonly tokeniser;
+    private active;
+    private cache;
+    private initialPrompt;
+    private outputConversation;
+    private actualTokeniser;
+    private lastToken;
+    private attentionData;
+    private probabilitiesData;
+    private embeddingsData;
+    private tokens;
+    private lastLoss;
+    private lastMultinomialRand;
+    private jobQueue;
+    private processingJob;
+    private startTime;
+    constructor(model: Model<ModelForwardAttributes>, tokeniser: ITokeniser);
+    private tokenisePrompt;
+    private processResponse;
+    /** Generate logits and select a token. */
+    private _generateToken;
+    /** Generate multiple tokens in a loop and produce text */
+    private _generate;
+    private resetCache;
+    reset(): void;
+    dispose(): void;
+    private initialise;
+    step(prompt: Conversation[], options?: IGenerateOptions): Promise<Conversation[]>;
+    step(options?: IGenerateOptions): Promise<Conversation[]>;
+    generate(prompt: Conversation[], options?: IGenerateOptions): Promise<Conversation[]>;
+    generate(options?: IGenerateOptions): Promise<Conversation[]>;
+    private startJob;
+    getQueueLength(): number;
+    stop(): void;
+    getConversation(): Conversation[];
+    getAttentionData(): number[][][][][];
+    getProbabilitiesData(): number[][][];
+    getEmbeddingsData(): {
+        name: string;
+        tensor: number[][];
+    }[][];
+    getTokens(): number[];
+    getLastLoss(): number | null;
+    getLastMultinomialRand(): number | null;
+}

package/dist/Generator.js

@@ -0,0 +1,2 @@
+import { c as e, s as t } from "./main-D5CbfCiV.js";
+export { t as default, e as isConversation };

package/dist/RealDiv-DBu0FQqT.js

@@ -0,0 +1,362 @@
+import { Dn as e, En as t, Io as n, Ks as r, Ms as i, Si as a, Tn as o, nc as s, oc as c, wn as l, xn as u } from "./dist-BewPQWjc.js";
+import { L as d } from "./backend_util-Cg-roD1p.js";
+import { o as f } from "./gpgpu_math-DvLcCH6u.js";
+import { J as p, b as m } from "./shared-DOgWaqvL.js";
+import { S as h, n as g } from "./kernel_funcs_utils-HiXOOx3f.js";
+import { t as _ } from "./Reshape-CABOPB9d.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/mean_gpu.js
+var v = class {
+	constructor(e, t) {
+		this.variableNames = ["x"];
+		let { windowSize: n, batchSize: i, inSize: a, outSize: o } = e;
+		this.outputShape = [i, o];
+		let s = Math.floor(n / 4) * 4, c = n % 4, l = "sumValue += dot(values, ones);";
+		if (t != null) {
+			let e = 1 / t;
+			l = `sumValue += dot(values * ${r(e) ? e.toPrecision(2) : e}, ones);`;
+		}
+		let u = "";
+		a % n > 0 && (u = `
+        if (inIdx < 0 || inIdx >= ${a}) {
+          return 0.0;
+        }
+      `), this.userCode = `
+      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
+
+      float getValue(int batch, int inIdx) {
+        ${u}
+        return getX(batch, inIdx);
+      }
+
+      void main() {
+        ivec2 coords = getOutputCoords();
+        int batch = coords[0];
+        int outIdx = coords[1];
+        int inOffset = outIdx * ${n};
+
+        float sumValue = 0.0;
+
+        for (int i = 0; i < ${s}; i += 4) {
+          int inIdx = inOffset + i;
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            getValue(batch, inIdx + 3)
+          );
+
+          ${l}
+        }
+
+        int inIdx = inOffset + ${s};
+        if (${c === 1}) {
+          vec4 values = vec4(getValue(batch, inIdx), 0.0, 0.0, 0.0);
+
+          ${l}
+        } else if (${c === 2}) {
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1), 0.0, 0.0);
+
+          ${l}
+        } else if (${c === 3}) {
+          vec4 values = vec4(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2), 0.0);
+
+          ${l}
+        }
+        setOutput(sumValue);
+      }
+    `;
+	}
+}, y = class {
+	constructor(e, t) {
+		this.variableNames = ["x"];
+		let { windowSize: n, batchSize: r, inSize: i, outSize: a } = e;
+		this.outputShape = [r, a];
+		let o = "0.0", s = "";
+		t === "prod" ? o = "1.0" : t === "min" ? (o = "1.0 / 1e-20", s = "min") : t === "max" && (o = "-1.0 / 1e-20", s = "max");
+		let c = `${t}(${t}(${t}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;
+		t === "sum" ? c = "sumValue" : t === "prod" ? c = "prodValue" : t === "all" ? c = "allValue" : t === "any" && (c = "anyValue");
+		let l = Math.floor(n / 4) * 4, u = n % 4, d = `
+      if (${t === "sum"}) {
+        sumValue += dot(values, ones);
+      } else if (${t === "prod"}) {
+        vec2 tmp = vec2(values[0], values[1]) * vec2(values[2], values[3]);
+        prodValue *= tmp[0] * tmp[1];
+      } else {
+        minMaxValue = ${s}(values, minMaxValue);
+        if (${t === "min"} || ${t === "max"}) {
+          minMaxValue = ${s}(values, minMaxValue);
+          bvec4 isNaN = isnan(values);
+          if (isNaN.r || isNaN.g || isNaN.b || isNaN.a) {
+            minMaxValue = vec4(NAN);
+          }
+        }
+      }
+    `, f = "vec4";
+		t === "all" ? (o = "1.0", d = "\n        bool reducedAllValue = all(values);\n        float floatedReducedAllValue = float(reducedAllValue);\n        allValue = float(allValue >= 1.0 && floatedReducedAllValue >= 1.0);\n      ", f = "bvec4") : t === "any" && (o = "0.0", d = "\n        bool reducedAnyValue = any(values);\n        float floatedReducedAnyValue = float(reducedAnyValue);\n        anyValue = float(anyValue >= 1.0 || floatedReducedAnyValue >= 1.0);\n      ", f = "bvec4");
+		let p = "";
+		i % n > 0 && (p = `
+        if (inIdx < 0 || inIdx >= ${i}) {
+          return initializationValue;
+        }
+      `), this.userCode = `
+      const float initializationValue = ${o};
+      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);
+
+      float getValue(int batch, int inIdx) {
+        ${p}
+        return getX(batch, inIdx);
+      }
+
+      void main() {
+        ivec2 coords = getOutputCoords();
+        int batch = coords[0];
+        int outIdx = coords[1];
+        int inOffset = outIdx * ${n};
+
+        vec4 minMaxValue = vec4(${o});
+        float prodValue = 1.0;
+        float sumValue = 0.0;
+        float allValue = 1.0;
+        float anyValue = 0.0;
+
+        for (int i = 0; i < ${l}; i += 4) {
+          int inIdx = inOffset + i;
+          ${f} values = ${f}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            getValue(batch, inIdx + 3)
+          );
+
+          ${d}
+        }
+
+        int inIdx = inOffset + ${l};
+        if (${u === 1}) {
+          ${f} values = ${f}(
+            getValue(batch, inIdx),
+            initializationValue,
+            initializationValue,
+            initializationValue
+          );
+
+          ${d}
+        } else if (${u === 2}) {
+          ${f} values = ${f}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            initializationValue,
+            initializationValue
+          );
+
+          ${d}
+        } else if (${u === 3}) {
+          ${f} values = ${f}(
+            getValue(batch, inIdx),
+            getValue(batch, inIdx + 1),
+            getValue(batch, inIdx + 2),
+            initializationValue
+          );
+
+          ${d}
+        }
+        setOutput(${c});
+      }
+    `;
+	}
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernel_utils/reduce.js
+function b(e) {
+	let t = [];
+	for (; t.length === 0 || t[t.length - 1].outSize !== 1;) {
+		let n = t.length ? t[t.length - 1].outSize : e[1], r = d(n);
+		t.push({
+			inSize: n,
+			windowSize: r,
+			outSize: Math.ceil(n / r)
+		});
+	}
+	return t;
+}
+function x(e, t, n, r) {
+	let i = b(e.shape), a = e;
+	for (let o = 0; o < i.length; o++) {
+		let { inSize: s, windowSize: c, outSize: l } = i[o], u, d;
+		u = n === "mean" ? o === 0 ? new v({
+			windowSize: c,
+			inSize: s,
+			batchSize: e.shape[0],
+			outSize: l
+		}, s) : new v({
+			windowSize: c,
+			inSize: s,
+			batchSize: e.shape[0],
+			outSize: l
+		}) : new y({
+			windowSize: c,
+			inSize: s,
+			batchSize: e.shape[0],
+			outSize: l
+		}, n), d = a, a = r.runWebGLProgram(u, [a], t), d.dataId !== e.dataId && r.disposeIntermediateTensorInfo(d);
+	}
+	return a;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/transpose_gpu.js
+var S = class {
+	constructor(e, t) {
+		this.variableNames = ["A"];
+		let n = Array(e.length);
+		for (let r = 0; r < n.length; r++) n[r] = e[t[r]];
+		this.outputShape = n, this.rank = n.length;
+		let r = f(this.rank), i = C(t);
+		this.userCode = `
+    void main() {
+      ${r} resRC = getOutputCoords();
+      setOutput(getA(${i}));
+    }
+    `;
+	}
+};
+function C(e) {
+	let t = e.length;
+	if (t > 6) throw Error(`Transpose for rank ${t} is not yet supported`);
+	let n = [
+		"resRC.x",
+		"resRC.y",
+		"resRC.z",
+		"resRC.w",
+		"resRC.u",
+		"resRC.v"
+	], r = Array(t);
+	for (let t = 0; t < e.length; t++) r[e[t]] = n[t];
+	return r.join();
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/transpose_packed_gpu.js
+var w = class {
+	constructor(e, t) {
+		this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0;
+		let n = Array(e.length);
+		for (let r = 0; r < n.length; r++) n[r] = e[t[r]];
+		if (this.outputShape = n, this.rank = n.length, this.rank > 6) throw Error(`Packed transpose for rank ${this.rank} is not yet supported.`);
+		let r = f(this.rank), i = h("rc", this.rank), a = Array(this.rank);
+		for (let e = 0; e < t.length; e++) a[t[e]] = i[e];
+		let o = `vec2(${a.slice(-2).join()})`, s = `++${i[this.rank - 1]} < ${n[this.rank - 1]}`, c = `getChannel(getA(${a.join()}), ${o})`;
+		this.userCode = `
+    void main() {
+      ${r} rc = getOutputCoords();
+      vec4 result = vec4(0.);
+      result[0] = ${c};
+      if(${s}) {
+        result[1] = ${c};
+      }
+      --${i[this.rank - 1]};
+      if(++${i[this.rank - 2]} < ${n[this.rank - 2]}) {
+        result[2] = ${c};
+        if(${s}) {
+          result[3] = ${c};
+        }
+      }
+      setOutput(result);
+    }
+    `;
+	}
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Transpose_impl.js
+function T(e, t, n) {
+	let r = i().getBool("WEBGL_PACK_ARRAY_OPERATIONS") ? new w(e.shape, t) : new S(e.shape, t);
+	return n.runWebGLProgram(r, [e], e.dtype);
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Sum_impl.js
+function E(n, r, i, d) {
+	let f = r, p = n.shape.length, m = s(f, n.shape), h = m, g = t(h, p), v = g != null, y = n;
+	v && (y = T(n, g, d), h = e(h.length, p)), u("sum", h, p);
+	let [b, S] = l(y.shape, h), C = b;
+	i && (C = o(b, m));
+	let w = c(S), E = c(n.shape) / w, D = _({
+		inputs: { x: y },
+		attrs: { shape: [E, w] },
+		backend: d
+	}), O = x(D, a(n.dtype), "sum", d), k = _({
+		inputs: { x: O },
+		attrs: { shape: C },
+		backend: d
+	});
+	return d.disposeIntermediateTensorInfo(D), d.disposeIntermediateTensorInfo(O), v && d.disposeIntermediateTensorInfo(y), k;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Sum.js
+function D(e) {
+	let { inputs: t, backend: n, attrs: r } = e, { x: i } = t, { axis: a, keepDims: o } = r;
+	return E(i, a, o, n);
+}
+var O = {
+	kernelName: "Sum",
+	backendName: "webgl",
+	kernelFunc: D
+};
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Max_impl.js
+function k(e, t, n, r) {
+	let i = c(t), a = c(e.shape) / i, o = _({
+		inputs: { x: e },
+		attrs: { shape: [a, i] },
+		backend: r
+	}), s = x(o, e.dtype, "max", r), l = _({
+		inputs: { x: s },
+		attrs: { shape: n },
+		backend: r
+	});
+	return r.disposeIntermediateTensorInfo(o), r.disposeIntermediateTensorInfo(s), l;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Max.js
+function A(n) {
+	let { inputs: r, backend: i, attrs: a } = n, { x: d } = r, { reductionIndices: f, keepDims: h } = a, g = d.shape.length, _ = s(f, d.shape), v = _, y = t(v, g), b = y != null, x = i.shouldExecuteOnCPU([d]), S = d;
+	if (b) {
+		if (x) {
+			let e = i.texData.get(S.dataId).values, t = Array(g);
+			for (let e = 0; e < t.length; e++) t[e] = d.shape[y[e]];
+			let n = p(e, d.shape, d.dtype, y, t);
+			S = i.makeTensorInfo(t, d.dtype);
+			let r = i.texData.get(S.dataId);
+			r.values = n;
+		} else S = T(d, y, i);
+		v = e(v.length, g);
+	}
+	u("max", v, g);
+	let [C, w] = l(S.shape, v), E = C;
+	h && (E = o(C, _));
+	let D;
+	if (x) {
+		let e = i.texData.get(S.dataId).values, t = m(e, c(w), E, d.dtype);
+		D = i.makeTensorInfo(E, d.dtype);
+		let n = i.texData.get(D.dataId);
+		n.values = t;
+	} else D = k(S, w, E, i);
+	return b && i.disposeIntermediateTensorInfo(S), D;
+}
+var j = {
+	kernelName: "Max",
+	backendName: "webgl",
+	kernelFunc: A
+}, M = g({
+	opSnippet: "\nif (a == b) {\n  return 1.0;\n};\nreturn a / b;",
+	packedOpSnippet: "\n  // vec4 one = vec4(equal(a, b));\n  // return one + (vec4(1.0) - one) * a / b;\n  vec4 result = a / b;\n  if(a.x == b.x) {\n    result.x = 1.;\n  }\n  if(a.y == b.y) {\n    result.y = 1.;\n  }\n  if(a.z == b.z) {\n    result.z = 1.;\n  }\n  if(a.w == b.w) {\n    result.w = 1.;\n  }\n\n  return result;\n",
+	checkOutOfBounds: !0
+}), N = {
+	kernelName: n,
+	backendName: "webgl",
+	kernelFunc: M
+};
+//#endregion
+export { D as a, x as c, j as i, N as n, O as o, A as r, T as s, M as t };

package/dist/Reshape-CABOPB9d.js

@@ -0,0 +1,94 @@
+import { Bo as e, Gs as t, Ps as n, oc as r } from "./dist-BewPQWjc.js";
+import { E as i, a, c as o, d as s, j as c, l, u, z as d } from "./gpgpu_math-DvLcCH6u.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/reshape_packed_gpu.js
+var f = class {
+	constructor(e, t) {
+		this.variableNames = ["A"], this.packedInputs = !0, this.packedOutput = !0, this.customUniforms = [{
+			name: "inputShape",
+			type: "ivec3"
+		}], this.outputShape = e, this.enableShapeUniforms = a(this.outputShape.length);
+		let n = "";
+		for (let e = 0; e < 4; e++) {
+			let t = "thisRC = rc;";
+			e % 2 == 1 && (t += "thisRC.z += 1;"), e > 1 && (t += "thisRC.y += 1;"), n += `
+        ${t}
+        ${e > 0 ? "if(thisRC.y < rows && thisRC.z < cols){" : ""}
+          int flatIndex = getFlatIndex(thisRC);
+
+          ivec3 inputRC = inputCoordsFromReshapedOutCoords(flatIndex);
+          vec2 inputRCInnerDims = vec2(float(inputRC.y),float(inputRC.z));
+
+          result[${e}] =
+            getChannel(getA(inputRC.x, inputRC.y, inputRC.z), inputRCInnerDims);
+        ${e > 0 ? "}" : ""}
+      `;
+		}
+		this.userCode = `
+      ${p(t, this.enableShapeUniforms)}
+      ${this.enableShapeUniforms ? l() : o(e)}
+
+      void main() {
+        ivec3 rc = getOutputCoords();
+
+        vec4 result = vec4(0.);
+
+        ivec3 thisRC;
+        int rows = ${this.enableShapeUniforms ? "outShape[1]" : e[1]};
+        int cols = ${this.enableShapeUniforms ? "outShape[2]" : e[2]};
+
+        ${n}
+
+        setOutput(result);
+      }
+    `;
+	}
+};
+function p(e, t) {
+	return `
+    ivec3 inputCoordsFromReshapedOutCoords(int index) {
+      ${t ? s([
+		"r",
+		"c",
+		"d"
+	], "inputShape") : u([
+		"r",
+		"c",
+		"d"
+	], e)}
+      return ivec3(r, c, d);
+    }
+  `;
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernel_utils/reshape.js
+function m(e, t, n) {
+	let r = [i(e.shape), ...c(e.shape)], a = {
+		dtype: e.dtype,
+		shape: r,
+		dataId: e.dataId
+	}, o = new f([i(t), ...c(t)], r), s = [r], l = n.runWebGLProgram(o, [a], e.dtype, s, !0);
+	return {
+		dataId: l.dataId,
+		shape: t,
+		dtype: l.dtype
+	};
+}
+//#endregion
+//#region node_modules/@tensorflow/tfjs-backend-webgl/dist/kernels/Reshape.js
+function h(e) {
+	let { inputs: i, backend: a, attrs: o } = e, { x: s } = i, { shape: c } = o, l = a, u = r(s.shape), f = t(c, u), p = r(f);
+	n(u === p, () => `The new shape (${f}) has ${p} elements and the old shape (${s.shape}) has ${u} elements. The new shape and old shape must have the same number of elements.`);
+	let h = l.texData.get(s.dataId);
+	return h.isPacked && !d(s.shape, f) && !(h.texture !== null && d(h.shape, f)) ? m(s, f, l) : (l.incRef(s.dataId), {
+		dataId: s.dataId,
+		shape: f,
+		dtype: s.dtype
+	});
+}
+var g = {
+	kernelName: e,
+	backendName: "webgl",
+	kernelFunc: h
+};
+//#endregion
+export { g as n, f as r, h as t };

package/dist/Reshape-DqO3r8BC.js

@@ -0,0 +1,17 @@
+import { Bo as e, Gs as t, Ps as n, oc as r } from "./dist-BewPQWjc.js";
+//#region node_modules/@tensorflow/tfjs-backend-webgpu/dist/kernels/Reshape.js
+function i(e) {
+	let { inputs: i, attrs: a } = e, { x: o } = i, { shape: s } = a, c = r(o.shape), l = t(s, c), u = r(l);
+	return n(c === u, () => `The new shape (${l}) has ${u} elements and the old shape (${o.shape}) has ${c} elements. The new shape and old shape must have the same number of elements.`), e.backend.incRef(o.dataId), {
+		dataId: o.dataId,
+		shape: l,
+		dtype: o.dtype
+	};
+}
+var a = {
+	kernelName: e,
+	backendName: "webgpu",
+	kernelFunc: i
+};
+//#endregion
+export { a as n, i as t };

package/dist/TeachableLLM.d.ts

@@ -0,0 +1,70 @@
+import { GPTConfig, LoRAConfig } from './models/config';
+import { Conversation, ITokeniser } from './tokeniser/type';
+import { SaveOptions } from './loader/save';
+import { LoadModelOptions } from './loader/load';
+import { IGenerateOptions, IGenerator } from './Generator';
+import { default as Trainer, TrainingType } from './Trainer';
+import { default as MemoryProfiler } from './utilities/profile';
+import { default as Model, ModelForwardAttributes } from './models/model';
+import { Task } from './training/tasks/Task';
+import { TrainingLogEntry, TrainingOptions } from './training/types';
+import { ModelMode, TransformersMetadata } from './loader/types';
+type TeachableLLMStatus = 'warmup' | 'awaitingTokens' | 'ready' | 'training' | 'loading' | 'busy' | 'error';
+export default class TeachableLLM {
+    private ee;
+    private _config?;
+    private _model?;
+    private _tokeniser?;
+    private _status;
+    private _memoryRequirements?;
+    meta: TransformersMetadata;
+    private _trainer;
+    constructor(tokeniser?: ITokeniser, model?: Model<ModelForwardAttributes, GPTConfig>);
+    get currentTrainer(): Trainer | null;
+    get vocab(): string[];
+    get mode(): ModelMode;
+    set mode(mode: ModelMode);
+    /** Model is fully loaded */
+    get loaded(): boolean;
+    get config(): GPTConfig;
+    get model(): Model<ModelForwardAttributes, GPTConfig>;
+    get tokeniser(): ITokeniser;
+    get status(): TeachableLLMStatus;
+    /** Model is both ready and not busy */
+    get ready(): boolean;
+    get busy(): boolean;
+    createLoRA(name: string, loraConfig: LoRAConfig): void;
+    deleteLoRA(name: string): void;
+    renameLoRA(oldName: string, newName: string): void;
+    attachLoRA(name: string): void;
+    detachLoRA(): void;
+    hasLoRA(name?: string): boolean;
+    listLoRAs(): string[];
+    estimateTrainingMemoryUsage(batchSize: number): number;
+    private setStatus;
+    saveModel(options?: SaveOptions): Promise<Blob>;
+    static loadModel(data: Blob | Buffer | string, options?: LoadModelOptions): TeachableLLM;
+    static create(tokeniserType: 'char' | 'bpe', config: GPTConfig): TeachableLLM;
+    getProfiler(): MemoryProfiler | undefined;
+    get enableProfiler(): boolean;
+    set enableProfiler(value: boolean);
+    getNumParams(): number;
+    trainer(trainingType?: TrainingType, options?: TrainingOptions): Trainer;
+    train(text: Task[], options?: TrainingOptions, trainingType?: TrainingType): Promise<void>;
+    trainTokeniser(text: Conversation[][]): Promise<number>;
+    generator(): IGenerator;
+    generateText(prompt: Conversation[], options?: IGenerateOptions): Promise<Conversation[]>;
+    generateText(options?: IGenerateOptions): Promise<Conversation[]>;
+    dispose(): void;
+    on(event: 'status', listener: (status: TeachableLLMStatus) => void): void;
+    on(event: 'mode', listener: (mode: ModelMode) => void): void;
+    on(event: 'error', listener: (error: Error) => void): void;
+    on(event: 'trainStep', listener: (step: TrainingLogEntry) => void): void;
+    on(event: 'loaded' | 'changeLoRA', listener: () => void): void;
+    off(event: 'status', listener: (status: TeachableLLMStatus) => void): void;
+    off(event: 'mode', listener: (mode: ModelMode) => void): void;
+    off(event: 'error', listener: (error: Error) => void): void;
+    off(event: 'trainStep', listener: (step: TrainingLogEntry) => void): void;
+    off(event: 'loaded' | 'changeLoRA', listener: () => void): void;
+}
+export {};

package/dist/TeachableLLM.js

@@ -0,0 +1,2 @@
+import { i as e } from "./main-D5CbfCiV.js";
+export { e as default };

package/dist/Trainer.d.ts

@@ -0,0 +1,43 @@
+import { ITokeniser } from './tokeniser/type';
+import { default as EE } from 'eventemitter3';
+import { default as Model, ModelForwardAttributes } from './models/model';
+import { Task } from './training/tasks/Task';
+import { TrainingOptions, TrainingLogEntry } from './training/types';
+import { AdamWOptimizer } from './training/AdamW';
+import { DatasetMetadata } from './loader/types';
+interface TrainingProgress {
+    lastLog: TrainingLogEntry;
+    progress: number;
+    remaining: number;
+}
+export type TrainingType = 'pretraining' | 'sft';
+export default class Trainer extends EE<'start' | 'stop' | 'log'> {
+    private trainer;
+    readonly trainingType: TrainingType;
+    private hasTrained;
+    private trainDataset?;
+    private validationDataset?;
+    private totalTokens;
+    private tokensProcessed;
+    log: TrainingLogEntry[];
+    private progress;
+    options: TrainingOptions;
+    protected tokenizer: ITokeniser;
+    constructor(model: Model<ModelForwardAttributes>, tokeniser: ITokeniser, trainingType?: TrainingType, options?: TrainingOptions, optimizer?: AdamWOptimizer);
+    constructor(trainer: Trainer, options?: TrainingOptions);
+    get model(): Model<ModelForwardAttributes>;
+    get optimizer(): AdamWOptimizer;
+    stop(): void;
+    reset(): void;
+    dispose(): void;
+    getTotalTokens(): number;
+    setOptions(options: TrainingOptions): void;
+    prepare(tasks?: Task[] | Uint16Array, datasets?: DatasetMetadata[]): Promise<void>;
+    private configureModel;
+    train(): Promise<void>;
+    step(options?: TrainingOptions): Promise<void>;
+    getLog(): TrainingLogEntry[];
+    getProgress(): TrainingProgress | null;
+    isPrepared(): boolean;
+}
+export {};

package/dist/Trainer.js

@@ -0,0 +1,2 @@
+import { a as e } from "./main-D5CbfCiV.js";
+export { e as default };

package/dist/backend.d.ts

@@ -0,0 +1,2 @@
+import { GPUOptions } from './patches/webgpu_base';
+export declare function selectBackend(backendName: 'cpu' | 'webgl' | 'webgpu', options?: GPUOptions): Promise<void>;