@matchbox-ai/train 0.1.0 → 0.2.1

package/dist/{record-BTZ5LWHF.js → record-MCYVi9O6.js}

@@ -1,38 +1,47 @@
 import { t as evaluateSequence } from "./evaluate-sequence-ZCwyomzQ.js";
 import { t as packageModel } from "./package-model-CPj0qnQs.js";
+import { createRequire } from "node:module";
 import { readRecordArtifact, recordFeatures, recordTokens, tensorPredictor } from "@matchbox-ai/core/internal";
 import { dirname, relative } from "node:path";
 import { createParser } from "@matchbox-ai/core/runtime";
 import { createHash } from "node:crypto";
-import * as tf from "@tensorflow/tfjs-node";
+//#region src/native/record.ts
+const require = createRequire(import.meta.url);
+function fitNativeRecord(config, inputs, labels, progress) {
+	return require("#native").fitRecord(JSON.stringify(config), Float32Array.from(inputs.flat()), Int32Array.from(labels), (error, values) => {
+		if (!error) progress?.(values[0], values[1]);
+	});
+}
+function predictNativeRecord(config, weights, inputs) {
+	return require("#native").predictRecord(JSON.stringify(config), Buffer.from(weights), Float32Array.from(inputs));
+}
+//#endregion
 //#region src/models/record/verify-export.ts
