agentdb 1.0.12 → 1.1.1

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

@@ -1,374 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-/**
- * 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

@@ -1 +0,0 @@
-{"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"}