@elizaos/training 2.0.0-alpha.10

package/python/scripts/test_generation.py

@@ -0,0 +1,29 @@
+
+import mlx.core as mx
+from mlx_lm import load, generate
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model", type=str, default="mlx-community/Qwen2.5-1.5B-Instruct-4bit")
+    parser.add_argument("--adapter-path", type=str, default="trained_models/should_respond_sft/adapters")
+    parser.add_argument("--temp", type=float, default=1.0)
+    args = parser.parse_args()
+
+    print(f"Loading {args.model} with {args.adapter_path}")
+    model, tokenizer = load(args.model, adapter_path=args.adapter_path)
+
+    prompt = "<task>Decide on behalf of Eliza whether they should respond to the message, ignore it or stop the conversation.</task>\n\n<providers>\n[RECENT_MESSAGES]\nUser: I heard Eliza is helping\n</providers>\n\n<instructions>Decide if Eliza should respond to or interact with the conversation.\n\nIMPORTANT RULES FOR RESPONDING:\n- If YOUR name (Eliza) is directly mentioned → RESPOND\n- If someone uses a DIFFERENT name (not Eliza) → IGNORE (they're talking to someone else)\n- If you're actively participating in a conversation and the message continues that thread → RESPOND\n- If someone tells you to stop or be quiet → STOP\n- Otherwise → IGNORE\n\nThe key distinction is:\n- \"Talking TO Eliza\" (your name mentioned, replies to you, continuing your conversation) → RESPOND\n- \"Talking ABOUT Eliza\" or to someone else → IGNORE\n</instructions>\n\n<output>\nDo NOT include any thinking, reasoning, or <think> sections in your response.\nGo directly to the XML response format without any preamble or explanation.\n\nRespond using XML format like this:\n<response>\n  <name>Eliza</name>\n  <reasoning>Your reasoning here</reasoning>\n  <action>RESPOND | IGNORE | STOP</action>\n</response>\n\nIMPORTANT: Your response must ONLY contain the <response></response> XML block above. Do not include any text, thinking, or reasoning before or after this XML block. Start your response immediately with <response> and end with </response>.\n</output>"
+
+    print("\n--- Gen 1 (temp={}) ---".format(args.temp))
+    from mlx_lm.sample_utils import make_sampler
+    sampler = make_sampler(temp=args.temp)
+    
+    print(generate(model, tokenizer, prompt=prompt, max_tokens=50, verbose=True, sampler=sampler))
+
+    print("\n--- Gen 2 (temp={}) ---".format(args.temp))
+    sampler2 = make_sampler(temp=args.temp)
+    print(generate(model, tokenizer, prompt=prompt, max_tokens=50, verbose=True, sampler=sampler2))
+
+if __name__ == "__main__":
+    main()

package/python/scripts/test_judge.py

