@elizaos/training 2.0.0-alpha.21 → 2.0.0-alpha.22

package/dist/training/BenchmarkService.js

@@ -0,0 +1,370 @@
+/**
+ * Training Benchmark Service
+ *
+ * Handles model benchmarking during the training pipeline.
+ *
+ * **Purpose:** Evaluate models as part of continuous training
+ * **Used by:** AutomationPipeline, continuous training scripts
+ * **Storage:** trainedModel.evalMetrics (JSON field)
+ * **Focus:** Training pipeline integration, deployment decisions
+ *
+ * **Note:** For HuggingFace upload benchmarking, see ModelBenchmarkService
+ *
+ * @see ModelBenchmarkService - For HuggingFace upload evaluation
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getTrainingDataAdapter } from "../adapter";
+import { BenchmarkRunner } from "../benchmark/BenchmarkRunner";
+import { getAgentRuntimeManager } from "../dependencies";
+import { logger } from "../utils/logger";
+export class BenchmarkService {
+    DEPLOYMENT_THRESHOLD = 0.95; // Deploy if new model >= 95% of best
+    // Use the 1-week benchmark we generated for comprehensive evaluation
+    DEFAULT_BENCHMARK_PATH = path.resolve(process.cwd(), "benchmarks/benchmark-week-10080-60-10-5-8-12345.json");
+    RESULTS_DIR = path.resolve(process.cwd(), "benchmark-results/models");
+    /**
+     * Get benchmark path with fallback to first available benchmark
+     *
+     * Attempts to use the default benchmark file, falling back to any
+     * available benchmark file if the default is not found.
+     *
+     * @returns Path to benchmark JSON file
+     * @throws Error if no benchmark files are found
+     */
+    async getBenchmarkPath() {
+        // Try default first
+        try {
+            await fs.access(this.DEFAULT_BENCHMARK_PATH);
+            return this.DEFAULT_BENCHMARK_PATH;
+        }
+        catch {
+            // Fallback: find any benchmark file
+            const benchmarkDir = path.resolve(process.cwd(), "benchmarks");
+            const files = await fs.readdir(benchmarkDir);
+            const benchmarkFiles = files.filter((f) => f.startsWith("benchmark-") && f.endsWith(".json"));
+            if (benchmarkFiles.length > 0) {
+                const firstFile = benchmarkFiles[0];
+                if (!firstFile)
+                    throw new Error("Benchmark files array empty");
+                const fallbackPath = path.join(benchmarkDir, firstFile);
+                logger.warn(`Default benchmark not found, using: ${fallbackPath}`, undefined, "BenchmarkService");
+                return fallbackPath;
+            }
+        }
+        throw new Error("No benchmark files found. Generate benchmark data before running evaluation.");
+    }
+    /**
+     * Run benchmark on a trained model
+     *
+     * Executes a full benchmark run using the BenchmarkRunner, evaluates
+     * the model's performance, and stores results in the database.
+     *
+     * @param modelId - Unique identifier for the trained model
+     * @param benchmarkPath - Optional path to benchmark file (uses default if not provided)
+     * @returns BenchmarkResults with comprehensive performance metrics
+     * @throws Error if model not found or benchmark fails
+     *
+     * @example
+     * ```typescript
+     * const results = await benchmarkService.benchmarkModel('model-123');
+     * console.log(`Score: ${results.benchmarkScore}`);
+     * console.log(`Accuracy: ${results.accuracy}`);
+     * ```
+     */
+    async benchmarkModel(modelId, benchmarkPath) {
+        logger.info(`Benchmarking model: ${modelId}`, undefined, "BenchmarkService");
+        const startTime = Date.now();
+        // Get benchmark file (with fallback logic)
+        const bmPath = benchmarkPath || (await this.getBenchmarkPath());
+        // Get test agent
+        const agent = await this.getTestAgent();
+        // Create output directory
+        const outputDir = path.join(this.RESULTS_DIR, modelId, Date.now().toString());
+        await fs.mkdir(outputDir, { recursive: true });
+        // Get agent runtime
+        const runtime = await getAgentRuntimeManager().getRuntime(agent.id);
+        // Force the runtime to use the specific model we're benchmarking
+        // by temporarily overriding the model selection
+        const model = await getTrainingDataAdapter().getModelById(modelId);
+        if (!model) {
+            throw new Error(`Model not found: ${modelId}`);
+        }
+        // Validate and get model identifier for inference
+        const modelIdentifier = this.getValidModelIdentifier(model);
+        // Run benchmark
+        logger.info("Running benchmark...", {
+            modelId,
+            modelIdentifier,
+            agent: agent.username,
+        }, "BenchmarkService");
+        const result = await BenchmarkRunner.runSingle({
+            benchmarkPath: bmPath,
+            agentRuntime: runtime,
+            agentUserId: agent.id,
+            saveTrajectory: true,
+            outputDir,
+            forceModel: modelIdentifier, // Use validated W&B model ID
+        });
+        const duration = Date.now() - startTime;
+        // Calculate composite benchmark score
+        // Formula: 0.4 * normalized_pnl + 0.3 * accuracy + 0.3 * optimality
+        const normalizedPnl = this.normalizePnl(result.metrics.totalPnl);
+        const benchmarkScore = 0.4 * normalizedPnl +
+            0.3 * result.metrics.predictionMetrics.accuracy +
+            0.3 * (result.metrics.optimalityScore / 100);
+        const benchmarkResults = {
+            modelId,
+            benchmarkScore,
+            pnl: result.metrics.totalPnl,
+            accuracy: result.metrics.predictionMetrics.accuracy,
+            optimality: result.metrics.optimalityScore,
+            perpTrades: result.metrics.perpMetrics.totalTrades,
+            correctPredictions: result.metrics.predictionMetrics.correctPredictions,
+            totalPositions: result.metrics.predictionMetrics.totalPositions,
+            duration,
+            timestamp: new Date(),
+        };
+        logger.info("Benchmark complete", {
+            modelId,
+            score: benchmarkScore.toFixed(3),
+            pnl: result.metrics.totalPnl.toFixed(2),
+            accuracy: `${(result.metrics.predictionMetrics.accuracy * 100).toFixed(1)}%`,
+            optimality: `${result.metrics.optimalityScore.toFixed(1)}%`,
+            duration: `${(duration / 1000).toFixed(1)}s`,
+        }, "BenchmarkService");
+        // Store results
+        await this.storeBenchmarkResults(modelId, benchmarkResults);
+        return benchmarkResults;
+    }
+    /**
+     * Compare new model performance against previous best
+     *
+     * Evaluates whether a new model should be deployed based on its benchmark
+     * score compared to the previous best model. Uses a configurable threshold.
+     *
+     * @param newModelId - Unique identifier for the new model to compare
+     * @param threshold - Deployment threshold (default: 0.95, meaning 95% of best)
+     * @returns ComparisonResults with deployment recommendation
+     * @throws Error if model not found or not benchmarked
+     *
+     * @example
+     * ```typescript
+     * const comparison = await benchmarkService.compareModels('model-123');
+     * if (comparison.shouldDeploy) {
+     *   console.log(`Deploying: ${comparison.reason}`);
+     * }
+     * ```
+     */
+    async compareModels(newModelId, threshold = this.DEPLOYMENT_THRESHOLD) {
+        logger.info(`Comparing model: ${newModelId}`, undefined, "BenchmarkService");
+        // Get new model's benchmark results
+        const newModel = await getTrainingDataAdapter().getModelById(newModelId);
+        if (!newModel) {
+            throw new Error(`Model not found: ${newModelId}`);
+        }
+        if (newModel.benchmarkScore === null) {
+            throw new Error(`Model has not been benchmarked: ${newModelId}`);
+        }
+        const newScore = newModel.benchmarkScore;
+        // Get previous best model (excluding the new one)
+        const previousBest = await getTrainingDataAdapter().getBestBenchmarkedModel(newModelId);
+        // If no previous model, always deploy
+        if (!previousBest) {
+            logger.info("No previous model to compare - will deploy", { newScore }, "BenchmarkService");
+            return {
+                newModel: newModelId,
+                previousModel: null,
+                newScore,
+                previousScore: null,
+                improvement: null,
+                shouldDeploy: true,
+                reason: "First model - no comparison available",
+            };
+        }
+        const previousScore = previousBest.benchmarkScore ?? 0;
+        const improvement = ((newScore - previousScore) / previousScore) * 100;
+        const thresholdScore = previousScore * threshold;
+        const shouldDeploy = newScore >= thresholdScore;
+        let reason = "";
+        if (shouldDeploy) {
+            if (newScore > previousScore) {
+                reason = `Improved by ${improvement.toFixed(1)}% (${newScore.toFixed(3)} > ${previousScore.toFixed(3)})`;
+            }
+            else {
+                reason = `Within acceptable range (${newScore.toFixed(3)} >= ${thresholdScore.toFixed(3)}, threshold: ${threshold * 100}%)`;
+            }
+        }
+        else {
+            reason = `Performance too low (${newScore.toFixed(3)} < ${thresholdScore.toFixed(3)}, need ${threshold * 100}% of best)`;
+        }
+        logger.info("Model comparison complete", {
+            newModel: newModelId,
+            newScore: newScore.toFixed(3),
+            previousModel: previousBest.modelId,
+            previousScore: previousScore.toFixed(3),
+            improvement: `${improvement.toFixed(1)}%`,
+            shouldDeploy,
+            reason,
+        }, "BenchmarkService");
+        return {
+            newModel: newModelId,
+            previousModel: previousBest.modelId,
+            newScore,
+            previousScore,
+            improvement,
+            shouldDeploy,
+            reason,
+        };
+    }
+    /**
+     * Store benchmark results in database
+     *
+     * Saves benchmark metrics to the trainedModel record for tracking
+     * and comparison purposes.
+     *
+     * @param modelId - Unique identifier for the trained model
+     * @param results - Benchmark results to store
+     * @throws Error if model not found or database update fails
+     */
+    async storeBenchmarkResults(modelId, results) {
+        await getTrainingDataAdapter().updateModelBenchmarkResults(modelId, {
+            benchmarkScore: results.benchmarkScore,
+            accuracy: results.accuracy,
+            evalMetrics: {
+                pnl: results.pnl,
+                accuracy: results.accuracy,
+                optimality: results.optimality,
+                perpTrades: results.perpTrades,
+                correctPredictions: results.correctPredictions,
+                totalPositions: results.totalPositions,
+                duration: results.duration,
+                benchmarkedAt: results.timestamp.toISOString(),
+            },
+        });
+        logger.info("Stored benchmark results", { modelId, score: results.benchmarkScore }, "BenchmarkService");
+    }
+    /**
+     * Determine if model should be deployed based on performance
+     *
+     * Convenience wrapper around compareModels() that returns only
+     * the deployment decision boolean.
+     *
+     * @param modelId - Unique identifier for the model to evaluate
+     * @param threshold - Deployment threshold (default: 0.95)
+     * @returns True if model should be deployed, false otherwise
+     * @throws Error if model not found or not benchmarked
+     */
+    async shouldDeploy(modelId, threshold = this.DEPLOYMENT_THRESHOLD) {
+        const comparison = await this.compareModels(modelId, threshold);
+        return comparison.shouldDeploy;
+    }
+    /**
+     * Validate and get model identifier for inference
+     *
+     * Ensures storagePath is a valid W&B model ID or HuggingFace path.
+     * Falls back to modelId or baseModel if storagePath is invalid.
+     *
+     * @param model - Model object with storagePath, modelId, and baseModel
+     * @returns Valid model identifier string for inference
+     *
+     * @remarks
+     * Valid formats:
+     * - W&B: "entity/project/model-name:version"
+     * - HuggingFace: "org/model-name"
+     * - Falls back to baseModel if none valid
+     */
+    getValidModelIdentifier(model) {
+        const storagePath = model.storagePath;
+        // Validate storagePath format (should be W&B model ID or HuggingFace path)
+        // W&B format: entity/project/model-name:version or entity/project/model-name:stepN
+        // HuggingFace: org/model-name
+        if (storagePath && storagePath.trim().length > 0) {
+            // Check if it looks like a valid model ID
+            if (storagePath.includes("/") || storagePath.includes(":")) {
+                return storagePath;
+            }
+            // StoragePath is invalid, log warning
+            logger.warn(`Invalid storagePath format: ${storagePath}, falling back to modelId`, { modelId: model.modelId }, "BenchmarkService");
+        }
+        // Fallback to base model if modelId also doesn't look valid
+        if (model.modelId.includes("/")) {
+            return model.modelId;
+        }
+        // Last resort: use base model from training
+        logger.warn(`No valid model identifier found, using baseModel`, { modelId: model.modelId, baseModel: model.baseModel }, "BenchmarkService");
+        return model.baseModel;
+    }
+    /**
+     * Get test agent for benchmarking
+     *
+     * Finds a suitable test agent for running benchmarks.
+     * Prefers specific test agents, falls back to any agent if none found.
+     *
+     * @returns User record for the test agent
+     * @throws Error if no agents found in database
+     */
+    async getTestAgent() {
+        const adapter = getTrainingDataAdapter();
+        const allAgents = await adapter.getAgentUsers();
+        // Try to find a specific test agent
+        const preferredUsernames = [
+            "trader-aggressive",
+            "test-agent",
+            "benchmark-agent",
+        ];
+        let agent = allAgents.find((a) => a.username && preferredUsernames.includes(a.username));
+        // Fall back to any agent
+        if (!agent) {
+            agent = allAgents[0];
+        }
+        if (!agent) {
+            throw new Error("No test agent available for benchmarking");
+        }
+        return agent;
+    }
+    /**
+     * Normalize P&L to 0-1 scale
+     * Assumes typical range of -5000 to +5000
+     */
+    normalizePnl(pnl) {
+        const min = -5000;
+        const max = 5000;
+        const normalized = (pnl - min) / (max - min);
+        return Math.max(0, Math.min(1, normalized)); // Clamp to [0, 1]
+    }
+    /**
+     * Get benchmark summary for monitoring
+     */
+    async getBenchmarkSummary() {
+        const models = await getTrainingDataAdapter().getBenchmarkedModels(10);
+        const summary = models.map((m) => ({
+            modelId: m.modelId,
+            version: m.version,
+            score: m.benchmarkScore,
+            accuracy: m.accuracy,
+            status: m.status,
+            createdAt: m.createdAt,
+        }));
+        return {
+            totalBenchmarked: models.length,
+            topModels: summary.slice(0, 5),
+            recentModels: summary
+                .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+                .slice(0, 5),
+        };
+    }
+    /**
+     * Run benchmark on multiple models for comparison
+     */
+    async benchmarkMultipleModels(modelIds, benchmarkPath) {
+        const results = {};
+        for (const modelId of modelIds) {
+            const result = await this.benchmarkModel(modelId, benchmarkPath);
+            results[modelId] = result;
+        }
+        return results;
+    }
+}
+// Export singleton instance
+export const benchmarkService = new BenchmarkService();

