@genai-fi/nanogpt 0.20.0 → 0.20.1

package/dist/training/tasks/PretrainingTask.js

@@ -0,0 +1,42 @@
+import { Task as e } from "./Task.js";
+//#region lib/training/tasks/PretrainingTask.ts
+var t = class extends e {
+	rawText;
+	index = 0;
+	get length() {
+		return this.rawText.length;
+	}
+	constructor(e) {
+		super(), this.rawText = e;
+	}
+	hasMoreConversations() {
+		return this.index < this.rawText.length;
+	}
+	nextConversation() {
+		if (this.index >= this.rawText.length) return null;
+		let e = {
+			role: "assistant",
+			content: this.rawText[this.index]
+		};
+		return this.index++, [e];
+	}
+	nextTokens(e, t) {
+		if (this.index >= this.rawText.length) return null;
+		let n = e.encodeSequence(this.rawText[this.index]);
+		return this.index++, t ? {
+			tokens: n,
+			mask: Array(n.length).fill(!0)
+		} : n;
+	}
+	shuffle() {
+		this.index = 0;
+	}
+	async estimateTokens(e) {
+		return e.encodeConversation([{
+			role: "assistant",
+			content: this.rawText[0]
+		}]).length * this.length;
+	}
+};
+//#endregion
+export { t as default };

package/dist/training/tasks/StartSentenceTask.d.ts

@@ -0,0 +1,18 @@
+import { Conversation, ITokeniser } from '../../../main';
+import { Task } from './Task';
+export default class StartSentenceTask extends Task {
+    private rawText;
+    private index;
+    get length(): number;
+    constructor(texts: string[]);
+    hasMoreConversations(): boolean;
+    nextConversation(): Conversation[] | null;
+    nextTokens(tokeniser: ITokeniser): number[] | null;
+    nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
+    shuffle(): void;
+    private conversationFromString;
+    estimateTokens(tokeniser: ITokeniser): Promise<number>;
+}

package/dist/training/tasks/StartSentenceTask.js

@@ -0,0 +1,45 @@
+import { Task as e } from "./Task.js";
+//#region lib/training/tasks/StartSentenceTask.ts
+var t = class extends e {
+	rawText;
+	index = 0;
+	get length() {
+		return this.rawText.length;
+	}
+	constructor(e) {
+		super(), this.rawText = e;
+	}
+	hasMoreConversations() {
+		return this.index < this.rawText.length;
+	}
+	nextConversation() {
+		if (this.index >= this.rawText.length) return null;
+		let e = this.rawText[this.index];
+		return this.index++, this.conversationFromString(e);
+	}
+	nextTokens(e, t) {
+		let n = this.nextConversation();
+		return n ? e.encodeConversation(n, !1, t) : null;
+	}
+	shuffle() {
+		this.index = 0;
+	}
+	conversationFromString(e) {
+		let t = e.indexOf(".");
+		return t === -1 ? [{
+			role: "assistant",
+			content: this.rawText[this.index]
+		}] : [{
+			role: "user",
+			content: e.slice(0, t + 1).trim()
+		}, {
+			role: "assistant",
+			content: e.slice(t + 1).trim()
+		}];
+	}
+	async estimateTokens(e) {
+		return (await e.encodeConversation(this.conversationFromString(this.rawText[0]))).length * this.length;
+	}
+};
+//#endregion
+export { t as default };

package/dist/training/tasks/Task.d.ts

