@sparkleideas/neural 3.5.2-patch.1

package/src/modes/research.ts

@@ -0,0 +1,486 @@
+/**
+ * Research Mode Implementation
+ *
+ * Optimized for maximum quality with:
+ * - +55% quality improvement target
+ * - Learning rate 0.002 (sweet spot)
+ * - Rank-16 LoRA
+ * - Gradient checkpointing
+ * - Full learning pipeline
+ */
+
+import type {
+  SONAModeConfig,
+  ModeOptimizations,
+  Trajectory,
+  Pattern,
+  PatternMatch,
+  LoRAWeights,
+  EWCState,
+} from '../types.js';
+import { BaseModeImplementation } from './base.js';
+
+/**
+ * Research mode for maximum quality learning
+ */
+export class ResearchMode extends BaseModeImplementation {
+  readonly mode = 'research';
+
+  // Extended pattern storage
+  private patternIndex: Map<string, number> = new Map();
+  private clusterCentroids: Float32Array[] = [];
+
+  // Learning state with checkpointing
+  private gradientHistory: Array<Map<string, Float32Array>> = [];
+  private checkpoints: Array<{ iteration: number; state: Map<string, Float32Array> }> = [];
+
+  // Adam optimizer state
+  private adamM: Map<string, Float32Array> = new Map();
+  private adamV: Map<string, Float32Array> = new Map();
+  private adamStep = 0;
+
+  // Stats
+  private totalPatternMatches = 0;
+  private totalPatternTime = 0;
+  private totalLearnTime = 0;
+  private learnIterations = 0;
+  private qualityHistory: number[] = [];
+  private explorationRewards: number[] = [];
+
+  async initialize(): Promise<void> {
+    await super.initialize();
+    this.patternIndex.clear();
+    this.clusterCentroids = [];
+    this.gradientHistory = [];
+    this.checkpoints = [];
+    this.adamM.clear();
+    this.adamV.clear();
+    this.adamStep = 0;
+  }
+
+  async cleanup(): Promise<void> {
+    this.patternIndex.clear();
+    this.clusterCentroids = [];
+    this.gradientHistory = [];
+    this.checkpoints = [];
+    this.adamM.clear();
+    this.adamV.clear();
+    await super.cleanup();
+  }
+
+  /**
+   * Find patterns using cluster-based search
+   */
+  async findPatterns(
+    embedding: Float32Array,
+    k: number,
+    patterns: Pattern[]
+  ): Promise<PatternMatch[]> {
+    const startTime = performance.now();
+
+    // Update clusters if needed
+    if (this.clusterCentroids.length !== this.config.patternClusters) {
+      await this.rebuildClusters(patterns);
+    }
+
+    // Find nearest cluster
+    let bestCluster = 0;
+    let bestSim = -1;
+    for (let c = 0; c < this.clusterCentroids.length; c++) {
+      const sim = this.cosineSimilarity(embedding, this.clusterCentroids[c]);
+      if (sim > bestSim) {
+        bestSim = sim;
+        bestCluster = c;
+      }
+    }
+
+    // Search within cluster + nearby clusters
+    const clustersToSearch = this.getNearestClusters(embedding, 3);
+    const candidates: PatternMatch[] = [];
+
+    for (const pattern of patterns) {
+      const patternCluster = this.patternIndex.get(pattern.patternId);
+      if (patternCluster !== undefined && clustersToSearch.includes(patternCluster)) {
+        const similarity = this.cosineSimilarity(embedding, pattern.embedding);
+        candidates.push({
+          pattern,
+          similarity,
+          confidence: this.computeConfidence(pattern, similarity),
+          latencyMs: 0,
+        });
+      }
+    }
+
+    // If not enough candidates, search all patterns
+    if (candidates.length < k) {
+      for (const pattern of patterns) {
+        if (!candidates.find(c => c.pattern.patternId === pattern.patternId)) {
+          const similarity = this.cosineSimilarity(embedding, pattern.embedding);
+          candidates.push({
+            pattern,
+            similarity,
+            confidence: this.computeConfidence(pattern, similarity),
+            latencyMs: 0,
+          });
+        }
+      }
+    }
+
+    // Sort and return top-k
+    candidates.sort((a, b) => b.similarity - a.similarity);
+
+    this.totalPatternTime += performance.now() - startTime;
+    this.totalPatternMatches++;
+
+    return candidates.slice(0, k);
+  }
+
+  /**
+   * Learn using full Adam optimizer with gradient checkpointing
+   */
+  async learn(
+    trajectories: Trajectory[],
+    config: SONAModeConfig,
+    ewcState: EWCState
+  ): Promise<number> {
+    const startTime = performance.now();
+
+    if (trajectories.length === 0) return 0;
+
+    // Research mode uses low threshold to learn from all data
+    const learningRate = config.learningRate; // 0.002 sweet spot
+    const batchSize = config.batchSize;
+
+    // Sort trajectories by quality
+    const sortedTrajectories = [...trajectories].sort((a, b) => b.qualityScore - a.qualityScore);
+
+    // Create checkpoint before learning
+    if (this.learnIterations % 10 === 0) {
+      this.createCheckpoint();
+    }
+
+    let totalLoss = 0;
+    let batchCount = 0;
+
+    // Process in mini-batches
+    for (let i = 0; i < sortedTrajectories.length; i += batchSize) {
+      const batch = sortedTrajectories.slice(i, i + batchSize);
+      const batchLoss = await this.processBatch(batch, learningRate, ewcState, config.ewcLambda);
+      totalLoss += batchLoss;
+      batchCount++;
+    }
+
+    // Track quality
+    const avgQuality = sortedTrajectories.reduce((s, t) => s + t.qualityScore, 0) / sortedTrajectories.length;
+    this.qualityHistory.push(avgQuality);
+    if (this.qualityHistory.length > 1000) {
+      this.qualityHistory = this.qualityHistory.slice(-1000);
+    }
+
+    // Compute improvement
+    const recentAvg = this.qualityHistory.slice(-10).reduce((a, b) => a + b, 0) / Math.min(10, this.qualityHistory.length);
+    const oldAvg = this.qualityHistory.slice(0, Math.max(1, this.qualityHistory.length - 10)).reduce((a, b) => a + b, 0) / Math.max(1, this.qualityHistory.length - 10);
+    const improvementDelta = recentAvg - oldAvg;
+
+    this.totalLearnTime += performance.now() - startTime;
+    this.learnIterations++;
+
+    return Math.max(0, improvementDelta * 2); // Scale for research mode
+  }
+
+  /**
+   * Apply LoRA with rank-16 for maximum expressivity
+   */
+  async applyLoRA(
+    input: Float32Array,
+    weights?: LoRAWeights
+  ): Promise<Float32Array> {
+    if (!weights) {
+      return input;
+    }
+
+    const output = new Float32Array(input.length);
+    output.set(input);
+
+    const rank = this.config.loraRank; // 16 for research mode
+
+    // Apply to all modules with higher blending
+    for (const module of ['q_proj', 'v_proj', 'k_proj', 'o_proj']) {
+      const A = weights.A.get(module);
+      const B = weights.B.get(module);
+
+      if (A && B) {
+        const adapted = this.applyLoRATransform(input, A, B, rank);
+        const alpha = 0.3; // Higher blending for research
+        for (let i = 0; i < output.length; i++) {
+          output[i] = output[i] * (1 - alpha) + adapted[i] * alpha;
+        }
+      }
+    }
+
+    return output;
+  }
+
+  getStats(): Record<string, number> {
+    const avgQuality = this.qualityHistory.length > 0
+      ? this.qualityHistory.reduce((a, b) => a + b, 0) / this.qualityHistory.length
+      : 0;
+
+    const recentQuality = this.qualityHistory.slice(-10).reduce((a, b) => a + b, 0) / Math.min(10, this.qualityHistory.length) || 0;
+
+    return {
+      avgPatternMatchMs: this.totalPatternMatches > 0
+        ? this.totalPatternTime / this.totalPatternMatches
+        : 0,
+      avgLearnMs: this.learnIterations > 0
+        ? this.totalLearnTime / this.learnIterations
+        : 0,
+      avgQuality,
+      recentQuality,
+      qualityImprovement: recentQuality - avgQuality,
+      clusterCount: this.clusterCentroids.length,
+      checkpointCount: this.checkpoints.length,
+      adamStep: this.adamStep,
+      learnIterations: this.learnIterations,
+    };
+  }
+
+  /**
+   * Rebuild cluster centroids using k-means
+   */
+  private async rebuildClusters(patterns: Pattern[]): Promise<void> {
+    if (patterns.length === 0) return;
+
+    const k = Math.min(this.config.patternClusters, patterns.length);
+    const dim = patterns[0].embedding.length;
+
+    // Initialize centroids randomly
+    this.clusterCentroids = [];
+    const indices = new Set<number>();
+    while (indices.size < k) {
+      indices.add(Math.floor(Math.random() * patterns.length));
+    }
+    for (const idx of indices) {
+      this.clusterCentroids.push(new Float32Array(patterns[idx].embedding));
+    }
+
+    // Run k-means iterations
+    for (let iter = 0; iter < 10; iter++) {
+      // Assign patterns to clusters
+      const clusterAssignments: number[][] = Array.from({ length: k }, () => []);
+
+      for (let p = 0; p < patterns.length; p++) {
+        let bestCluster = 0;
+        let bestSim = -1;
+        for (let c = 0; c < k; c++) {
+          const sim = this.cosineSimilarity(patterns[p].embedding, this.clusterCentroids[c]);
+          if (sim > bestSim) {
+            bestSim = sim;
+            bestCluster = c;
+          }
+        }
+        clusterAssignments[bestCluster].push(p);
+        this.patternIndex.set(patterns[p].patternId, bestCluster);
+      }
+
+      // Update centroids
+      for (let c = 0; c < k; c++) {
+        if (clusterAssignments[c].length > 0) {
+          const newCentroid = new Float32Array(dim);
+          for (const p of clusterAssignments[c]) {
+            for (let d = 0; d < dim; d++) {
+              newCentroid[d] += patterns[p].embedding[d];
+            }
+          }
+          for (let d = 0; d < dim; d++) {
+            newCentroid[d] /= clusterAssignments[c].length;
+          }
+          this.clusterCentroids[c] = newCentroid;
+        }
+      }
+    }
+  }
+
+  /**
+   * Get nearest clusters to embedding
+   */
+  private getNearestClusters(embedding: Float32Array, n: number): number[] {
+    const similarities: Array<{ cluster: number; sim: number }> = [];
+    for (let c = 0; c < this.clusterCentroids.length; c++) {
+      similarities.push({ cluster: c, sim: this.cosineSimilarity(embedding, this.clusterCentroids[c]) });
+    }
+    similarities.sort((a, b) => b.sim - a.sim);
+    return similarities.slice(0, n).map(s => s.cluster);
+  }
+
+  /**
+   * Compute confidence for pattern match
+   */
+  private computeConfidence(pattern: Pattern, similarity: number): number {
+    // Combine similarity with pattern history
+    const historyWeight = Math.min(pattern.usageCount / 10, 1);
+    return similarity * (1 - historyWeight * 0.3) + pattern.successRate * historyWeight * 0.3;
+  }
+
+  /**
+   * Create learning checkpoint
+   */
+  private createCheckpoint(): void {
+    const state = new Map<string, Float32Array>();
+    for (const [key, value] of this.adamM) {
+      state.set(`m_${key}`, new Float32Array(value));
+    }
+    for (const [key, value] of this.adamV) {
+      state.set(`v_${key}`, new Float32Array(value));
+    }
+
+    this.checkpoints.push({ iteration: this.learnIterations, state });
+
+    // Keep only last 10 checkpoints
+    if (this.checkpoints.length > 10) {
+      this.checkpoints = this.checkpoints.slice(-10);
+    }
+  }
+
+  /**
+   * Process a mini-batch with Adam optimizer
+   */
+  private async processBatch(
+    batch: Trajectory[],
+    learningRate: number,
+    ewcState: EWCState,
+    ewcLambda: number
+  ): Promise<number> {
+    const beta1 = 0.9;
+    const beta2 = 0.999;
+    const epsilon = 1e-8;
+
+    this.adamStep++;
+
+    let totalLoss = 0;
+
+    for (const trajectory of batch) {
+      if (trajectory.steps.length === 0) continue;
+
+      // Compute gradient from trajectory
+      const gradient = this.computeTrajectoryGradient(trajectory);
+
+      for (const [key, grad] of gradient) {
+        // Get or initialize Adam state
+        let m = this.adamM.get(key);
+        let v = this.adamV.get(key);
+
+        if (!m) {
+          m = new Float32Array(grad.length);
+          this.adamM.set(key, m);
+        }
+        if (!v) {
+          v = new Float32Array(grad.length);
+          this.adamV.set(key, v);
+        }
+
+        // Update biased first moment estimate
+        for (let i = 0; i < grad.length; i++) {
+          m[i] = beta1 * m[i] + (1 - beta1) * grad[i];
+        }
+
+        // Update biased second moment estimate
+        for (let i = 0; i < grad.length; i++) {
+          v[i] = beta2 * v[i] + (1 - beta2) * grad[i] * grad[i];
+        }
+
+        // Bias correction
+        const mHat = new Float32Array(grad.length);
+        const vHat = new Float32Array(grad.length);
+        for (let i = 0; i < grad.length; i++) {
+          mHat[i] = m[i] / (1 - Math.pow(beta1, this.adamStep));
+          vHat[i] = v[i] / (1 - Math.pow(beta2, this.adamStep));
+        }
+
+        // Compute loss contribution
+        for (let i = 0; i < grad.length; i++) {
+          totalLoss += grad[i] * grad[i];
+        }
+      }
+    }
+
+    // Add EWC penalty
+    const ewcPenalty = this.computeEWCLoss(ewcState, ewcLambda);
+    totalLoss += ewcPenalty;
+
+    return totalLoss / batch.length;
+  }
+
+  /**
+   * Compute gradient from trajectory
+   */
+  private computeTrajectoryGradient(trajectory: Trajectory): Map<string, Float32Array> {
+    const gradient = new Map<string, Float32Array>();
+
+    if (trajectory.steps.length < 2) return gradient;
+
+    // Use advantage estimation
+    const rewards = trajectory.steps.map(s => s.reward);
+    const advantages = this.computeAdvantages(rewards);
+
+    for (let i = 0; i < trajectory.steps.length; i++) {
+      const step = trajectory.steps[i];
+      const advantage = advantages[i];
+
+      // Policy gradient: grad = advantage * grad_log_pi
+      const stateGrad = new Float32Array(step.stateAfter.length);
+      for (let j = 0; j < stateGrad.length; j++) {
+        stateGrad[j] = step.stateAfter[j] * advantage;
+      }
+
+      gradient.set(`step_${i}`, stateGrad);
+    }
+
+    return gradient;
+  }
+
+  /**
+   * Compute advantages using GAE
+   */
+  private computeAdvantages(rewards: number[]): number[] {
+    const gamma = 0.99;
+    const lambda = 0.95;
+
+    const advantages = new Array(rewards.length).fill(0);
+    let lastGae = 0;
+
+    for (let t = rewards.length - 1; t >= 0; t--) {
+      const nextValue = t < rewards.length - 1 ? rewards[t + 1] : 0;
+      const delta = rewards[t] + gamma * nextValue - rewards[t];
+      lastGae = delta + gamma * lambda * lastGae;
+      advantages[t] = lastGae;
+    }
+
+    // Normalize advantages
+    const mean = advantages.reduce((a, b) => a + b, 0) / advantages.length;
+    const std = Math.sqrt(advantages.reduce((a, b) => a + (b - mean) ** 2, 0) / advantages.length) + 1e-8;
+
+    return advantages.map(a => (a - mean) / std);
+  }
+
+  /**
+   * Compute EWC loss for continual learning
+   */
+  private computeEWCLoss(ewcState: EWCState, lambda: number): number {
+    let loss = 0;
+
+    for (const [key, fisher] of ewcState.fisher) {
+      const means = ewcState.means.get(key);
+      const current = this.adamM.get(key);
+
+      if (means && current) {
+        for (let i = 0; i < Math.min(fisher.length, means.length, current.length); i++) {
+          const diff = current[i] - means[i];
+          loss += fisher[i] * diff * diff;
+        }
+      }
+    }
+
+    return lambda * loss * 0.5;
+  }
+}