-async function verifyExport(model, artifact, probes) {
-	const native = probes.map((input) => tf.tidy(() => {
-		const logits = model.predict(tf.tensor2d([recordFeatures(input, artifact.vocabulary)]));
-		let offset = 0;
-		return artifact.fields.map((field) => {
-			const probabilities = Array.from(tf.softmax(tf.slice(logits, [0, offset], [1, field.values.length])).dataSync());
-			offset += field.values.length;
-			return probabilities;
-		});
-	}));
+async function verifyExport(weights, artifact, probes) {
+	const config = {
+		vocabularySize: artifact.vocabulary.length,
+		fields: artifact.fields.map((field) => field.values.length)
+	};
 	const predictor = await tensorPredictor(artifact);
 	let maxConfidenceError = 0;
 	let labelDisagreements = 0;
 	try {
-		probes.forEach((input, probeIndex) => {
+		for (const input of probes) {
+			const native = predictNativeRecord(config, weights, recordFeatures(input, artifact.vocabulary));
+			let offset = 0;
 			predictor.record(input).fields.forEach((prediction, index) => {
-				const scores = native[probeIndex][index];
+				const field = artifact.fields[index];
+				const scores = native.slice(offset, offset + field.values.length);
+				offset += field.values.length;
 				const maximum = Math.max(...scores);
 				maxConfidenceError = Math.max(maxConfidenceError, Math.abs(maximum - prediction.confidence));
-				if (prediction.value !== artifact.fields[index].values[scores.indexOf(maximum)]) labelDisagreements++;
+				if (prediction.value !== field.values[scores.indexOf(maximum)]) labelDisagreements++;
 			});
-		});
+		}
 	} finally {
 		predictor.dispose();
-		await tf.setBackend("tensorflow");
 	}
-	if (labelDisagreements || maxConfidenceError > 1e-5) throw new Error("Serialized TensorFlow model disagrees with native predictions.");
+	if (labelDisagreements || maxConfidenceError > 1e-5) throw new Error("Burn native and WASM record predictions disagree.");
 	return {
 		examples: probes.length,
 		labelDisagreements,
@@ -59,88 +68,32 @@ async function fitRecord(examples, metadata, probes, progress) {
 		};
 	});
 	const vocabulary = [...new Set(examples.flatMap((row) => recordTokens(row.input)))].sort();
-	const outputs = fields.reduce((sum, field) => sum + field.values.length, 0);
 	if (fields.length > 32 || fields.some((field) => field.values.length > 256) || vocabulary.length > 1e4) throw new Error("Default trainer capacity exceeded. Use a custom pipeline for larger output domains.");
-	await tf.setBackend("tensorflow");
-	await tf.ready();
-	const model = tf.sequential({ layers: [tf.layers.dense({
-		inputShape: [vocabulary.length],
-		units: 32,
-		activation: "tanh",
-		kernelInitializer: tf.initializers.glorotUniform({ seed: 42 })
-	}), tf.layers.dense({
-		units: outputs,
-		kernelInitializer: tf.initializers.glorotUniform({ seed: 43 })
-	})] });
-	const optimizer = tf.train.adam(.02);
-	model.compile({
-		optimizer,
-		loss: (gold, logits) => tf.tidy(() => {
-			let offset = 0;
-			const losses = fields.map((field) => {
-				const count = field.values.length;
-				const target = tf.slice(gold, [0, offset], [-1, count]);
-				const scores = tf.slice(logits, [0, offset], [-1, count]);
-				offset += count;
-				return tf.neg(tf.sum(tf.mul(target, tf.logSoftmax(scores)), 1));
-			});
-			return tf.mean(tf.addN(losses));
-		})
+	const result = await fitNativeRecord({
+		vocabularySize: vocabulary.length,
+		fields: fields.map((field) => field.values.length)
+	}, examples.map((row) => recordFeatures(row.input, vocabulary)), examples.flatMap((row) => fields.map((field) => field.values.indexOf(row.output[field.name]))), progress);
+	const artifact = (weights) => readRecordArtifact({
+		formatVersion: 3,
+		engine: "burn-0.21",
+		kind: "record-parser",
+		architecture: "bag-of-words-mlp",
+		...metadata,
+		decoderModule: null,
+		fields,
+		vocabulary,
+		threshold: .75,
+		precision: "float32",
+		weights: Buffer.from(weights).toString("base64")
 	});
-	const x = tf.tensor2d(examples.map((row) => recordFeatures(row.input, vocabulary)));
-	const y = tf.tensor2d(examples.map((row) => fields.flatMap((field) => field.values.map((value) => value === row.output[field.name] ? 1 : 0))));
-	function exported(precision) {
-		const weights = model.getWeights().map((tensor, index) => {
-			const values = Array.from(tensor.dataSync());
-			const scale = precision === "int8" ? values.reduce((max, value) => Math.max(max, Math.abs(value)), 0) / 127 || 1 : 1;
-			return {
-				name: model.weights[index].originalName,
-				shape: tensor.shape,
-				values: precision === "int8" ? values.map((value) => Math.round(value / scale)) : values,
-				scale
-			};
-		});
-		return readRecordArtifact({
-			formatVersion: 2,
-			kind: "record-parser",
-			architecture: "bag-of-words-mlp",
-			...metadata,
-			modelTopology: JSON.parse(model.toJSON()),
-			decoderModule: null,
-			fields,
-			vocabulary,
-			threshold: .75,
-			precision,
-			weights
-		});
-	}
-	const untrained = exported("float32");
-	const history = [];
-	try {
-		await model.fit(x, y, {
-			epochs: 100,
-			batchSize: 128,
-			shuffle: false,
-			verbose: 0,
-			callbacks: { onEpochEnd(epoch, logs) {
-				history.push(Number(logs?.loss));
-				progress?.(epoch + 1, Number(logs?.loss));
-			} }
-		});
-		const float = exported("float32");
-		return {
-			float,
-			quantized: exported("int8"),
-			untrained,
-			history,
-			parity: await verifyExport(model, float, probes)
-		};
-	} finally {
-		x.dispose();
-		y.dispose();
-		model.dispose();
-		optimizer.dispose();
-	}
+	const model = artifact(result.weights);
+	const parity = await verifyExport(result.weights, model, probes);
+	return {
+		model,
+		parameters: result.parameters,
+		history: result.loss,
+		parity
+	};
 }
 //#endregion
 //#region src/models/record/run.ts
@@ -159,17 +112,17 @@ async function runRecord(project, progress) {
 			parser.dispose();
 		}
 	};
-	const validation = await evaluate(fit.quantized, project.validation);
-	const bytes = Buffer.byteLength(JSON.stringify(fit.quantized));
+	const validation = await evaluate(fit.model, project.validation);
+	const bytes = Buffer.byteLength(JSON.stringify(fit.model));
 	if (validation.exactAccuracy < project.config.minAccuracy || bytes > project.config.maxBytes) throw new Error(`Record model failed validation/size requirements (${validation.exactAccuracy}, ${bytes} bytes). ${JSON.stringify(validation.failures.slice(0, 10))}`);
 	const report = {
-		formatVersion: 1,
-		architecture: fit.quantized.architecture,
-		backend: "TensorFlow native CPU",
+		formatVersion: 2,
+		architecture: fit.model.architecture,
+		backend: "Burn native CPU",
 		seed: 42,
-		artifactSha256: createHash("sha256").update(JSON.stringify(fit.quantized)).digest("hex"),
+		artifactSha256: createHash("sha256").update(JSON.stringify(fit.model)).digest("hex"),
 		bytes,
-		parameters: fit.quantized.weights.reduce((sum, weight) => sum + weight.values.length, 0),
+		parameters: fit.parameters,
 		datasetSha256: project.sources.map((source) => ({
 			source: source.source,
 			sha256: createHash("sha256").update(source.text).digest("hex")
@@ -182,18 +135,11 @@ async function runRecord(project, progress) {
 		loss: fit.history,
 		exportParity: fit.parity,
 		validation,
-		quantized: await evaluate(fit.quantized),
-		float: await evaluate(fit.float),
-		untrained: await evaluate(fit.untrained),
-		untrainedUngated: await evaluate({
-			...fit.untrained,
-			threshold: 0
-		}),
-		baseline: project.baseline ? await evaluateSequence(project.baseline, project.evaluation, (value) => project.task.validateOutput(value).success) : null,
+		evaluation: await evaluate(fit.model),
 		trainingMs: performance.now() - start,
 		notes: "Each field classifies values present in training data. Vocabulary and value domains are fitted only on training. There are no number dictionaries, aliases, normalization rules, or span annotations. Unknown tokens abstain. Bag-of-words ignores order. Confidence is uncalibrated. This model cannot emit unseen numeric values."
 	};
-	await packageModel(project.output, fit.quantized, report);
+	await packageModel(project.output, fit.model, report);
 	return {
 		report,
 		output: project.output
@@ -202,4 +148,4 @@ async function runRecord(project, progress) {
 //#endregion
 export { runRecord };
 
-//# sourceMappingURL=record-BTZ5LWHF.js.map
+//# sourceMappingURL=record-MCYVi9O6.js.map

package/dist/record-MCYVi9O6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-MCYVi9O6.js","names":[],"sources":["../src/native/record.ts","../src/models/record/verify-export.ts","../src/models/record/fit.ts","../src/models/record/run.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\nconst require = createRequire(import.meta.url);\ntype Config = { vocabularySize: number; fields: number[] };\ninterface Native {\n  fitRecord(\n    config: string,\n    inputs: Float32Array,\n    labels: Int32Array,\n    progress: (error: Error | null, values: number[]) => void,\n  ): Promise<{ parameters: number; weights: Uint8Array; loss: number[] }>;\n  predictRecord(config: string, weights: Buffer, inputs: Float32Array): number[];\n}\nexport function fitNativeRecord(\n  config: Config,\n  inputs: number[][],\n  labels: number[],\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const native = require(\"#native\") as Native;\n  return native.fitRecord(\n    JSON.stringify(config),\n    Float32Array.from(inputs.flat()),\n    Int32Array.from(labels),\n    (error, values) => {\n      if (!error) {\n        progress?.(values[0]!, values[1]!);\n      }\n    },\n  );\n}\nexport function predictNativeRecord(config: Config, weights: Uint8Array, inputs: number[]) {\n  return (require(\"#native\") as Native).predictRecord(\n    JSON.stringify(config),\n    Buffer.from(weights),\n    Float32Array.from(inputs),\n  );\n}\n","import { predictNativeRecord } from \"../../native/index.js\";\nimport { recordFeatures, tensorPredictor } from \"@matchbox-ai/core/internal\";\nimport type { RecordArtifact } from \"@matchbox-ai/core/internal\";\nexport async function verifyExport(\n  weights: Uint8Array,\n  artifact: RecordArtifact,\n  probes: readonly string[],\n) {\n  const config = {\n    vocabularySize: artifact.vocabulary.length,\n    fields: artifact.fields.map((field) => field.values.length),\n  };\n  const predictor = await tensorPredictor(artifact);\n  let maxConfidenceError = 0;\n  let labelDisagreements = 0;\n  try {\n    for (const input of probes) {\n      const native = predictNativeRecord(\n        config,\n        weights,\n        recordFeatures(input, artifact.vocabulary),\n      );\n      let offset = 0;\n      predictor.record(input).fields.forEach((prediction, index) => {\n        const field = artifact.fields[index]!;\n        const scores = native.slice(offset, offset + field.values.length);\n        offset += field.values.length;\n        const maximum = Math.max(...scores);\n        maxConfidenceError = Math.max(\n          maxConfidenceError,\n          Math.abs(maximum - prediction.confidence),\n        );\n        if (prediction.value !== field.values[scores.indexOf(maximum)]) {\n          labelDisagreements++;\n        }\n      });\n    }\n  } finally {\n    predictor.dispose();\n  }\n  if (labelDisagreements || maxConfidenceError > 1e-5) {\n    throw new Error(\"Burn native and WASM record predictions disagree.\");\n  }\n  return { examples: probes.length, labelDisagreements, maxConfidenceError };\n}\n","import { verifyExport } from \"./verify-export.js\";\nimport { fitNativeRecord } from \"../../native/index.js\";\nimport { recordFeatures, recordTokens, readRecordArtifact } from \"@matchbox-ai/core/internal\";\nimport type { RecordArtifact } from \"@matchbox-ai/core/internal\";\nimport type { DatasetExample, ParserMetadata } from \"@matchbox-ai/core\";\nexport async function fitRecord(\n  examples: readonly DatasetExample<unknown>[],\n  metadata: { taskModule: string; taskMetadata: ParserMetadata },\n  probes: readonly string[],\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const schema = metadata.taskMetadata.output;\n  if (schema.type !== \"object\" || !schema.properties || schema.additionalProperties !== false) {\n    throw new Error(\n      \"The default trainer currently supports strict flat objects with primitive field values. Use an explicit sequence pipeline for other shapes.\",\n    );\n  }\n  const fields = Object.keys(schema.properties).map((name) => {\n    const values = [\n      ...new Map(\n        examples.map((row) => {\n          const value = (row.output as Record<string, unknown>)[name];\n          if (value !== null && ![\"number\", \"string\", \"boolean\"].includes(typeof value)) {\n            throw new Error(`output.${name}: the default trainer requires primitive field values.`);\n          }\n          return [JSON.stringify(value), value as string | number | boolean | null] as const;\n        }),\n      ).entries(),\n    ]\n      .sort(([a], [b]) => a.localeCompare(b))\n      .map(([, value]) => value);\n    return { name, values };\n  });\n  const vocabulary = [...new Set(examples.flatMap((row) => recordTokens(row.input)))].sort();\n  if (\n    fields.length > 32 ||\n    fields.some((field) => field.values.length > 256) ||\n    vocabulary.length > 10000\n  ) {\n    throw new Error(\n      \"Default trainer capacity exceeded. Use a custom pipeline for larger output domains.\",\n    );\n  }\n  const config = {\n    vocabularySize: vocabulary.length,\n    fields: fields.map((field) => field.values.length),\n  };\n  const result = await fitNativeRecord(\n    config,\n    examples.map((row) => recordFeatures(row.input, vocabulary)),\n    examples.flatMap((row) =>\n      fields.map((field) =>\n        field.values.indexOf(\n          (row.output as Record<string, string | number | boolean | null>)[field.name]!,\n        ),\n      ),\n    ),\n    progress,\n  );\n  const artifact = (weights: Uint8Array): RecordArtifact =>\n    readRecordArtifact({\n      formatVersion: 3,\n      engine: \"burn-0.21\",\n      kind: \"record-parser\",\n      architecture: \"bag-of-words-mlp\",\n      ...metadata,\n      decoderModule: null,\n      fields,\n      vocabulary,\n      threshold: 0.75,\n      precision: \"float32\",\n      weights: Buffer.from(weights).toString(\"base64\"),\n    });\n  const model = artifact(result.weights);\n  const parity = await verifyExport(result.weights, model, probes);\n  return {\n    model,\n    parameters: result.parameters,\n    history: result.loss,\n    parity,\n  };\n}\n","import { createHash } from \"node:crypto\";\nimport { dirname, relative } from \"node:path\";\nimport { createParser } from \"@matchbox-ai/core/runtime\";\nimport type { RecordArtifact } from \"@matchbox-ai/core/internal\";\nimport type { loadProject } from \"../../load-project.js\";\nimport { packageModel } from \"../../packaging/package-model.js\";\nimport { evaluateSequence } from \"../../evaluation/evaluate-sequence.js\";\nimport { fitRecord } from \"./fit.js\";\nexport async function runRecord(\n  project: Awaited<ReturnType<typeof loadProject>>,\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const start = performance.now();\n  const taskModule = relative(dirname(project.output), project.taskPath).replaceAll(\"\\\\\", \"/\");\n  const fit = await fitRecord(\n    project.train,\n    {\n      taskModule: taskModule.startsWith(\".\") ? taskModule : `./${taskModule}`,\n      taskMetadata: project.task.toJSON(),\n    },\n    project.validation.map((row) => row.input),\n    progress,\n  );\n  const evaluate = async (artifact: RecordArtifact, rows = project.evaluation) => {\n    const parser = createParser(artifact, project.task);\n    try {\n      return await evaluateSequence(\n        parser,\n        rows,\n        (value) => project.task.validateOutput(value).success,\n      );\n    } finally {\n      parser.dispose();\n    }\n  };\n  const validation = await evaluate(fit.model, project.validation);\n  const bytes = Buffer.byteLength(JSON.stringify(fit.model));\n  if (validation.exactAccuracy < project.config.minAccuracy || bytes > project.config.maxBytes) {\n    throw new Error(\n      `Record model failed validation/size requirements (${validation.exactAccuracy}, ${bytes} bytes). ${JSON.stringify(validation.failures.slice(0, 10))}`,\n    );\n  }\n  const report = {\n    formatVersion: 2,\n    architecture: fit.model.architecture,\n    backend: \"Burn native CPU\",\n    seed: 42,\n    artifactSha256: createHash(\"sha256\").update(JSON.stringify(fit.model)).digest(\"hex\"),\n    bytes,\n    parameters: fit.parameters,\n    datasetSha256: project.sources.map((source) => ({\n      source: source.source,\n      sha256: createHash(\"sha256\").update(source.text).digest(\"hex\"),\n    })),\n    examples: {\n      train: project.train.length,\n      validation: project.validation.length,\n      eval: project.evaluation.length,\n    },\n    loss: fit.history,\n    exportParity: fit.parity,\n    validation,\n    evaluation: await evaluate(fit.model),\n    trainingMs: performance.now() - start,\n    notes:\n      \"Each field classifies values present in training data. Vocabulary and value domains are fitted only on training. There are no number dictionaries, aliases, normalization rules, or span annotations. Unknown tokens abstain. Bag-of-words ignores order. Confidence is uncalibrated. This model cannot emit unseen numeric values.\",\n  };\n  await packageModel(project.output, fit.model, report);\n  return { report, output: project.output };\n}\n"],"mappings":"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"}

package/dist/{run-Cwa7vD_T.js → run-PB_jiKnw.js}

@@ -1,4 +1,4 @@
-import { r as loadConfig } from "./project-BP331m20.js";
+import { i as loadConfig } from "./project-BR13wXHr.js";
 import "zod";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -9,7 +9,6 @@ async function loadProject(path) {
 	const { config, root } = await loadConfig(path);
 	const taskPath = resolve(root, config.task);
 	const task = (await import(pathToFileURL(taskPath).href)).default;
-	const baseline = config.baseline ? (await import(pathToFileURL(resolve(root, config.baseline)).href)).default : null;
 	const sources = await Promise.all([
 		config.train,
 		config.validation,
@@ -45,7 +44,6 @@ async function loadProject(path) {
 		root,
 		config,
 		task,
-		baseline,
 		taskPath,
 		output: resolve(root, config.output),
 		sources,
@@ -59,14 +57,14 @@ async function loadProject(path) {
 async function run(command, path, progress) {
 	const project = await loadProject(path);
 	if (project.config.sequence) {
-		const { runSequence } = await import("./sequence-C_WfVGO1.js");
+		const { runSequence } = await import("./sequence-DGoGU7kG.js");
 		return runSequence(command, project, progress);
 	}
 	if (command !== "train") throw new Error("Use the eval CLI command to evaluate a saved artifact.");
-	const { runRecord } = await import("./record-BTZ5LWHF.js");
+	const { runRecord } = await import("./record-MCYVi9O6.js");
 	return runRecord(project, progress);
 }
 //#endregion
 export { run };
 
-//# sourceMappingURL=run-Cwa7vD_T.js.map
+//# sourceMappingURL=run-PB_jiKnw.js.map

package/dist/run-PB_jiKnw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-PB_jiKnw.js","names":[],"sources":["../src/load-project.ts","../src/run.ts"],"sourcesContent":["import { loadConfig } from \"./project/index.js\";\nimport { readFile } from \"node:fs/promises\";\nimport { resolve } from \"node:path\";\nimport { pathToFileURL } from \"node:url\";\nimport { z } from \"zod\";\nimport { parseDatasets } from \"@matchbox-ai/core\";\nimport type { ParserDefinition } from \"@matchbox-ai/core\";\nexport async function loadProject(path: string) {\n  const { config, root } = await loadConfig(path);\n  const taskPath = resolve(root, config.task);\n  const task: ParserDefinition<z.ZodType> = (await import(pathToFileURL(taskPath).href)).default;\n  const sources = await Promise.all(\n    [config.train, config.validation, config.eval].map(async (source) => ({\n      source,\n      text: await readFile(resolve(root, source), \"utf8\"),\n    })),\n  );\n  const training = parseDatasets(task, { formatVersion: 1, train: sources[0]!, eval: sources[1]! });\n  const evaluation = parseDatasets(task, {\n    formatVersion: 1,\n    train: sources[0]!,\n    eval: sources[2]!,\n  });\n  for (const result of [training, evaluation]) {\n    if (!result.success) {\n      throw new Error(\n        result.issues\n          .map((issue) => `${issue.source}:${issue.line} ${issue.path.join(\".\")}: ${issue.message}`)\n          .join(\"\\n\"),\n      );\n    }\n  }\n  if (!training.success || !evaluation.success) {\n    throw new Error(\"Invalid datasets.\");\n  }\n  const groups = [training.data.train, training.data.eval, evaluation.data.eval];\n  const seen = new Map<string, number>();\n  groups.forEach((group, split) =>\n    group.forEach((row) => {\n      const key = row.input.trim().toLowerCase();\n      if (seen.has(key) && seen.get(key) !== split) {\n        throw new Error(`Input overlaps dataset splits: ${row.input}`);\n      }\n      seen.set(key, split);\n    }),\n  );\n  return {\n    root,\n    config,\n    task,\n    taskPath,\n    output: resolve(root, config.output),\n    sources,\n    train: training.data.train,\n    validation: training.data.eval,\n    evaluation: evaluation.data.eval,\n  };\n}\n","import { loadProject } from \"./load-project.js\";\nexport async function run(\n  command: \"train\" | \"eval\",\n  path: string,\n  progress?: (epoch: number, loss: number) => void,\n) {\n  const project = await loadProject(path);\n  if (project.config.sequence) {\n    const { runSequence } = await import(\"./models/sequence/index.js\");\n    return runSequence(command, project, progress);\n  }\n  if (command !== \"train\") {\n    throw new Error(\"Use the eval CLI command to evaluate a saved artifact.\");\n  }\n  const { runRecord } = await import(\"./models/record/index.js\");\n  return runRecord(project, progress);\n}\n"],"mappings":";;;;;;;AAOA,eAAsB,YAAY,MAAc;CAC9C,MAAM,EAAE,QAAQ,SAAS,MAAM,WAAW,IAAI;CAC9C,MAAM,WAAW,QAAQ,MAAM,OAAO,IAAI;CAC1C,MAAM,QAAqC,MAAM,OAAO,cAAc,QAAQ,CAAC,CAAC,MAAA,CAAO;CACvF,MAAM,UAAU,MAAM,QAAQ,IAC5B;EAAC,OAAO;EAAO,OAAO;EAAY,OAAO;CAAI,CAAC,CAAC,IAAI,OAAO,YAAY;EACpE;EACA,MAAM,MAAM,SAAS,QAAQ,MAAM,MAAM,GAAG,MAAM;CACpD,EAAE,CACJ;CACA,MAAM,WAAW,cAAc,MAAM;EAAE,eAAe;EAAG,OAAO,QAAQ;EAAK,MAAM,QAAQ;CAAI,CAAC;CAChG,MAAM,aAAa,cAAc,MAAM;EACrC,eAAe;EACf,OAAO,QAAQ;EACf,MAAM,QAAQ;CAChB,CAAC;CACD,KAAK,MAAM,UAAU,CAAC,UAAU,UAAU,GACxC,IAAI,CAAC,OAAO,SACV,MAAM,IAAI,MACR,OAAO,OACJ,KAAK,UAAU,GAAG,MAAM,OAAO,GAAG,MAAM,KAAK,GAAG,MAAM,KAAK,KAAK,GAAG,EAAE,IAAI,MAAM,SAAS,CAAC,CACzF,KAAK,IAAI,CACd;CAGJ,IAAI,CAAC,SAAS,WAAW,CAAC,WAAW,SACnC,MAAM,IAAI,MAAM,mBAAmB;CAErC,MAAM,SAAS;EAAC,SAAS,KAAK;EAAO,SAAS,KAAK;EAAM,WAAW,KAAK;CAAI;CAC7E,MAAM,uBAAO,IAAI,IAAoB;CACrC,OAAO,SAAS,OAAO,UACrB,MAAM,SAAS,QAAQ;EACrB,MAAM,MAAM,IAAI,MAAM,KAAK,CAAC,CAAC,YAAY;EACzC,IAAI,KAAK,IAAI,GAAG,KAAK,KAAK,IAAI,GAAG,MAAM,OACrC,MAAM,IAAI,MAAM,kCAAkC,IAAI,OAAO;EAE/D,KAAK,IAAI,KAAK,KAAK;CACrB,CAAC,CACH;CACA,OAAO;EACL;EACA;EACA;EACA;EACA,QAAQ,QAAQ,MAAM,OAAO,MAAM;EACnC;EACA,OAAO,SAAS,KAAK;EACrB,YAAY,SAAS,KAAK;EAC1B,YAAY,WAAW,KAAK;CAC9B;AACF;;;ACxDA,eAAsB,IACpB,SACA,MACA,UACA;CACA,MAAM,UAAU,MAAM,YAAY,IAAI;CACtC,IAAI,QAAQ,OAAO,UAAU;EAC3B,MAAM,EAAE,gBAAgB,MAAM,OAAO;EACrC,OAAO,YAAY,SAAS,SAAS,QAAQ;CAC/C;CACA,IAAI,YAAY,SACd,MAAM,IAAI,MAAM,wDAAwD;CAE1E,MAAM,EAAE,cAAc,MAAM,OAAO;CACnC,OAAO,UAAU,SAAS,QAAQ;AACpC"}

package/dist/run.d.ts

@@ -31,23 +31,11 @@ export declare function run(command: "train" | "eval", path: string, progress?:
         }[];
         examples: {
             train: number;
+            rejections: number;
             validation: number;
             eval: number;
         };
-        shuffledLabelsUngated: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        } | null;
+        supervisionSha256: string;
         supervisedTokens: number;
         loss: number[];
         exportParity: {
@@ -69,49 +57,7 @@ export declare function run(command: "train" | "eval", path: string, progress?:
                 actual: unknown;
             }[];
         };
-        untrainedUngated: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        untrained: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        float: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        quantized: {
+        evaluation: {
             examples: number;
             invalidOutputRate: number;
             exactAccuracy: number;
@@ -139,20 +85,6 @@ export declare function run(command: "train" | "eval", path: string, progress?:
                 actual: unknown;
             }[];
         } | null;
-        baseline: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        } | null;
         trainingMs: number;
         notes: string;
     };
@@ -195,35 +127,7 @@ export declare function run(command: "train" | "eval", path: string, progress?:
                 actual: unknown;
             }[];
         };
-        quantized: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        float: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        untrained: {
+        evaluation: {
             examples: number;
             invalidOutputRate: number;
             exactAccuracy: number;
@@ -237,34 +141,6 @@ export declare function run(command: "train" | "eval", path: string, progress?:
                 actual: unknown;
             }[];
         };
-        untrainedUngated: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        };
-        baseline: {
-            examples: number;
-            invalidOutputRate: number;
-            exactAccuracy: number;
-            accepted: number;
-            acceptedAccuracy: number | null;
-            abstentionRate: number;
-            correctAbstentions: number;
-            failures: {
-                input: string;
-                expected: unknown;
-                actual: unknown;
-            }[];
-        } | null;
         trainingMs: number;
         notes: string;
     };

package/dist/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,wBAAsB,GAAG,CACvB,OAAO,EAAE,OAAO,GAAG,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAWjD"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AACA,wBAAsB,GAAG,CACvB,OAAO,EAAE,OAAO,GAAG,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAYjD"}