@@ -0,0 +1,22 @@
+import { Conversation, ITokeniser } from '../../../main';
+export declare abstract class Task {
+    abstract get length(): number;
+    abstract hasMoreConversations(): boolean;
+    abstract nextConversation(): Conversation[] | null;
+    abstract nextTokens(tokeniser: ITokeniser): number[] | null;
+    abstract nextTokens(tokeniser: ITokeniser, masking: boolean): {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
+    abstract nextTokens(tokeniser: ITokeniser, masking?: boolean): number[] | {
+        tokens: number[];
+        mask: boolean[];
+    } | null;
+    abstract estimateTokens(tokeniser: ITokeniser): Promise<number>;
+    abstract shuffle(): void;
+}
+export declare function tokensFromTasks(tasks: Task[], tokenizer: ITokeniser, cb?: (tokens: number) => void): Promise<Uint16Array>;
+export declare function tokensFromTasks(tasks: Task[], tokenizer: ITokeniser, cb?: (tokens: number) => void, masking?: boolean): Promise<{
+    tokens: Uint16Array;
+    mask: Uint8Array;
+}>;

package/dist/training/tasks/Task.js

@@ -0,0 +1,55 @@
+import { yieldIfNeeded as e } from "../../utilities/yielder.js";
+//#region lib/training/tasks/Task.ts
+var t = class {};
+function n(e, t, n, r, i, a) {
+	for (let o of e) {
+		let e = o.nextTokens(n, a ? !0 : void 0);
+		if (e) {
+			let n = Array.isArray(e) ? e : e.tokens;
+			r.total += n.length;
+			let o = t[t.length - 1], s = a ? a[a.length - 1] : null;
+			if (r.offset + n.length > o.length) {
+				let c = o.length - r.offset;
+				o.set(n.slice(0, c), r.offset);
+				let l = new Uint16Array(Math.floor(i * .1) + 100);
+				if (l.set(n.slice(c), 0), t.push(l), a && s && !Array.isArray(e)) {
+					s.set(e.mask.slice(0, c).map((e) => +!!e), r.offset);
+					let t = new Uint8Array(l.length);
+					t.set(e.mask.slice(c).map((e) => +!!e), 0), a.push(t);
+				}
+				r.offset = n.length - c;
+			} else o.set(n, r.offset), s && !Array.isArray(e) && s.set(e.mask.map((e) => +!!e), r.offset), r.offset += n.length;
+		}
+	}
+}
+async function r(t, r, i, a) {
+	let o = Math.min((await Promise.all(t.map((e) => e.estimateTokens(r)))).reduce((e, t) => e + t, 0), r.vocabSize * 1e4), s = [new Uint16Array(o)], c = a ? [new Uint8Array(o)] : null, l = {
+		offset: 0,
+		total: 0
+	}, u = performance.now();
+	for (; l.offset < o && (n(t, s, r, l, o, c || void 0), !t.every((e) => !e.hasMoreConversations()));) u = await e(u, i, l.total);
+	if (s.length === 1) return c ? {
+		tokens: s[0].subarray(0, l.offset),
+		mask: c[0].subarray(0, l.offset)
+	} : s[0].subarray(0, l.offset);
+	let d = s.reduce((e, t) => e + t.length, 0) - (s[s.length - 1].length - l.offset), f = new Uint16Array(d), p = 0;
+	for (let e = 0; e < s.length; e++) {
+		let t = s[e];
+		e === s.length - 1 ? (f.set(t.subarray(0, l.offset), p), p += l.offset) : (f.set(t, p), p += t.length);
+	}
+	if (c) {
+		let e = new Uint8Array(d);
+		p = 0;
+		for (let t = 0; t < c.length; t++) {
+			let n = c[t];
+			t === c.length - 1 ? (e.set(n.subarray(0, l.offset), p), p += l.offset) : (e.set(n, p), p += n.length);
+		}
+		return {
+			tokens: f,
+			mask: e
+		};
+	}
+	return f;
+}
+//#endregion
+export { t as Task, r as tokensFromTasks };

package/dist/training/tasks/splitter.d.ts

@@ -0,0 +1,5 @@
+import { Task } from './Task';
+export default function splitValidation(tasks: Task[], validationSplit: number): {
+    training: Task;
+    validation: Task;
+};

package/dist/training/tasks/splitter.js

@@ -0,0 +1,18 @@
+import e from "./ConversationTask.js";
+//#region lib/training/tasks/splitter.ts
+function t(t, n) {
+	if (n <= 0 || n >= 1) throw Error("validationSplit must be between 0 and 1");
+	t.forEach((e) => e.shuffle());
+	let r = [], i = [];
+	for (let e of t) for (; e.hasMoreConversations();) {
+		let t = e.nextConversation();
+		if (!t) break;
+		Math.random() < n ? i.push(t) : r.push(t);
+	}
+	return {
+		training: new e(r),
+		validation: new e(i)
+	};
+}
+//#endregion
+export { t as default };

package/dist/training/types.d.ts

@@ -0,0 +1,78 @@
+import { TensorStatistics } from '../../checks/weights';
+import { LoRAConfig } from '../../models/config';
+import { NamedTensorMap, Tensor } from '@tensorflow/tfjs-core';
+export interface Metrics {
+    accuracy?: number;
+    perplexity?: number;
+    loss: number;
+}
+export interface TrainingLogEntry {
+    trainingMetrics: Metrics;
+    validationMetrics?: Metrics;
+    step: number;
+    time: number;
+    example?: string;
+    batchSize: number;
+    gradientMetrics?: Map<string, TensorStatistics>;
+    learningRate?: number;
+    gradientNorm?: number;
+    weightNorm?: number;
+    weightStatistics?: Map<string, TensorStatistics>;
+    memoryUsage?: number;
+    tokensPerSecond: number;
+    duration: number;
+    totalTokens: number;
+}
+export interface LRSchedulerConfig {
+    warmupSteps: number;
+    decayEpochs: number;
+    minLearningRate: number;
+    epochSteps: number;
+    step?: number;
+}
+export interface AdamWOptimizerConfig extends LRSchedulerConfig {
+    learningRate: number;
+    beta1: number;
+    beta2: number;
+    accBeta1?: number;
+    accBeta2?: number;
+    epsilon?: number;
+    weightDecay: number;
+    lossScaling: number;
+    clipNorm?: number;
+    orthoGrad?: boolean;
+}
+export type TrainingMetrics = 'accuracy' | 'perplexity' | 'gradientNorm' | 'gradientStatistics' | 'weightNorm' | 'weightStatistics' | 'memoryUsage' | 'tokensPerSecond' | 'learningRate';
+export interface TrainingOptions extends Partial<AdamWOptimizerConfig> {
+    batchSize: number;
+    maxEpochs?: number;
+    logInterval?: number;
+    prompt?: string;
+    validationSplit?: number;
+    gradientCheckpointing?: boolean;
+    mixedPrecision?: boolean;
+    trainableWeights?: string[];
+    loraConfig?: LoRAConfig;
+    loraName?: string;
+    sftMode: 'full' | 'lora' | 'last-layer';
+    maskedLoss?: boolean;
+    metrics?: TrainingMetrics[];
+    contextScaling?: number;
+    labelSmoothing?: number;
+    dropout?: number;
+    layerDrop?: number;
+    debug?: boolean;
+    onStep?: (log: TrainingLogEntry) => void;
+}
+export interface TrainingState {
+    step: number;
+    lastLoss: number;
+    totalSteps: number;
+    losses: number[];
+    validationLosses: number[];
+    logStartTime: number;
+    trainingDuration: number;
+    gradients?: NamedTensorMap;
+    gradientNorm?: Tensor;
+    accuracy?: Tensor;
+}

package/dist/training/validation.d.ts

@@ -0,0 +1,17 @@
+import { ITokeniser, Task } from '../../main';
+import { Tensor } from '@tensorflow/tfjs-core';
+import { Dataset } from '@tensorflow/tfjs-data';
+import { DatasetBuilder, DatasetState } from './DatasetBuilder';
+export declare function createTrainValidationSplit(tasks: Task[] | Uint16Array, tokeniser: ITokeniser, datasetBuilder: DatasetBuilder, batchSize: number, validationSplit?: number, masking?: boolean): Promise<{
+    trainDataset: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    validationDataset: Dataset<{
+        xs: Tensor;
+        ys: Tensor;
+    }>;
+    size: number;
+    validationState: DatasetState;
+    trainState: DatasetState;
+}>;

package/dist/training/validation.js

@@ -0,0 +1,2 @@
+import { o as e } from "../main-CPjeMv0G.js";
+export { e as createTrainValidationSplit };

package/dist/utilities/arrayClose.d.ts

@@ -0,0 +1 @@
+export declare function arraysClose(a: unknown, b: unknown): number;

package/dist/utilities/arrayClose.js

@@ -0,0 +1,16 @@
+//#region lib/utilities/arrayClose.ts
+function e(t, n) {
+	let r = 0;
+	if ((Array.isArray(t) || t instanceof Float32Array) && (Array.isArray(n) || n instanceof Float32Array)) {
+		if (t.length !== n.length) return Infinity;
+		for (let i = 0; i < t.length; ++i) r = Math.max(r, e(t[i], n[i]));
+		return r;
+	} else if (typeof t == "number" && typeof n == "number") {
+		if (isNaN(t) && isNaN(n)) return 0;
+		if (!isFinite(t) || !isFinite(n)) return t === n ? 0 : Infinity;
+		let e = Math.abs(t - n);
+		return r = Math.max(r, e), r;
+	} else return Infinity;
+}
+//#endregion
+export { e as arraysClose };

package/dist/utilities/datasetID.d.ts

@@ -0,0 +1,2 @@
+import { DatasetMetadata } from '../loader/types';
+export default function generateDatasetID(datasets: DatasetMetadata[]): string;

package/dist/utilities/datasetID.js

@@ -0,0 +1,18 @@
+//#region lib/utilities/datasetID.ts
+function e(e) {
+	let t = e.map((e) => String(e.id)).sort(), n = 2166136261, r = 2654435769, i = (e) => {
+		n ^= e & 255, n = Math.imul(n, 16777619), r ^= e & 255, r = Math.imul(r, 2246822507);
+	}, a = (e) => {
+		let t = e.length >>> 0;
+		i(t & 255), i(t >>> 8 & 255), i(t >>> 16 & 255), i(t >>> 24 & 255);
+		for (let t = 0; t < e.length; t++) {
+			let n = e.charCodeAt(t);
+			i(n & 255), i(n >>> 8 & 255);
+		}
+	}, o = t.length >>> 0;
+	i(o & 255), i(o >>> 8 & 255), i(o >>> 16 & 255), i(o >>> 24 & 255);
+	for (let e of t) a(e);
+	return "dataset__" + (n >>> 0).toString(36) + "_" + (r >>> 0).toString(36);
+}
+//#endregion
+export { e as default };

package/dist/utilities/dummy.d.ts

@@ -0,0 +1,9 @@
+import { default as Model, ModelForwardAttributes } from '../../models/model';
+export declare function dummyPassAsync(model: Model<ModelForwardAttributes>): Promise<void>;
+export interface MemoryRequirements {
+    perBatch: number;
+    tapeSize: number;
+    gradients: number;
+}
+export declare function dummyPassTrainAsync(model: Model<ModelForwardAttributes>): Promise<MemoryRequirements>;
+export declare function dummyPass(model: Model<ModelForwardAttributes>): void;

package/dist/utilities/dummy.js

@@ -0,0 +1,36 @@
+import { ii as e, kt as t, qt as n, si as r } from "../dist-BewPQWjc.js";
+//#region lib/utilities/dummy.ts
+async function i(e) {
+	let n = t([1, e.config.blockSize], "int32"), r = e.forward({ training: !1 }, n);
+	await r.data(), r.dispose(), n.dispose();
+}
+async function a(a) {
+	let o = r(), s = o.numBytesInGPUAllocated ?? o.numBytesAllocatedInGPU ?? o.numBytes;
+	await i(a);
+	let c = t([1, a.config.blockSize], "int32"), l = {
+		perBatch: 0,
+		tapeSize: 0,
+		gradients: a.getNumParams() * 4
+	};
+	try {
+		let { value: t, grads: i } = n(() => {
+			let t = a.forward({ training: !0 }, c), n = e().state.activeTape, r = 0;
+			if (n) for (let e of n) r += e.saved?.reduce((e, t) => e + t.size * 4, 0) || 0;
+			l.tapeSize = r;
+			let i = t.mean();
+			return t.dispose(), i;
+		}), o = r();
+		l.perBatch = (o.numBytesInGPUAllocated ?? o.numBytesAllocatedInGPU ?? o.numBytes) - s - l.gradients, await t.data(), t.dispose();
+		for (let e in i) i[e].dispose();
+		c.dispose();
+	} catch (e) {
+		console.error("Error during dummy training pass:", e), c.dispose();
+	}
+	return l;
+}
+function o(e) {
+	let n = t([1, e.config.blockSize], "int32");
+	e.forward({ training: !1 }, n).dispose(), n.dispose();
+}
+//#endregion
+export { o as dummyPass, i as dummyPassAsync, a as dummyPassTrainAsync };

package/dist/utilities/multinomialCPU.d.ts

@@ -0,0 +1,2 @@
+import { Tensor2D } from '@tensorflow/tfjs-core';
+export default function multinomialCPU(probs: number[], randomNumber?: number): Tensor2D;

package/dist/utilities/multinomialCPU.js

@@ -0,0 +1,9 @@
+import { I as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/multinomialCPU.ts
+function t(t, n) {
+	let r = 0, i = n ?? Math.random();
+	for (let n = 0; n < t.length; n++) if (r += t[n], i < r) return e([[n]], [1, 1], "int32");
+	return e([[t.length - 1]], [1, 1], "int32");
+}
+//#endregion
+export { t as default };

package/dist/utilities/naming.d.ts

@@ -0,0 +1,4 @@
+export interface VariableNaming {
+    blockIndex?: number;
+    component?: 'mlp' | 'attn' | 'rms' | 'embeddings';
+}

package/dist/utilities/packed.d.ts

@@ -0,0 +1,4 @@
+import { Tensor } from '@tensorflow/tfjs-core';
+export declare function packingSupported(): boolean;
+export declare function isPackableTensor(tensor: Tensor): boolean;
+export declare function isPackedTensor(tensor: Tensor): boolean;

package/dist/utilities/packed.js

@@ -0,0 +1,13 @@
+import { ii as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/packed.ts
+function t() {
+	return e().backendName === "webgpu";
+}
+function n(e) {
+	return e.dtype === "packedF16";
+}
+function r(e) {
+	return n(e);
+}
+//#endregion
+export { n as isPackableTensor, r as isPackedTensor, t as packingSupported };

package/dist/utilities/parameters.d.ts

@@ -0,0 +1,11 @@
+import { GPTConfig } from '../../models/config';
+export declare function estimateLayerParameters(config: GPTConfig): number;
+export declare function estimateParameterCount(config: GPTConfig): number;
+export declare function estimateMemoryUsage(config: GPTConfig): number;
+export declare function estimateTrainingMemoryUsage(config: GPTConfig, batchSize: number): number;
+export declare function estimateResources(config: GPTConfig, batchSize: number): {
+    numParams: number;
+    modelMemoryMB: number;
+    trainingMemoryMB: number;
+};
+export declare function validateConfig(config: GPTConfig): void;

package/dist/utilities/parameters.js

@@ -0,0 +1,38 @@
+//#region lib/utilities/parameters.ts
+var e = 4;
+function t(e) {
+	return 4 * e.nEmbed * e.nEmbed + (e.mlpFactor * e.nEmbed * e.nEmbed + e.nEmbed * e.mlpFactor * e.nEmbed);
+}
+function n(e) {
+	let t = e.vocabSize * e.nEmbed, n = e.nLayer * (4 * e.nEmbed * e.nEmbed), r = e.nLayer * (e.mlpFactor * e.nEmbed * e.nEmbed + e.nEmbed * e.mlpFactor * e.nEmbed);
+	return t + n + r;
+}
+function r(t) {
+	return n(t) * e;
+}
+function i(t, n) {
+	let i = r(t), a = i * 2, o = i * 2, s = n * t.blockSize * t.nEmbed * e;
+	return i + a + o + s;
+}
+function a(e, t) {
+	return {
+		numParams: n(e),
+		modelMemoryMB: r(e) / (1024 * 1024),
+		trainingMemoryMB: i(e, t) / (1024 * 1024)
+	};
+}
+function o(e) {
+	if (e.nEmbed % e.nHead !== 0) throw Error("nEmbed_divisible_nHead");
+	if (e.blockSize <= 0) throw Error("blockSize_positive");
+	if (e.vocabSize <= 0) throw Error("vocabSize_positive");
+	if (e.nLayer <= 0) throw Error("nLayer_positive");
+	if (e.mlpFactor <= 0) throw Error("mlpFactor_positive");
+	if (e.nEmbed / e.nHead % 2 != 0) throw Error("headDim_even");
+	if (!Number.isInteger(e.nEmbed)) throw Error("nEmbed_integer");
+	if (!Number.isInteger(e.nHead)) throw Error("nHead_integer");
+	if (!Number.isInteger(e.nLayer)) throw Error("nLayer_integer");
+	if (!Number.isInteger(e.blockSize)) throw Error("blockSize_integer");
+	if (!Number.isInteger(e.vocabSize)) throw Error("vocabSize_integer");
+}
+//#endregion
+export { t as estimateLayerParameters, r as estimateMemoryUsage, n as estimateParameterCount, a as estimateResources, i as estimateTrainingMemoryUsage, o as validateConfig };

package/dist/utilities/performance.d.ts

@@ -0,0 +1,2 @@
+import { Tensor } from '@tensorflow/tfjs-core';
+export default function performanceTest(fn: () => Tensor, iterations?: number, allowPromise?: boolean): Promise<number>;

package/dist/utilities/performance.js

@@ -0,0 +1,16 @@
+import { di as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/performance.ts
+async function t(t, n = 10, r = !1) {
+	for (let n = 0; n < 100; n++) {
+		let i = r ? await t() : e(t);
+		n === 99 && await i.data(), i.dispose();
+	}
+	let i = performance.now();
+	for (let i = 0; i < n; i++) {
+		let a = r ? await t() : e(t);
+		i === n - 1 && await a.data(), a.dispose();
+	}
+	return (performance.now() - i) / n;
+}
+//#endregion
+export { t as default };

package/dist/utilities/profile.d.ts

@@ -0,0 +1,17 @@
+import { MemoryInfo } from '@tensorflow/tfjs-core';
+export interface ExtendedMemoryInfo extends MemoryInfo {
+    numBytesInGPUAllocated?: number;
+    numBytesAllocatedInGPU?: number;
+}
+export default class MemoryProfiler {
+    private log;
+    private maxMemory;
+    private maxLabel?;
+    private lastMemInfo;
+    private peakMemory;
+    startMemory(): void;
+    getPeakMemory(): number;
+    getMaxMemory(): number;
+    endMemory(label: string): void;
+    printSummary(): void;
+}

package/dist/utilities/profile.js

@@ -0,0 +1,33 @@
+import { si as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/profile.ts
+var t = 1024 * 1024, n = class {
+	log = /* @__PURE__ */ new Map();
+	maxMemory = 0;
+	maxLabel;
+	lastMemInfo = [];
+	peakMemory = 0;
+	startMemory() {
+		this.lastMemInfo.push(e());
+	}
+	getPeakMemory() {
+		return this.peakMemory;
+	}
+	getMaxMemory() {
+		return this.maxMemory;
+	}
+	endMemory(t) {
+		if (this.lastMemInfo.length === 0) {
+			console.warn("MemoryProfiler: endMemory called without matching startMemory");
+			return;
+		}
+		let n = e(), r = this.lastMemInfo.pop(), i = (n.numBytesInGPUAllocated ?? n.numBytesAllocatedInGPU ?? n.numBytes) - (r?.numBytesInGPUAllocated ?? r?.numBytesAllocatedInGPU ?? r?.numBytes ?? 0);
+		this.log.set(t, Math.max(this.log.get(t) || 0, i)), i > this.maxMemory && (this.maxMemory = i, this.maxLabel = t), this.peakMemory = Math.max(this.peakMemory, n.numBytesInGPUAllocated ?? n.numBytesAllocatedInGPU ?? n.numBytes);
+	}
+	printSummary() {
+		console.log("Memory Usage Summary:");
+		for (let [e, n] of this.log.entries()) console.log(`- ${e}: ${(n / t).toFixed(2)} MB`);
+		this.maxLabel && console.log(`Peak Memory Usage: ${(this.maxMemory / t).toFixed(2)} MB at "${this.maxLabel}"`), console.log(`Overall Peak Memory Usage: ${(this.peakMemory / t).toFixed(2)} MB`);
+	}
+};
+//#endregion
+export { n as default };

package/dist/utilities/safetensors.d.ts

@@ -0,0 +1,3 @@
+import { Tensor } from '@tensorflow/tfjs-core';
+export declare function save_safetensors(tensors: Record<string, Tensor>): Promise<ArrayBuffer>;
+export declare function load_safetensors(buffer: ArrayBuffer): Promise<Record<string, Tensor>>;

package/dist/utilities/safetensors.js

@@ -0,0 +1,53 @@
+import { fi as e } from "../dist-BewPQWjc.js";
+//#region lib/utilities/safetensors.ts
+function t(e) {
+	if (e === "float32") return "F32";
+	if (e === "int32") return "I32";
+	throw Error(`Unsupported dtype: ${e}`);
+}
+function n(e) {
+	if (e === "F32") return "float32";
+	if (e === "I32") return "int32";
+	throw Error(`Unsupported dtype: ${e}`);
+}
+async function r(e) {
+	let n = {}, r = 0;
+	for (let [i, a] of Object.entries(e)) n[i] = {
+		dtype: t(a.dtype),
+		shape: a.shape,
+		data_offsets: [r, r + a.size * 4]
+	}, r += a.size * 4;
+	let i = JSON.stringify(n), a = new TextEncoder().encode(i);
+	if (a.length % 4 != 0) {
+		let e = 4 - a.length % 4, t = new Uint8Array(a.length + e);
+		t.set(a);
+		for (let e = a.length; e < t.length; e++) t[e] = 32;
+		a = t;
+	}
+	let o = a.length, s = 8 + o + r, c = new ArrayBuffer(s);
+	new DataView(c).setUint32(0, o, !0), new Uint8Array(c, 8, o).set(a);
+	let l = 8 + o;
+	for (let t of Object.values(e)) {
+		if (t.size === 0) continue;
+		let e = await t.data();
+		if (t.dtype === "float32") new Float32Array(c, l, t.size).set(e), l += t.size * 4;
+		else if (t.dtype === "int32") new Int32Array(c, l, t.size).set(e), l += t.size * 4;
+		else throw Error(`Unsupported dtype: ${t.dtype}`);
+	}
+	return c;
+}
+async function i(t) {
+	let r = new DataView(t).getUint32(0, !0), i = new Uint8Array(t, 8, r), a = JSON.parse(new TextDecoder().decode(i)), o = {};
+	for (let [i, s] of Object.entries(a)) {
+		if (s.data_offsets[0] === s.data_offsets[1]) {
+			o[i] = e([], s.shape, n(s.dtype));
+			continue;
+		}
+		if (s.dtype === "F32") o[i] = e(new Float32Array(t, s.data_offsets[0] + 8 + r, (s.data_offsets[1] - s.data_offsets[0]) / 4), s.shape, n(s.dtype));
+		else if (s.dtype === "I32") o[i] = e(new Int32Array(t, s.data_offsets[0] + 8 + r, (s.data_offsets[1] - s.data_offsets[0]) / 4), s.shape, n(s.dtype));
+		else throw Error(`Unsupported dtype: ${s.dtype}`);
+	}
+	return o;
+}
+//#endregion
+export { i as load_safetensors, r as save_safetensors };

package/dist/utilities/sentences.d.ts

@@ -0,0 +1,5 @@
+import { default as TeachableLLM } from '../../TeachableLLM';
+import { Tensor2D, Tensor3D } from '@tensorflow/tfjs-core';
+export declare function meanPooling(embeddings: Tensor3D, attentionMask?: Tensor2D): Tensor2D;
+export declare function sentenceEmbeddingsTensor(model: TeachableLLM, sentences: string[], batchSize?: number): Tensor2D;
+export declare function sentenceEmbeddings(model: TeachableLLM, sentences: string[], batchSize?: number): Promise<number[][]>;