agentdb 1.0.12 → 1.1.0

package/dist/plugins/implementations/federated-learning.mjs

@@ -1,431 +0,0 @@
-/**
- * Federated Learning Plugin
- *
- * Implements privacy-preserving distributed learning where multiple
- * agents learn collaboratively without sharing raw data.
- *
- * Key features:
- * - Client-side model updates
- * - Secure aggregation of gradients
- * - Differential privacy
- * - Byzantine fault tolerance
- * - Personalized federated learning
- */
-import { BasePlugin } from '../base-plugin.mjs';
-/**
- * Federated Learning Plugin Implementation
- */
-export class FederatedLearningPlugin extends BasePlugin {
-    constructor(config) {
-        super();
-        this.name = 'federated-learning';
-        this.version = '1.0.0';
-        this.experiences = [];
-        this.clients = new Map();
-        this.globalWeights = new Map();
-        this.roundNumber = 0;
-        this.aggregationStrategy = 'fedavg';
-        // Privacy parameters
-        this.privacyBudget = 1.0;
-        this.noisyScale = 0.1;
-        this.clippingNorm = 1.0;
-        // Byzantine tolerance
-        this.byzantineFraction = 0.2;
-        this.useMedianAggregation = false;
-        if (config) {
-            this.aggregationStrategy = config.aggregationStrategy || 'fedavg';
-            this.privacyBudget = config.privacyBudget || 1.0;
-            this.noisyScale = config.noisyScale || 0.1;
-            this.byzantineFraction = config.byzantineFraction || 0.2;
-        }
-        this.initializeGlobalModel();
-        // Mark as initialized for in-memory operation
-        this.initialized = true;
-    }
-    /**
-     * Override to skip initialization check for in-memory operation
-     */
-    checkInitialized() {
-        // No-op for federated learning - operates in-memory
-    }
-    /**
-     * Override to store experiences in-memory without vectorDB
-     */
-    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 global model weights
-     */
-    initializeGlobalModel() {
-        // Initialize with small random weights
-        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.globalWeights.set(`layer${layer}`, weights);
-        }
-    }
-    /**
-     * Register a new federated client
-     */
-    async registerClient(clientId) {
-        if (this.clients.has(clientId)) {
-            return;
-        }
-        // Clone global weights for client
-        const clientWeights = new Map();
-        this.globalWeights.forEach((weights, key) => {
-            clientWeights.set(key, [...weights]);
-        });
-        this.clients.set(clientId, {
-            id: clientId,
-            weights: clientWeights,
-            dataCount: 0,
-            lastUpdate: Date.now(),
-            reputationScore: 1.0,
-        });
-    }
-    /**
-     * Client performs local training
-     */
-    async trainLocalModel(clientId, experiences, epochs = 5) {
-        const client = this.clients.get(clientId);
-        if (!client) {
-            throw new Error(`Client ${clientId} not registered`);
-        }
-        if (!experiences || experiences.length === 0) {
-            throw new Error('No training data provided');
-        }
-        // Local SGD training
-        for (let epoch = 0; epoch < epochs; epoch++) {
-            for (const exp of experiences) {
-                // Compute gradients (simplified)
-                const gradients = this.computeGradients(exp, client.weights);
-                // Update local weights
-                client.weights.forEach((weights, layer) => {
-                    const grad = gradients.get(layer) || [];
-                    for (let i = 0; i < weights.length; i++) {
-                        weights[i] -= 0.01 * grad[i];
-                    }
-                });
-            }
-        }
-        client.dataCount += experiences.length;
-        client.lastUpdate = Date.now();
-        return client.weights;
-    }
-    /**
-     * Compute gradients for experience
-     */
-    computeGradients(exp, weights) {
-        const gradients = new Map();
-        // Simplified gradient computation
-        weights.forEach((w, layer) => {
-            const grad = new Array(w.length).fill(0);
-            for (let i = 0; i < w.length; i++) {
-                // Gradient approximation
-                grad[i] = (Math.random() - 0.5) * 0.1 * exp.reward;
-            }
-            gradients.set(layer, grad);
-        });
-        return gradients;
-    }
-    /**
-     * Add differential privacy noise to gradients
-     */
-    addDifferentialPrivacy(weights) {
-        const noisyWeights = [...weights];
-        const sensitivity = this.clippingNorm;
-        const epsilon = this.privacyBudget / (this.roundNumber + 1);
-        for (let i = 0; i < noisyWeights.length; i++) {
-            // Laplace noise
-            const u = Math.random() - 0.5;
-            const noise = -Math.sign(u) * Math.log(1 - 2 * Math.abs(u)) * (sensitivity / epsilon);
-            noisyWeights[i] += noise * this.noisyScale;
-        }
-        return noisyWeights;
-    }
-    /**
-     * Clip gradients for privacy
-     */
-    clipGradients(weights) {
-        const norm = Math.sqrt(weights.reduce((sum, w) => sum + w * w, 0));
-        if (norm > this.clippingNorm) {
-            return weights.map(w => w * (this.clippingNorm / norm));
-        }
-        return weights;
-    }
-    /**
-     * Aggregate client updates into global model
-     */
-    async aggregateUpdates(clientIds) {
-        this.roundNumber++;
-        const selectedClients = clientIds
-            .map(id => this.clients.get(id))
-            .filter((c) => c !== undefined);
-        if (selectedClients.length === 0) {
-            throw new Error('No valid clients found for aggregation');
-        }
-        switch (this.aggregationStrategy) {
-            case 'fedavg':
-                this.aggregateFedAvg(selectedClients);
-                break;
-            case 'fedprox':
-                this.aggregateFedProx(selectedClients);
-                break;
-            case 'fedopt':
-                this.aggregateFedOpt(selectedClients);
-                break;
-            case 'scaffold':
-                this.aggregateScaffold(selectedClients);
-                break;
-        }
-        // Broadcast updated global model to all clients
-        await this.broadcastGlobalModel();
-    }
-    /**
-     * FedAvg: Weighted average by data count
-     */
-    aggregateFedAvg(clients) {
-        const totalData = clients.reduce((sum, c) => sum + c.dataCount, 0);
-        this.globalWeights.forEach((globalW, layer) => {
-            const aggregated = new Array(globalW.length).fill(0);
-            clients.forEach(client => {
-                const clientW = client.weights.get(layer);
-                if (!clientW)
-                    return;
-                const weight = client.dataCount / totalData;
-                // Apply differential privacy
-                const privatizedW = this.addDifferentialPrivacy(this.clipGradients(clientW));
-                for (let i = 0; i < aggregated.length; i++) {
-                    aggregated[i] += privatizedW[i] * weight;
-                }
-            });
-            this.globalWeights.set(layer, aggregated);
-        });
-    }
-    /**
-     * FedProx: Proximal term to handle heterogeneity
-     */
-    aggregateFedProx(clients) {
-        const mu = 0.01; // Proximal parameter
-        const totalData = clients.reduce((sum, c) => sum + c.dataCount, 0);
-        this.globalWeights.forEach((globalW, layer) => {
-            const aggregated = new Array(globalW.length).fill(0);
-            clients.forEach(client => {
-                const clientW = client.weights.get(layer);
-                if (!clientW)
-                    return;
-                const weight = client.dataCount / totalData;
-                for (let i = 0; i < aggregated.length; i++) {
-                    // Proximal term regularization
-                    const regularized = clientW[i] - mu * (clientW[i] - globalW[i]);
-                    aggregated[i] += regularized * weight;
-                }
-            });
-            this.globalWeights.set(layer, aggregated);
-        });
-    }
-    /**
-     * FedOpt: Server-side adaptive optimization
-     */
-    aggregateFedOpt(clients) {
-        const serverLR = 0.01;
-        const totalData = clients.reduce((sum, c) => sum + c.dataCount, 0);
-        this.globalWeights.forEach((globalW, layer) => {
-            const gradient = new Array(globalW.length).fill(0);
-            // Compute pseudo-gradient
-            clients.forEach(client => {
-                const clientW = client.weights.get(layer);
-                if (!clientW)
-                    return;
-                const weight = client.dataCount / totalData;
-                for (let i = 0; i < gradient.length; i++) {
-                    gradient[i] += (clientW[i] - globalW[i]) * weight;
-                }
-            });
-            // Server-side Adam-like update
-            for (let i = 0; i < globalW.length; i++) {
-                globalW[i] += serverLR * gradient[i];
-            }
-        });
-    }
-    /**
-     * SCAFFOLD: Control variates to reduce client drift
-     */
-    aggregateScaffold(clients) {
-        const totalData = clients.reduce((sum, c) => sum + c.dataCount, 0);
-        this.globalWeights.forEach((globalW, layer) => {
-            const aggregated = new Array(globalW.length).fill(0);
-            const controlVariate = new Array(globalW.length).fill(0);
-            clients.forEach(client => {
-                const clientW = client.weights.get(layer);
-                if (!clientW)
-                    return;
-                const weight = client.dataCount / totalData;
-                for (let i = 0; i < aggregated.length; i++) {
-                    aggregated[i] += clientW[i] * weight;
-                    // Control variate correction
-                    controlVariate[i] += (clientW[i] - globalW[i]) * weight;
-                }
-            });
-            // Update with control variate
-            for (let i = 0; i < globalW.length; i++) {
-                globalW[i] = aggregated[i] - 0.1 * controlVariate[i];
-            }
-        });
-    }
-    /**
-     * Detect and filter Byzantine clients
-     */
-    filterByzantineClients(clients) {
-        if (!this.useMedianAggregation) {
-            return clients;
-        }
-        // Compute median update for each parameter
-        const medianUpdates = new Map();
-        this.globalWeights.forEach((globalW, layer) => {
-            const paramUpdates = Array(globalW.length)
-                .fill(0)
-                .map(() => []);
-            clients.forEach(client => {
-                const clientW = client.weights.get(layer);
-                if (!clientW)
-                    return;
-                for (let i = 0; i < globalW.length; i++) {
-                    paramUpdates[i].push(clientW[i] - globalW[i]);
-                }
-            });
-            const median = paramUpdates.map(updates => {
-                updates.sort((a, b) => a - b);
-                return updates[Math.floor(updates.length / 2)];
-            });
-            medianUpdates.set(layer, median);
-        });
-        // Filter clients whose updates deviate too much from median
-        return clients.filter(client => {
-            let totalDeviation = 0;
-            let paramCount = 0;
-            this.globalWeights.forEach((globalW, layer) => {
-                const clientW = client.weights.get(layer);
-                const median = medianUpdates.get(layer);
-                if (!clientW || !median)
-                    return;
-                for (let i = 0; i < globalW.length; i++) {
-                    const update = clientW[i] - globalW[i];
-                    totalDeviation += Math.abs(update - median[i]);
-                    paramCount++;
-                }
-            });
-            const avgDeviation = totalDeviation / paramCount;
-            return avgDeviation < 1.0; // Threshold for Byzantine detection
-        });
-    }
-    /**
-     * Broadcast updated global model to all clients
-     */
-    async broadcastGlobalModel() {
-        this.clients.forEach(client => {
-            this.globalWeights.forEach((weights, layer) => {
-                client.weights.set(layer, [...weights]);
-            });
-        });
-    }
-    /**
-     * Encode state vector for transmission
-     */
-    encodeState(state) {
-        return state;
-    }
-    /**
-     * Select action using current global model
-     */
-    async selectAction(state, context) {
-        // Forward pass through global model
-        const stateArray = Array.isArray(state) ? state : [state];
-        const stateEmbedding = this.encodeState(stateArray);
-        let activation = stateEmbedding;
-        this.globalWeights.forEach(weights => {
-            const output = this.forward(activation, weights);
-            activation = output;
-        });
-        // Action selection based on output
-        const actionValue = activation[0] || 0;
-        return {
-            id: String(Math.floor(Math.abs(actionValue) * 10)),
-            embedding: stateArray,
-            confidence: Math.abs(actionValue),
-        };
-    }
-    /**
-     * 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 using federated learning rounds
-     */
-    async train(options) {
-        const startTime = Date.now();
-        const rounds = options?.epochs || 10;
-        const clientsPerRound = 5;
-        let totalLoss = 0;
-        for (let round = 0; round < rounds; round++) {
-            // Sample clients for this round
-            const clientIds = Array.from(this.clients.keys())
-                .sort(() => Math.random() - 0.5)
-                .slice(0, clientsPerRound);
-            // Each client trains locally
-            for (const clientId of clientIds) {
-                const results = await this.retrieveSimilar(new Array(128).fill(0), 10);
-                const experiences = results.map(r => r.metadata);
-                await this.trainLocalModel(clientId, experiences, 5);
-            }
-            // Aggregate updates
-            await this.aggregateUpdates(clientIds);
-            // Compute loss (simplified)
-            totalLoss += Math.random() * 0.1;
-        }
-        const duration = Date.now() - startTime;
-        return {
-            loss: totalLoss / rounds,
-            experiencesProcessed: this.clients.size * 10,
-            duration,
-            federatedRounds: rounds,
-            clientsPerRound: clientsPerRound,
-        };
-    }
-    /**
-     * Get global model weights
-     */
-    getGlobalWeights() {
-        return new Map(this.globalWeights);
-    }
-    /**
-     * Get client statistics
-     */
-    getClientStats() {
-        return Array.from(this.clients.values()).map(c => ({
-            id: c.id,
-            dataCount: c.dataCount,
-            reputation: c.reputationScore,
-        }));
-    }
-}

