@ruvector/ruvllm 4.0.0 → 4.1.0

package/dist/cjs/lora.js

@@ -0,0 +1,509 @@
+"use strict";
+/**
+ * LoRA (Low-Rank Adaptation) Runtime
+ *
+ * Efficient parameter-efficient fine-tuning adapters for LLMs.
+ * Supports micro-LoRA (fast, small updates) and base-LoRA (deeper adaptation).
+ *
+ * @example
+ * ```typescript
+ * import { LoraAdapter, LoraManager } from '@ruvector/ruvllm';
+ *
+ * // Create adapter
+ * const adapter = new LoraAdapter({
+ *   rank: 8,
+ *   alpha: 16,
+ *   dropout: 0.1,
+ *   targetModules: ['query', 'value'],
+ * });
+ *
+ * // Apply to hidden states
+ * const output = adapter.forward(hiddenStates);
+ *
+ * // Manage multiple adapters
+ * const manager = new LoraManager();
+ * manager.register('task-1', adapter);
+ * manager.activate('task-1');
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoraManager = exports.LoraAdapter = void 0;
+/**
+ * Default LoRA configuration
+ */
+const DEFAULT_LORA_CONFIG = {
+    rank: 8,
+    alpha: 16,
+    dropout: 0.1,
+    targetModules: ['query', 'value'],
+};
+/**
+ * LoRA Adapter
+ *
+ * Implements low-rank decomposition for parameter-efficient fine-tuning.
+ * W' = W + BA where A is (d x r) and B is (r x d), r << d
+ *
+ * @example
+ * ```typescript
+ * const adapter = new LoraAdapter({
+ *   rank: 8,
+ *   alpha: 16,
+ *   inputDim: 768,
+ *   outputDim: 768,
+ * });
+ *
+ * // Forward pass
+ * const output = adapter.forward(input);
+ *
+ * // Training step
+ * adapter.backward(input, gradOutput, 0.001);
+ * ```
+ */
+class LoraAdapter {
+    constructor(config, inputDim = 256, outputDim = 256) {
+        this.trainingState = null;
+        this.frozen = false;
+        this.config = { ...DEFAULT_LORA_CONFIG, ...config };
+        this.inputDim = inputDim;
+        this.outputDim = outputDim;
+        // Initialize weights
+        this.weights = this.initializeWeights();
+    }
+    /**
+     * Forward pass through LoRA adapter
+     * OPTIMIZED: Uses Float64Array and loop unrolling
+     *
+     * output = input + scaling * (input @ A @ B)
+     */
+    forward(input) {
+        const rank = this.config.rank;
+        const dim = Math.min(input.length, this.inputDim);
+        const scaling = this.weights.scaling;
+        // Apply dropout during training (simplified check)
+        const applyDropout = this.trainingState !== null && this.config.dropout > 0;
+        // input @ A (d -> r) - use typed array for hidden
+        const hidden = new Float64Array(rank);
+        for (let r = 0; r < rank; r++) {
+            let sum = 0;
+            const loraACol = this.weights.loraA;
+            // Unroll loop for better performance
+            let i = 0;
+            if (applyDropout) {
+                for (; i < dim; i++) {
+                    if (Math.random() > this.config.dropout) {
+                        sum += input[i] * loraACol[i][r];
+                    }
+                }
+            }
+            else {
+                for (; i + 3 < dim; i += 4) {
+                    sum += input[i] * loraACol[i][r] +
+                        input[i + 1] * loraACol[i + 1][r] +
+                        input[i + 2] * loraACol[i + 2][r] +
+                        input[i + 3] * loraACol[i + 3][r];
+                }
+                for (; i < dim; i++) {
+                    sum += input[i] * loraACol[i][r];
+                }
+            }
+            hidden[r] = sum;
+        }
+        // hidden @ B (r -> d) + residual
+        const output = new Array(this.outputDim);
+        const loraB = this.weights.loraB;
+        for (let i = 0; i < this.outputDim; i++) {
+            let delta = 0;
+            for (let r = 0; r < rank; r++) {
+                delta += hidden[r] * loraB[r][i];
+            }
+            // Add scaled delta to input (residual connection)
+            output[i] = (input[i] || 0) + scaling * delta;
+        }
+        return output;
+    }
+    /**
+     * Forward with batch processing
+     */
+    forwardBatch(inputs) {
+        return inputs.map(input => this.forward(input));
+    }
+    /**
+     * Backward pass and weight update
+     */
+    backward(input, gradOutput, learningRate) {
+        if (this.frozen)
+            return 0;
+        const rank = this.config.rank;
+        const dim = Math.min(input.length, this.inputDim);
+        // Compute hidden activations (for gradient)
+        const hidden = new Array(rank).fill(0);
+        for (let r = 0; r < rank; r++) {
+            for (let i = 0; i < dim; i++) {
+                hidden[r] += input[i] * this.weights.loraA[i][r];
+            }
+        }
+        // Gradient for B: hidden^T @ gradOutput
+        const gradB = Array(rank).fill(null).map(() => Array(this.outputDim).fill(0));
+        for (let r = 0; r < rank; r++) {
+            for (let i = 0; i < this.outputDim; i++) {
+                gradB[r][i] = hidden[r] * (gradOutput[i] || 0) * this.weights.scaling;
+            }
+        }
+        // Gradient for hidden: gradOutput @ B^T
+        const gradHidden = new Array(rank).fill(0);
+        for (let r = 0; r < rank; r++) {
+            for (let i = 0; i < this.outputDim; i++) {
+                gradHidden[r] += (gradOutput[i] || 0) * this.weights.loraB[r][i] * this.weights.scaling;
+            }
+        }
+        // Gradient for A: input^T @ gradHidden
+        const gradA = Array(dim).fill(null).map(() => Array(rank).fill(0));
+        for (let i = 0; i < dim; i++) {
+            for (let r = 0; r < rank; r++) {
+                gradA[i][r] = input[i] * gradHidden[r];
+            }
+        }
+        // Update weights
+        let totalGrad = 0;
+        for (let i = 0; i < dim; i++) {
+            for (let r = 0; r < rank; r++) {
+                this.weights.loraA[i][r] -= learningRate * gradA[i][r];
+                totalGrad += Math.abs(gradA[i][r]);
+            }
+        }
+        for (let r = 0; r < rank; r++) {
+            for (let i = 0; i < this.outputDim; i++) {
+                this.weights.loraB[r][i] -= learningRate * gradB[r][i];
+                totalGrad += Math.abs(gradB[r][i]);
+            }
+        }
+        // Track training state
+        if (this.trainingState) {
+            this.trainingState.step++;
+            this.trainingState.lossHistory.push(totalGrad);
+        }
+        return totalGrad;
+    }
+    /**
+     * Start training mode
+     */
+    startTraining(learningRate = 0.001) {
+        this.trainingState = {
+            step: 0,
+            learningRate,
+            gradA: Array(this.inputDim).fill(null).map(() => Array(this.config.rank).fill(0)),
+            gradB: Array(this.config.rank).fill(null).map(() => Array(this.outputDim).fill(0)),
+            lossHistory: [],
+        };
+    }
+    /**
+     * End training mode
+     */
+    endTraining() {
+        const state = this.trainingState;
+        this.trainingState = null;
+        return state;
+    }
+    /**
+     * Freeze adapter (no more updates)
+     */
+    freeze() {
+        this.frozen = true;
+    }
+    /**
+     * Unfreeze adapter
+     */
+    unfreeze() {
+        this.frozen = false;
+    }
+    /**
+     * Check if frozen
+     */
+    isFrozen() {
+        return this.frozen;
+    }
+    /**
+     * Get adapter config
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Get input dimension (rows of loraA).
+     *
+     * The adapter's geometry (inputDim/outputDim) is not part of LoRAConfig,
+     * so these getters expose it for checkpoint metadata and shape validation.
+     */
+    getInputDim() {
+        return this.inputDim;
+    }
+    /**
+     * Get output dimension (cols of loraB).
+     */
+    getOutputDim() {
+        return this.outputDim;
+    }
+    /**
+     * Get adapter weights
+     */
+    getWeights() {
+        return {
+            loraA: this.weights.loraA.map(row => [...row]),
+            loraB: this.weights.loraB.map(row => [...row]),
+            scaling: this.weights.scaling,
+        };
+    }
+    /**
+     * Set adapter weights
+     */
+    setWeights(weights) {
+        this.weights = {
+            loraA: weights.loraA.map(row => [...row]),
+            loraB: weights.loraB.map(row => [...row]),
+            scaling: weights.scaling,
+        };
+    }
+    /**
+     * Merge adapter into base weights
+     *
+     * Returns delta to add to base model weights
+     */
+    merge() {
+        const delta = Array(this.inputDim)
+            .fill(null)
+            .map(() => Array(this.outputDim).fill(0));
+        const rank = this.config.rank;
+        for (let i = 0; i < this.inputDim; i++) {
+            for (let j = 0; j < this.outputDim; j++) {
+                for (let r = 0; r < rank; r++) {
+                    delta[i][j] += this.weights.loraA[i][r] * this.weights.loraB[r][j];
+                }
+                delta[i][j] *= this.weights.scaling;
+            }
+        }
+        return delta;
+    }
+    /**
+     * Get number of trainable parameters
+     */
+    numParameters() {
+        return (this.inputDim * this.config.rank) + (this.config.rank * this.outputDim);
+    }
+    /**
+     * Reset to initial weights
+     */
+    reset() {
+        this.weights = this.initializeWeights();
+        this.trainingState = null;
+        this.frozen = false;
+    }
+    /**
+     * Clone adapter
+     */
+    clone() {
+        const adapter = new LoraAdapter(this.config, this.inputDim, this.outputDim);
+        adapter.setWeights(this.getWeights());
+        return adapter;
+    }
+    /**
+     * Serialize to JSON
+     */
+    toJSON() {
+        return JSON.stringify({
+            config: this.config,
+            inputDim: this.inputDim,
+            outputDim: this.outputDim,
+            weights: this.weights,
+            frozen: this.frozen,
+        });
+    }
+    /**
+     * Deserialize from JSON
+     */
+    static fromJSON(json) {
+        const data = JSON.parse(json);
+        const adapter = new LoraAdapter(data.config, data.inputDim, data.outputDim);
+        adapter.setWeights(data.weights);
+        if (data.frozen)
+            adapter.freeze();
+        return adapter;
+    }
+    initializeWeights() {
+        const rank = this.config.rank;
+        // Kaiming initialization for A, zero initialization for B
+        const loraA = Array(this.inputDim)
+            .fill(null)
+            .map(() => Array(rank)
+            .fill(0)
+            .map(() => (Math.random() - 0.5) * Math.sqrt(2 / this.inputDim)));
+        const loraB = Array(rank)
+            .fill(null)
+            .map(() => Array(this.outputDim).fill(0));
+        return {
+            loraA,
+            loraB,
+            scaling: this.config.alpha / this.config.rank,
+        };
+    }
+}
+exports.LoraAdapter = LoraAdapter;
+/**
+ * LoRA Manager for multiple adapters
+ *
+ * Manages a collection of LoRA adapters for different tasks/domains.
+ */
+class LoraManager {
+    constructor(defaultConfig) {
+        this.adapters = new Map();
+        this.activeAdapterId = null;
+        this.defaultConfig = { ...DEFAULT_LORA_CONFIG, ...defaultConfig };
+    }
+    /**
+     * Register a new adapter
+     */
+    register(id, adapter) {
+        this.adapters.set(id, adapter);
+    }
+    /**
+     * Create and register a new adapter
+     */
+    create(id, config, inputDim, outputDim) {
+        const mergedConfig = { ...this.defaultConfig, ...config };
+        const adapter = new LoraAdapter(mergedConfig, inputDim, outputDim);
+        this.register(id, adapter);
+        return adapter;
+    }
+    /**
+     * Get adapter by ID
+     */
+    get(id) {
+        return this.adapters.get(id);
+    }
+    /**
+     * Remove adapter
+     */
+    remove(id) {
+        if (this.activeAdapterId === id) {
+            this.activeAdapterId = null;
+        }
+        return this.adapters.delete(id);
+    }
+    /**
+     * Activate an adapter
+     */
+    activate(id) {
+        if (this.adapters.has(id)) {
+            this.activeAdapterId = id;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Deactivate current adapter
+     */
+    deactivate() {
+        this.activeAdapterId = null;
+    }
+    /**
+     * Get active adapter
+     */
+    getActive() {
+        return this.activeAdapterId ? this.adapters.get(this.activeAdapterId) || null : null;
+    }
+    /**
+     * Get active adapter ID
+     */
+    getActiveId() {
+        return this.activeAdapterId;
+    }
+    /**
+     * Apply active adapter
+     */
+    forward(input) {
+        const active = this.getActive();
+        return active ? active.forward(input) : [...input];
+    }
+    /**
+     * List all adapter IDs
+     */
+    list() {
+        return Array.from(this.adapters.keys());
+    }
+    /**
+     * Get adapter count
+     */
+    count() {
+        return this.adapters.size;
+    }
+    /**
+     * Freeze all adapters
+     */
+    freezeAll() {
+        for (const adapter of this.adapters.values()) {
+            adapter.freeze();
+        }
+    }
+    /**
+     * Unfreeze all adapters
+     */
+    unfreezeAll() {
+        for (const adapter of this.adapters.values()) {
+            adapter.unfreeze();
+        }
+    }
+    /**
+     * Merge multiple adapters into one
+     */
+    mergeAdapters(ids, outputId) {
+        const adapters = ids.map(id => this.adapters.get(id)).filter(Boolean);
+        if (adapters.length === 0)
+            return null;
+        // Use first adapter as base
+        const merged = adapters[0].clone();
+        const weights = merged.getWeights();
+        // Average weights from other adapters
+        for (let i = 1; i < adapters.length; i++) {
+            const otherWeights = adapters[i].getWeights();
+            for (let row = 0; row < weights.loraA.length && row < otherWeights.loraA.length; row++) {
+                for (let col = 0; col < weights.loraA[row].length && col < otherWeights.loraA[row].length; col++) {
+                    weights.loraA[row][col] = (weights.loraA[row][col] + otherWeights.loraA[row][col]) / 2;
+                }
+            }
+            for (let row = 0; row < weights.loraB.length && row < otherWeights.loraB.length; row++) {
+                for (let col = 0; col < weights.loraB[row].length && col < otherWeights.loraB[row].length; col++) {
+                    weights.loraB[row][col] = (weights.loraB[row][col] + otherWeights.loraB[row][col]) / 2;
+                }
+            }
+        }
+        merged.setWeights(weights);
+        this.register(outputId, merged);
+        return merged;
+    }
+    /**
+     * Get statistics
+     */
+    stats() {
+        let totalParams = 0;
+        let frozenCount = 0;
+        for (const adapter of this.adapters.values()) {
+            totalParams += adapter.numParameters();
+            if (adapter.isFrozen())
+                frozenCount++;
+        }
+        return {
+            totalAdapters: this.adapters.size,
+            activeAdapter: this.activeAdapterId,
+            totalParameters: totalParams,
+            frozenCount,
+        };
+    }
+    /**
+     * Clear all adapters
+     */
+    clear() {
+        this.adapters.clear();
+        this.activeAdapterId = null;
+    }
+}
+exports.LoraManager = LoraManager;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lora.js","sourceRoot":"","sources":["../../src/lora.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * LoRA (Low-Rank Adaptation) Runtime\n *\n * Efficient parameter-efficient fine-tuning adapters for LLMs.\n * Supports micro-LoRA (fast, small updates) and base-LoRA (deeper adaptation).\n *\n * @example\n * ```typescript\n * import { LoraAdapter, LoraManager } from '@ruvector/ruvllm';\n *\n * // Create adapter\n * const adapter = new LoraAdapter({\n *   rank: 8,\n *   alpha: 16,\n *   dropout: 0.1,\n *   targetModules: ['query', 'value'],\n * });\n *\n * // Apply to hidden states\n * const output = adapter.forward(hiddenStates);\n *\n * // Manage multiple adapters\n * const manager = new LoraManager();\n * manager.register('task-1', adapter);\n * manager.activate('task-1');\n * ```\n */\n\nimport { LoRAConfig, Embedding } from './types';\n\n/**\n * Default LoRA configuration\n */\nconst DEFAULT_LORA_CONFIG: Required<LoRAConfig> = {\n  rank: 8,\n  alpha: 16,\n  dropout: 0.1,\n  targetModules: ['query', 'value'],\n};\n\n/**\n * LoRA adapter weights\n */\nexport interface LoraWeights {\n  /** Down projection matrix (d x r) */\n  loraA: number[][];\n  /** Up projection matrix (r x d) */\n  loraB: number[][];\n  /** Scaling factor */\n  scaling: number;\n}\n\n/**\n * LoRA training state\n */\nexport interface LoraTrainingState {\n  /** Current step */\n  step: number;\n  /** Learning rate */\n  learningRate: number;\n  /** Accumulated gradients for A */\n  gradA: number[][];\n  /** Accumulated gradients for B */\n  gradB: number[][];\n  /** Loss history */\n  lossHistory: number[];\n}\n\n/**\n * LoRA Adapter\n *\n * Implements low-rank decomposition for parameter-efficient fine-tuning.\n * W' = W + BA where A is (d x r) and B is (r x d), r << d\n *\n * @example\n * ```typescript\n * const adapter = new LoraAdapter({\n *   rank: 8,\n *   alpha: 16,\n *   inputDim: 768,\n *   outputDim: 768,\n * });\n *\n * // Forward pass\n * const output = adapter.forward(input);\n *\n * // Training step\n * adapter.backward(input, gradOutput, 0.001);\n * ```\n */\nexport class LoraAdapter {\n  private config: Required<LoRAConfig>;\n  private inputDim: number;\n  private outputDim: number;\n  private weights: LoraWeights;\n  private trainingState: LoraTrainingState | null = null;\n  private frozen: boolean = false;\n\n  constructor(config?: Partial<LoRAConfig>, inputDim = 256, outputDim = 256) {\n    this.config = { ...DEFAULT_LORA_CONFIG, ...config };\n    this.inputDim = inputDim;\n    this.outputDim = outputDim;\n\n    // Initialize weights\n    this.weights = this.initializeWeights();\n  }\n\n  /**\n   * Forward pass through LoRA adapter\n   * OPTIMIZED: Uses Float64Array and loop unrolling\n   *\n   * output = input + scaling * (input @ A @ B)\n   */\n  forward(input: number[]): number[] {\n    const rank = this.config.rank;\n    const dim = Math.min(input.length, this.inputDim);\n    const scaling = this.weights.scaling;\n\n    // Apply dropout during training (simplified check)\n    const applyDropout = this.trainingState !== null && this.config.dropout > 0;\n\n    // input @ A (d -> r) - use typed array for hidden\n    const hidden = new Float64Array(rank);\n    for (let r = 0; r < rank; r++) {\n      let sum = 0;\n      const loraACol = this.weights.loraA;\n      // Unroll loop for better performance\n      let i = 0;\n      if (applyDropout) {\n        for (; i < dim; i++) {\n          if (Math.random() > this.config.dropout) {\n            sum += input[i] * loraACol[i][r];\n          }\n        }\n      } else {\n        for (; i + 3 < dim; i += 4) {\n          sum += input[i] * loraACol[i][r] +\n                 input[i + 1] * loraACol[i + 1][r] +\n                 input[i + 2] * loraACol[i + 2][r] +\n                 input[i + 3] * loraACol[i + 3][r];\n        }\n        for (; i < dim; i++) {\n          sum += input[i] * loraACol[i][r];\n        }\n      }\n      hidden[r] = sum;\n    }\n\n    // hidden @ B (r -> d) + residual\n    const output = new Array(this.outputDim);\n    const loraB = this.weights.loraB;\n    for (let i = 0; i < this.outputDim; i++) {\n      let delta = 0;\n      for (let r = 0; r < rank; r++) {\n        delta += hidden[r] * loraB[r][i];\n      }\n      // Add scaled delta to input (residual connection)\n      output[i] = (input[i] || 0) + scaling * delta;\n    }\n\n    return output;\n  }\n\n  /**\n   * Forward with batch processing\n   */\n  forwardBatch(inputs: number[][]): number[][] {\n    return inputs.map(input => this.forward(input));\n  }\n\n  /**\n   * Backward pass and weight update\n   */\n  backward(input: number[], gradOutput: number[], learningRate: number): number {\n    if (this.frozen) return 0;\n\n    const rank = this.config.rank;\n    const dim = Math.min(input.length, this.inputDim);\n\n    // Compute hidden activations (for gradient)\n    const hidden = new Array(rank).fill(0);\n    for (let r = 0; r < rank; r++) {\n      for (let i = 0; i < dim; i++) {\n        hidden[r] += input[i] * this.weights.loraA[i][r];\n      }\n    }\n\n    // Gradient for B: hidden^T @ gradOutput\n    const gradB: number[][] = Array(rank).fill(null).map(() => Array(this.outputDim).fill(0));\n    for (let r = 0; r < rank; r++) {\n      for (let i = 0; i < this.outputDim; i++) {\n        gradB[r][i] = hidden[r] * (gradOutput[i] || 0) * this.weights.scaling;\n      }\n    }\n\n    // Gradient for hidden: gradOutput @ B^T\n    const gradHidden = new Array(rank).fill(0);\n    for (let r = 0; r < rank; r++) {\n      for (let i = 0; i < this.outputDim; i++) {\n        gradHidden[r] += (gradOutput[i] || 0) * this.weights.loraB[r][i] * this.weights.scaling;\n      }\n    }\n\n    // Gradient for A: input^T @ gradHidden\n    const gradA: number[][] = Array(dim).fill(null).map(() => Array(rank).fill(0));\n    for (let i = 0; i < dim; i++) {\n      for (let r = 0; r < rank; r++) {\n        gradA[i][r] = input[i] * gradHidden[r];\n      }\n    }\n\n    // Update weights\n    let totalGrad = 0;\n    for (let i = 0; i < dim; i++) {\n      for (let r = 0; r < rank; r++) {\n        this.weights.loraA[i][r] -= learningRate * gradA[i][r];\n        totalGrad += Math.abs(gradA[i][r]);\n      }\n    }\n    for (let r = 0; r < rank; r++) {\n      for (let i = 0; i < this.outputDim; i++) {\n        this.weights.loraB[r][i] -= learningRate * gradB[r][i];\n        totalGrad += Math.abs(gradB[r][i]);\n      }\n    }\n\n    // Track training state\n    if (this.trainingState) {\n      this.trainingState.step++;\n      this.trainingState.lossHistory.push(totalGrad);\n    }\n\n    return totalGrad;\n  }\n\n  /**\n   * Start training mode\n   */\n  startTraining(learningRate = 0.001): void {\n    this.trainingState = {\n      step: 0,\n      learningRate,\n      gradA: Array(this.inputDim).fill(null).map(() => Array(this.config.rank).fill(0)),\n      gradB: Array(this.config.rank).fill(null).map(() => Array(this.outputDim).fill(0)),\n      lossHistory: [],\n    };\n  }\n\n  /**\n   * End training mode\n   */\n  endTraining(): LoraTrainingState | null {\n    const state = this.trainingState;\n    this.trainingState = null;\n    return state;\n  }\n\n  /**\n   * Freeze adapter (no more updates)\n   */\n  freeze(): void {\n    this.frozen = true;\n  }\n\n  /**\n   * Unfreeze adapter\n   */\n  unfreeze(): void {\n    this.frozen = false;\n  }\n\n  /**\n   * Check if frozen\n   */\n  isFrozen(): boolean {\n    return this.frozen;\n  }\n\n  /**\n   * Get adapter config\n   */\n  getConfig(): Required<LoRAConfig> {\n    return { ...this.config };\n  }\n\n  /**\n   * Get input dimension (rows of loraA).\n   *\n   * The adapter's geometry (inputDim/outputDim) is not part of LoRAConfig,\n   * so these getters expose it for checkpoint metadata and shape validation.\n   */\n  getInputDim(): number {\n    return this.inputDim;\n  }\n\n  /**\n   * Get output dimension (cols of loraB).\n   */\n  getOutputDim(): number {\n    return this.outputDim;\n  }\n\n  /**\n   * Get adapter weights\n   */\n  getWeights(): LoraWeights {\n    return {\n      loraA: this.weights.loraA.map(row => [...row]),\n      loraB: this.weights.loraB.map(row => [...row]),\n      scaling: this.weights.scaling,\n    };\n  }\n\n  /**\n   * Set adapter weights\n   */\n  setWeights(weights: LoraWeights): void {\n    this.weights = {\n      loraA: weights.loraA.map(row => [...row]),\n      loraB: weights.loraB.map(row => [...row]),\n      scaling: weights.scaling,\n    };\n  }\n\n  /**\n   * Merge adapter into base weights\n   *\n   * Returns delta to add to base model weights\n   */\n  merge(): number[][] {\n    const delta: number[][] = Array(this.inputDim)\n      .fill(null)\n      .map(() => Array(this.outputDim).fill(0));\n\n    const rank = this.config.rank;\n    for (let i = 0; i < this.inputDim; i++) {\n      for (let j = 0; j < this.outputDim; j++) {\n        for (let r = 0; r < rank; r++) {\n          delta[i][j] += this.weights.loraA[i][r] * this.weights.loraB[r][j];\n        }\n        delta[i][j] *= this.weights.scaling;\n      }\n    }\n\n    return delta;\n  }\n\n  /**\n   * Get number of trainable parameters\n   */\n  numParameters(): number {\n    return (this.inputDim * this.config.rank) + (this.config.rank * this.outputDim);\n  }\n\n  /**\n   * Reset to initial weights\n   */\n  reset(): void {\n    this.weights = this.initializeWeights();\n    this.trainingState = null;\n    this.frozen = false;\n  }\n\n  /**\n   * Clone adapter\n   */\n  clone(): LoraAdapter {\n    const adapter = new LoraAdapter(this.config, this.inputDim, this.outputDim);\n    adapter.setWeights(this.getWeights());\n    return adapter;\n  }\n\n  /**\n   * Serialize to JSON\n   */\n  toJSON(): string {\n    return JSON.stringify({\n      config: this.config,\n      inputDim: this.inputDim,\n      outputDim: this.outputDim,\n      weights: this.weights,\n      frozen: this.frozen,\n    });\n  }\n\n  /**\n   * Deserialize from JSON\n   */\n  static fromJSON(json: string): LoraAdapter {\n    const data = JSON.parse(json);\n    const adapter = new LoraAdapter(data.config, data.inputDim, data.outputDim);\n    adapter.setWeights(data.weights);\n    if (data.frozen) adapter.freeze();\n    return adapter;\n  }\n\n  private initializeWeights(): LoraWeights {\n    const rank = this.config.rank;\n\n    // Kaiming initialization for A, zero initialization for B\n    const loraA: number[][] = Array(this.inputDim)\n      .fill(null)\n      .map(() =>\n        Array(rank)\n          .fill(0)\n          .map(() => (Math.random() - 0.5) * Math.sqrt(2 / this.inputDim))\n      );\n\n    const loraB: number[][] = Array(rank)\n      .fill(null)\n      .map(() => Array(this.outputDim).fill(0));\n\n    return {\n      loraA,\n      loraB,\n      scaling: this.config.alpha / this.config.rank,\n    };\n  }\n}\n\n/**\n * LoRA Manager for multiple adapters\n *\n * Manages a collection of LoRA adapters for different tasks/domains.\n */\nexport class LoraManager {\n  private adapters: Map<string, LoraAdapter> = new Map();\n  private activeAdapterId: string | null = null;\n  private defaultConfig: Required<LoRAConfig>;\n\n  constructor(defaultConfig?: Partial<LoRAConfig>) {\n    this.defaultConfig = { ...DEFAULT_LORA_CONFIG, ...defaultConfig };\n  }\n\n  /**\n   * Register a new adapter\n   */\n  register(id: string, adapter: LoraAdapter): void {\n    this.adapters.set(id, adapter);\n  }\n\n  /**\n   * Create and register a new adapter\n   */\n  create(id: string, config?: Partial<LoRAConfig>, inputDim?: number, outputDim?: number): LoraAdapter {\n    const mergedConfig = { ...this.defaultConfig, ...config };\n    const adapter = new LoraAdapter(mergedConfig, inputDim, outputDim);\n    this.register(id, adapter);\n    return adapter;\n  }\n\n  /**\n   * Get adapter by ID\n   */\n  get(id: string): LoraAdapter | undefined {\n    return this.adapters.get(id);\n  }\n\n  /**\n   * Remove adapter\n   */\n  remove(id: string): boolean {\n    if (this.activeAdapterId === id) {\n      this.activeAdapterId = null;\n    }\n    return this.adapters.delete(id);\n  }\n\n  /**\n   * Activate an adapter\n   */\n  activate(id: string): boolean {\n    if (this.adapters.has(id)) {\n      this.activeAdapterId = id;\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Deactivate current adapter\n   */\n  deactivate(): void {\n    this.activeAdapterId = null;\n  }\n\n  /**\n   * Get active adapter\n   */\n  getActive(): LoraAdapter | null {\n    return this.activeAdapterId ? this.adapters.get(this.activeAdapterId) || null : null;\n  }\n\n  /**\n   * Get active adapter ID\n   */\n  getActiveId(): string | null {\n    return this.activeAdapterId;\n  }\n\n  /**\n   * Apply active adapter\n   */\n  forward(input: number[]): number[] {\n    const active = this.getActive();\n    return active ? active.forward(input) : [...input];\n  }\n\n  /**\n   * List all adapter IDs\n   */\n  list(): string[] {\n    return Array.from(this.adapters.keys());\n  }\n\n  /**\n   * Get adapter count\n   */\n  count(): number {\n    return this.adapters.size;\n  }\n\n  /**\n   * Freeze all adapters\n   */\n  freezeAll(): void {\n    for (const adapter of this.adapters.values()) {\n      adapter.freeze();\n    }\n  }\n\n  /**\n   * Unfreeze all adapters\n   */\n  unfreezeAll(): void {\n    for (const adapter of this.adapters.values()) {\n      adapter.unfreeze();\n    }\n  }\n\n  /**\n   * Merge multiple adapters into one\n   */\n  mergeAdapters(ids: string[], outputId: string): LoraAdapter | null {\n    const adapters = ids.map(id => this.adapters.get(id)).filter(Boolean) as LoraAdapter[];\n    if (adapters.length === 0) return null;\n\n    // Use first adapter as base\n    const merged = adapters[0].clone();\n    const weights = merged.getWeights();\n\n    // Average weights from other adapters\n    for (let i = 1; i < adapters.length; i++) {\n      const otherWeights = adapters[i].getWeights();\n\n      for (let row = 0; row < weights.loraA.length && row < otherWeights.loraA.length; row++) {\n        for (let col = 0; col < weights.loraA[row].length && col < otherWeights.loraA[row].length; col++) {\n          weights.loraA[row][col] = (weights.loraA[row][col] + otherWeights.loraA[row][col]) / 2;\n        }\n      }\n      for (let row = 0; row < weights.loraB.length && row < otherWeights.loraB.length; row++) {\n        for (let col = 0; col < weights.loraB[row].length && col < otherWeights.loraB[row].length; col++) {\n          weights.loraB[row][col] = (weights.loraB[row][col] + otherWeights.loraB[row][col]) / 2;\n        }\n      }\n    }\n\n    merged.setWeights(weights);\n    this.register(outputId, merged);\n    return merged;\n  }\n\n  /**\n   * Get statistics\n   */\n  stats(): {\n    totalAdapters: number;\n    activeAdapter: string | null;\n    totalParameters: number;\n    frozenCount: number;\n  } {\n    let totalParams = 0;\n    let frozenCount = 0;\n\n    for (const adapter of this.adapters.values()) {\n      totalParams += adapter.numParameters();\n      if (adapter.isFrozen()) frozenCount++;\n    }\n\n    return {\n      totalAdapters: this.adapters.size,\n      activeAdapter: this.activeAdapterId,\n      totalParameters: totalParams,\n      frozenCount,\n    };\n  }\n\n  /**\n   * Clear all adapters\n   */\n  clear(): void {\n    this.adapters.clear();\n    this.activeAdapterId = null;\n  }\n}\n"]}