package/src/pattern-learner.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Pattern Learner
+ *
+ * Implements pattern extraction, matching, and evolution for
+ * continuous learning from agent experiences.
+ *
+ * Performance Targets:
+ * - Pattern matching: <1ms
+ * - Pattern extraction: <5ms
+ * - Evolution step: <2ms
+ */
+import type { Pattern, PatternMatch, Trajectory, DistilledMemory, NeuralEventListener } from './types.js';
+/**
+ * Configuration for Pattern Learner
+ */
+export interface PatternLearnerConfig {
+    /** Maximum number of patterns to store */
+    maxPatterns: number;
+    /** Similarity threshold for matching */
+    matchThreshold: number;
+    /** Minimum usages before pattern is stable */
+    minUsagesForStable: number;
+    /** Quality threshold for pattern inclusion */
+    qualityThreshold: number;
+    /** Enable pattern clustering */
+    enableClustering: boolean;
+    /** Number of clusters (if clustering enabled) */
+    numClusters: number;
+    /** Evolution learning rate */
+    evolutionLearningRate: number;
+}
+/**
+ * Pattern Learner - Manages pattern extraction, matching, and evolution
+ */
+export declare class PatternLearner {
+    private config;
+    private patterns;
+    private clusters;
+    private patternToCluster;
+    private matchCount;
+    private totalMatchTime;
+    private extractionCount;
+    private totalExtractionTime;
+    private evolutionCount;
+    private totalEvolutionTime;
+    private eventListeners;
+    constructor(config?: Partial<PatternLearnerConfig>);
+    /**
+     * Find matching patterns for a query embedding
+     * Target: <1ms
+     */
+    findMatches(queryEmbedding: Float32Array, k?: number): PatternMatch[];
+    /**
+     * Find best single match
+     */
+    findBestMatch(queryEmbedding: Float32Array): PatternMatch | null;
+    /**
+     * Extract a pattern from a trajectory
+     * Target: <5ms
+     */
+    extractPattern(trajectory: Trajectory, memory?: DistilledMemory): Pattern | null;
+    /**
+     * Extract patterns from multiple trajectories in batch
+     */
+    extractPatternsBatch(trajectories: Trajectory[]): Pattern[];
+    /**
+     * Evolve a pattern based on new experience
+     * Target: <2ms
+     */
+    evolvePattern(patternId: string, quality: number, context?: string): void;
+    /**
+     * Merge two similar patterns
+     */
+    mergePatterns(patternId1: string, patternId2: string): Pattern | null;
+    /**
+     * Split a pattern into more specific sub-patterns
+     */
+    splitPattern(patternId: string, numSplits?: number): Pattern[];
+    /**
+     * Get all patterns
+     */
+    getPatterns(): Pattern[];
+    /**
+     * Get pattern by ID
+     */
+    getPattern(patternId: string): Pattern | undefined;
+    /**
+     * Get patterns by domain
+     */
+    getPatternsByDomain(domain: string): Pattern[];
+    /**
+     * Get stable patterns (sufficient usage)
+     */
+    getStablePatterns(): Pattern[];
+    getStats(): Record<string, number>;
+    addEventListener(listener: NeuralEventListener): void;
+    removeEventListener(listener: NeuralEventListener): void;
+    private emitEvent;
+    private cosineSimilarity;
+    private computeMatchConfidence;
+    private getCandidatesFromClusters;
+    private findSimilarPattern;
+    private updatePatternFromTrajectory;
+    private computePatternEmbedding;
+    private generatePatternName;
+    private extractStrategy;
+    private assignToCluster;
+    private updateClusterCentroid;
+    private rebuildClusters;
+    private prunePatterns;
+    private determineEvolutionType;
+}
+/**
+ * Factory function for creating PatternLearner
+ */
+export declare function createPatternLearner(config?: Partial<PatternLearnerConfig>): PatternLearner;
+//# sourceMappingURL=pattern-learner.d.ts.map

package/src/pattern-learner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-learner.d.ts","sourceRoot":"","sources":["pattern-learner.ts"],"names":[],"mappings":"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"}