package/dist/plugins/implementations/index.d.ts

@@ -1,30 +0,0 @@
-/**
- * Concrete implementations of learning plugins
- *
- * This module exports all available learning plugin implementations:
- *
- * Core RL Algorithms:
- * - DecisionTransformerPlugin: Sequence modeling with 3-tier action selection
- * - QLearningPlugin: Off-policy value-based learning with experience replay
- * - SARSAPlugin: On-policy learning with eligibility traces
- * - ActorCriticPlugin: Policy gradient with value function baseline
- *
- * Advanced Learning Paradigms:
- * - FederatedLearningPlugin: Privacy-preserving distributed learning
- * - CurriculumLearningPlugin: Structured learning from easy to hard
- * - ActiveLearningPlugin: Query-based learning with uncertainty sampling
- * - AdversarialTrainingPlugin: Robust learning through adversarial examples
- * - NeuralArchitectureSearchPlugin: Automated architecture optimization
- * - MultiTaskLearningPlugin: Joint learning across multiple related tasks
- */
-export { DecisionTransformerPlugin } from './decision-transformer';
-export { QLearningPlugin } from './q-learning';
-export { SARSAPlugin } from './sarsa';
-export { ActorCriticPlugin } from './actor-critic';
-export { FederatedLearningPlugin } from './federated-learning';
-export { CurriculumLearningPlugin } from './curriculum-learning';
-export { ActiveLearningPlugin } from './active-learning';
-export { AdversarialTrainingPlugin } from './adversarial-training';
-export { NeuralArchitectureSearchPlugin } from './neural-architecture-search';
-export { MultiTaskLearningPlugin } from './multi-task-learning';
-//# sourceMappingURL=index.d.ts.map

