/**
 * 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 { LoraAdapter } from './lora';
import { EwcManager } from './sona';
/**
 * 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,
};
/**
 * 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;
        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
     */
    train() {
        const totalSteps = this.batches.length * this.config.epochs;
        this.scheduler = new LRScheduler(this.config, totalSteps);
        this.metrics.reset();
        this.adapter.startTraining(this.config.learningRate);
        let earlyStopped = false;
        for (let epoch = 0; 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;
                }
                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 checkpoint
     */
    saveCheckpoint() {
        this.checkpoints.push({
            epoch: this.currentEpoch,
            step: this.currentStep,
            loss: this.metrics.avgLoss(100),
            weights: this.adapter.toJSON(),
            timestamp: Date.now(),
        });
    }
    /**
     * Load checkpoint
     */
    loadCheckpoint(index) {
        const checkpoint = this.checkpoints[index];
        if (!checkpoint)
            return false;
        this.adapter = LoraAdapter.fromJSON(checkpoint.weights);
        this.currentEpoch = checkpoint.epoch;
        this.currentStep = checkpoint.step;
        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.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 { 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};\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 * 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\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  train(): TrainingResult {\n    const totalSteps = this.batches.length * this.config.epochs;\n    this.scheduler = new LRScheduler(this.config, totalSteps);\n    this.metrics.reset();\n    this.adapter.startTraining(this.config.learningRate);\n\n    let earlyStopped = false;\n\n    for (let epoch = 0; 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        } 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 checkpoint\n   */\n  private saveCheckpoint(): void {\n    this.checkpoints.push({\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  }\n\n  /**\n   * Load checkpoint\n   */\n  loadCheckpoint(index: number): boolean {\n    const checkpoint = this.checkpoints[index];\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   * 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.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"]}