package/dist/training/ConfigValidator.js

@@ -0,0 +1,153 @@
+/**
+ * Configuration Validator
+ *
+ * Validates RL pipeline configuration before execution.
+ */
+import { logger } from "../utils/logger";
+/**
+ * Validate training configuration
+ */
+export function validateTrainingConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate batch size
+    if (config.batch_size <= 0) {
+        errors.push("batch_size must be greater than 0");
+    }
+    if (config.batch_size > 64) {
+        warnings.push("batch_size > 64 may cause memory issues");
+    }
+    // Validate learning rate
+    if (config.learning_rate <= 0) {
+        errors.push("learning_rate must be greater than 0");
+    }
+    if (config.learning_rate > 1e-3) {
+        warnings.push("learning_rate > 1e-3 may cause training instability");
+    }
+    if (config.learning_rate < 1e-8) {
+        warnings.push("learning_rate < 1e-8 may be too small for effective learning");
+    }
+    // Validate KL penalty
+    if (config.kl_penalty < 0) {
+        errors.push("kl_penalty must be non-negative");
+    }
+    if (config.kl_penalty > 1.0) {
+        warnings.push("kl_penalty > 1.0 may be too high");
+    }
+    // Validate iterations
+    if (config.iterations_per_window <= 0) {
+        errors.push("iterations_per_window must be greater than 0");
+    }
+    // Validate warmup steps
+    if (config.warmup_steps < 0) {
+        errors.push("warmup_steps must be non-negative");
+    }
+    // Validate max grad norm
+    if (config.max_grad_norm <= 0) {
+        errors.push("max_grad_norm must be greater than 0");
+    }
+    // Validate gamma
+    if (config.gamma < 0 || config.gamma > 1) {
+        errors.push("gamma must be between 0 and 1");
+    }
+    // Validate min trajectories
+    if (config.min_trajectories_per_batch <= 0) {
+        errors.push("min_trajectories_per_batch must be greater than 0");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate benchmark configuration
+ */
+export function validateBenchmarkConfig(config) {
+    const errors = [];
+    const warnings = [];
+    if (config.duration_minutes <= 0) {
+        errors.push("duration_minutes must be greater than 0");
+    }
+    if (config.duration_minutes > 10080) {
+        warnings.push("duration_minutes > 10080 (1 week) may take a long time to generate");
+    }
+    if (config.tick_interval_seconds <= 0) {
+        errors.push("tick_interval_seconds must be greater than 0");
+    }
+    if (config.num_prediction_markets <= 0) {
+        errors.push("num_prediction_markets must be greater than 0");
+    }
+    if (config.num_perpetual_markets <= 0) {
+        errors.push("num_perpetual_markets must be greater than 0");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate full pipeline config
+ */
+export function validatePipelineConfig(config) {
+    const errors = [];
+    const warnings = [];
+    // Validate benchmark config
+    if (config.benchmark) {
+        const benchmarkResult = validateBenchmarkConfig({
+            duration_minutes: config.benchmark.durationMinutes,
+            tick_interval_seconds: config.benchmark.tickInterval,
+            num_prediction_markets: config.benchmark.numPredictionMarkets,
+            num_perpetual_markets: config.benchmark.numPerpetualMarkets,
+        });
+        errors.push(...benchmarkResult.errors);
+        warnings.push(...benchmarkResult.warnings);
+    }
+    // Validate training config
+    if (config.training) {
+        const trainingResult = validateTrainingConfig(config.training);
+        errors.push(...trainingResult.errors);
+        warnings.push(...trainingResult.warnings);
+    }
+    // Validate agent config
+    if (config.agents.test_agent_count <= 0) {
+        errors.push("test_agent_count must be greater than 0");
+    }
+    if (config.agents.test_agent_count > 10) {
+        warnings.push("test_agent_count > 10 may be slow");
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate and log results
+ */
+export function validateAndLog(config) {
+    const result = validatePipelineConfig(config);
+    if (result.warnings.length > 0) {
+        logger.warn("Configuration warnings", { warnings: result.warnings }, "ConfigValidator");
+        result.warnings.forEach((w) => {
+            console.log(`  ⚠️  ${w}`);
+        });
+    }
+    if (result.errors.length > 0) {
+        logger.error("Configuration errors", { errors: result.errors }, "ConfigValidator");
+        result.errors.forEach((e) => {
+            console.error(`  ❌ ${e}`);
+        });
+        return false;
+    }
+    logger.info("Configuration validation passed", undefined, "ConfigValidator");
+    return true;
+}
+/** @deprecated Use standalone functions instead */
+export const ConfigValidator = {
+    validateTrainingConfig,
+    validateBenchmarkConfig,
+    validatePipelineConfig,
+    validateAndLog,
+};

package/dist/training/MarketOutcomesTracker.js

@@ -0,0 +1,142 @@
+/**
+ * Market Outcomes Tracker
+ *
+ * Tracks market outcomes per time window for context-rich RULER judging.
+ * This gives RULER the ground truth to evaluate agent decisions.
+ */
+import { getMarketDataAdapter } from "../adapter";
+import { generateSnowflakeId, logger } from "../utils";
+import { getPreviousWindowId } from "./window-utils";
+export class MarketOutcomesTracker {
+    /**
+     * Track outcomes for a specific window
+     */
+    async trackWindowOutcomes(windowId) {
+        logger.info(`Tracking market outcomes for window: ${windowId}`);
+        const marketAdapter = getMarketDataAdapter();
+        if (!marketAdapter) {
+            logger.warn("Market data adapter not available, skipping outcome tracking");
+            return;
+        }
+        const windowStart = new Date(windowId);
+        const windowEnd = new Date(windowStart.getTime() + 60 * 60 * 1000);
+        // Get stock price movements from perpetual positions
+        const perpTrades = await marketAdapter.getPerpPositionsForWindow(windowStart, windowEnd);
+        // Group by ticker and calculate movements
+        const stockMovements = new Map();
+        for (const trade of perpTrades) {
+            if (!trade.ticker)
+                continue;
+            const existing = stockMovements.get(trade.ticker);
+            const endPrice = Number(trade.currentPrice ?? trade.exitPrice ?? trade.entryPrice);
+            if (!existing) {
+                stockMovements.set(trade.ticker, {
+                    start: Number(trade.entryPrice),
+                    end: endPrice,
+                    count: 1,
+                });
+            }
+            else {
+                // Average the prices
+                existing.end = endPrice;
+                existing.count++;
+            }
+        }
+        // Save stock outcomes
+        for (const [ticker, data] of stockMovements.entries()) {
+            const changePercent = ((data.end - data.start) / data.start) * 100;
+            await marketAdapter.insertMarketOutcome({
+                id: await generateSnowflakeId(),
+                windowId,
+                stockTicker: ticker,
+                startPrice: String(data.start),
+                endPrice: String(data.end),
+                changePercent: String(changePercent),
+                sentiment: changePercent > 0 ? "BULLISH" : "BEARISH",
+            });
+        }
+        // Get prediction market resolutions
+        const resolvedMarkets = await marketAdapter.getResolvedMarketsForWindow(windowStart, windowEnd);
+        // Save prediction outcomes
+        for (const market of resolvedMarkets) {
+            await marketAdapter.insertMarketOutcome({
+                id: await generateSnowflakeId(),
+                windowId,
+                predictionMarketId: market.id,
+                question: market.question,
+                outcome: market.outcome ? "YES" : "NO",
+                finalProbability: String(market.finalProbability ?? 0.5),
+            });
+        }
+        logger.info(`Tracked outcomes for ${windowId}`, {
+            stocks: stockMovements.size,
+            predictions: resolvedMarkets.length,
+        });
+    }
+    /**
+     * Sync outcomes for recent windows
+     */
+    async syncRecentWindows(hours = 24) {
+        logger.info(`Syncing market outcomes for last ${hours} hours`);
+        const marketAdapter = getMarketDataAdapter();
+        if (!marketAdapter) {
+            logger.warn("Market data adapter not available");
+            return 0;
+        }
+        let synced = 0;
+        for (let i = 0; i < hours; i++) {
+            const windowId = getPreviousWindowId(i);
+            // Check if already tracked
+            const exists = await marketAdapter.hasOutcomesForWindow(windowId);
+            if (!exists) {
+                await this.trackWindowOutcomes(windowId);
+                synced++;
+            }
+        }
+        logger.info(`Synced ${synced} windows`);
+        return synced;
+    }
+    /**
+     * Get outcomes for a window
+     */
+    async getWindowOutcomes(windowId) {
+        const marketAdapter = getMarketDataAdapter();
+        if (!marketAdapter) {
+            return null;
+        }
+        const outcomes = await marketAdapter.getMarketOutcomesByWindow(windowId);
+        if (outcomes.length === 0) {
+            return null;
+        }
+        // Access fields through the adapter's dynamic record type
+        const stocks = outcomes
+            .filter((o) => o.stockTicker)
+            .map((o) => {
+            const r = o;
+            return {
+                ticker: r.stockTicker,
+                startPrice: Number(r.startPrice),
+                endPrice: Number(r.endPrice),
+                changePercent: Number(r.changePercent),
+                sentiment: r.sentiment || undefined,
+                news: r.newsEvents,
+            };
+        });
+        const predictions = outcomes
+            .filter((o) => o.predictionMarketId)
+            .map((o) => {
+            const r = o;
+            return {
+                marketId: r.predictionMarketId,
+                question: r.question || "",
+                outcome: r.outcome || "UNRESOLVED",
+                finalProbability: Number(r.finalProbability || 0),
+            };
+        });
+        return {
+            windowId,
+            stocks,
+            predictions,
+        };
+    }
+}