package/dist/plugins/implementations/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/plugins/implementations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACtC,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAC/D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,EAAE,8BAA8B,EAAE,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/plugins/implementations/index.js

@@ -1,45 +0,0 @@
-"use strict";
-/**
- * Concrete implementations of learning plugins
- *
- * This module exports all available learning plugin implementations:
- *
- * Core RL Algorithms:
- * - DecisionTransformerPlugin: Sequence modeling with 3-tier action selection
- * - QLearningPlugin: Off-policy value-based learning with experience replay
- * - SARSAPlugin: On-policy learning with eligibility traces
- * - ActorCriticPlugin: Policy gradient with value function baseline
- *
- * Advanced Learning Paradigms:
- * - FederatedLearningPlugin: Privacy-preserving distributed learning
- * - CurriculumLearningPlugin: Structured learning from easy to hard
- * - ActiveLearningPlugin: Query-based learning with uncertainty sampling
- * - AdversarialTrainingPlugin: Robust learning through adversarial examples
- * - NeuralArchitectureSearchPlugin: Automated architecture optimization
- * - MultiTaskLearningPlugin: Joint learning across multiple related tasks
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MultiTaskLearningPlugin = exports.NeuralArchitectureSearchPlugin = exports.AdversarialTrainingPlugin = exports.ActiveLearningPlugin = exports.CurriculumLearningPlugin = exports.FederatedLearningPlugin = exports.ActorCriticPlugin = exports.SARSAPlugin = exports.QLearningPlugin = exports.DecisionTransformerPlugin = void 0;
-// Core RL Algorithms
-var decision_transformer_1 = require("./decision-transformer");
-Object.defineProperty(exports, "DecisionTransformerPlugin", { enumerable: true, get: function () { return decision_transformer_1.DecisionTransformerPlugin; } });
-var q_learning_1 = require("./q-learning");
-Object.defineProperty(exports, "QLearningPlugin", { enumerable: true, get: function () { return q_learning_1.QLearningPlugin; } });
-var sarsa_1 = require("./sarsa");
-Object.defineProperty(exports, "SARSAPlugin", { enumerable: true, get: function () { return sarsa_1.SARSAPlugin; } });
-var actor_critic_1 = require("./actor-critic");
-Object.defineProperty(exports, "ActorCriticPlugin", { enumerable: true, get: function () { return actor_critic_1.ActorCriticPlugin; } });
-// Advanced Learning Paradigms
-var federated_learning_1 = require("./federated-learning");
-Object.defineProperty(exports, "FederatedLearningPlugin", { enumerable: true, get: function () { return federated_learning_1.FederatedLearningPlugin; } });
-var curriculum_learning_1 = require("./curriculum-learning");
-Object.defineProperty(exports, "CurriculumLearningPlugin", { enumerable: true, get: function () { return curriculum_learning_1.CurriculumLearningPlugin; } });
-var active_learning_1 = require("./active-learning");
-Object.defineProperty(exports, "ActiveLearningPlugin", { enumerable: true, get: function () { return active_learning_1.ActiveLearningPlugin; } });
-var adversarial_training_1 = require("./adversarial-training");
-Object.defineProperty(exports, "AdversarialTrainingPlugin", { enumerable: true, get: function () { return adversarial_training_1.AdversarialTrainingPlugin; } });
-var neural_architecture_search_1 = require("./neural-architecture-search");
-Object.defineProperty(exports, "NeuralArchitectureSearchPlugin", { enumerable: true, get: function () { return neural_architecture_search_1.NeuralArchitectureSearchPlugin; } });
-var multi_task_learning_1 = require("./multi-task-learning");
-Object.defineProperty(exports, "MultiTaskLearningPlugin", { enumerable: true, get: function () { return multi_task_learning_1.MultiTaskLearningPlugin; } });
-//# sourceMappingURL=index.js.map

package/dist/plugins/implementations/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/plugins/implementations/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;GAkBG;;;AAEH,qBAAqB;AACrB,+DAAmE;AAA1D,iIAAA,yBAAyB,OAAA;AAClC,2CAA+C;AAAtC,6GAAA,eAAe,OAAA;AACxB,iCAAsC;AAA7B,oGAAA,WAAW,OAAA;AACpB,+CAAmD;AAA1C,iHAAA,iBAAiB,OAAA;AAE1B,8BAA8B;AAC9B,2DAA+D;AAAtD,6HAAA,uBAAuB,OAAA;AAChC,6DAAiE;AAAxD,+HAAA,wBAAwB,OAAA;AACjC,qDAAyD;AAAhD,uHAAA,oBAAoB,OAAA;AAC7B,+DAAmE;AAA1D,iIAAA,yBAAyB,OAAA;AAClC,2EAA8E;AAArE,4IAAA,8BAA8B,OAAA;AACvC,6DAAgE;AAAvD,8HAAA,uBAAuB,OAAA"}

package/dist/plugins/implementations/index.mjs

@@ -1,31 +0,0 @@
-/**
- * Concrete implementations of learning plugins
- *
- * This module exports all available learning plugin implementations:
- *
- * Core RL Algorithms:
- * - DecisionTransformerPlugin: Sequence modeling with 3-tier action selection
- * - QLearningPlugin: Off-policy value-based learning with experience replay
- * - SARSAPlugin: On-policy learning with eligibility traces
- * - ActorCriticPlugin: Policy gradient with value function baseline
- *
- * Advanced Learning Paradigms:
- * - FederatedLearningPlugin: Privacy-preserving distributed learning
- * - CurriculumLearningPlugin: Structured learning from easy to hard
- * - ActiveLearningPlugin: Query-based learning with uncertainty sampling
- * - AdversarialTrainingPlugin: Robust learning through adversarial examples
- * - NeuralArchitectureSearchPlugin: Automated architecture optimization
- * - MultiTaskLearningPlugin: Joint learning across multiple related tasks
- */
-// Core RL Algorithms
-export { DecisionTransformerPlugin } from './decision-transformer.mjs';
-export { QLearningPlugin } from './q-learning.mjs';
-export { SARSAPlugin } from './sarsa.mjs';
-export { ActorCriticPlugin } from './actor-critic.mjs';
-// Advanced Learning Paradigms
-export { FederatedLearningPlugin } from './federated-learning.mjs';
-export { CurriculumLearningPlugin } from './curriculum-learning.mjs';
-export { ActiveLearningPlugin } from './active-learning.mjs';
-export { AdversarialTrainingPlugin } from './adversarial-training.mjs';
-export { NeuralArchitectureSearchPlugin } from './neural-architecture-search.mjs';
-export { MultiTaskLearningPlugin } from './multi-task-learning.mjs';

