@simulatte/doppler 0.1.5 → 0.1.7

package/src/training/lora.js

@@ -12,18 +12,32 @@ export class LoraAdapter {
     const aBytes = tensorBytes([inDim, rank], dtype);
     const bBytes = tensorBytes([rank, outDim], dtype);
 
-    this.A = createTensor(
-      acquireBuffer(aBytes, BufferUsage.STORAGE, 'lora_A'),
-      dtype,
-      [inDim, rank],
-      'lora_A'
-    );
-    this.B = createTensor(
-      acquireBuffer(bBytes, BufferUsage.STORAGE, 'lora_B'),
-      dtype,
-      [rank, outDim],
-      'lora_B'
-    );
+    let aBuffer = null;
+    let bBuffer = null;
+    try {
+      aBuffer = acquireBuffer(aBytes, BufferUsage.STORAGE, 'lora_A');
+      bBuffer = acquireBuffer(bBytes, BufferUsage.STORAGE, 'lora_B');
+      this.A = createTensor(
+        aBuffer,
+        dtype,
+        [inDim, rank],
+        'lora_A'
+      );
+      this.B = createTensor(
+        bBuffer,
+        dtype,
+        [rank, outDim],
+        'lora_B'
+      );
+    } catch (error) {
+      if (aBuffer) {
+        releaseBuffer(aBuffer);
+      }
+      if (bBuffer) {
+        releaseBuffer(bBuffer);
+      }
+      throw error;
+    }
     this.alpha = alpha;
     this.rank = rank;
   }

package/src/training/loss.js

@@ -1,6 +1,5 @@
 
 import { runSoftmax, runCrossEntropyLoss, castF16ToF32 } from '../gpu/kernels/index.js';
