@ruvector/ruvllm 4.0.0 → 4.1.0

package/dist/esm/training.js

@@ -0,0 +1,603 @@
+/**
+ * Training Pipeline for SONA
+ *
+ * Comprehensive training infrastructure with metrics tracking,
+ * learning rate scheduling, and checkpoint management.
+ *
+ * @example
+ * ```typescript
+ * import { TrainingPipeline, TrainingConfig } from '@ruvector/ruvllm';
+ *
+ * const pipeline = new TrainingPipeline({
+ *   learningRate: 0.001,
+ *   batchSize: 32,
+ *   epochs: 10,
+ * });
+ *
+ * // Add training data
+ * pipeline.addBatch(inputs, targets, qualities);
+ *
+ * // Run training
+ * const result = pipeline.train();
+ * console.log(`Final loss: ${result.finalLoss}`);
+ * ```
+ */
+import { writeFileSync, readFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { LoraAdapter } from './lora.js';
+import { EwcManager } from './sona.js';
+/**
+ * Default training config
+ */
+const DEFAULT_TRAINING_CONFIG = {
+    learningRate: 0.001,
+    batchSize: 32,
+    epochs: 10,
+    scheduler: 'cosine',
+    warmupSteps: 100,
+    weightDecay: 0.01,
+    gradientClip: 1.0,
+    earlyStoppingPatience: 3,
+    checkpointInterval: 1,
+    ewcLambda: 2000,
+    validationSplit: 0.1,
+    keepBestCheckpoint: '',
+};
+/**
+ * On-disk checkpoint envelope version.
+ *
+ * v1 — {format, version:1, epoch, step, loss, weights, timestamp}. No adapter
+ *      geometry, so loadCheckpoint() could not detect a shape mismatch.
+ * v2 — adds {config:{inputDim, outputDim, rank}, pipelineConfig:{learningRate,
+ *      batchSize}} so loadCheckpoint() can reject weights that don't fit the
+ *      current adapter. v1 files still load (back-compat) with no shape check.
+ */
+const CHECKPOINT_FORMAT_VERSION = 2;
+/**
+ * Learning Rate Scheduler
+ */
+export class LRScheduler {
+    constructor(config, totalSteps) {
+        this.currentStep = 0;
+        this.config = config;
+        this.initialLR = config.learningRate;
+        this.totalSteps = totalSteps;
+    }
+    /**
+     * Get learning rate for current step
+     */
+    getLR() {
+        switch (this.config.scheduler) {
+            case 'constant':
+                return this.initialLR;
+            case 'linear':
+                return this.initialLR * (1 - this.currentStep / this.totalSteps);
+            case 'cosine':
+                return this.initialLR * 0.5 * (1 + Math.cos(Math.PI * this.currentStep / this.totalSteps));
+            case 'warmup':
+                if (this.currentStep < this.config.warmupSteps) {
+                    return this.initialLR * (this.currentStep / this.config.warmupSteps);
+                }
+                // Cosine decay after warmup
+                const decaySteps = this.totalSteps - this.config.warmupSteps;
+                const decayProgress = (this.currentStep - this.config.warmupSteps) / decaySteps;
+                return this.initialLR * 0.5 * (1 + Math.cos(Math.PI * decayProgress));
+            default:
+                return this.initialLR;
+        }
+    }
+    /**
+     * Step the scheduler
+     */
+    step() {
+        this.currentStep++;
+    }
+    /**
+     * Reset scheduler
+     */
+    reset() {
+        this.currentStep = 0;
+    }
+}
+/**
+ * Training Metrics Tracker
+ */
+export class MetricsTracker {
+    constructor() {
+        this.lossHistory = [];
+        this.valLossHistory = [];
+        this.gradNormHistory = [];
+        this.startTime = Date.now();
+        this.stepTimes = [];
+    }
+    /**
+     * Record training loss
+     */
+    recordLoss(loss) {
+        this.lossHistory.push(loss);
+    }
+    /**
+     * Record validation loss
+     */
+    recordValLoss(loss) {
+        this.valLossHistory.push(loss);
+    }
+    /**
+     * Record gradient norm
+     */
+    recordGradNorm(norm) {
+        this.gradNormHistory.push(norm);
+    }
+    /**
+     * Record step time
+     */
+    recordStepTime(ms) {
+        this.stepTimes.push(ms);
+    }
+    /**
+     * Get average loss over last N steps
+     */
+    avgLoss(n = 100) {
+        const recent = this.lossHistory.slice(-n);
+        return recent.length > 0 ? recent.reduce((a, b) => a + b, 0) / recent.length : 0;
+    }
+    /**
+     * Get average validation loss
+     */
+    avgValLoss(n = 10) {
+        const recent = this.valLossHistory.slice(-n);
+        return recent.length > 0 ? recent.reduce((a, b) => a + b, 0) / recent.length : 0;
+    }
+    /**
+     * Get steps per second
+     */
+    stepsPerSecond() {
+        if (this.stepTimes.length === 0)
+            return 0;
+        const avgStepTime = this.stepTimes.slice(-100).reduce((a, b) => a + b, 0) / Math.min(this.stepTimes.length, 100);
+        return avgStepTime > 0 ? 1000 / avgStepTime : 0;
+    }
+    /**
+     * Get ETA in seconds
+     */
+    eta(remainingSteps) {
+        const sps = this.stepsPerSecond();
+        return sps > 0 ? remainingSteps / sps : 0;
+    }
+    /**
+     * Get best validation loss
+     */
+    bestValLoss() {
+        return this.valLossHistory.length > 0 ? Math.min(...this.valLossHistory) : Infinity;
+    }
+    /**
+     * Get total duration
+     */
+    duration() {
+        return Date.now() - this.startTime;
+    }
+    /**
+     * Get all loss history
+     */
+    getLossHistory() {
+        return [...this.lossHistory];
+    }
+    /**
+     * Get all validation loss history
+     */
+    getValLossHistory() {
+        return [...this.valLossHistory];
+    }
+    /**
+     * Reset tracker
+     */
+    reset() {
+        this.lossHistory = [];
+        this.valLossHistory = [];
+        this.gradNormHistory = [];
+        this.stepTimes = [];
+        this.startTime = Date.now();
+    }
+}
+/**
+ * Training Pipeline
+ *
+ * Full training infrastructure for SONA models.
+ */
+export class TrainingPipeline {
+    constructor(config, adapter) {
+        this.scheduler = null;
+        this.batches = [];
+        this.checkpoints = [];
+        this.currentEpoch = 0;
+        this.currentStep = 0;
+        this.bestValLoss = Infinity;
+        this.patienceCounter = 0;
+        /** Set by resumeFrom(); makes the next train() continue instead of restart. */
+        this.resumePending = false;
+        this.config = { ...DEFAULT_TRAINING_CONFIG, ...config };
+        this.adapter = adapter || new LoraAdapter({ rank: 8 });
+        this.ewcManager = new EwcManager(this.config.ewcLambda);
+        this.metrics = new MetricsTracker();
+    }
+    /**
+     * Add training batch
+     */
+    addBatch(inputs, targets, qualities) {
+        this.batches.push({ inputs, targets, qualities });
+    }
+    /**
+     * Add training data
+     */
+    addData(data) {
+        // Group into batches
+        for (let i = 0; i < data.length; i += this.config.batchSize) {
+            const batch = data.slice(i, i + this.config.batchSize);
+            this.addBatch(batch.map(d => d.input), batch.map(d => d.target), batch.map(d => d.quality));
+        }
+    }
+    /**
+     * Run training.
+     *
+     * When {@link resumeFrom} primed the pipeline, this continues from the
+     * restored epoch (running the remaining epochs of `config.epochs`) and
+     * advances the LR scheduler to the restored step so the schedule is
+     * unbroken; metrics history is preserved. Without a resume the run is
+     * unchanged from a fresh start — same reset, same scheduler, same result
+     * shape as before this method learned to resume.
+     */
+    train() {
+        const resuming = this.resumePending;
+        this.resumePending = false;
+        // currentEpoch is the last COMPLETED epoch index, so resume the next one.
+        const startEpoch = resuming ? this.currentEpoch + 1 : 0;
+        const totalSteps = this.batches.length * this.config.epochs;
+        this.scheduler = new LRScheduler(this.config, totalSteps);
+        if (resuming) {
+            // Fast-forward the fresh scheduler to the restored step.
+            for (let s = 0; s < this.currentStep && s < totalSteps; s++) {
+                this.scheduler.step();
+            }
+        }
+        else {
+            this.metrics.reset();
+        }
+        this.adapter.startTraining(this.config.learningRate);
+        let earlyStopped = false;
+        for (let epoch = startEpoch; epoch < this.config.epochs; epoch++) {
+            this.currentEpoch = epoch;
+            // Shuffle batches
+            const shuffledBatches = this.shuffleBatches();
+            // Split into train/val
+            const valSize = Math.floor(shuffledBatches.length * this.config.validationSplit);
+            const trainBatches = shuffledBatches.slice(valSize);
+            const valBatches = shuffledBatches.slice(0, valSize);
+            // Training epoch
+            for (const batch of trainBatches) {
+                const stepStart = Date.now();
+                const loss = this.trainStep(batch);
+                this.metrics.recordLoss(loss);
+                this.metrics.recordStepTime(Date.now() - stepStart);
+                this.scheduler.step();
+                this.currentStep++;
+            }
+            // Validation
+            if (valBatches.length > 0) {
+                const valLoss = this.validate(valBatches);
+                this.metrics.recordValLoss(valLoss);
+                // Early stopping
+                if (valLoss < this.bestValLoss) {
+                    this.bestValLoss = valLoss;
+                    this.patienceCounter = 0;
+                    // Retain the best-validation model to a stable path when configured.
+                    if (this.config.keepBestCheckpoint) {
+                        this.saveCheckpoint(this.config.keepBestCheckpoint);
+                    }
+                }
+                else {
+                    this.patienceCounter++;
+                    if (this.patienceCounter >= this.config.earlyStoppingPatience) {
+                        earlyStopped = true;
+                        break;
+                    }
+                }
+            }
+            // Checkpoint
+            if ((epoch + 1) % this.config.checkpointInterval === 0) {
+                this.saveCheckpoint();
+            }
+        }
+        this.adapter.endTraining();
+        // Register with EWC for continual learning
+        const weights = this.adapter.merge().flat();
+        this.ewcManager.registerTask(`task-${Date.now()}`, weights);
+        return {
+            epochs: this.currentEpoch + 1,
+            steps: this.currentStep,
+            finalLoss: this.metrics.avgLoss(100),
+            bestValLoss: this.bestValLoss,
+            durationMs: this.metrics.duration(),
+            lossHistory: this.metrics.getLossHistory(),
+            valLossHistory: this.metrics.getValLossHistory(),
+            earlyStopped,
+        };
+    }
+    /**
+     * Single training step
+     */
+    trainStep(batch) {
+        let totalLoss = 0;
+        const lr = this.scheduler?.getLR() || this.config.learningRate;
+        for (let i = 0; i < batch.inputs.length; i++) {
+            const input = batch.inputs[i];
+            const target = batch.targets[i];
+            const quality = batch.qualities[i];
+            // Forward pass
+            const output = this.adapter.forward(input);
+            // Compute loss (MSE weighted by quality)
+            const gradOutput = [];
+            let loss = 0;
+            for (let j = 0; j < output.length; j++) {
+                const diff = output[j] - (target[j] || 0);
+                loss += diff * diff;
+                gradOutput.push(2 * diff * quality); // Quality-weighted gradient
+            }
+            loss = (loss / output.length) * quality;
+            // Add EWC penalty
+            const ewcPenalty = this.ewcManager.computePenalty(this.adapter.merge().flat());
+            loss += ewcPenalty * 0.001;
+            // Backward pass
+            this.adapter.backward(input, gradOutput, lr);
+            totalLoss += loss;
+        }
+        return totalLoss / batch.inputs.length;
+    }
+    /**
+     * Validation pass
+     */
+    validate(batches) {
+        let totalLoss = 0;
+        let count = 0;
+        for (const batch of batches) {
+            for (let i = 0; i < batch.inputs.length; i++) {
+                const output = this.adapter.forward(batch.inputs[i]);
+                const target = batch.targets[i];
+                let loss = 0;
+                for (let j = 0; j < output.length; j++) {
+                    const diff = output[j] - (target[j] || 0);
+                    loss += diff * diff;
+                }
+                totalLoss += loss / output.length;
+                count++;
+            }
+        }
+        return count > 0 ? totalLoss / count : 0;
+    }
+    /**
+     * Save a checkpoint.
+     *
+     * Always records the checkpoint in the in-memory list (the behavior the
+     * training loop relies on). When `path` is given, additionally persists
+     * the checkpoint to disk as versioned JSON — before v2.5.7 this method
+     * was private, ignored any argument, and never wrote a file, so callers
+     * passing a path got `undefined` back and zero bytes on disk.
+     *
+     * @param path Optional file path; parent directories are created.
+     * @returns Where the checkpoint went — in-memory index, and file
+     *          path + byte size when persisted.
+     */
+    saveCheckpoint(path) {
+        const checkpoint = {
+            epoch: this.currentEpoch,
+            step: this.currentStep,
+            loss: this.metrics.avgLoss(100),
+            weights: this.adapter.toJSON(),
+            timestamp: Date.now(),
+        };
+        this.checkpoints.push(checkpoint);
+        const result = {
+            index: this.checkpoints.length - 1,
+            epoch: checkpoint.epoch,
+            step: checkpoint.step,
+            loss: checkpoint.loss,
+        };
+        if (path) {
+            const envelope = {
+                format: 'ruvllm-checkpoint',
+                version: CHECKPOINT_FORMAT_VERSION,
+                // Adapter geometry + pipeline hyperparams — lets loadCheckpoint()
+                // reject weights that don't fit the current adapter (v2, see below).
+                config: {
+                    inputDim: this.adapter.getInputDim(),
+                    outputDim: this.adapter.getOutputDim(),
+                    rank: this.adapter.getConfig().rank,
+                },
+                pipelineConfig: {
+                    learningRate: this.config.learningRate,
+                    batchSize: this.config.batchSize,
+                },
+                ...checkpoint,
+            };
+            const serialized = JSON.stringify(envelope);
+            mkdirSync(dirname(path), { recursive: true });
+            writeFileSync(path, serialized, 'utf-8');
+            result.path = path;
+            result.bytes = Buffer.byteLength(serialized, 'utf-8');
+        }
+        return result;
+    }
+    /**
+     * Load a checkpoint — by in-memory index, or from a file previously
+     * written by `saveCheckpoint(path)`.
+     *
+     * For v2 files, the envelope's adapter geometry is checked against the
+     * current adapter first; a mismatch (different inputDim/outputDim/rank)
+     * returns false and leaves the adapter untouched, so mis-shaped weights
+     * are never silently restored. v1 files carry no geometry and load as
+     * before (back-compat).
+     */
+    loadCheckpoint(indexOrPath) {
+        let checkpoint;
+        if (typeof indexOrPath === 'number') {
+            checkpoint = this.checkpoints[indexOrPath];
+        }
+        else {
+            try {
+                const parsed = JSON.parse(readFileSync(indexOrPath, 'utf-8'));
+                if (parsed?.format !== 'ruvllm-checkpoint' || typeof parsed.weights !== 'string') {
+                    return false;
+                }
+                if (typeof parsed.version === 'number' && parsed.version >= 2 && parsed.config) {
+                    const c = parsed.config;
+                    if (c.inputDim !== this.adapter.getInputDim() ||
+                        c.outputDim !== this.adapter.getOutputDim() ||
+                        c.rank !== this.adapter.getConfig().rank) {
+                        return false;
+                    }
+                }
+                checkpoint = parsed;
+            }
+            catch {
+                return false;
+            }
+        }
+        if (!checkpoint)
+            return false;
+        this.adapter = LoraAdapter.fromJSON(checkpoint.weights);
+        this.currentEpoch = checkpoint.epoch;
+        this.currentStep = checkpoint.step;
+        return true;
+    }
+    /**
+     * Resume training from a checkpoint file.
+     *
+     * Loads the checkpoint (with the same v2 shape validation as
+     * {@link loadCheckpoint}) AND primes the pipeline so the next {@link train}
+     * call continues from the restored epoch/step rather than restarting. This
+     * is the explicit, least-invasive resume path: a plain `loadCheckpoint()`
+     * still restores weights only (train() from scratch), while `resumeFrom()`
+     * additionally makes the subsequent train() pick up where the run stopped.
+     *
+     * @returns true when the checkpoint loaded and resume was primed; false if
+     *          the file was missing, foreign, or shape-mismatched (in which case
+     *          no resume is armed).
+     */
+    resumeFrom(path) {
+        if (!this.loadCheckpoint(path))
+            return false;
+        this.resumePending = true;
+        return true;
+    }
+    /**
+     * Get current metrics
+     */
+    getMetrics() {
+        return {
+            epoch: this.currentEpoch,
+            step: this.currentStep,
+            trainLoss: this.metrics.avgLoss(100),
+            valLoss: this.metrics.avgValLoss(10),
+            learningRate: this.scheduler?.getLR() || this.config.learningRate,
+            gradNorm: 0,
+            stepsPerSecond: this.metrics.stepsPerSecond(),
+            etaSeconds: this.metrics.eta((this.config.epochs - this.currentEpoch) * this.batches.length),
+        };
+    }
+    /**
+     * Get adapter
+     */
+    getAdapter() {
+        return this.adapter;
+    }
+    /**
+     * Get EWC manager
+     */
+    getEwcManager() {
+        return this.ewcManager;
+    }
+    /**
+     * Get checkpoints
+     */
+    getCheckpoints() {
+        return [...this.checkpoints];
+    }
+    /**
+     * Reset pipeline
+     */
+    reset() {
+        this.batches = [];
+        this.checkpoints = [];
+        this.currentEpoch = 0;
+        this.currentStep = 0;
+        this.bestValLoss = Infinity;
+        this.patienceCounter = 0;
+        this.resumePending = false;
+        this.metrics.reset();
+        this.adapter.reset();
+    }
+    shuffleBatches() {
+        const shuffled = [...this.batches];
+        for (let i = shuffled.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+        }
+        return shuffled;
+    }
+}
+/**
+ * Training Factory
+ *
+ * Create pre-configured training pipelines for common scenarios.
+ */
+export class TrainingFactory {
+    /**
+     * Create pipeline for quick fine-tuning
+     */
+    static quickFinetune() {
+        return new TrainingPipeline({
+            learningRate: 0.01,
+            epochs: 3,
+            batchSize: 16,
+            scheduler: 'constant',
+        });
+    }
+    /**
+     * Create pipeline for deep training
+     */
+    static deepTraining() {
+        return new TrainingPipeline({
+            learningRate: 0.001,
+            epochs: 50,
+            batchSize: 32,
+            scheduler: 'warmup',
+            warmupSteps: 500,
+            earlyStoppingPatience: 5,
+        });
+    }
+    /**
+     * Create pipeline for continual learning
+     */
+    static continualLearning(ewcLambda = 5000) {
+        return new TrainingPipeline({
+            learningRate: 0.0005,
+            epochs: 10,
+            batchSize: 16,
+            scheduler: 'cosine',
+            ewcLambda,
+            earlyStoppingPatience: 10,
+        });
+    }
+    /**
+     * Create pipeline for federated aggregation
+     */
+    static federatedAggregation() {
+        return new TrainingPipeline({
+            learningRate: 0.0001,
+            epochs: 5,
+            batchSize: 64,
+            scheduler: 'linear',
+            ewcLambda: 2000,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"training.js","sourceRoot":"","sources":["../../src/training.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Training Pipeline for SONA\n *\n * Comprehensive training infrastructure with metrics tracking,\n * learning rate scheduling, and checkpoint management.\n *\n * @example\n * ```typescript\n * import { TrainingPipeline, TrainingConfig } from '@ruvector/ruvllm';\n *\n * const pipeline = new TrainingPipeline({\n *   learningRate: 0.001,\n *   batchSize: 32,\n *   epochs: 10,\n * });\n *\n * // Add training data\n * pipeline.addBatch(inputs, targets, qualities);\n *\n * // Run training\n * const result = pipeline.train();\n * console.log(`Final loss: ${result.finalLoss}`);\n * ```\n */\n\nimport { writeFileSync, readFileSync, mkdirSync } from 'fs';\nimport { dirname } from 'path';\nimport { Embedding, TrainingConfig, TrainingResult } from './types';\nimport { LoraAdapter } from './lora';\nimport { EwcManager } from './sona';\n\n/**\n * Default training config\n */\nconst DEFAULT_TRAINING_CONFIG: Required<TrainingConfig> = {\n  learningRate: 0.001,\n  batchSize: 32,\n  epochs: 10,\n  scheduler: 'cosine',\n  warmupSteps: 100,\n  weightDecay: 0.01,\n  gradientClip: 1.0,\n  earlyStoppingPatience: 3,\n  checkpointInterval: 1,\n  ewcLambda: 2000,\n  validationSplit: 0.1,\n  keepBestCheckpoint: '',\n};\n\n/**\n * Training metrics\n */\nexport interface TrainingMetrics {\n  /** Current epoch */\n  epoch: number;\n  /** Current step */\n  step: number;\n  /** Training loss */\n  trainLoss: number;\n  /** Validation loss */\n  valLoss: number;\n  /** Learning rate */\n  learningRate: number;\n  /** Gradient norm */\n  gradNorm: number;\n  /** Steps per second */\n  stepsPerSecond: number;\n  /** ETA in seconds */\n  etaSeconds: number;\n}\n\n/**\n * Training data batch\n */\nexport interface TrainingBatch {\n  /** Input embeddings */\n  inputs: Embedding[];\n  /** Target outputs */\n  targets: Embedding[];\n  /** Quality scores */\n  qualities: number[];\n}\n\n/**\n * Checkpoint data\n */\nexport interface Checkpoint {\n  /** Epoch number */\n  epoch: number;\n  /** Step number */\n  step: number;\n  /** Training loss at checkpoint */\n  loss: number;\n  /** Model weights (serialized) */\n  weights: string;\n  /** Timestamp */\n  timestamp: number;\n}\n\n/**\n * Result of a saveCheckpoint() call.\n */\nexport interface CheckpointSaveResult {\n  /** Index of the checkpoint in the in-memory checkpoint list */\n  index: number;\n  /** Epoch the checkpoint captured */\n  epoch: number;\n  /** Step the checkpoint captured */\n  step: number;\n  /** Training loss at checkpoint time */\n  loss: number;\n  /** Absolute or as-given file path, when persisted to disk */\n  path?: string;\n  /** Serialized size in bytes, when persisted to disk */\n  bytes?: number;\n}\n\n/**\n * On-disk checkpoint envelope version.\n *\n * v1 — {format, version:1, epoch, step, loss, weights, timestamp}. No adapter\n *      geometry, so loadCheckpoint() could not detect a shape mismatch.\n * v2 — adds {config:{inputDim, outputDim, rank}, pipelineConfig:{learningRate,\n *      batchSize}} so loadCheckpoint() can reject weights that don't fit the\n *      current adapter. v1 files still load (back-compat) with no shape check.\n */\nconst CHECKPOINT_FORMAT_VERSION = 2;\n\n/**\n * Learning Rate Scheduler\n */\nexport class LRScheduler {\n  private config: Required<TrainingConfig>;\n  private initialLR: number;\n  private currentStep: number = 0;\n  private totalSteps: number;\n\n  constructor(config: Required<TrainingConfig>, totalSteps: number) {\n    this.config = config;\n    this.initialLR = config.learningRate;\n    this.totalSteps = totalSteps;\n  }\n\n  /**\n   * Get learning rate for current step\n   */\n  getLR(): number {\n    switch (this.config.scheduler) {\n      case 'constant':\n        return this.initialLR;\n\n      case 'linear':\n        return this.initialLR * (1 - this.currentStep / this.totalSteps);\n\n      case 'cosine':\n        return this.initialLR * 0.5 * (1 + Math.cos(Math.PI * this.currentStep / this.totalSteps));\n\n      case 'warmup':\n        if (this.currentStep < this.config.warmupSteps) {\n          return this.initialLR * (this.currentStep / this.config.warmupSteps);\n        }\n        // Cosine decay after warmup\n        const decaySteps = this.totalSteps - this.config.warmupSteps;\n        const decayProgress = (this.currentStep - this.config.warmupSteps) / decaySteps;\n        return this.initialLR * 0.5 * (1 + Math.cos(Math.PI * decayProgress));\n\n      default:\n        return this.initialLR;\n    }\n  }\n\n  /**\n   * Step the scheduler\n   */\n  step(): void {\n    this.currentStep++;\n  }\n\n  /**\n   * Reset scheduler\n   */\n  reset(): void {\n    this.currentStep = 0;\n  }\n}\n\n/**\n * Training Metrics Tracker\n */\nexport class MetricsTracker {\n  private lossHistory: number[] = [];\n  private valLossHistory: number[] = [];\n  private gradNormHistory: number[] = [];\n  private startTime: number = Date.now();\n  private stepTimes: number[] = [];\n\n  /**\n   * Record training loss\n   */\n  recordLoss(loss: number): void {\n    this.lossHistory.push(loss);\n  }\n\n  /**\n   * Record validation loss\n   */\n  recordValLoss(loss: number): void {\n    this.valLossHistory.push(loss);\n  }\n\n  /**\n   * Record gradient norm\n   */\n  recordGradNorm(norm: number): void {\n    this.gradNormHistory.push(norm);\n  }\n\n  /**\n   * Record step time\n   */\n  recordStepTime(ms: number): void {\n    this.stepTimes.push(ms);\n  }\n\n  /**\n   * Get average loss over last N steps\n   */\n  avgLoss(n: number = 100): number {\n    const recent = this.lossHistory.slice(-n);\n    return recent.length > 0 ? recent.reduce((a, b) => a + b, 0) / recent.length : 0;\n  }\n\n  /**\n   * Get average validation loss\n   */\n  avgValLoss(n: number = 10): number {\n    const recent = this.valLossHistory.slice(-n);\n    return recent.length > 0 ? recent.reduce((a, b) => a + b, 0) / recent.length : 0;\n  }\n\n  /**\n   * Get steps per second\n   */\n  stepsPerSecond(): number {\n    if (this.stepTimes.length === 0) return 0;\n    const avgStepTime = this.stepTimes.slice(-100).reduce((a, b) => a + b, 0) / Math.min(this.stepTimes.length, 100);\n    return avgStepTime > 0 ? 1000 / avgStepTime : 0;\n  }\n\n  /**\n   * Get ETA in seconds\n   */\n  eta(remainingSteps: number): number {\n    const sps = this.stepsPerSecond();\n    return sps > 0 ? remainingSteps / sps : 0;\n  }\n\n  /**\n   * Get best validation loss\n   */\n  bestValLoss(): number {\n    return this.valLossHistory.length > 0 ? Math.min(...this.valLossHistory) : Infinity;\n  }\n\n  /**\n   * Get total duration\n   */\n  duration(): number {\n    return Date.now() - this.startTime;\n  }\n\n  /**\n   * Get all loss history\n   */\n  getLossHistory(): number[] {\n    return [...this.lossHistory];\n  }\n\n  /**\n   * Get all validation loss history\n   */\n  getValLossHistory(): number[] {\n    return [...this.valLossHistory];\n  }\n\n  /**\n   * Reset tracker\n   */\n  reset(): void {\n    this.lossHistory = [];\n    this.valLossHistory = [];\n    this.gradNormHistory = [];\n    this.stepTimes = [];\n    this.startTime = Date.now();\n  }\n}\n\n/**\n * Training Pipeline\n *\n * Full training infrastructure for SONA models.\n */\nexport class TrainingPipeline {\n  private config: Required<TrainingConfig>;\n  private adapter: LoraAdapter;\n  private ewcManager: EwcManager;\n  private metrics: MetricsTracker;\n  private scheduler: LRScheduler | null = null;\n  private batches: TrainingBatch[] = [];\n  private checkpoints: Checkpoint[] = [];\n  private currentEpoch: number = 0;\n  private currentStep: number = 0;\n  private bestValLoss: number = Infinity;\n  private patienceCounter: number = 0;\n  /** Set by resumeFrom(); makes the next train() continue instead of restart. */\n  private resumePending: boolean = false;\n\n  constructor(config?: TrainingConfig, adapter?: LoraAdapter) {\n    this.config = { ...DEFAULT_TRAINING_CONFIG, ...config };\n    this.adapter = adapter || new LoraAdapter({ rank: 8 });\n    this.ewcManager = new EwcManager(this.config.ewcLambda);\n    this.metrics = new MetricsTracker();\n  }\n\n  /**\n   * Add training batch\n   */\n  addBatch(inputs: Embedding[], targets: Embedding[], qualities: number[]): void {\n    this.batches.push({ inputs, targets, qualities });\n  }\n\n  /**\n   * Add training data\n   */\n  addData(data: Array<{ input: Embedding; target: Embedding; quality: number }>): void {\n    // Group into batches\n    for (let i = 0; i < data.length; i += this.config.batchSize) {\n      const batch = data.slice(i, i + this.config.batchSize);\n      this.addBatch(\n        batch.map(d => d.input),\n        batch.map(d => d.target),\n        batch.map(d => d.quality)\n      );\n    }\n  }\n\n  /**\n   * Run training.\n   *\n   * When {@link resumeFrom} primed the pipeline, this continues from the\n   * restored epoch (running the remaining epochs of `config.epochs`) and\n   * advances the LR scheduler to the restored step so the schedule is\n   * unbroken; metrics history is preserved. Without a resume the run is\n   * unchanged from a fresh start — same reset, same scheduler, same result\n   * shape as before this method learned to resume.\n   */\n  train(): TrainingResult {\n    const resuming = this.resumePending;\n    this.resumePending = false;\n    // currentEpoch is the last COMPLETED epoch index, so resume the next one.\n    const startEpoch = resuming ? this.currentEpoch + 1 : 0;\n\n    const totalSteps = this.batches.length * this.config.epochs;\n    this.scheduler = new LRScheduler(this.config, totalSteps);\n    if (resuming) {\n      // Fast-forward the fresh scheduler to the restored step.\n      for (let s = 0; s < this.currentStep && s < totalSteps; s++) {\n        this.scheduler.step();\n      }\n    } else {\n      this.metrics.reset();\n    }\n    this.adapter.startTraining(this.config.learningRate);\n\n    let earlyStopped = false;\n\n    for (let epoch = startEpoch; epoch < this.config.epochs; epoch++) {\n      this.currentEpoch = epoch;\n\n      // Shuffle batches\n      const shuffledBatches = this.shuffleBatches();\n\n      // Split into train/val\n      const valSize = Math.floor(shuffledBatches.length * this.config.validationSplit);\n      const trainBatches = shuffledBatches.slice(valSize);\n      const valBatches = shuffledBatches.slice(0, valSize);\n\n      // Training epoch\n      for (const batch of trainBatches) {\n        const stepStart = Date.now();\n        const loss = this.trainStep(batch);\n        this.metrics.recordLoss(loss);\n        this.metrics.recordStepTime(Date.now() - stepStart);\n        this.scheduler.step();\n        this.currentStep++;\n      }\n\n      // Validation\n      if (valBatches.length > 0) {\n        const valLoss = this.validate(valBatches);\n        this.metrics.recordValLoss(valLoss);\n\n        // Early stopping\n        if (valLoss < this.bestValLoss) {\n          this.bestValLoss = valLoss;\n          this.patienceCounter = 0;\n          // Retain the best-validation model to a stable path when configured.\n          if (this.config.keepBestCheckpoint) {\n            this.saveCheckpoint(this.config.keepBestCheckpoint);\n          }\n        } else {\n          this.patienceCounter++;\n          if (this.patienceCounter >= this.config.earlyStoppingPatience) {\n            earlyStopped = true;\n            break;\n          }\n        }\n      }\n\n      // Checkpoint\n      if ((epoch + 1) % this.config.checkpointInterval === 0) {\n        this.saveCheckpoint();\n      }\n    }\n\n    this.adapter.endTraining();\n\n    // Register with EWC for continual learning\n    const weights = this.adapter.merge().flat();\n    this.ewcManager.registerTask(`task-${Date.now()}`, weights);\n\n    return {\n      epochs: this.currentEpoch + 1,\n      steps: this.currentStep,\n      finalLoss: this.metrics.avgLoss(100),\n      bestValLoss: this.bestValLoss,\n      durationMs: this.metrics.duration(),\n      lossHistory: this.metrics.getLossHistory(),\n      valLossHistory: this.metrics.getValLossHistory(),\n      earlyStopped,\n    };\n  }\n\n  /**\n   * Single training step\n   */\n  private trainStep(batch: TrainingBatch): number {\n    let totalLoss = 0;\n    const lr = this.scheduler?.getLR() || this.config.learningRate;\n\n    for (let i = 0; i < batch.inputs.length; i++) {\n      const input = batch.inputs[i];\n      const target = batch.targets[i];\n      const quality = batch.qualities[i];\n\n      // Forward pass\n      const output = this.adapter.forward(input);\n\n      // Compute loss (MSE weighted by quality)\n      const gradOutput: number[] = [];\n      let loss = 0;\n      for (let j = 0; j < output.length; j++) {\n        const diff = output[j] - (target[j] || 0);\n        loss += diff * diff;\n        gradOutput.push(2 * diff * quality); // Quality-weighted gradient\n      }\n      loss = (loss / output.length) * quality;\n\n      // Add EWC penalty\n      const ewcPenalty = this.ewcManager.computePenalty(this.adapter.merge().flat());\n      loss += ewcPenalty * 0.001;\n\n      // Backward pass\n      this.adapter.backward(input, gradOutput, lr);\n\n      totalLoss += loss;\n    }\n\n    return totalLoss / batch.inputs.length;\n  }\n\n  /**\n   * Validation pass\n   */\n  private validate(batches: TrainingBatch[]): number {\n    let totalLoss = 0;\n    let count = 0;\n\n    for (const batch of batches) {\n      for (let i = 0; i < batch.inputs.length; i++) {\n        const output = this.adapter.forward(batch.inputs[i]);\n        const target = batch.targets[i];\n\n        let loss = 0;\n        for (let j = 0; j < output.length; j++) {\n          const diff = output[j] - (target[j] || 0);\n          loss += diff * diff;\n        }\n        totalLoss += loss / output.length;\n        count++;\n      }\n    }\n\n    return count > 0 ? totalLoss / count : 0;\n  }\n\n  /**\n   * Save a checkpoint.\n   *\n   * Always records the checkpoint in the in-memory list (the behavior the\n   * training loop relies on). When `path` is given, additionally persists\n   * the checkpoint to disk as versioned JSON — before v2.5.7 this method\n   * was private, ignored any argument, and never wrote a file, so callers\n   * passing a path got `undefined` back and zero bytes on disk.\n   *\n   * @param path Optional file path; parent directories are created.\n   * @returns Where the checkpoint went — in-memory index, and file\n   *          path + byte size when persisted.\n   */\n  saveCheckpoint(path?: string): CheckpointSaveResult {\n    const checkpoint: Checkpoint = {\n      epoch: this.currentEpoch,\n      step: this.currentStep,\n      loss: this.metrics.avgLoss(100),\n      weights: this.adapter.toJSON(),\n      timestamp: Date.now(),\n    };\n    this.checkpoints.push(checkpoint);\n\n    const result: CheckpointSaveResult = {\n      index: this.checkpoints.length - 1,\n      epoch: checkpoint.epoch,\n      step: checkpoint.step,\n      loss: checkpoint.loss,\n    };\n\n    if (path) {\n      const envelope = {\n        format: 'ruvllm-checkpoint',\n        version: CHECKPOINT_FORMAT_VERSION,\n        // Adapter geometry + pipeline hyperparams — lets loadCheckpoint()\n        // reject weights that don't fit the current adapter (v2, see below).\n        config: {\n          inputDim: this.adapter.getInputDim(),\n          outputDim: this.adapter.getOutputDim(),\n          rank: this.adapter.getConfig().rank,\n        },\n        pipelineConfig: {\n          learningRate: this.config.learningRate,\n          batchSize: this.config.batchSize,\n        },\n        ...checkpoint,\n      };\n      const serialized = JSON.stringify(envelope);\n      mkdirSync(dirname(path), { recursive: true });\n      writeFileSync(path, serialized, 'utf-8');\n      result.path = path;\n      result.bytes = Buffer.byteLength(serialized, 'utf-8');\n    }\n\n    return result;\n  }\n\n  /**\n   * Load a checkpoint — by in-memory index, or from a file previously\n   * written by `saveCheckpoint(path)`.\n   *\n   * For v2 files, the envelope's adapter geometry is checked against the\n   * current adapter first; a mismatch (different inputDim/outputDim/rank)\n   * returns false and leaves the adapter untouched, so mis-shaped weights\n   * are never silently restored. v1 files carry no geometry and load as\n   * before (back-compat).\n   */\n  loadCheckpoint(indexOrPath: number | string): boolean {\n    let checkpoint: Checkpoint | undefined;\n\n    if (typeof indexOrPath === 'number') {\n      checkpoint = this.checkpoints[indexOrPath];\n    } else {\n      try {\n        const parsed = JSON.parse(readFileSync(indexOrPath, 'utf-8'));\n        if (parsed?.format !== 'ruvllm-checkpoint' || typeof parsed.weights !== 'string') {\n          return false;\n        }\n        if (typeof parsed.version === 'number' && parsed.version >= 2 && parsed.config) {\n          const c = parsed.config;\n          if (\n            c.inputDim !== this.adapter.getInputDim() ||\n            c.outputDim !== this.adapter.getOutputDim() ||\n            c.rank !== this.adapter.getConfig().rank\n          ) {\n            return false;\n          }\n        }\n        checkpoint = parsed as Checkpoint;\n      } catch {\n        return false;\n      }\n    }\n    if (!checkpoint) return false;\n\n    this.adapter = LoraAdapter.fromJSON(checkpoint.weights);\n    this.currentEpoch = checkpoint.epoch;\n    this.currentStep = checkpoint.step;\n    return true;\n  }\n\n  /**\n   * Resume training from a checkpoint file.\n   *\n   * Loads the checkpoint (with the same v2 shape validation as\n   * {@link loadCheckpoint}) AND primes the pipeline so the next {@link train}\n   * call continues from the restored epoch/step rather than restarting. This\n   * is the explicit, least-invasive resume path: a plain `loadCheckpoint()`\n   * still restores weights only (train() from scratch), while `resumeFrom()`\n   * additionally makes the subsequent train() pick up where the run stopped.\n   *\n   * @returns true when the checkpoint loaded and resume was primed; false if\n   *          the file was missing, foreign, or shape-mismatched (in which case\n   *          no resume is armed).\n   */\n  resumeFrom(path: string): boolean {\n    if (!this.loadCheckpoint(path)) return false;\n    this.resumePending = true;\n    return true;\n  }\n\n  /**\n   * Get current metrics\n   */\n  getMetrics(): TrainingMetrics {\n    return {\n      epoch: this.currentEpoch,\n      step: this.currentStep,\n      trainLoss: this.metrics.avgLoss(100),\n      valLoss: this.metrics.avgValLoss(10),\n      learningRate: this.scheduler?.getLR() || this.config.learningRate,\n      gradNorm: 0,\n      stepsPerSecond: this.metrics.stepsPerSecond(),\n      etaSeconds: this.metrics.eta(\n        (this.config.epochs - this.currentEpoch) * this.batches.length\n      ),\n    };\n  }\n\n  /**\n   * Get adapter\n   */\n  getAdapter(): LoraAdapter {\n    return this.adapter;\n  }\n\n  /**\n   * Get EWC manager\n   */\n  getEwcManager(): EwcManager {\n    return this.ewcManager;\n  }\n\n  /**\n   * Get checkpoints\n   */\n  getCheckpoints(): Checkpoint[] {\n    return [...this.checkpoints];\n  }\n\n  /**\n   * Reset pipeline\n   */\n  reset(): void {\n    this.batches = [];\n    this.checkpoints = [];\n    this.currentEpoch = 0;\n    this.currentStep = 0;\n    this.bestValLoss = Infinity;\n    this.patienceCounter = 0;\n    this.resumePending = false;\n    this.metrics.reset();\n    this.adapter.reset();\n  }\n\n  private shuffleBatches(): TrainingBatch[] {\n    const shuffled = [...this.batches];\n    for (let i = shuffled.length - 1; i > 0; i--) {\n      const j = Math.floor(Math.random() * (i + 1));\n      [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];\n    }\n    return shuffled;\n  }\n}\n\n/**\n * Training Factory\n *\n * Create pre-configured training pipelines for common scenarios.\n */\nexport class TrainingFactory {\n  /**\n   * Create pipeline for quick fine-tuning\n   */\n  static quickFinetune(): TrainingPipeline {\n    return new TrainingPipeline({\n      learningRate: 0.01,\n      epochs: 3,\n      batchSize: 16,\n      scheduler: 'constant',\n    });\n  }\n\n  /**\n   * Create pipeline for deep training\n   */\n  static deepTraining(): TrainingPipeline {\n    return new TrainingPipeline({\n      learningRate: 0.001,\n      epochs: 50,\n      batchSize: 32,\n      scheduler: 'warmup',\n      warmupSteps: 500,\n      earlyStoppingPatience: 5,\n    });\n  }\n\n  /**\n   * Create pipeline for continual learning\n   */\n  static continualLearning(ewcLambda: number = 5000): TrainingPipeline {\n    return new TrainingPipeline({\n      learningRate: 0.0005,\n      epochs: 10,\n      batchSize: 16,\n      scheduler: 'cosine',\n      ewcLambda,\n      earlyStoppingPatience: 10,\n    });\n  }\n\n  /**\n   * Create pipeline for federated aggregation\n   */\n  static federatedAggregation(): TrainingPipeline {\n    return new TrainingPipeline({\n      learningRate: 0.0001,\n      epochs: 5,\n      batchSize: 64,\n      scheduler: 'linear',\n      ewcLambda: 2000,\n    });\n  }\n}\n"]}