package/dist/plugins/implementations/multi-task-learning.d.ts

@@ -1,115 +0,0 @@
-/**
- * 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';
-import { Action, Context, Experience, TrainOptions, TrainingMetrics, Vector } from '../learning-plugin.interface';
-/**
- * Multi-Task Learning Plugin Implementation
- */
-export declare class MultiTaskLearningPlugin extends BasePlugin {
-    name: string;
-    version: string;
-    private experiences;
-    private tasks;
-    private sharingStrategy;
-    private sharedWeights;
-    private taskSpecificWeights;
-    private taskSimilarity;
-    private auxiliaryTasks;
-    private uncertaintyWeighting;
-    private gradientNormalization;
-    constructor(config?: Partial<any>);
-    /**
-     * Override to skip initialization check for in-memory operation
-     */
-    protected checkInitialized(): void;
-    /**
-     * Encode state to fixed dimension
-     */
-    private encodeState;
-    /**
-     * Override selectAction to provide base implementation
-     */
-    selectAction(state: Vector, context?: Context): Promise<Action>;
-    /**
-     * Override to store experiences in-memory without vectorDB
-     */
-    storeExperience(experience: Experience): Promise<void>;
-    /**
-     * Override to retrieve from local experiences
-     */
-    retrieveSimilar(state: number[], k: number): Promise<import('../..').SearchResult<Experience>[]>;
-    /**
-     * Initialize shared layers
-     */
-    private initializeSharedLayers;
-    /**
-     * Add task to multi-task learning
-     */
-    addTask(taskId: string, name: string, priority?: number, isAuxiliary?: boolean): void;
-    /**
-     * Compute task similarity
-     */
-    private computeTaskSimilarity;
-    /**
-     * Get experiences for specific task
-     */
-    private getTaskExperiences;
-    /**
-     * Average embedding
-     */
-    private averageEmbedding;
-    /**
-     * Cosine similarity
-     */
-    private cosineSimilarity;
-    /**
-     * Compute automatic task weights using uncertainty
-     */
-    private computeUncertaintyWeights;
-    /**
-     * Normalize gradients across tasks
-     */
-    private normalizeGradients;
-    /**
-     * Forward pass through shared and task-specific layers
-     */
-    private forwardMultiTask;
-    /**
-     * Forward pass through layer
-     */
-    private forward;
-    /**
-     * Train across multiple tasks
-     */
-    train(options?: TrainOptions): Promise<TrainingMetrics>;
-    /**
-     * Get task statistics
-     */
-    getTaskStats(): Array<{
-        id: string;
-        name: string;
-        performance: number;
-        weight: number;
-        priority: number;
-    }>;
-    /**
-     * Get task relationship matrix
-     */
-    getTaskRelationships(): Map<string, Map<string, number>>;
-    /**
-     * Select action for specific task
-     */
-    selectActionForTask(state: Vector, taskId: string, context?: Context): Promise<Action>;
-}
-//# sourceMappingURL=multi-task-learning.d.ts.map

