@genai-fi/nanogpt 0.24.0 → 1.0.0

package/dist/TeachableLLM.js

@@ -1,2 +1,201 @@
-import { r as e } from "./main-Dz72vadm.js";
-export { e as default };
+import { t as e } from "./eventemitter3-D_qV3Lof.js";
+import t from "./tokeniser/CharTokeniser.js";
+import n from "./tokeniser/bpe.js";
+import { validateConfig as r } from "./models/config.js";
+import { dummyPassTrainAsync as i } from "./utilities/dummy.js";
+import a from "./models/factory.js";
+import { loadModel as o } from "./loader/load.js";
+import { saveModel as s } from "./loader/save.js";
+import c from "./utilities/profile.js";
+import l from "./api/responses.js";
+import u from "./api/training.js";
+import { selectBackend as d } from "./backend.js";
+//#region lib/TeachableLLM.ts
+var f = class f {
+	ee = new e();
+	_config;
+	_model;
+	_tokeniser;
+	_status = "loading";
+	_memoryRequirements;
+	_responses = null;
+	_training = null;
+	meta = {
+		version: 2,
+		application: "@genai-fi/nanogpt"
+	};
+	static selectBackend(e, t) {
+		return d(e, t);
+	}
+	constructor(e, t) {
+		this._config = t?.config, this._tokeniser = e, this._model = t, t?.metaData && (this.meta = t.metaData);
+	}
+	get vocab() {
+		return this._tokeniser?.getVocab() || [];
+	}
+	get mode() {
+		return this._model?.metaData?.mode ?? "untrained";
+	}
+	set mode(e) {
+		if (!this._model) throw Error("model_not_initialized.");
+		this._model.metaData.mode === "conversational" && e === "completion" || e !== "untrained" && (this._model.metaData.mode = e, this.ee.emit("mode", e));
+	}
+	get loaded() {
+		return !!this._model && !!this._tokeniser && !!this._config;
+	}
+	get config() {
+		if (!this._config) throw Error("configuration_not_initialized.");
+		return this._config;
+	}
+	get model() {
+		if (!this._model) throw Error("model_not_initialized.");
+		return this._model;
+	}
+	get tokeniser() {
+		if (!this._tokeniser) throw Error("tokeniser_not_initialized.");
+		return this._tokeniser;
+	}
+	get status() {
+		return this._status;
+	}
+	get ready() {
+		return this._status === "ready" && !!this._model && !!this._tokeniser;
+	}
+	get busy() {
+		return this._status === "busy" || this._status === "training";
+	}
+	createLoRA(e, t) {
+		if (!this._model) throw Error("model_not_initialized.");
+		this._model.createLoRA(e, t), this.ee.emit("changeLoRA");
+	}
+	deleteLoRA(e) {
+		if (!this._model) throw Error("model_not_initialized.");
+		this._model.deleteLoRA(e), this.ee.emit("changeLoRA");
+	}
+	renameLoRA(e, t) {
+		if (!this._model) throw Error("model_not_initialized.");
+		this._model.renameLoRA(e, t), this.ee.emit("changeLoRA");
+	}
+	attachLoRA(e) {
+		if (!this._model) throw Error("model_not_initialized.");
+		this.model.lora?.name !== e && (this._model.attachLoRA(e), this.ee.emit("changeLoRA"));
+	}
+	detachLoRA() {
+		if (!this._model) throw Error("model_not_initialized.");
+		this._model.detachLoRA(), this.ee.emit("changeLoRA");
+	}
+	hasLoRA(e) {
+		if (!this._model) throw Error("model_not_initialized.");
+		return this._model.hasLoRA(e);
+	}
+	listLoRAs() {
+		if (!this._model) throw Error("model_not_initialized.");
+		return this._model.listLoRAs();
+	}
+	estimateTrainingMemoryUsage(e) {
+		let t = this._memoryRequirements ?? {
+			perBatch: 0,
+			tapeSize: 0,
+			gradients: 0
+		}, n = t.perBatch * e, r = t.gradients;
+		return n * .66 + r * 4;
+	}
+	setStatus(e) {
+		this._status !== e && (this._status = e, this.ee.emit("status", e));
+	}
+	saveModel(e) {
+		if (!this._model || !this._tokeniser) throw Error("model_or_tokeniser_not_initialized.");
+		let t = (e?.includeOptimizer && this._training?.getPretrainingJob()) ?? null;
+		return s(this._model, this._tokeniser, {
+			...e,
+			name: e?.name || this.meta.name
+		}, t ? {
+			optimizer: t.trainer.optimizer,
+			trainingLog: t.trainer.log
+		} : void 0);
+	}
+	static loadModel(e, t) {
+		let n = new f();
+		return o(e, t).then(({ model: e, tokeniser: t, metaData: a, optimizer: o, log: s }) => {
+			r(e.config), n._model = e, n._tokeniser = t, n._config = e.config, a && (n.meta = a), n.setStatus("warmup"), i(e).then((t) => {
+				n._memoryRequirements = t, o && e.metaData.pretrainingSettings && e.metaData.pretrainingData && n.training.restore(e.metaData.pretrainingSettings, s || [], o, e.metaData.pretrainingData), n.setStatus("ready"), n.ee.emit("loaded"), n.ee.emit("mode", n.mode);
+			}).catch((e) => {
+				n.setStatus("error"), n.ee.emit("error", e), console.error("Error during warmup:", e);
+			});
+		}).catch((e) => {
+			n.setStatus("error"), n.ee.emit("error", e), console.error("Error loading model:", e);
+		}), n;
+	}
+	static create(e, o) {
+		r(o);
+		let s = o, c = e === "char" ? new t(s.vocabSize) : e === "bpe" ? new n(s.vocabSize) : e, l = a(s), u = new f(c, l);
+		return u.setStatus("warmup"), i(l).then((e) => {
+			u._memoryRequirements = e, u.tokeniser.trained ? (u.setStatus("ready"), u.ee.emit("loaded"), u.ee.emit("mode", u.mode)) : (u.setStatus("awaitingTokens"), u.ee.emit("loaded"), u.ee.emit("mode", u.mode), u.tokeniser.once("trainStatus", (e) => {
+				e === "trained" && u.setStatus("ready");
+			}));
+		}).catch((e) => {
+			u.setStatus("error"), u.ee.emit("error", e), console.error("Error during warmup:", e);
+		}), u;
+	}
+	getProfiler() {
+		return this._model?.getProfiler();
+	}
+	get enableProfiler() {
+		return !!this._model?.getProfiler();
+	}
+	set enableProfiler(e) {
+		if (e) {
+			if (!this._config) return;
+			this.model.getProfiler() || this.model.setProfiler(new c());
+		} else this.model.getProfiler() && this.model.setProfiler(null);
+	}
+	getNumParams() {
+		return this._model ? this._model.getNumParams() : 0;
+	}
+	async trainTokeniser(e) {
+		if (!this._tokeniser) throw Error("tokeniser_not_initialized.");
+		let t = await this._tokeniser.train(e);
+		return this._status === "awaitingTokens" && this.setStatus("ready"), t;
+	}
+	get responses() {
+		if (!this._responses) {
+			if (!this._model || !this._tokeniser) throw Error("model_or_tokeniser_not_initialized.");
+			this._responses = new l(this._model, this._tokeniser), this._responses.on("error", (e) => {
+				this.setStatus("error"), this.ee.emit("error", e);
+			}), this._responses.on("status", (e) => {
+				e === "busy" ? this.setStatus("busy") : e === "ready" && this.setStatus("ready");
+			});
+		}
+		return this._responses;
+	}
+	get training() {
+		if (!this._training) {
+			if (!this._model || !this._tokeniser) throw Error("model_or_tokeniser_not_initialized.");
+			this._training = new u(this._model, this._tokeniser), this._training.on("running", () => {
+				this.setStatus("busy");
+			}), this._training.on("completed", () => {
+				this._training?.training || this.setStatus("ready");
+			}), this._training.on("cancelled", () => {
+				this._training?.training || this.setStatus("ready");
+			}), this._training.on("error", (e) => {
+				this.setStatus("error"), this.ee.emit("error", e);
+			});
+		}
+		return this._training;
+	}
+	dispose() {
+		this._responses &&= (this._responses.dispose(), null), this._training &&= (this._training.dispose(), null), this._model?.dispose(), this.ee.removeAllListeners();
+	}
+	on(e, t) {
+		if (e === "loaded" && this.loaded) {
+			setTimeout(() => t(), 0);
+			return;
+		}
+		this.ee.on(e, t);
+	}
+	off(e, t) {
+		this.ee.off(e, t);
+	}
+};
+//#endregion
+export { f as default };

