agentdb 1.0.0

package/dist/plugins/implementations/neural-architecture-search.mjs

@@ -0,0 +1,374 @@
+/**
+ * Neural Architecture Search (NAS) Plugin
+ *
+ * Implements automated neural architecture optimization using
+ * evolutionary algorithms and reinforcement learning.
+ *
+ * Key features:
+ * - Architecture encoding and mutation
+ * - Population-based search
+ * - Performance prediction
+ * - Efficient architecture evaluation
+ * - Transfer learning from meta-architectures
+ */
+import { BasePlugin } from '../base-plugin.mjs';
+/**
+ * Neural Architecture Search Plugin Implementation
+ */
+export class NeuralArchitectureSearchPlugin extends BasePlugin {
+    constructor(config) {
+        super();
+        this.name = 'neural-architecture-search';
+        this.version = '1.0.0';
+        this.experiences = [];
+        this.strategy = 'evolutionary';
+        this.population = [];
+        this.populationSize = 20;
+        this.eliteSize = 5;
+        this.mutationRate = 0.2;
+        this.crossoverRate = 0.7;
+        // Search space constraints
+        this.maxLayers = 10;
+        this.maxNodesPerLayer = 512;
+        this.layerTypes = ['dense', 'conv', 'dropout', 'batchnorm'];
+        // Performance tracking
+        this.bestArchitecture = null;
+        this.generation = 0;
+        this.evaluationHistory = new Map();
+        if (config) {
+            this.strategy = config.strategy || 'evolutionary';
+            this.populationSize = config.populationSize || 20;
+            this.mutationRate = config.mutationRate || 0.2;
+            this.maxLayers = config.maxLayers || 10;
+        }
+        this.initializePopulation();
+        // Mark as initialized for in-memory operation
+        this.initialized = true;
+    }
+    /**
+     * Override to skip initialization check for in-memory operation
+     */
+    checkInitialized() {
+        // No-op for NAS - operates in-memory
+    }
+    /**
+     * Override to store experiences in-memory without vectorDB
+     */
+    /**
+     * Override selectAction to provide base implementation
+     */
+    async selectAction(state, context) {
+        // Simple default action selection
+        const stateArray = Array.isArray(state) ? state : [state];
+        const stateSum = stateArray.reduce((a, b) => a + b, 0);
+        const value = Math.tanh(stateSum / stateArray.length);
+        return {
+            id: String(Math.floor(Math.abs(value) * 10)),
+            embedding: stateArray,
+            confidence: Math.abs(value),
+        };
+    }
+    async storeExperience(experience) {
+        this.experiences.push(experience);
+    }
+    /**
+     * Override to retrieve from local experiences
+     */
+    async retrieveSimilar(state, k) {
+        return this.experiences.slice(0, k).map((exp, idx) => ({
+            id: exp.id || `exp-${idx}`,
+            embedding: exp.state,
+            metadata: exp,
+            score: 1.0 - (idx * 0.1),
+        }));
+    }
+    /**
+     * Initialize random population
+     */
+    initializePopulation() {
+        for (let i = 0; i < this.populationSize; i++) {
+            this.population.push(this.generateRandomArchitecture());
+        }
+    }
+    /**
+     * Generate random architecture
+     */
+    generateRandomArchitecture() {
+        // Ensure numLayers is between 2 and maxLayers (inclusive)
+        const numLayers = 2 + Math.floor(Math.random() * (this.maxLayers - 1));
+        const layers = [];
+        for (let i = 0; i < numLayers; i++) {
+            layers.push(this.generateRandomLayer());
+        }
+        return {
+            id: this.generateArchitectureId(layers),
+            layers,
+            fitness: 0,
+            complexity: this.calculateComplexity(layers),
+            generation: this.generation,
+        };
+    }
+    /**
+     * Generate random layer
+     */
+    generateRandomLayer() {
+        const type = this.layerTypes[Math.floor(Math.random() * this.layerTypes.length)];
+        const spec = { type };
+        switch (type) {
+            case 'dense':
+                spec.size = Math.pow(2, Math.floor(Math.random() * 6) + 5); // 32 to 512
+                spec.activation = ['relu', 'tanh', 'sigmoid', 'leaky_relu'][Math.floor(Math.random() * 4)];
+                break;
+            case 'conv':
+                spec.size = Math.pow(2, Math.floor(Math.random() * 5) + 4); // 16 to 256
+                spec.kernelSize = [3, 5, 7][Math.floor(Math.random() * 3)];
+                spec.activation = 'relu';
+                break;
+            case 'dropout':
+                spec.dropout = 0.1 + Math.random() * 0.4; // 0.1 to 0.5
+                break;
+            case 'batchnorm':
+                // No additional params
+                break;
+        }
+        return spec;
+    }
+    /**
+     * Generate unique ID for architecture
+     */
+    generateArchitectureId(layers) {
+        const signature = layers.map(l => `${l.type}-${l.size || 0}-${l.activation || 'none'}`).join('|');
+        return Buffer.from(signature).toString('base64').substring(0, 16);
+    }
+    /**
+     * Calculate architecture complexity
+     */
+    calculateComplexity(layers) {
+        let params = 0;
+        for (let i = 0; i < layers.length - 1; i++) {
+            const current = layers[i];
+            const next = layers[i + 1];
+            if (current.type === 'dense' && next.type === 'dense') {
+                params += (current.size || 128) * (next.size || 128);
+            }
+            else if (current.type === 'conv') {
+                const kernelSize = current.kernelSize || 3;
+                params += kernelSize * kernelSize * (current.size || 64);
+            }
+        }
+        // Ensure minimum complexity: count layer sizes or base complexity per layer
+        if (params === 0 && layers.length > 0) {
+            const totalSize = layers.reduce((sum, layer) => sum + (layer.size || 0), 0);
+            // If no sized layers, use layer count as base complexity
+            params = totalSize > 0 ? totalSize : layers.length * 10;
+        }
+        return params;
+    }
+    /**
+     * Evaluate architecture fitness
+     */
+    async evaluateArchitecture(arch) {
+        // Check cache
+        if (this.evaluationHistory.has(arch.id)) {
+            return this.evaluationHistory.get(arch.id);
+        }
+        // Simplified fitness: combination of performance and complexity
+        const performanceScore = await this.estimatePerformance(arch);
+        const complexityPenalty = Math.log(arch.complexity + 1) / 20;
+        const fitness = performanceScore - complexityPenalty;
+        this.evaluationHistory.set(arch.id, fitness);
+        return fitness;
+    }
+    /**
+     * Estimate architecture performance (simplified)
+     */
+    async estimatePerformance(arch) {
+        // In real NAS: would train architecture and evaluate
+        // Here: simplified heuristic
+        let score = 0.5;
+        // Favor architectures with reasonable depth
+        const optimalDepth = 5;
+        const depthScore = 1 - Math.abs(arch.layers.length - optimalDepth) / optimalDepth;
+        score += depthScore * 0.2;
+        // Favor architectures with batch norm
+        const hasBatchNorm = arch.layers.some(l => l.type === 'batchnorm');
+        if (hasBatchNorm)
+            score += 0.1;
+        // Favor ReLU activations
+        const reluLayers = arch.layers.filter(l => l.activation === 'relu').length;
+        score += (reluLayers / arch.layers.length) * 0.1;
+        // Favor dropout for regularization
+        const hasDropout = arch.layers.some(l => l.type === 'dropout');
+        if (hasDropout)
+            score += 0.1;
+        // Add randomness to simulate training variance
+        score += (Math.random() - 0.5) * 0.1;
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Mutate architecture
+     */
+    mutate(arch) {
+        const layers = [...arch.layers];
+        const mutationType = Math.random();
+        if (mutationType < 0.33 && layers.length < this.maxLayers) {
+            // Add layer
+            const position = Math.floor(Math.random() * layers.length);
+            layers.splice(position, 0, this.generateRandomLayer());
+        }
+        else if (mutationType < 0.66 && layers.length > 2) {
+            // Remove layer
+            const position = Math.floor(Math.random() * layers.length);
+            layers.splice(position, 1);
+        }
+        else {
+            // Modify layer
+            const position = Math.floor(Math.random() * layers.length);
+            layers[position] = this.generateRandomLayer();
+        }
+        return {
+            id: this.generateArchitectureId(layers),
+            layers,
+            fitness: 0,
+            complexity: this.calculateComplexity(layers),
+            generation: this.generation + 1,
+        };
+    }
+    /**
+     * Crossover two architectures
+     */
+    crossover(parent1, parent2) {
+        const point = Math.floor(Math.random() * Math.min(parent1.layers.length, parent2.layers.length));
+        const layers = [
+            ...parent1.layers.slice(0, point),
+            ...parent2.layers.slice(point),
+        ];
+        return {
+            id: this.generateArchitectureId(layers),
+            layers,
+            fitness: 0,
+            complexity: this.calculateComplexity(layers),
+            generation: this.generation + 1,
+        };
+    }
+    /**
+     * Select parent using tournament selection
+     */
+    selectParent() {
+        const tournamentSize = 3;
+        const tournament = [];
+        for (let i = 0; i < tournamentSize; i++) {
+            const idx = Math.floor(Math.random() * this.population.length);
+            tournament.push(this.population[idx]);
+        }
+        tournament.sort((a, b) => b.fitness - a.fitness);
+        return tournament[0];
+    }
+    /**
+     * Evolve population for one generation
+     */
+    async evolveGeneration() {
+        // Evaluate all architectures
+        for (const arch of this.population) {
+            arch.fitness = await this.evaluateArchitecture(arch);
+        }
+        // Sort by fitness
+        this.population.sort((a, b) => b.fitness - a.fitness);
+        // Update best
+        if (!this.bestArchitecture || this.population[0].fitness > this.bestArchitecture.fitness) {
+            this.bestArchitecture = { ...this.population[0] };
+        }
+        // Create next generation
+        const nextGeneration = [];
+        // Elitism: keep best architectures
+        const eliteCount = Math.min(this.eliteSize, this.population.length);
+        for (let i = 0; i < eliteCount; i++) {
+            nextGeneration.push({ ...this.population[i] });
+        }
+        // Generate offspring
+        while (nextGeneration.length < this.populationSize) {
+            if (Math.random() < this.crossoverRate) {
+                // Crossover
+                const parent1 = this.selectParent();
+                const parent2 = this.selectParent();
+                let offspring = this.crossover(parent1, parent2);
+                if (Math.random() < this.mutationRate) {
+                    offspring = this.mutate(offspring);
+                }
+                nextGeneration.push(offspring);
+            }
+            else {
+                // Mutation only
+                const parent = this.selectParent();
+                nextGeneration.push(this.mutate(parent));
+            }
+        }
+        this.population = nextGeneration;
+        this.generation++;
+    }
+    /**
+     * Train using NAS
+     */
+    async train(options) {
+        const startTime = Date.now();
+        const generations = options?.epochs !== undefined ? options.epochs : 20;
+        for (let gen = 0; gen < generations; gen++) {
+            await this.evolveGeneration();
+        }
+        const duration = Date.now() - startTime;
+        return {
+            loss: this.bestArchitecture ? 1 - this.bestArchitecture.fitness : 1,
+            experiencesProcessed: this.evaluationHistory.size,
+            duration,
+            generation: this.generation,
+            bestFitness: this.bestArchitecture?.fitness || 0,
+            bestComplexity: this.bestArchitecture?.complexity || 0,
+            populationDiversity: this.calculatePopulationDiversity(),
+        };
+    }
+    /**
+     * Calculate population diversity
+     */
+    calculatePopulationDiversity() {
+        const uniqueIds = new Set(this.population.map((a) => a.id));
+        return uniqueIds.size / this.population.length;
+    }
+    /**
+     * Get best architecture
+     */
+    getBestArchitecture() {
+        return this.bestArchitecture;
+    }
+    /**
+     * Export architecture as JSON
+     */
+    exportArchitecture(arch) {
+        return JSON.stringify({
+            id: arch.id,
+            layers: arch.layers,
+            fitness: arch.fitness,
+            complexity: arch.complexity,
+            generation: arch.generation,
+        }, null, 2);
+    }
+    /**
+     * Import architecture from JSON
+     */
+    importArchitecture(json) {
+        return JSON.parse(json);
+    }
+    /**
+     * Get search statistics
+     */
+    getSearchStats() {
+        const avgComplexity = this.population.reduce((sum, a) => sum + a.complexity, 0)
+            / this.population.length;
+        return {
+            generation: this.generation,
+            evaluations: this.evaluationHistory.size,
+            bestFitness: this.bestArchitecture?.fitness || 0,
+            populationDiversity: this.calculatePopulationDiversity(),
+            avgComplexity,
+        };
+    }
+}

package/dist/plugins/implementations/q-learning.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Q-Learning Plugin
+ *
+ * Implements the Q-Learning algorithm with experience replay.
+ * Q-Learning is a model-free, off-policy RL algorithm that learns
+ * the optimal action-value function (Q-function).
+ *
+ * Key features:
+ * - Epsilon-greedy exploration
+ * - Experience replay buffer
+ * - Optional prioritized experience replay
+ * - Temporal difference learning
+ */
+import { BasePlugin } from '../base-plugin';
+import { Action, Context, Experience, TrainOptions, TrainingMetrics } from '../learning-plugin.interface';
+/**
+ * Q-Learning Plugin Implementation
+ */
+export declare class QLearningPlugin extends BasePlugin {
+    name: string;
+    version: string;
+    private qTable;
+    private epsilon;
+    private epsilonMin;
+    private epsilonDecay;
+    private replayBuffer;
+    private usePrioritized;
+    private trainCounter;
+    /**
+     * Initialize Q-Learning plugin
+     */
+    protected onInitialize(): Promise<void>;
+    /**
+     * Select action using epsilon-greedy policy
+     *
+     * @param state - Current state vector
+     * @param context - Optional context
+     * @returns Selected action
+     */
+    selectAction(state: number[], context?: Context): Promise<Action>;
+    /**
+     * Select random action (exploration)
+     */
+    private randomAction;
+    /**
+     * Select greedy action (exploitation)
+     */
+    private greedyAction;
+    /**
+     * Store experience and update Q-table
+     */
+    protected onStoreExperience(experience: Experience): Promise<void>;
+    /**
+     * Train Q-Learning on replay buffer
+     */
+    train(options?: TrainOptions): Promise<TrainingMetrics>;
+    /**
+     * Compute TD error for prioritized replay
+     */
+    private computeTDError;
+    /**
+     * Get Q-value for state-action pair
+     */
+    private getQValue;
+    /**
+     * Set Q-value for state-action pair
+     */
+    private setQValue;
+    /**
+     * Get maximum Q-value for a state
+     */
+    private getMaxQValue;
+    /**
+     * Hash state vector to string key
+     */
+    private hashState;
+    /**
+     * Hash action to string key
+     */
+    private hashAction;
+    /**
+     * Get action embedding from ID
+     */
+    private getActionEmbedding;
+    /**
+     * Normalize Q-value to 0-1 confidence
+     */
+    private normalizeQValue;
+    /**
+     * Save Q-table
+     */
+    protected onSave(path: string): Promise<void>;
+    /**
+     * Load Q-table
+     */
+    protected onLoad(path: string): Promise<void>;
+}
+//# sourceMappingURL=q-learning.d.ts.map

package/dist/plugins/implementations/q-learning.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"q-learning.d.ts","sourceRoot":"","sources":["../../../src/plugins/implementations/q-learning.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACL,MAAM,EACN,OAAO,EACP,UAAU,EACV,YAAY,EACZ,eAAe,EAChB,MAAM,8BAA8B,CAAC;AA8ItC;;GAEG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IACtC,IAAI,SAAgB;IACpB,OAAO,SAAW;IAEzB,OAAO,CAAC,MAAM,CAA+C;IAC7D,OAAO,CAAC,OAAO,CAAe;IAC9B,OAAO,CAAC,UAAU,CAAgB;IAClC,OAAO,CAAC,YAAY,CAAiB;IACrC,OAAO,CAAC,YAAY,CAA0C;IAC9D,OAAO,CAAC,cAAc,CAAkB;IACxC,OAAO,CAAC,YAAY,CAAa;IAEjC;;OAEG;cACa,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB7C;;;;;;OAMG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAYvE;;OAEG;YACW,YAAY;IAuC1B;;OAEG;YACW,YAAY;IA+C1B;;OAEG;cACa,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAsBxE;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IA+E7D;;OAEG;IACH,OAAO,CAAC,cAAc;IAatB;;OAEG;IACH,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,YAAY;IAUpB;;OAEG;IACH,OAAO,CAAC,SAAS;IAKjB;;OAEG;IACH,OAAO,CAAC,UAAU;IAYlB;;OAEG;YACW,kBAAkB;IAMhC;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;cACa,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAKnD;;OAEG;cACa,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAIpD"}