package/dist/plugins/implementations/multi-task-learning.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"multi-task-learning.d.ts","sourceRoot":"","sources":["../../../src/plugins/implementations/multi-task-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,EACf,MAAM,EACP,MAAM,8BAA8B,CAAC;AAsBtC;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,UAAU;IACrD,IAAI,SAAyB;IAC7B,OAAO,SAAW;IAElB,OAAO,CAAC,WAAW,CAAoB;IACvC,OAAO,CAAC,KAAK,CAAgC;IAC7C,OAAO,CAAC,eAAe,CAAmC;IAG1D,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,mBAAmB,CAA+C;IAG1E,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,cAAc,CAA0B;IAGhD,OAAO,CAAC,oBAAoB,CAAiB;IAC7C,OAAO,CAAC,qBAAqB,CAAiB;gBAElC,MAAM,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC;IAcjC;;OAEG;IACH,SAAS,CAAC,gBAAgB,IAAI,IAAI;IAIlC;;OAEG;IACH,OAAO,CAAC,WAAW;IAenB;;OAEG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAarE;;OAEG;IACG,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAa5D;;OAEG;IACG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;IAStG;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAS9B;;OAEG;IACH,OAAO,CACL,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,MAAY,EACtB,WAAW,GAAE,OAAe,GAC3B,IAAI;IAmBP;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAgB7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAK1B;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAgBxB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;OAEG;IACH,OAAO,CAAC,yBAAyB;IAiBjC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAyB1B;;OAEG;YACW,gBAAgB;IAsB9B;;OAEG;IACH,OAAO,CAAC,OAAO;IAYf;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC;IA2F7D;;OAEG;IACH,YAAY,IAAI,KAAK,CAAC;QACpB,EAAE,EAAE,MAAM,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC;IAUF;;OAEG;IACH,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAkBxD;;OAEG;IACG,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;CAU7F"}