package/dist/api/responses.d.ts

@@ -0,0 +1,81 @@
+import { IGenerateOptions, IGeneratorResponse } from '../../inference/types';
+import { ITokeniser } from '../../tokeniser/type';
+import { default as Model, ModelForwardAttributes } from '../../models/model';
+import { GPTConfig } from '../../models/config';
+interface ResponseEvents {
+    status: (status: 'ready' | 'busy') => void;
+    error: (error: Error) => void;
+    done: (id: string) => void;
+    hook: (id: string) => void;
+    generating: (id: string) => void;
+}
+export default class Responses {
+    private ee;
+    private _model;
+    private _tokeniser;
+    private _busyCount;
+    private _responses;
+    private _jobQueue;
+    private _hookedResponses;
+    private _resumeWaiters;
+    constructor(model: Model<ModelForwardAttributes, GPTConfig>, tokeniser: ITokeniser);
+    /** Number of generation jobs currently queued. */
+    get queued(): number;
+    private _processNextJob;
+    private _runForRecord;
+    /**
+     * Subscribe to response lifecycle events.
+     * @param event One of `status`, `error`, `done`, `hook`, or `generating`
+     * @param listener Callback invoked when the event fires
+     */
+    on<E extends keyof ResponseEvents>(event: E, listener: ResponseEvents[E]): void;
+    /**
+     * Unsubscribe a previously registered event listener.
+     * @param event Event name the listener was registered for
+     * @param listener The listener to remove
+     */
+    off<E extends keyof ResponseEvents>(event: E, listener: ResponseEvents[E]): void;
+    private generator;
+    private _cleanup;
+    /** Start a new text generation or resume a previous one.
+     *  @param options Response options object
+     *  @param callback Intermediate responses per token or chunk.
+     */
+    create(options: IGenerateOptions, callback?: (response: IGeneratorResponse) => void): Promise<IGeneratorResponse>;
+    /**
+     * Retry a previous response generation, optionally truncating the conversation at `index`.
+     * @param id ID of the existing response to retry
+     * @param index Optional conversation index to truncate before regenerating
+     */
+    retry(id: string, index?: number): Promise<IGeneratorResponse>;
+    /**
+     * Get the current generator response for a given ID.
+     * Returns `null` if no response with that ID exists.
+     * @param id Response ID
+     */
+    getResponse(id: string): IGeneratorResponse | null;
+    /**
+     * Cancel an in-progress generation and resolve any waiting hooks.
+     * @param id Response ID to cancel
+     * @returns `true` if the response was found and cancelled, otherwise `false`
+     */
+    cancel(id: string): boolean;
+    /**
+     * Put a response into "hooked" mode so generation pauses at the next chunk.
+     * @param id Response ID to hook
+     * @returns `true` if the response exists and was hooked, otherwise `false`
+     */
+    hook(id: string): boolean;
+    /**
+     * Resume a previously hooked response, releasing a single paused chunk.
+     * @param id Response ID to resume
+     * @returns `true` if the resume action was performed or the response is still hooked
+     */
+    resume(id: string): boolean;
+    /**
+     * Dispose all generators, clear queues and internal bookkeeping.
+     * This releases resources held by this Responses manager.
+     */
+    dispose(): void;
+}
+export {};