-import { releaseBuffer } from '../memory/buffer-pool.js';
 import { OpType } from './autograd.js';
 
 export async function crossEntropyLoss(logits, targets, config, tape) {
@@ -25,13 +24,13 @@ export async function crossEntropyLoss(logits, targets, config, tape) {
     OpType.SOFTMAX,
     (input) => runSoftmax(input, -1, { batchSize: numTokens, size: vocabSize }),
     [logitsF32],
-    { rows: numTokens, cols: vocabSize }
+    {
+      rows: numTokens,
+      cols: vocabSize,
+      retainBuffers: logitsF32 !== logits ? [logitsF32.buffer] : [],
+    }
   );
 
-  if (logitsF32 !== logits) {
-    releaseBuffer(logitsF32.buffer);
-  }
-
   return tape.record(
     OpType.CROSS_ENTROPY,
     (input, target) => runCrossEntropyLoss(input, target, { numTokens, vocabSize }),

package/src/training/objectives/cross_entropy.js

@@ -1,15 +1,12 @@
 import { crossEntropyLoss as defaultCrossEntropyLoss } from '../loss.js';
-import { acquireBuffer, uploadData } from '../../memory/buffer-pool.js';
-import { createTensor } from '../../gpu/tensor.js';
 import { createTrainingObjective } from './base.js';
+import { createUploadedTensor } from '../tensor-factory.js';
 
 function createLossGradient(loss, lossScale) {
   const lossElements = loss.shape.reduce((acc, value) => acc * value, 1);
   const gradData = new Float32Array(lossElements);
   gradData.fill(lossScale);
-  const gradBuf = acquireBuffer(gradData.byteLength, undefined, 'loss_grad_output');
-  uploadData(gradBuf, gradData);
-  return createTensor(gradBuf, 'f32', [...loss.shape], 'loss_grad_output');
+  return createUploadedTensor(gradData, 'f32', loss.shape, 'loss_grad_output');
 }
 
 export function createCrossEntropyObjective(options = {}) {

package/src/training/objectives/distill_kd.js

@@ -1,8 +1,8 @@
 import { crossEntropyLoss as defaultCrossEntropyLoss } from '../loss.js';
 import { createTrainingObjective } from './base.js';
-import { acquireBuffer, readBuffer, uploadData } from '../../memory/buffer-pool.js';
-import { createTensor } from '../../gpu/tensor.js';
+import { readBuffer } from '../../memory/buffer-pool.js';
 import { f16ToF32Array, f32ToF16Array } from '../../inference/kv-cache/types.js';
+import { createUploadedTensor } from '../tensor-factory.js';
 
 const EPS = 1e-8;
 
@@ -31,9 +31,7 @@ function createLossGradient(loss, lossScale) {
   const lossElements = loss.shape.reduce((acc, value) => acc * value, 1);
   const gradData = new Float32Array(lossElements);
   gradData.fill(lossScale);
-  const gradBuf = acquireBuffer(gradData.byteLength, undefined, 'distill_kd_loss_grad_output');
-  uploadData(gradBuf, gradData);
-  return createTensor(gradBuf, 'f32', [...loss.shape], 'distill_kd_loss_grad_output');
+  return createUploadedTensor(gradData, 'f32', loss.shape, 'distill_kd_loss_grad_output');
 }
 
 function createGradientTensor(values, shape, dtype, label) {
@@ -42,9 +40,7 @@ function createGradientTensor(values, shape, dtype, label) {
   const payload = tensorDtype === 'f16'
     ? f32ToF16Array(floatValues)
     : floatValues;
-  const gradBuf = acquireBuffer(payload.byteLength, undefined, label);
-  uploadData(gradBuf, payload);
-  return createTensor(gradBuf, tensorDtype, [...shape], label);
+  return createUploadedTensor(payload, tensorDtype, shape, label);
 }
 
 async function readLogitsRows(logitsTensor) {

package/src/training/objectives/distill_triplet.js

@@ -1,8 +1,8 @@
 import { crossEntropyLoss as defaultCrossEntropyLoss } from '../loss.js';
 import { createTrainingObjective } from './base.js';
-import { acquireBuffer, readBuffer, uploadData } from '../../memory/buffer-pool.js';
-import { createTensor } from '../../gpu/tensor.js';
+import { readBuffer } from '../../memory/buffer-pool.js';
 import { f16ToF32Array, f32ToF16Array } from '../../inference/kv-cache/types.js';
+import { createUploadedTensor } from '../tensor-factory.js';
 
 function toFinite(value, fallback) {
   const parsed = Number(value);
@@ -29,9 +29,7 @@ function createLossGradient(loss, lossScale) {
   const lossElements = loss.shape.reduce((acc, value) => acc * value, 1);
   const gradData = new Float32Array(lossElements);
   gradData.fill(lossScale);
-  const gradBuf = acquireBuffer(gradData.byteLength, undefined, 'distill_triplet_loss_grad_output');
-  uploadData(gradBuf, gradData);
-  return createTensor(gradBuf, 'f32', [...loss.shape], 'distill_triplet_loss_grad_output');
+  return createUploadedTensor(gradData, 'f32', loss.shape, 'distill_triplet_loss_grad_output');
 }
 
 function createGradientTensor(values, shape, dtype, label) {
@@ -40,9 +38,7 @@ function createGradientTensor(values, shape, dtype, label) {
   const payload = tensorDtype === 'f16'
     ? f32ToF16Array(floatValues)
     : floatValues;
-  const gradBuf = acquireBuffer(payload.byteLength, undefined, label);
-  uploadData(gradBuf, payload);
-  return createTensor(gradBuf, tensorDtype, [...shape], label);
+  return createUploadedTensor(payload, tensorDtype, shape, label);
 }
 
 async function readLogitsRows(logitsTensor) {

package/src/training/objectives/ul_stage2_base.js

@@ -1,7 +1,7 @@
 import { crossEntropyLoss as defaultCrossEntropyLoss } from '../loss.js';
 import { createTrainingObjective } from './base.js';
-import { acquireBuffer, uploadData, releaseBuffer } from '../../memory/buffer-pool.js';
-import { createTensor } from '../../gpu/tensor.js';
+import { releaseBuffer } from '../../memory/buffer-pool.js';
+import { createUploadedTensor } from '../tensor-factory.js';
 
 function sigmoid(value) {
   return 1 / (1 + Math.exp(-value));
@@ -9,17 +9,13 @@ function sigmoid(value) {
 
 function createF32Tensor(values, shape, label) {
   const data = values instanceof Float32Array ? values : new Float32Array(values);
-  const buffer = acquireBuffer(data.byteLength, undefined, label);
-  uploadData(buffer, data);
-  return createTensor(buffer, 'f32', [...shape], label);
+  return createUploadedTensor(data, 'f32', shape, label);
 }
 
 function createU32TokenTensor(values, shape, label) {
   const data = values instanceof Uint32Array ? values : new Uint32Array(values);
-  const buffer = acquireBuffer(data.byteLength, undefined, label);
-  uploadData(buffer, data);
   // Token targets are consumed as raw u32 bytes by loss kernels.
-  return createTensor(buffer, 'f32', [...shape], label);
+  return createUploadedTensor(data, 'f32', shape, label);
 }
 
 function releaseTensor(tensor) {

package/src/training/operator-artifacts.d.ts

@@ -0,0 +1,62 @@
+import type { LoadedTrainingWorkload, TrainingWorkloadPack } from './workloads.js';
+
+export interface TrainingRunLayout {
+  runRoot: string;
+  logs: string;
+  checkpoints: string;
+  eval: string;
+  scoreboard: string;
+  exports: string;
+  compare: string;
+  qualityGate: string;
+}
+
+export declare function normalizeTrainingTimestamp(value?: string | Date | null): string;
+
+export declare function createTrainingRunLayout(options: {
+  kind: string;
+  workloadId: string;
+  timestamp?: string | Date | null;
+}): Promise<TrainingRunLayout>;
+
+export declare function writeJsonArtifact(
+  filePath: string,
+  payload: Record<string, unknown>
+): Promise<{ path: string; sha256: string; relativePath: string }>;
+
+export declare function writeNdjsonRow(
+  filePath: string,
+  row: Record<string, unknown>
+): Promise<{ path: string; sha256: string; relativePath: string }>;
+
+export declare function writeWorkloadLock(
+  layout: TrainingRunLayout,
+  loadedWorkload: LoadedTrainingWorkload
+): Promise<{ path: string; sha256: string; relativePath: string }>;
+
+export declare function writeRunContract(
+  layout: TrainingRunLayout,
+  payload: Record<string, unknown>
+): Promise<{ path: string; sha256: string; relativePath: string }>;
+
+export declare function buildArtifactBase(options: {
+  artifactType: string;
+  reportId: string;
+  workload: TrainingWorkloadPack;
+  workloadPath: string;
+  workloadSha256: string;
+  datasetPath: string | null;
+  datasetHash: string | null;
+  baseModelId: string | null;
+  teacherModelId?: string | null;
+  studentModelId?: string | null;
+  stage?: string | null;
+  checkpointStep?: number | null;
+  parentArtifacts?: Array<Record<string, unknown>>;
+  runtime?: string;
+  surface?: string;
+  claimBoundary: string;
+  configHash: string;
+}): Record<string, unknown>;
+
+export declare function hashArtifactPayload(payload: Record<string, unknown>): string;

package/src/training/operator-artifacts.js

@@ -0,0 +1,140 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+
+import { sha256Hex } from '../utils/sha256.js';
+import { serializeTrainingWorkloadLock } from './workloads.js';
+
+function stableSortObject(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => stableSortObject(entry));
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  const sorted = {};
+  for (const key of Object.keys(value).sort()) {
+    sorted[key] = stableSortObject(value[key]);
+  }
+  return sorted;
+}
+
+function stableJson(value) {
+  return JSON.stringify(stableSortObject(value));
+}
+
+export function normalizeTrainingTimestamp(value = null) {
+  const date = value instanceof Date
+    ? value
+    : (typeof value === 'string' && value.trim() ? new Date(value) : new Date());
+  return date.toISOString().replace(/[:]/g, '-');
+}
+
+export async function createTrainingRunLayout({ kind, workloadId, timestamp = null }) {
+  const normalizedKind = String(kind || '').trim();
+  const normalizedWorkloadId = String(workloadId || '').trim();
+  if (!normalizedKind || !normalizedWorkloadId) {
+    throw new Error('createTrainingRunLayout requires kind and workloadId.');
+  }
+  const ts = normalizeTrainingTimestamp(timestamp);
+  const runRoot = resolve('reports', 'training', normalizedKind, normalizedWorkloadId, ts);
+  const directories = {
+    runRoot,
+    logs: join(runRoot, 'logs'),
+    checkpoints: join(runRoot, 'checkpoints'),
+    eval: join(runRoot, 'eval'),
+    scoreboard: join(runRoot, 'scoreboard'),
+    exports: join(runRoot, 'exports'),
+    compare: join(runRoot, 'compare'),
+    qualityGate: join(runRoot, 'quality-gate'),
+  };
+  await Promise.all(Object.values(directories).map((dirPath) => mkdir(dirPath, { recursive: true })));
+  return directories;
+}
+
+export async function writeJsonArtifact(filePath, payload) {
+  const absolutePath = resolve(String(filePath));
+  const json = `${JSON.stringify(payload, null, 2)}\n`;
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, json, 'utf8');
+  return {
+    path: absolutePath,
+    sha256: sha256Hex(json),
+    relativePath: relative(process.cwd(), absolutePath),
+  };
+}
+
+export async function writeNdjsonRow(filePath, row) {
+  const absolutePath = resolve(String(filePath));
+  let existing = '';
+  try {
+    existing = await readFile(absolutePath, 'utf8');
+  } catch (error) {
+    if (error?.code !== 'ENOENT') {
+      throw error;
+    }
+  }
+  const serialized = `${existing}${JSON.stringify(row)}\n`;
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, serialized, 'utf8');
+  return {
+    path: absolutePath,
+    sha256: sha256Hex(serialized),
+    relativePath: relative(process.cwd(), absolutePath),
+  };
+}
+
+export async function writeWorkloadLock(layout, loadedWorkload) {
+  const filePath = join(layout.runRoot, 'workload.lock.json');
+  const payload = JSON.parse(serializeTrainingWorkloadLock(loadedWorkload));
+  return writeJsonArtifact(filePath, payload);
+}
+
+export async function writeRunContract(layout, payload) {
+  return writeJsonArtifact(join(layout.runRoot, 'run_contract.json'), payload);
+}
+
+export function buildArtifactBase({
+  artifactType,
+  reportId,
+  workload,
+  workloadPath,
+  workloadSha256,
+  datasetPath,
+  datasetHash,
+  baseModelId,
+  teacherModelId = null,
+  studentModelId = null,
+  stage = null,
+  checkpointStep = null,
+  parentArtifacts = [],
+  runtime = 'node',
+  surface = 'node',
+  claimBoundary,
+  configHash,
+}) {
+  return {
+    artifactType,
+    schemaVersion: 1,
+    reportId,
+    workloadId: workload.id,
+    workloadPath,
+    workloadSha256,
+    configHash,
+    datasetPath: datasetPath || null,
+    datasetHash: datasetHash || null,
+    baseModelId: baseModelId || null,
+    teacherModelId: teacherModelId || null,
+    studentModelId: studentModelId || null,
+    stage,
+    checkpointStep,
+    parentArtifacts,
+    generatedAt: new Date().toISOString(),
+    runtime,
+    surface,
+    claimBoundary,
+  };
+}
+
+export function hashArtifactPayload(payload) {
+  return sha256Hex(stableJson(payload));
+}

package/src/training/operator-command.d.ts

@@ -0,0 +1,5 @@
+import type { ToolingCommandRequest } from '../tooling/command-api.js';
+
+export declare function runTrainingOperatorCommand(
+  request: ToolingCommandRequest
+): Promise<Record<string, unknown>>;