agentdb 1.0.0

package/dist/plugins/implementations/multi-task-learning.mjs

@@ -0,0 +1,364 @@
+/**
+ * Multi-Task Learning Plugin
+ *
+ * Implements learning across multiple related tasks simultaneously,
+ * leveraging shared representations and transfer learning.
+ *
+ * Key features:
+ * - Shared and task-specific layers
+ * - Task weighting and balancing
+ * - Hard and soft parameter sharing
+ * - Auxiliary task learning
+ * - Task relationship modeling
+ */
+import { BasePlugin } from '../base-plugin.mjs';
+/**
+ * Multi-Task Learning Plugin Implementation
+ */
+export class MultiTaskLearningPlugin extends BasePlugin {
+    constructor(config) {
+        super();
+        this.name = 'multi-task-learning';
+        this.version = '1.0.0';
+        this.experiences = [];
+        this.tasks = new Map();
+        this.sharingStrategy = 'hard_sharing';
+        // Shared representations
+        this.sharedWeights = new Map();
+        this.taskSpecificWeights = new Map();
+        // Task relationships
+        this.taskSimilarity = new Map();
+        this.auxiliaryTasks = new Set();
+        // Training parameters
+        this.uncertaintyWeighting = true;
+        this.gradientNormalization = true;
+        if (config) {
+            this.sharingStrategy = config.sharingStrategy || 'hard_sharing';
+            this.uncertaintyWeighting = config.uncertaintyWeighting !== false;
+        }
+        this.initializeSharedLayers();
+        // Mark as initialized for in-memory operation
+        this.initialized = true;
+    }
+    /**
+     * Override to skip initialization check for in-memory operation
+     */
+    checkInitialized() {
+        // No-op for multi-task learning - operates in-memory
+    }
+    /**
+     * Encode state to fixed dimension
+     */
+    encodeState(state) {
+        // Simple state encoding - ensure fixed dimension
+        const targetDim = 128;
+        if (state.length >= targetDim) {
+            return state.slice(0, targetDim);
+        }
+        // Pad if too short
+        const encoded = [...state];
+        while (encoded.length < targetDim) {
+            encoded.push(0);
+        }
+        return encoded;
+    }
+    /**
+     * 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),
+        };
+    }
+    /**
+     * Override to store experiences in-memory without vectorDB
+     */
+    async storeExperience(experience) {
+        this.experiences.push(experience);
+        const taskId = experience.metadata?.taskId;
+        if (taskId && this.tasks.has(taskId)) {
+            // Update task performance
+            const task = this.tasks.get(taskId);
+            const alpha = 0.1;
+            const success = experience.reward > 0 ? 1 : 0;
+            task.performance = (1 - alpha) * task.performance + alpha * success;
+        }
+    }
+    /**
+     * 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 shared layers
+     */
+    initializeSharedLayers() {
+        // Shared representation layers
+        for (let layer = 0; layer < 3; layer++) {
+            const size = [256, 128, 64][layer];
+            const weights = new Array(size).fill(0).map(() => Math.random() * 0.1 - 0.05);
+            this.sharedWeights.set(`shared_${layer}`, weights);
+        }
+    }
+    /**
+     * Add task to multi-task learning
+     */
+    addTask(taskId, name, priority = 1.0, isAuxiliary = false) {
+        this.tasks.set(taskId, {
+            id: taskId,
+            name,
+            priority,
+            weight: 1.0,
+            performance: 0,
+        });
+        if (isAuxiliary) {
+            this.auxiliaryTasks.add(taskId);
+        }
+        // Initialize task-specific layers
+        const taskLayers = new Map();
+        taskLayers.set('task_head', new Array(64).fill(0).map(() => Math.random() * 0.1 - 0.05));
+        this.taskSpecificWeights.set(taskId, taskLayers);
+    }
+    /**
+     * Compute task similarity
+     */
+    computeTaskSimilarity(task1Id, task2Id) {
+        const experiences1 = this.getTaskExperiences(task1Id);
+        const experiences2 = this.getTaskExperiences(task2Id);
+        if (experiences1.length === 0 || experiences2.length === 0) {
+            return 0.5;
+        }
+        // Compute average state embeddings
+        const avg1 = this.averageEmbedding(experiences1.map(e => e.state));
+        const avg2 = this.averageEmbedding(experiences2.map(e => e.state));
+        // Cosine similarity
+        return this.cosineSimilarity(avg1, avg2);
+    }
+    /**
+     * Get experiences for specific task
+     */
+    getTaskExperiences(taskId) {
+        // Simplified: return empty array
+        return [];
+    }
+    /**
+     * Average embedding
+     */
+    averageEmbedding(embeddings) {
+        if (embeddings.length === 0) {
+            return [];
+        }
+        const avg = new Array(embeddings[0].length).fill(0);
+        embeddings.forEach(emb => {
+            for (let i = 0; i < emb.length; i++) {
+                avg[i] += emb[i];
+            }
+        });
+        return avg.map(v => v / embeddings.length);
+    }
+    /**
+     * Cosine similarity
+     */
+    cosineSimilarity(a, b) {
+        let dot = 0;
+        let magA = 0;
+        let magB = 0;
+        for (let i = 0; i < Math.min(a.length, b.length); i++) {
+            dot += a[i] * b[i];
+            magA += a[i] * a[i];
+            magB += b[i] * b[i];
+        }
+        return dot / (Math.sqrt(magA) * Math.sqrt(magB) + 1e-8);
+    }
+    /**
+     * Compute automatic task weights using uncertainty
+     */
+    computeUncertaintyWeights() {
+        // Multi-task uncertainty weighting (Kendall et al., 2018)
+        const logVars = new Map();
+        this.tasks.forEach((task, taskId) => {
+            // Estimate log variance from task performance
+            const logVar = Math.log(1 - task.performance + 1e-8);
+            logVars.set(taskId, logVar);
+        });
+        // Compute weights
+        this.tasks.forEach((task, taskId) => {
+            const logVar = logVars.get(taskId);
+            task.weight = Math.exp(-logVar);
+        });
+    }
+    /**
+     * Normalize gradients across tasks
+     */
+    normalizeGradients(gradients) {
+        if (!this.gradientNormalization) {
+            return gradients;
+        }
+        const normalized = new Map();
+        // Compute gradient norms
+        const norms = new Map();
+        gradients.forEach((grad, taskId) => {
+            const norm = Math.sqrt(grad.reduce((sum, g) => sum + g * g, 0));
+            norms.set(taskId, norm);
+        });
+        // Normalize to unit norm
+        gradients.forEach((grad, taskId) => {
+            const norm = norms.get(taskId);
+            normalized.set(taskId, grad.map(g => g / (norm + 1e-8)));
+        });
+        return normalized;
+    }
+    /**
+     * Forward pass through shared and task-specific layers
+     */
+    async forwardMultiTask(state, taskId) {
+        let activation = this.encodeState(state);
+        // Shared layers
+        this.sharedWeights.forEach(weights => {
+            activation = this.forward(activation, weights);
+        });
+        // Task-specific layers
+        const taskWeights = this.taskSpecificWeights.get(taskId);
+        if (taskWeights) {
+            taskWeights.forEach(weights => {
+                activation = this.forward(activation, weights);
+            });
+        }
+        return activation[0] || 0;
+    }
+    /**
+     * Forward pass through layer
+     */
+    forward(input, weights) {
+        const output = new Array(weights.length).fill(0);
+        for (let i = 0; i < output.length; i++) {
+            output[i] = input[i % input.length] * weights[i];
+            output[i] = Math.tanh(output[i]); // Activation
+        }
+        return output;
+    }
+    /**
+     * Train across multiple tasks
+     */
+    async train(options) {
+        const startTime = Date.now();
+        const epochs = options?.epochs || 50;
+        const batchSize = options?.batchSize || 32;
+        let totalLoss = 0;
+        const taskLosses = new Map();
+        let experiencesProcessed = 0;
+        for (let epoch = 0; epoch < epochs; epoch++) {
+            // Update task weights if using uncertainty weighting
+            if (this.uncertaintyWeighting) {
+                this.computeUncertaintyWeights();
+            }
+            const taskGradients = new Map();
+            // Train on each task
+            for (const [taskId, task] of this.tasks) {
+                // Skip auxiliary tasks with low priority
+                if (this.auxiliaryTasks.has(taskId) && task.priority < 0.5) {
+                    continue;
+                }
+                // Retrieve task-specific experiences from local storage
+                const experiences = await this.retrieveSimilar(new Array(128).fill(0), batchSize);
+                const taskExps = experiences
+                    .filter(e => e.metadata?.metadata?.taskId === taskId)
+                    .map(e => ({
+                    state: e.metadata.state,
+                    action: { id: '0', embedding: e.metadata.state },
+                    reward: e.metadata?.reward || 0,
+                    nextState: e.metadata?.nextState || e.metadata.state,
+                    done: e.metadata?.done || false,
+                    metadata: e.metadata,
+                }));
+                let taskLoss = 0;
+                // Compute gradients for task
+                const gradients = new Array(256).fill(0);
+                for (const exp of taskExps) {
+                    const prediction = await this.forwardMultiTask(exp.state, taskId);
+                    const loss = Math.pow(prediction - exp.reward, 2);
+                    taskLoss += loss * task.weight;
+                    experiencesProcessed++;
+                    // Simplified gradient
+                    for (let i = 0; i < gradients.length; i++) {
+                        gradients[i] += (prediction - exp.reward) * exp.state[i % exp.state.length];
+                    }
+                }
+                taskGradients.set(taskId, gradients);
+                taskLosses.set(taskId, taskLoss / Math.max(1, taskExps.length));
+                totalLoss += taskLoss;
+            }
+            // Normalize gradients
+            const normalizedGradients = this.normalizeGradients(taskGradients);
+            // Update shared weights with aggregated gradients
+            normalizedGradients.forEach((gradients, taskId) => {
+                const task = this.tasks.get(taskId);
+                this.sharedWeights.forEach((weights, layer) => {
+                    for (let i = 0; i < weights.length; i++) {
+                        weights[i] -= 0.01 * task.weight * gradients[i % gradients.length];
+                    }
+                });
+            });
+        }
+        const duration = Date.now() - startTime;
+        const metrics = {
+            loss: totalLoss / Math.max(1, experiencesProcessed),
+            experiencesProcessed,
+            duration,
+            taskLosses: Object.fromEntries(taskLosses),
+        };
+        return metrics;
+    }
+    /**
+     * Get task statistics
+     */
+    getTaskStats() {
+        return Array.from(this.tasks.values()).map(task => ({
+            id: task.id,
+            name: task.name,
+            performance: task.performance,
+            weight: task.weight,
+            priority: task.priority,
+        }));
+    }
+    /**
+     * Get task relationship matrix
+     */
+    getTaskRelationships() {
+        const relationships = new Map();
+        this.tasks.forEach((_, task1Id) => {
+            const similarities = new Map();
+            this.tasks.forEach((_, task2Id) => {
+                if (task1Id !== task2Id) {
+                    similarities.set(task2Id, this.computeTaskSimilarity(task1Id, task2Id));
+                }
+            });
+            relationships.set(task1Id, similarities);
+        });
+        return relationships;
+    }
+    /**
+     * Select action for specific task
+     */
+    async selectActionForTask(state, taskId, context) {
+        const prediction = await this.forwardMultiTask(state, taskId);
+        return {
+            id: String(Math.floor(Math.abs(prediction) * 10)),
+            embedding: Array.isArray(state) ? state : [state],
+            confidence: Math.abs(prediction),
+            metadata: { taskId },
+        };
+    }
+}