package/dist/api/responses.js

@@ -0,0 +1,169 @@
+import { t as e } from "../eventemitter3-D_qV3Lof.js";
+import t from "../inference/Generator.js";
+import { t as n } from "../v4-BK7K-jy_.js";
+//#region lib/api/responses.ts
+var r = class {
+	ee;
+	_model;
+	_tokeniser;
+	_busyCount = 0;
+	_responses = /* @__PURE__ */ new Map();
+	_jobQueue = [];
+	_hookedResponses = /* @__PURE__ */ new Set();
+	_resumeWaiters = /* @__PURE__ */ new Map();
+	constructor(t, n) {
+		this._model = t, this._tokeniser = n, this.ee = new e();
+	}
+	get queued() {
+		return this._jobQueue.length;
+	}
+	async _processNextJob() {
+		if (this._jobQueue.length === 0) return;
+		let e = this._jobQueue.shift();
+		try {
+			let t = await this._runForRecord(e.id, e.options, e.callback);
+			e.resolve && e.resolve(t);
+		} catch (t) {
+			e.reject && e.reject(t), this.ee.emit("error", t);
+		}
+	}
+	async _runForRecord(e, t, n) {
+		let r = t.previous_response_id ? this._responses.get(t.previous_response_id) : void 0;
+		if (r) {
+			let e = r.generator.getConversation();
+			t.input && Array.isArray(t.input) ? t.input = [...e, ...t.input] : t.input && typeof t.input == "string" ? t.input = [...e, {
+				role: t.nonConversational ? "text" : "user",
+				content: t.input
+			}] : t.input = e;
+		}
+		let i = r ? r.generator : this._responses.get(e).generator, a = n ? () => n({
+			output: i.getConversation(),
+			id: e,
+			done: !1
+		}) : null;
+		a && i.on("tokens", a);
+		let o = this._responses.get(e), s = {
+			...t,
+			_onChunk: async () => {
+				this._hookedResponses.has(e) && await new Promise((t) => {
+					let n = this._resumeWaiters.get(e) || [];
+					n.push(t), this._resumeWaiters.set(e, n), this.ee.emit("hook", e);
+				});
+			}
+		};
+		this.ee.emit("generating", t.previous_response_id || e);
+		let c = t.input ? i.generate(Array.isArray(t.input) ? t.input : [{
+			role: t.nonConversational ? "text" : "user",
+			content: t.input
+		}], s) : i.generate(s);
+		if (t.background) return c.then(() => {
+			o.done = !0, this._hookedResponses.delete(e), this._resumeWaiters.delete(e), a && i.off("tokens", a), this.ee.emit("done", e), this._processNextJob();
+		}), {
+			output: null,
+			id: e,
+			done: !1
+		};
+		let l = await c;
+		return a && i.off("tokens", a), o.done = !0, this._hookedResponses.delete(e), this._resumeWaiters.delete(e), this.ee.emit("done", e), this._processNextJob(), {
+			output: l,
+			id: e,
+			done: !0
+		};
+	}
+	on(e, t) {
+		this.ee.on(e, t);
+	}
+	off(e, t) {
+		this.ee.off(e, t);
+	}
+	generator() {
+		if (!this._model || !this._tokeniser) throw Error("model_or_tokeniser_not_initialized.");
+		let e = new t(this._model, this._tokeniser);
+		return e.on("start", () => {
+			this._busyCount === 0 && this.ee.emit("status", "busy"), this._busyCount++;
+		}), e.on("stop", () => {
+			this._busyCount--, this._busyCount === 0 && this.ee.emit("status", "ready");
+		}), e;
+	}
+	_cleanup() {
+		let e = Date.now();
+		this._responses.forEach((t, n) => {
+			t.done && e - t.timestamp > 300 * 1e3 && (t.generator.dispose(), this._responses.delete(n));
+		});
+	}
+	async create(e, t) {
+		let r = n(), i = e.previous_response_id ? this._responses.get(e.previous_response_id) : void 0;
+		i ? i.timestamp = Date.now() : this._cleanup();
+		let a = {
+			id: r,
+			generator: i ? i.generator : this.generator(),
+			done: !1,
+			timestamp: Date.now(),
+			options: e,
+			callback: t
+		};
+		if (this._responses.set(r, a), this._busyCount > 0 && !e.background) {
+			if (this._jobQueue.length > 10) throw Error("Job queue is too long, rejecting new job");
+			return new Promise((n, i) => {
+				this._jobQueue.push({
+					id: r,
+					options: e,
+					callback: t,
+					resolve: n,
+					reject: i
+				});
+			});
+		}
+		return this._runForRecord(r, e, t);
+	}
+	async retry(e, t) {
+		let n = this._responses.get(e);
+		if (n) {
+			let r = n.generator.getConversation();
+			if (t !== void 0 && t >= 0 && t < r.length && r.splice(t), n.done = !1, n.timestamp = Date.now(), this._busyCount > 0 && !n.options.background) {
+				if (this._jobQueue.length > 10) throw Error("Job queue is too long, rejecting new job");
+				return new Promise((t, r) => {
+					this._jobQueue.push({
+						id: e,
+						options: n.options,
+						callback: n.callback,
+						resolve: t,
+						reject: r
+					});
+				});
+			}
+			return this._runForRecord(e, n.options, n.callback);
+		}
+		throw Error(`No response found for id: ${e}`);
+	}
+	getResponse(e) {
+		let t = this._responses.get(e);
+		return t ? {
+			output: t.generator.getConversation(),
+			id: t.id,
+			done: t.done
+		} : null;
+	}
+	cancel(e) {
+		let t = this._responses.get(e);
+		return t ? (this._hookedResponses.delete(e), (this._resumeWaiters.get(e) || []).forEach((e) => e()), this._resumeWaiters.delete(e), t.generator.stop(), !0) : !1;
+	}
+	hook(e) {
+		return this._responses.has(e) ? (this._hookedResponses.add(e), !0) : !1;
+	}
+	resume(e) {
+		let t = this._resumeWaiters.get(e);
+		if (!t || t.length === 0) return this._hookedResponses.has(e);
+		let n = t.shift();
+		return t.length === 0 && this._resumeWaiters.delete(e), n(), !0;
+	}
+	dispose() {
+		this._resumeWaiters.forEach((e) => {
+			e.forEach((e) => e());
+		}), this._resumeWaiters.clear(), this._hookedResponses.clear(), this._responses.forEach((e) => {
+			e.generator.dispose();
+		}), this._responses.clear(), this.ee.removeAllListeners();
+	}
+};
+//#endregion
+export { r as default };