@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+"""
+Test The Judge (PR #4)
+
+Loads trajectories and evaluates them using the new reward functions.
+Verifies:
+1. Financial Rewards (PnL, Risk)
+2. Format Rewards (XML validation)
+3. Reasoning Alignment (Financial Literacy)
+"""
+
+import sys
+import logging
+from pathlib import Path
+
+# Add python directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from src.data_bridge.reader import JsonTrajectoryReader
+from src.models import BabylonTrajectory
+from src.training.rewards import (
+    TrajectoryRewardInputs,
+    composite_reward,
+    calculate_pnl_reward,
+    calculate_risk_reward
+)
+from src.training.quality_utils import (
+    calculate_detailed_tick_quality,
+    validate_xml_structure
+)
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger("TheJudge")
+
+
+def evaluate_trajectory(traj: BabylonTrajectory):
+    print(f"\n--- Judging Trajectory: {traj.trajectory_id} ---")
+
+    # 1. Financials
+    # In your current JSON, you might need to calculate start/end from steps if not top-level
+    start_bal = 10000.0
+    end_bal = start_bal + traj.final_pnl
+
+    pnl_score = calculate_pnl_reward(start_bal, end_bal)
+    print(f"💰 Financials: PnL ${traj.final_pnl:.2f} -> Score: {pnl_score:.2f}")
+
+    # 2. Step-by-Step Analysis
+    total_format = 0.0
+    total_reasoning = 0.0
+    risk_penalties = 0
+    valid_steps = 0
+
+    for i, step in enumerate(traj.steps):
+        # Skip steps without LLM calls
+        if not step.llm_calls:
+            continue
+
+        valid_steps += 1
+
+        # Calculate Quality Scores
+        fmt, rsn = calculate_detailed_tick_quality(
+            step.llm_calls,
+            step.action,
+            None,  # Feedback
+            "default"
+        )
+
+        # Calculate Risk (Mocking exposure calculation for this test)
+        # Assuming open_positions count proxies for exposure roughly
+        exposure = min(1.0, step.environment_state.open_positions * 0.1)
+        action_type = step.action.action_type if step.action else "wait"
+        risk_penalty = calculate_risk_reward(exposure, action_type)
+
+        if risk_penalty < 0:
+            risk_penalties += 1
+
+        total_format += fmt
+        total_reasoning += rsn
+
+        # Log interesting steps (e.g., failed XML or high reasoning)
+        if fmt < 0:
+            print(f"   ⚠️ Step {i} Bad XML: {fmt}")
+        if rsn > 0.6:
+            print(f"   ✨ Step {i} Good Reasoning: {rsn:.2f}")
+
+    # Averages
+    avg_format = total_format / max(1, valid_steps)
+    avg_reasoning = total_reasoning / max(1, valid_steps)
+
+    print(
+        f"📝 Quality: Avg XML {avg_format:.2f} | Avg Reasoning {avg_reasoning:.2f}")
+    if risk_penalties > 0:
+        print(f"🚨 Risk: {risk_penalties} dangerous actions detected")
+
+    # 3. Final Composite Score
+    inputs = TrajectoryRewardInputs(
+        final_pnl=traj.final_pnl,
+        starting_balance=start_bal,
+        end_balance=end_bal,
+        format_score=avg_format,
+        reasoning_score=avg_reasoning,
+        risky_actions_count=risk_penalties
+    )
+
+    final_score = composite_reward(inputs)
+
+    verdict = "✅ PASSED" if final_score > 0 else "❌ FAILED"
+    print(f"⚖️  FINAL SCORE: {final_score:.4f} ({verdict})")
+
+
+def main():
+    # Look for trajectory data in the training package output directory
+    source_dir = Path(__file__).parent.parent.parent / "training-data-output" / "trajectories"
+    if not source_dir.exists():
+        # Fallback to engine output if training output doesn't exist
+        source_dir = Path(__file__).parent.parent.parent.parent / "engine" / "training-data-output" / "trajectories"
+    
+    # Validate that at least one path exists
+    if not source_dir.exists():
+        logger.error("No trajectory data found. Checked paths:")
+        logger.error(f"  - {Path(__file__).parent.parent.parent / 'training-data-output' / 'trajectories'}")
+        logger.error(f"  - {source_dir}")
+        logger.error("Run 'make tier4-generate' or 'bun run packages/engine/examples/generate-training-data.ts' first.")
+        sys.exit(1)
+    
+    source_dir = str(source_dir)
+    try:
+        reader = JsonTrajectoryReader(source_dir)
+        window_ids = reader.get_window_ids()
+
+        count = 0
+        for window_id in window_ids:
+            raw_trajs = reader.get_trajectories_by_window(window_id)
+            for raw in raw_trajs:
+                if 'trajectory' in raw:
+                    raw = raw['trajectory']
+                if isinstance(raw.get('stepsJson'), str):
+                    import json
+                    raw['steps'] = json.loads(raw['stepsJson'])
+
+                try:
+                    traj = BabylonTrajectory.model_validate(raw)
+                    evaluate_trajectory(traj)
+                    count += 1
+                    if count >= 5:
+                        return  # Just test 5 for now
+                except Exception as e:
+                    print(f"Skipping invalid: {e}")
+
+    except Exception as e:
+        logger.error(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

package/python/scripts/test_pipeline.py

@@ -0,0 +1,356 @@
+#!/usr/bin/env python3
+"""
+ElizaOS Training Pipeline - End-to-End Test
+
+This script validates the complete training pipeline:
+1. Database connectivity
+2. Real trajectory data loading
+3. Data conversion to training format
+4. Backend availability (MLX/CUDA/CPU)
+
+Run this BEFORE training to verify everything is set up correctly.
+
+Usage:
+    python scripts/test_pipeline.py
+"""
+
+import asyncio
+import logging
+import os
+import sys
+from pathlib import Path
+
+# Add src to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from dotenv import load_dotenv
+
+# Load environment
+env_path = Path(__file__).parent.parent.parent.parent.parent / ".env"
+if env_path.exists():
+    load_dotenv(env_path)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(levelname)s] %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+class TestResult:
+    def __init__(self, name: str):
+        self.name = name
+        self.passed = False
+        self.message = ""
+        self.details: dict = {}
+
+
+async def test_database_connection() -> TestResult:
+    """Test database connectivity."""
+    result = TestResult("Database Connection")
+    
+    database_url = os.getenv("DATABASE_URL", "")
+    if not database_url:
+        result.message = "DATABASE_URL not set"
+        return result
+    
+    try:
+        import asyncpg
+        pool = await asyncpg.create_pool(database_url, min_size=1, max_size=2)
+        
+        # Test query
+        async with pool.acquire() as conn:
+            count = await conn.fetchval("SELECT COUNT(*) FROM trajectories")
+        
+        await pool.close()
+        
+        result.passed = True
+        result.message = f"Connected. Found {count} trajectories"
+        result.details["trajectory_count"] = count
+        
+    except Exception as e:
+        result.message = f"Connection failed: {e}"
+    
+    return result
+
+
+async def test_trajectory_data() -> TestResult:
+    """Test that real trajectory data exists."""
+    result = TestResult("Real Trajectory Data")
+    
+    database_url = os.getenv("DATABASE_URL", "")
+    if not database_url:
+        result.message = "DATABASE_URL not set"
+        return result
+    
+    try:
+        from src.data_bridge import PostgresTrajectoryReader
+        
+        async with PostgresTrajectoryReader(database_url) as reader:
+            windows = await reader.get_window_ids(min_agents=1, lookback_hours=168)
+            
+            if not windows:
+                result.message = "No trajectory windows found"
+                return result
+            
+            # Load trajectories from first window
+            trajectories = await reader.get_trajectories_by_window(
+                windows[0], min_actions=1
+            )
+            
+            # Count those with LLM calls
+            with_llm_calls = 0
+            total_llm_calls = 0
+            
+            for traj in trajectories:
+                has_calls = False
+                for step in traj.steps:
+                    if step.llm_calls:
+                        total_llm_calls += len(step.llm_calls)
+                        has_calls = True
+                if has_calls:
+                    with_llm_calls += 1
+            
+            result.passed = with_llm_calls > 0
+            result.message = (
+                f"Found {len(windows)} windows, "
+                f"{len(trajectories)} trajectories in first window, "
+                f"{with_llm_calls} have LLM calls ({total_llm_calls} total calls)"
+            )
+            result.details = {
+                "windows": len(windows),
+                "trajectories": len(trajectories),
+                "with_llm_calls": with_llm_calls,
+                "total_llm_calls": total_llm_calls,
+            }
+            
+    except Exception as e:
+        result.message = f"Failed: {e}"
+        import traceback
+        traceback.print_exc()
+    
+    return result
+
+
+async def test_data_conversion() -> TestResult:
+    """Test conversion of trajectories to training samples."""
+    result = TestResult("Data Conversion")
+    
+    database_url = os.getenv("DATABASE_URL", "")
+    if not database_url:
+        result.message = "DATABASE_URL not set"
+        return result
+    
+    try:
+        from src.data_bridge import PostgresTrajectoryReader
+        
+        async with PostgresTrajectoryReader(database_url) as reader:
+            windows = await reader.get_window_ids(min_agents=1, lookback_hours=168)
+            
+            if not windows:
+                result.message = "No windows found"
+                return result
+            
+            trajectories = await reader.get_trajectories_by_window(
+                windows[0], min_actions=1
+            )
+        
+        # Convert to training samples
+        samples = []
+        for traj in trajectories:
+            for step in traj.steps:
+                if not step.llm_calls:
+                    continue
+                
+                for llm_call in step.llm_calls:
+                    if not llm_call.response or len(llm_call.response) < 20:
+                        continue
+                    
+                    messages = []
+                    if llm_call.system_prompt:
+                        messages.append({"role": "system", "content": llm_call.system_prompt})
+                    if llm_call.user_prompt:
+                        messages.append({"role": "user", "content": llm_call.user_prompt})
+                    messages.append({"role": "assistant", "content": llm_call.response})
+                    
+                    if len(messages) >= 2:
+                        samples.append({"messages": messages})
+        
+        result.passed = len(samples) >= 10
+        result.message = f"Created {len(samples)} training samples"
+        result.details["samples"] = len(samples)
+        
+        if len(samples) > 0:
+            # Show sample
+            sample = samples[0]
+            result.details["sample_preview"] = {
+                "roles": [m["role"] for m in sample["messages"]],
+                "lengths": [len(m["content"]) for m in sample["messages"]],
+            }
+        
+    except Exception as e:
+        result.message = f"Failed: {e}"
+        import traceback
+        traceback.print_exc()
+    
+    return result
+
+
+def test_mlx_backend() -> TestResult:
+    """Test MLX backend availability."""
+    result = TestResult("MLX Backend")
+    
+    try:
+        import mlx.core as mx
+        import mlx_lm
+        
+        result.passed = True
+        result.message = f"MLX available (mlx-lm version: {mlx_lm.__version__})"
+        
+    except ImportError as e:
+        result.message = f"MLX not available: {e}"
+    
+    return result
+
+
+def test_cuda_backend() -> TestResult:
+    """Test CUDA backend availability."""
+    result = TestResult("CUDA Backend")
+    
+    try:
+        import torch
+        
+        if torch.cuda.is_available():
+            device_name = torch.cuda.get_device_name(0)
+            vram = torch.cuda.get_device_properties(0).total_memory / 1e9
+            
+            result.passed = True
+            result.message = f"CUDA available: {device_name} ({vram:.1f} GB)"
+            result.details = {
+                "device": device_name,
+                "vram_gb": vram,
+            }
+        else:
+            result.message = "PyTorch installed but CUDA not available"
+            
+    except ImportError as e:
+        result.message = f"PyTorch not installed: {e}"
+    
+    return result
+
+
+def test_transformers() -> TestResult:
+    """Test transformers library."""
+    result = TestResult("Transformers Library")
+    
+    try:
+        import transformers
+        
+        result.passed = True
+        result.message = f"transformers {transformers.__version__}"
+        
+    except ImportError as e:
+        result.message = f"Not installed: {e}"
+    
+    return result
+
+
+def test_environment_variables() -> TestResult:
+    """Test required environment variables."""
+    result = TestResult("Environment Variables")
+    
+    checks = {
+        "DATABASE_URL": bool(os.getenv("DATABASE_URL")),
+        "OPENAI_API_KEY": bool(os.getenv("OPENAI_API_KEY")),
+        "TINKER_API_KEY": bool(os.getenv("TINKER_API_KEY")),
+    }
+    
+    required = ["DATABASE_URL"]
+    optional = ["OPENAI_API_KEY", "TINKER_API_KEY"]
+    
+    missing_required = [k for k in required if not checks[k]]
+    missing_optional = [k for k in optional if not checks[k]]
+    
+    result.passed = len(missing_required) == 0
+    
+    if result.passed:
+        result.message = f"Required vars set. Optional missing: {', '.join(missing_optional) or 'none'}"
+    else:
+        result.message = f"Missing required: {', '.join(missing_required)}"
+    
+    result.details = checks
+    return result
+
+
+async def main():
+    """Run all tests."""
+    print("=" * 70)
+    print("  ELIZAOS TRAINING PIPELINE - END-TO-END TEST")
+    print("=" * 70)
+    print()
+    
+    # Run tests
+    tests = [
+        ("Environment Variables", test_environment_variables()),
+        ("Database Connection", await test_database_connection()),
+        ("Real Trajectory Data", await test_trajectory_data()),
+        ("Data Conversion", await test_data_conversion()),
+        ("Transformers Library", test_transformers()),
+        ("MLX Backend", test_mlx_backend()),
+        ("CUDA Backend", test_cuda_backend()),
+    ]
+    
+    passed = 0
+    failed = 0
+    
+    for name, result in tests:
+        status = "✅" if result.passed else "❌"
+        print(f"{status} {result.name}")
+        print(f"   {result.message}")
+        if result.details:
+            for k, v in result.details.items():
+                if k != "sample_preview":
+                    print(f"   - {k}: {v}")
+        print()
+        
+        if result.passed:
+            passed += 1
+        else:
+            failed += 1
+    
+    # Summary
+    print("=" * 70)
+    print(f"  RESULTS: {passed} passed, {failed} failed")
+    print("=" * 70)
+    
+    # Required checks
+    required_tests = [
+        "Environment Variables",
+        "Database Connection", 
+        "Real Trajectory Data",
+        "Data Conversion",
+    ]
+    
+    required_passed = all(
+        result.passed for name, result in tests 
+        if result.name in required_tests
+    )
+    
+    if required_passed:
+        print()
+        print("✅ All required checks passed!")
+        print()
+        print("Ready to train. Run:")
+        print("  python scripts/train_local.py")
+        print()
+        return 0
+    else:
+        print()
+        print("❌ Some required checks failed. Fix issues before training.")
+        print()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(asyncio.run(main()))
+