@ruvector/edge-net 0.5.0 → 0.5.3

package/onnx-worker.js

@@ -22,52 +22,173 @@ let loadedGenModel = null;
 
 /**
  * Available embedding models (smallest first)
+ * Optimized for edge computing with size/quality tradeoffs
  */
 export const EMBEDDING_MODELS = {
+    // Tier 1: Ultra-fast (~20-30MB)
     'minilm-l6': {
         id: 'Xenova/all-MiniLM-L6-v2',
         dimensions: 384,
         size: '~22MB',
         description: 'Fast, good quality embeddings',
+        tier: 1,
     },
+    'e5-small': {
+        id: 'Xenova/e5-small-v2',
+        dimensions: 384,
+        size: '~28MB',
+        description: 'Microsoft E5 - excellent retrieval',
+        tier: 1,
+    },
+    // Tier 2: Balanced (~30-70MB)
     'minilm-l12': {
         id: 'Xenova/all-MiniLM-L12-v2',
         dimensions: 384,
         size: '~33MB',
         description: 'Better quality, slightly slower',
+        tier: 2,
+    },
+    'bge-small': {
+        id: 'Xenova/bge-small-en-v1.5',
+        dimensions: 384,
+        size: '~33MB',
+        description: 'Best for retrieval tasks',
+        tier: 2,
     },
     'gte-small': {
         id: 'Xenova/gte-small',
         dimensions: 384,
         size: '~67MB',
         description: 'High quality embeddings',
+        tier: 2,
     },
-    'bge-small': {
-        id: 'Xenova/bge-small-en-v1.5',
+    // Tier 3: High quality (~100MB+)
+    'gte-base': {
+        id: 'Xenova/gte-base',
+        dimensions: 768,
+        size: '~100MB',
+        description: 'Higher quality, 768d',
+        tier: 3,
+    },
+    'bge-base': {
+        id: 'Xenova/bge-base-en-v1.5',
+        dimensions: 768,
+        size: '~108MB',
+        description: 'High quality BAAI retrieval',
+        tier: 3,
+    },
+    // Specialized: Multilingual
+    'multilingual-e5': {
+        id: 'Xenova/multilingual-e5-small',
         dimensions: 384,
-        size: '~33MB',
-        description: 'Best for retrieval tasks',
+        size: '~118MB',
+        description: '100+ languages support',
+        tier: 3,
     },
 };
 
 /**
  * Available text generation models
+ * Organized by size and capability for edge deployment
  */
 export const GENERATION_MODELS = {
+    // Tier 1: Ultra-small (< 100MB) - Fast inference
+    'tinystories': {
+        id: 'Xenova/TinyStories-33M',
+        size: '~65MB',
+        description: 'Ultra-small for stories',
+        tier: 1,
+        capabilities: ['stories', 'creative'],
+    },
     'distilgpt2': {
         id: 'Xenova/distilgpt2',
         size: '~82MB',
         description: 'Fast text generation',
+        tier: 1,
+        capabilities: ['general', 'completion'],
     },
+    // Tier 2: Small (100-300MB) - Good quality
     'gpt2': {
         id: 'Xenova/gpt2',
         size: '~250MB',
         description: 'Classic GPT-2',
+        tier: 2,
+        capabilities: ['general', 'completion', 'creative'],
     },
-    'tinystories': {
-        id: 'Xenova/TinyStories-33M',
-        size: '~65MB',
-        description: 'Ultra-small for stories',
+    'phi-1.5': {
+        id: 'Xenova/phi-1_5',
+        size: '~280MB',
+        description: 'Microsoft Phi-1.5 - code & reasoning',
+        tier: 2,
+        capabilities: ['code', 'reasoning', 'math'],
+    },
+    'phi-2': {
+        id: 'Xenova/phi-2',
+        size: '~550MB',
+        description: 'Microsoft Phi-2 - advanced reasoning',
+        tier: 3,
+        capabilities: ['code', 'reasoning', 'math', 'general'],
+    },
+    // Tier 3: Medium (300MB-1GB) - High quality
+    'qwen-0.5b': {
+        id: 'Xenova/Qwen1.5-0.5B',
+        size: '~430MB',
+        description: 'Qwen 0.5B - multilingual small model',
+        tier: 3,
+        capabilities: ['multilingual', 'general', 'code'],
+    },
+    'gemma-2b': {
+        id: 'Xenova/gemma-2b-it',
+        size: '~1.1GB',
+        description: 'Google Gemma 2B instruction-tuned',
+        tier: 4,
+        capabilities: ['instruction', 'general', 'code', 'reasoning'],
+    },
+    // Code-specialized models
+    'codegen-350m': {
+        id: 'Xenova/codegen-350M-mono',
+        size: '~320MB',
+        description: 'Salesforce CodeGen - Python specialist',
+        tier: 2,
+        capabilities: ['code', 'python'],
+    },
+    'starcoder-tiny': {
+        id: 'Xenova/tiny_starcoder_py',
+        size: '~40MB',
+        description: 'Ultra-small Python code model',
+        tier: 1,
+        capabilities: ['code', 'python'],
+    },
+};
+
+/**
+ * Recommended models by use case
+ */
+export const MODEL_RECOMMENDATIONS = {
+    'edge-minimal': {
+        embedding: 'minilm-l6',
+        generation: 'distilgpt2',
+        description: 'Minimal footprint for constrained devices',
+    },
+    'edge-balanced': {
+        embedding: 'e5-small',
+        generation: 'phi-1.5',
+        description: 'Best quality/size ratio for edge',
+    },
+    'edge-code': {
+        embedding: 'bge-small',
+        generation: 'starcoder-tiny',
+        description: 'Optimized for code tasks',
+    },
+    'edge-full': {
+        embedding: 'gte-base',
+        generation: 'phi-2',
+        description: 'Maximum quality on edge',
+    },
+    'cloud-optimal': {
+        embedding: 'bge-base',
+        generation: 'gemma-2b',
+        description: 'Best quality for cloud deployment',
     },
 };
 
@@ -475,6 +596,339 @@ export class OnnxWorkerPool extends EventEmitter {
     }
 }
 
+// ============================================
+// ONLINE LEARNING FROM CORRECTIONS
+// ============================================
+
+/**
+ * OnlineLearner - Learns from user corrections in real-time
+ *
+ * Uses RAG + few-shot learning to improve model outputs
+ * without actual weight updates (inference-time adaptation)
+ */
+export class OnlineLearner {
+    constructor(options = {}) {
+        this.corrections = [];
+        this.maxCorrections = options.maxCorrections || 100;
+        this.patterns = new Map(); // Pattern -> correction mapping
+        this.stats = {
+            totalCorrections: 0,
+            successfulApplications: 0,
+            avgSimilarityThreshold: 0.65,
+        };
+    }
+
+    /**
+     * Record a correction for learning
+     * @param {string} input - Original input
+     * @param {string} wrongOutput - Incorrect model output
+     * @param {string} correctOutput - User-provided correction
+     * @param {object} metadata - Optional metadata (task type, domain, etc.)
+     */
+    async recordCorrection(input, wrongOutput, correctOutput, metadata = {}) {
+        // Generate embedding for the input pattern
+        const result = await embed(input);
+        const embedding = result.embeddings?.[0]?.embedding || null;
+
+        const correction = {
+            input,
+            wrongOutput,
+            correctOutput,
+            embedding,
+            metadata,
+            timestamp: Date.now(),
+            useCount: 0,
+        };
+
+        // Store in corrections list
+        this.corrections.push(correction);
+        this.stats.totalCorrections++;
+
+        // Evict oldest if over capacity
+        if (this.corrections.length > this.maxCorrections) {
+            // Remove least used correction
+            this.corrections.sort((a, b) => b.useCount - a.useCount);
+            this.corrections = this.corrections.slice(0, this.maxCorrections);
+        }
+
+        // Extract and store pattern
+        const pattern = this.extractPattern(input, wrongOutput, correctOutput);
+        if (pattern) {
+            this.patterns.set(pattern.key, pattern);
+        }
+
+        return correction;
+    }
+
+    /**
+     * Extract reusable pattern from correction
+     */
+    extractPattern(input, wrongOutput, correctOutput) {
+        // Simple pattern extraction - can be enhanced
+        const inputTokens = input.toLowerCase().split(/\s+/);
+        const wrongTokens = wrongOutput.toLowerCase().split(/\s+/);
+        const correctTokens = correctOutput.toLowerCase().split(/\s+/);
+
+        // Find common elements that indicate the pattern
+        if (inputTokens.length > 0 && wrongTokens.length > 0) {
+            const key = inputTokens.slice(0, 3).join('_');
+            return {
+                key,
+                inputPattern: inputTokens.slice(0, 5).join(' '),
+                wrongPattern: wrongTokens.slice(0, 5).join(' '),
+                correctPattern: correctTokens.slice(0, 5).join(' '),
+                fullCorrection: correctOutput,
+            };
+        }
+        return null;
+    }
+
+    /**
+     * Find relevant corrections for a new input (RAG-style)
+     * @param {string} input - New input to find corrections for
+     * @param {number} topK - Number of corrections to return
+     */
+    async findRelevantCorrections(input, topK = 3) {
+        if (this.corrections.length === 0) return [];
+
+        // Embed the input
+        const result = await embed(input);
+        const queryEmb = result.embeddings?.[0]?.embedding;
+        if (!queryEmb) return [];
+
+        // Score all corrections by similarity
+        const scored = this.corrections
+            .filter(c => c.embedding)
+            .map(c => {
+                const sim = this.cosineSimilarity(queryEmb, c.embedding);
+                return { correction: c, similarity: sim };
+            })
+            .filter(s => s.similarity > this.stats.avgSimilarityThreshold)
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, topK);
+
+        // Update use counts
+        for (const s of scored) {
+            s.correction.useCount++;
+        }
+
+        return scored;
+    }
+
+    /**
+     * Generate few-shot examples from corrections
+     * @param {string} input - Current input
+     */
+    async generateFewShotExamples(input) {
+        const relevant = await this.findRelevantCorrections(input, 3);
+        if (relevant.length === 0) return '';
+
+        let examples = '\n\n# Previous corrections (apply similar fixes):\n';
+        for (const { correction, similarity } of relevant) {
+            examples += `\nInput: ${correction.input.slice(0, 100)}`;
+            examples += `\nWrong: ${correction.wrongOutput.slice(0, 100)}`;
+            examples += `\nCorrect: ${correction.correctOutput.slice(0, 100)}`;
+            examples += `\nSimilarity: ${(similarity * 100).toFixed(1)}%\n`;
+        }
+        return examples;
+    }
+
+    /**
+     * Apply learned corrections to generation
+     * @param {string} prompt - Original prompt
+     * @param {object} options - Generation options
+     */
+    async generateWithLearning(prompt, options = {}) {
+        // Find relevant corrections
+        const fewShot = await this.generateFewShotExamples(prompt);
+
+        // Inject few-shot examples into prompt
+        const enhancedPrompt = fewShot ? `${fewShot}\n\nNow handle this:\n${prompt}` : prompt;
+
+        // Generate with enhanced prompt
+        const result = await generate(enhancedPrompt, {
+            ...options,
+            maxTokens: options.maxTokens || 128,
+        });
+
+        if (fewShot) {
+            this.stats.successfulApplications++;
+        }
+
+        return result;
+    }
+
+    cosineSimilarity(a, b) {
+        let dot = 0, normA = 0, normB = 0;
+        for (let i = 0; i < a.length && i < b.length; i++) {
+            dot += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(normA) * Math.sqrt(normB) + 1e-8);
+    }
+
+    getStats() {
+        return {
+            ...this.stats,
+            storedCorrections: this.corrections.length,
+            extractedPatterns: this.patterns.size,
+        };
+    }
+
+    export() {
+        return {
+            corrections: this.corrections,
+            patterns: Array.from(this.patterns.entries()),
+            stats: this.stats,
+        };
+    }
+
+    import(data) {
+        if (data.corrections) this.corrections = data.corrections;
+        if (data.patterns) this.patterns = new Map(data.patterns);
+        if (data.stats) this.stats = { ...this.stats, ...data.stats };
+    }
+}
+
+// ============================================
+// ADAPTER INJECTION LAYER
+// ============================================
+
+/**
+ * AdapterInjector - Applies lightweight adapters to ONNX model outputs
+ *
+ * Since we can't modify ONNX weights at runtime, this applies post-hoc
+ * transformations to model outputs using learned patterns
+ */
+export class AdapterInjector {
+    constructor(options = {}) {
+        this.rank = options.rank || 8;
+        this.dimension = options.dimension || 384;
+        this.scale = options.scale || 0.1;
+
+        // LoRA-style adapters (applied to embeddings)
+        this.adapterA = this.initMatrix(this.dimension, this.rank);
+        this.adapterB = this.initMatrix(this.rank, this.dimension, 0.01);
+
+        // Domain-specific bias terms
+        this.domainBiases = new Map();
+
+        this.stats = {
+            adaptations: 0,
+            domains: 0,
+        };
+    }
+
+    initMatrix(rows, cols, scale = 1) {
+        const matrix = [];
+        const std = Math.sqrt(2 / (rows + cols)) * scale;
+        for (let i = 0; i < rows; i++) {
+            const row = [];
+            for (let j = 0; j < cols; j++) {
+                row.push((Math.random() - 0.5) * 2 * std);
+            }
+            matrix.push(row);
+        }
+        return matrix;
+    }
+
+    /**
+     * Apply adapter transformation to embedding
+     * output = input + scale * (input @ A @ B)
+     */
+    adapt(embedding, domain = null) {
+        const adapted = [...embedding];
+
+        // Apply LoRA-style transformation
+        // Step 1: input @ A (dim -> rank)
+        const hidden = new Array(this.rank).fill(0);
+        for (let r = 0; r < this.rank; r++) {
+            for (let d = 0; d < Math.min(embedding.length, this.dimension); d++) {
+                hidden[r] += embedding[d] * this.adapterA[d][r];
+            }
+        }
+
+        // Step 2: hidden @ B (rank -> dim)
+        for (let d = 0; d < Math.min(adapted.length, this.dimension); d++) {
+            let delta = 0;
+            for (let r = 0; r < this.rank; r++) {
+                delta += hidden[r] * this.adapterB[r][d];
+            }
+            adapted[d] += this.scale * delta;
+        }
+
+        // Apply domain-specific bias if available
+        if (domain && this.domainBiases.has(domain)) {
+            const bias = this.domainBiases.get(domain);
+            for (let i = 0; i < adapted.length && i < bias.length; i++) {
+                adapted[i] += bias[i];
+            }
+        }
+
+        this.stats.adaptations++;
+        return adapted;
+    }
+
+    /**
+     * Learn from positive/negative example pairs
+     */
+    learn(anchor, positive, negatives = [], learningRate = 0.01) {
+        // Simple gradient descent on adapter weights
+        // Pull anchor closer to positive, push away from negatives
+
+        const anchorAdapted = this.adapt(anchor);
+
+        // Gradient from positive pair (pull closer)
+        if (positive) {
+            for (let d = 0; d < this.dimension && d < anchor.length; d++) {
+                for (let r = 0; r < this.rank; r++) {
+                    const grad = anchor[d] * (positive[r % positive.length] - anchorAdapted[r % anchorAdapted.length]);
+                    this.adapterA[d][r] += learningRate * grad * this.scale;
+                }
+            }
+        }
+
+        return this.stats.adaptations;
+    }
+
+    /**
+     * Register a domain-specific bias
+     */
+    registerDomain(domain, examples) {
+        if (!examples || examples.length === 0) return;
+
+        // Compute mean of examples as domain bias
+        const bias = new Array(this.dimension).fill(0);
+        for (const emb of examples) {
+            for (let i = 0; i < this.dimension && i < emb.length; i++) {
+                bias[i] += emb[i] / examples.length;
+            }
+        }
+
+        this.domainBiases.set(domain, bias);
+        this.stats.domains = this.domainBiases.size;
+    }
+
+    export() {
+        return {
+            adapterA: this.adapterA,
+            adapterB: this.adapterB,
+            domainBiases: Array.from(this.domainBiases.entries()),
+            stats: this.stats,
+        };
+    }
+
+    import(data) {
+        if (data.adapterA) this.adapterA = data.adapterA;
+        if (data.adapterB) this.adapterB = data.adapterB;
+        if (data.domainBiases) {
+            this.domainBiases = new Map(data.domainBiases);
+        }
+        if (data.stats) this.stats = data.stats;
+    }
+}
+
 // ============================================
 // EXPORTS
 // ============================================

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruvector/edge-net",
-  "version": "0.5.0",
+  "version": "0.5.3",
   "type": "module",
   "description": "Distributed compute intelligence network with WASM cryptographic security - contribute browser compute, spawn distributed AI agents, earn credits. Features Ed25519 signing, PiKey identity, Time Crystal coordination, Neural DAG attention, P2P swarm intelligence, ONNX inference, WebRTC signaling, CRDT ledger, and multi-agent workflows.",
   "main": "ruvector_edge_net.js",