package/dist/api/training.d.ts

@@ -0,0 +1,70 @@
+import { ITokeniser } from '../../tokeniser/type';
+import { default as Model, ModelForwardAttributes } from '../../models/model';
+import { GPTConfig } from '../../models/config';
+import { ConversationStream } from '../../data/stream';
+import { TokenStore } from '../../training/tasks/TokenStore';
+import { DatasetMetadata } from '../../loader/types';
+import { TrainingLogEntry, TrainingOptions } from '../../training/types';
+import { default as BasicTrainer } from '../../training/BasicTrainer';
+import { Dataset } from '@tensorflow/tfjs-data';
+import { Tensor } from '@tensorflow/tfjs-core';
+import { AdamWOptimizer } from '../../training/AdamW';
+export type TrainingState = 'pending' | 'running' | 'paused' | 'pausing' | 'completed' | 'cancelled' | 'cancelling' | 'error';
+export interface ITrainingJob {
+    id: string;
+    state: TrainingState;
+    history: TrainingLogEntry[] | null;
+    progress: number;
+    remaining: number;
+    trainer: BasicTrainer;
+    options: TrainingOptions;
+    trainDataset?: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    validationDataset?: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    totalTokens: number;
+    datasets: DatasetMetadata[];
+    datasetId?: string;
+    breakOnLog: boolean;
+}
+interface TrainingEvents {
+    error: (id: string, error: Error) => void;
+    completed: (id: string) => void;
+    running: (id: string) => void;
+    paused: (id: string) => void;
+    cancelled: (id: string) => void;
+    pausing: (id: string) => void;
+    cancelling: (id: string) => void;
+    progress: (job: ITrainingJob) => void;
+}
+export default class Training {
+    private ee;
+    private _model;
+    private _tokeniser;
+    private _jobs;
+    constructor(model: Model<ModelForwardAttributes, GPTConfig>, tokeniser: ITokeniser);
+    private setState;
+    get activeJobs(): number;
+    get training(): boolean;
+    private assertValidJobId;
+    private assertValidOptions;
+    private assertValidDatasets;
+    private assertValidDataInput;
+    on<E extends keyof TrainingEvents>(event: E, listener: TrainingEvents[E]): void;
+    off<E extends keyof TrainingEvents>(event: E, listener: TrainingEvents[E]): void;
+    restore(options: TrainingOptions, log: TrainingLogEntry[], optimizer: AdamWOptimizer, datasets: DatasetMetadata[]): ITrainingJob;
+    private launchJob;
+    job(options: TrainingOptions, data: (ConversationStream[] | Uint16Array[] | TokenStore) | undefined, datasets: DatasetMetadata[], validation?: Uint16Array[] | TokenStore): Promise<ITrainingJob>;
+    getJob(id: string): ITrainingJob | null;
+    /** Resume a paused job and optionally change some options. */
+    resume(id: string): Promise<void>;
+    cancel(id: string): void;
+    breakpoints(id: string, enabled: boolean): void;
+    getPretrainingJob(): ITrainingJob | null;
+    dispose(): void;
+}
+export {};