package/dist/plugins/implementations/neural-architecture-search.d.ts

@@ -0,0 +1,148 @@
+/**
+ * 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';
+import { Action, Context, Experience, TrainOptions, TrainingMetrics } from '../learning-plugin.interface';
+/**
+ * Layer specification
+ */
+interface LayerSpec {
+    type: 'dense' | 'conv' | 'pool' | 'dropout' | 'batchnorm';
+    size?: number;
+    activation?: 'relu' | 'tanh' | 'sigmoid' | 'leaky_relu';
+    dropout?: number;
+    kernelSize?: number;
+}
+/**
+ * Architecture specification
+ */
+interface Architecture {
+    id: string;
+    layers: LayerSpec[];
+    fitness: number;
+    complexity: number;
+    generation: number;
+}
+/**
+ * Neural Architecture Search Plugin Implementation
+ */
+export declare class NeuralArchitectureSearchPlugin extends BasePlugin {
+    name: string;
+    version: string;
+    private experiences;
+    private strategy;
+    private population;
+    private populationSize;
+    private eliteSize;
+    private mutationRate;
+    private crossoverRate;
+    private maxLayers;
+    private maxNodesPerLayer;
+    private layerTypes;
+    private bestArchitecture;
+    private generation;
+    private evaluationHistory;
+    constructor(config?: Partial<any>);
+    /**
+     * Override to skip initialization check for in-memory operation
+     */
+    protected checkInitialized(): void;
+    /**
+     * Override to store experiences in-memory without vectorDB
+     */
+    /**
+     * Override selectAction to provide base implementation
+     */
+    selectAction(state: number[] | any, context?: Context): Promise<Action>;
+    storeExperience(experience: Experience): Promise<void>;
+    /**
+     * Override to retrieve from local experiences
+     */
+    retrieveSimilar(state: number[], k: number): Promise<import('../..').SearchResult<Experience>[]>;
+    /**
+     * Initialize random population
+     */
+    private initializePopulation;
+    /**
+     * Generate random architecture
+     */
+    private generateRandomArchitecture;
+    /**
+     * Generate random layer
+     */
+    private generateRandomLayer;
+    /**
+     * Generate unique ID for architecture
+     */
+    private generateArchitectureId;
+    /**
+     * Calculate architecture complexity
+     */
+    private calculateComplexity;
+    /**
+     * Evaluate architecture fitness
+     */
+    private evaluateArchitecture;
+    /**
+     * Estimate architecture performance (simplified)
+     */
+    private estimatePerformance;
+    /**
+     * Mutate architecture
+     */
+    private mutate;
+    /**
+     * Crossover two architectures
+     */
+    private crossover;
+    /**
+     * Select parent using tournament selection
+     */
+    private selectParent;
+    /**
+     * Evolve population for one generation
+     */
+    private evolveGeneration;
+    /**
+     * Train using NAS
+     */
+    train(options?: TrainOptions): Promise<TrainingMetrics>;
+    /**
+     * Calculate population diversity
+     */
+    private calculatePopulationDiversity;
+    /**
+     * Get best architecture
+     */
+    getBestArchitecture(): Architecture | null;
+    /**
+     * Export architecture as JSON
+     */
+    exportArchitecture(arch: Architecture): string;
+    /**
+     * Import architecture from JSON
+     */
+    importArchitecture(json: string): Architecture;
+    /**
+     * Get search statistics
+     */
+    getSearchStats(): {
+        generation: number;
+        evaluations: number;
+        bestFitness: number;
+        populationDiversity: number;
+        avgComplexity: number;
+    };
+}
+export {};
+//# sourceMappingURL=neural-architecture-search.d.ts.map

package/dist/plugins/implementations/neural-architecture-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"neural-architecture-search.d.ts","sourceRoot":"","sources":["../../../src/plugins/implementations/neural-architecture-search.ts"],"names":[],"mappings":"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"}