@@ -12,7 +12,8 @@
     "edge-net-join": "./join.js",
     "edge-net-genesis": "./genesis.js",
     "edge-net-firebase-setup": "./firebase-setup.js",
-    "edge-net-plugins": "./plugins/cli.js"
+    "edge-net-plugins": "./plugins/cli.js",
+    "edge-net-models": "./models/models-cli.js"
   },
   "keywords": [
     "wasm",
@@ -80,6 +81,7 @@
     "node/",
     "deploy/",
     "tests/",
+    "models/",
     "index.js",
     "cli.js",
     "join.js",
@@ -107,6 +109,8 @@
     "credits.js",
     "task-execution-handler.js",
     "plugins/",
+    "network-genesis.js",
+    "core-invariants.js",
     "README.md",
     "LICENSE"
   ],
@@ -189,6 +193,24 @@
     },
     "./plugins/catalog": {
       "import": "./plugins/plugin-manifest.js"
+    },
+    "./genesis": {
+      "import": "./network-genesis.js"
+    },
+    "./models": {
+      "import": "./models/model-utils.js"
+    },
+    "./models/cli": {
+      "import": "./models/models-cli.js"
+    },
+    "./models/registry": {
+      "import": "./models/registry.json"
+    },
+    "./models/optimizer": {
+      "import": "./models/model-optimizer.js"
+    },
+    "./models/benchmark": {
+      "import": "./models/benchmark.js"
     }
   },
   "sideEffects": [
@@ -218,11 +240,19 @@
     "p2p": "node -e \"import('./p2p.js').then(m => m.createP2PNetwork({ nodeId: 'test' }))\"",
     "monitor": "node -e \"import('./monitor.js').then(m => { const mon = new m.Monitor(); mon.start(); setInterval(() => console.log(JSON.stringify(mon.generateReport(), null, 2)), 5000); })\"",
     "firebase:setup": "node firebase-setup.js",
-    "firebase:check": "node firebase-setup.js --check"
+    "firebase:check": "node firebase-setup.js --check",
+    "models:list": "node models/models-cli.js list",
+    "models:download": "node models/models-cli.js download",
+    "models:optimize": "node models/models-cli.js optimize",
+    "models:benchmark": "node models/models-cli.js benchmark",
+    "models:upload": "node models/models-cli.js upload",
+    "models:train": "node models/models-cli.js train",
+    "models:cache": "node models/models-cli.js cache"
   },
   "dependencies": {
     "@ruvector/ruvllm": "^0.2.3",
     "@xenova/transformers": "^2.17.2",
+    "commander": "^12.1.0",
     "firebase": "^10.14.1",
     "wrtc": "^0.4.7",
     "ws": "^8.18.3"