synth-ai 0.2.2.dev0__py3-none-any.whl → 0.2.3__py3-none-any.whl

synth_ai/environments/examples/crafter_classic/agent_demos/crafter_openai_ft/filter_traces_sft_turso.py

@@ -0,0 +1,580 @@
+#!/usr/bin/env python3
+"""
+Filter traces from Turso/SQLite (v3) to create OpenAI SFT-ready .jsonl files
+Supports two modes:
+1. Trajectory-level filtering: Include entire trajectories above a score threshold
+2. Window-based filtering: Extract high-scoring windows of actions
+
+This is the v3 version using the new async Turso-based tracing system.
+"""
+
+import json
+import argparse
+import asyncio
+from pathlib import Path
+from typing import List, Dict, Any, Tuple, Optional
+from collections import defaultdict
+import numpy as np
+import os
+import sys
+import toml
+import pandas as pd
+
+# Add synth_ai to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent.parent))
+
+from synth_ai.tracing_v3 import SessionTracer
+from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
+from synth_ai.tracing_v3.abstractions import LMCAISEvent, EnvironmentEvent, RuntimeEvent
+
+
+def create_histogram(data: List[float], bins: int = 20, width: int = 60, height: int = 15, 
+                    title: str = "", x_label: str = "", y_label: str = "") -> str:
+    """Create a beautiful ASCII histogram."""
+    if not data:
+        return "No data to display"
+    
+    # Create histogram
+    counts, edges = np.histogram(data, bins=bins)
+    max_count = max(counts) if len(counts) > 0 else 1
+    
+    # Normalize heights
+    if max_count > 0:
+        heights = [int(c * height / max_count) for c in counts]
+    else:
+        heights = [0] * len(counts)
+    
+    # Build the plot
+    lines = []
+    
+    # Title
+    if title:
+        lines.append(f"\n{title.center(width + 10)}")
+        lines.append("=" * (width + 10))
+    
+    # Y-axis label
+    if y_label:
+        lines.append(f"{y_label}")
+    
+    # Plot area with y-axis
+    for y in range(height, 0, -1):
+        # Y-axis value
+        y_val = int(max_count * y / height)
+        line = f"{y_val:>6} │"
+        
+        # Bars
+        for h in heights:
+            if h >= y:
+                line += "█"
+            else:
+                line += " "
+        
+        lines.append(line)
+    
+    # X-axis
+    lines.append(f"{'':>6} └" + "─" * len(heights))
+    
+    # X-axis labels
+    x_labels_line = " " * 8
+    min_val, max_val = min(data), max(data)
+    
+    # Add labels at key positions
+    label_positions = [0, len(heights)//4, len(heights)//2, 3*len(heights)//4, len(heights)-1]
+    for i, pos in enumerate(label_positions):
+        if pos < len(edges) - 1:
+            val = edges[pos]
+            label = f"{val:.1f}"
+            # Calculate position
+            target_pos = 8 + pos
+            if i == 0:
+                x_labels_line = label + x_labels_line[len(label):]
+            elif i == len(label_positions) - 1:
+                start = max(0, target_pos - len(label))
+                x_labels_line = x_labels_line[:start] + label
+            else:
+                start = max(0, target_pos - len(label)//2)
+                end = min(len(x_labels_line), start + len(label))
+                if start < len(x_labels_line):
+                    x_labels_line = x_labels_line[:start] + label[:end-start] + x_labels_line[end:]
+    
+    lines.append(x_labels_line)
+    
+    # X-axis label
+    if x_label:
+        lines.append(f"\n{x_label.center(width + 10)}")
+    
+    return "\n".join(lines)
+
+
+def create_bar_chart(categories: List[str], values: List[int], width: int = 60, 
+                     title: str = "", show_values: bool = True) -> str:
+    """Create a horizontal bar chart."""
+    if not categories or not values:
+        return "No data to display"
+    
+    max_val = max(values) if values else 1
+    lines = []
+    
+    # Title
+    if title:
+        lines.append(f"\n{title}")
+        lines.append("=" * (width + 20))
+    
+    # Find longest category name for alignment
+    max_cat_len = max(len(cat) for cat in categories)
+    
+    # Create bars
+    for cat, val in zip(categories, values):
+        # Normalize bar length
+        bar_len = int(val * width / max_val) if max_val > 0 else 0
+        bar = "█" * bar_len
+        
+        # Format line
+        if show_values:
+            line = f"{cat:<{max_cat_len}} │ {bar} {val}"
+        else:
+            line = f"{cat:<{max_cat_len}} │ {bar}"
+        
+        lines.append(line)
+    
+    return "\n".join(lines)
+
+
+class FinetuningDataExtractorV3:
+    """Extract fine-tuning data from v3 Turso traces."""
+    
+    def __init__(self, db_url: str):
+        self.db_manager = AsyncSQLTraceManager(db_url)
+        self._initialized = False
+    
+    async def __aenter__(self):
+        await self.db_manager.initialize()
+        self._initialized = True
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.db_manager.close()
+    
+    async def get_all_sessions(self) -> pd.DataFrame:
+        """Get all session IDs from the database."""
+        query = """
+        SELECT DISTINCT session_id, created_at
+        FROM session_traces
+        ORDER BY created_at DESC
+        """
+        return await self.db_manager.query_traces(query)
+    
+    async def get_session_metrics(self, session_id: str) -> Dict[str, Any]:
+        """Get metrics for a specific session."""
+        # Get total reward from environment events
+        reward_query = """
+        SELECT COALESCE(SUM(CAST(data->>'reward' AS REAL)), 0) as total_reward
+        FROM events
+        WHERE session_id = :session_id
+        AND event_type = 'environment'
+        AND data->>'reward' IS NOT NULL
+        """
+        reward_df = await self.db_manager.query_traces(reward_query, {"session_id": session_id})
+        total_reward = float(reward_df['total_reward'].iloc[0]) if not reward_df.empty else 0.0
+        
+        # Get total tokens and cost from LM events
+        lm_query = """
+        SELECT 
+            COALESCE(SUM(CAST(data->>'total_tokens' AS INTEGER)), 0) as total_tokens,
+            COALESCE(SUM(CAST(data->>'cost_usd' AS REAL)), 0) as total_cost
+        FROM events
+        WHERE session_id = :session_id
+        AND event_type = 'lm_cais'
+        """
+        lm_df = await self.db_manager.query_traces(lm_query, {"session_id": session_id})
+        
+        total_tokens = int(lm_df['total_tokens'].iloc[0]) if not lm_df.empty else 0
+        total_cost = float(lm_df['total_cost'].iloc[0]) if not lm_df.empty else 0.0
+        
+        return {
+            'session_id': session_id,
+            'total_reward': total_reward,
+            'total_tokens': total_tokens,
+            'total_cost': total_cost
+        }
+    
+    async def get_session_achievements(self, session_id: str) -> List[str]:
+        """Get list of achievements unlocked in a session."""
+        # Look for achievement events in environment data
+        query = """
+        SELECT DISTINCT data->>'$.system_state_after.achievements_status' as achievements
+        FROM events
+        WHERE session_id = :session_id
+        AND event_type = 'environment'
+        AND data->>'$.system_state_after.achievements_status' IS NOT NULL
+        ORDER BY created_at DESC
+        LIMIT 1
+        """
+        df = await self.db_manager.query_traces(query, {"session_id": session_id})
+        
+        if df.empty:
+            return []
+        
+        try:
+            # Parse the achievements JSON
+            achievements_str = df['achievements'].iloc[0]
+            if achievements_str:
+                achievements = json.loads(achievements_str)
+                # Return list of unlocked achievements
+                return [k for k, v in achievements.items() if v]
+        except:
+            pass
+        
+        return []
+    
+    async def filter_by_achievements(self, min_achievements: int) -> List[str]:
+        """Get sessions with at least min_achievements unlocked."""
+        all_sessions = await self.get_all_sessions()
+        qualifying_sessions = []
+        
+        for _, row in all_sessions.iterrows():
+            session_id = row['session_id']
+            achievements = await self.get_session_achievements(session_id)
+            if len(achievements) >= min_achievements:
+                qualifying_sessions.append(session_id)
+        
+        return qualifying_sessions
+    
+    async def extract_openai_format(self, session_ids: List[str], min_reward: float = 0.0) -> List[Dict[str, Any]]:
+        """Extract training data in OpenAI format from filtered sessions."""
+        training_data = []
+        
+        for session_id in session_ids:
+            # Get session trace
+            trace_data = await self.db_manager.get_session_trace(session_id)
+            if not trace_data:
+                continue
+            
+            # Build conversation history
+            messages = []
+            
+            # Add system message if available
+            system_message = None
+            for timestep in trace_data.get('timesteps', []):
+                for msg in timestep.get('messages', []):
+                    if msg['message_type'] == 'system' and system_message is None:
+                        system_message = msg['content']
+                        break
+                if system_message:
+                    break
+            
+            if system_message:
+                messages.append({"role": "system", "content": system_message})
+            
+            # Process timesteps in order
+            for timestep in sorted(trace_data.get('timesteps', []), key=lambda x: x['turn_number']):
+                # Add messages from this timestep
+                for msg in timestep.get('messages', []):
+                    if msg['message_type'] == 'user':
+                        messages.append({"role": "user", "content": msg['content']})
+                    elif msg['message_type'] == 'assistant':
+                        messages.append({"role": "assistant", "content": msg['content']})
+            
+            # Only include if we have a complete conversation
+            if len(messages) > 1:
+                training_data.append({
+                    "messages": messages,
+                    "metadata": {
+                        "session_id": session_id,
+                        "total_reward": trace_data.get('metadata', {}).get('total_reward', 0)
+                    }
+                })
+        
+        return training_data
+
+
+async def filter_traces_from_turso(
+    db_url: str,
+    output_path: str,
+    config: Dict[str, Any]
+) -> Tuple[int, Dict[str, Any]]:
+    """
+    Filter traces from Turso/SQLite v3 database based on configuration.
+    
+    Returns:
+        Tuple of (num_examples, statistics_dict)
+    """
+    mode = config.get("mode", "trajectory")
+    filters = config.get("filters", {})
+    
+    # Extract filtering parameters
+    min_reward = filters.get("min_total_reward", 0.0)
+    min_achievements = filters.get("min_achievements", 0)
+    max_cost = filters.get("max_cost", float('inf'))
+    max_tokens = filters.get("max_tokens", float('inf'))
+    
+    # OpenAI specific: filter by model if specified
+    target_models = filters.get("models", [])
+    
+    statistics = {
+        "total_sessions": 0,
+        "filtered_sessions": 0,
+        "total_examples": 0,
+        "reward_distribution": [],
+        "token_distribution": [],
+        "cost_distribution": [],
+        "model_distribution": defaultdict(int)
+    }
+    
+    async with FinetuningDataExtractorV3(db_url) as extractor:
+        # Get all sessions
+        all_sessions = await extractor.get_all_sessions()
+        statistics["total_sessions"] = len(all_sessions)
+        
+        # Filter sessions based on criteria
+        filtered_sessions = []
+        
+        for _, row in all_sessions.iterrows():
+            session_id = row['session_id']
+            metrics = await extractor.get_session_metrics(session_id)
+            
+            # Apply filters
+            if metrics['total_reward'] < min_reward:
+                continue
+            if metrics['total_cost'] > max_cost:
+                continue
+            if metrics['total_tokens'] > max_tokens:
+                continue
+            
+            # Check achievements if required
+            if min_achievements > 0:
+                achievements = await extractor.get_session_achievements(session_id)
+                if len(achievements) < min_achievements:
+                    continue
+            
+            # Check model filter if specified
+            if target_models:
+                model_query = """
+                    SELECT DISTINCT data->>'model_name' as model_name
+                    FROM events
+                    WHERE session_id = :session_id
+                    AND event_type = 'lm_cais'
+                    AND data->>'model_name' IS NOT NULL
+                """
+                model_df = await extractor.db_manager.query_traces(
+                    model_query, {"session_id": session_id}
+                )
+                session_models = model_df['model_name'].tolist() if not model_df.empty else []
+                if not any(model in target_models for model in session_models):
+                    continue
+            
+            filtered_sessions.append(session_id)
+            
+            # Collect statistics
+            statistics["reward_distribution"].append(metrics['total_reward'])
+            statistics["token_distribution"].append(metrics['total_tokens'])
+            statistics["cost_distribution"].append(metrics['total_cost'])
+        
+        statistics["filtered_sessions"] = len(filtered_sessions)
+        
+        # Extract training data
+        if mode == "trajectory":
+            training_data = await extractor.extract_openai_format(
+                session_ids=filtered_sessions,
+                min_reward=min_reward
+            )
+        else:  # window mode
+            # For window mode, we need to implement window extraction
+            # For now, use trajectory mode
+            training_data = await extractor.extract_openai_format(
+                session_ids=filtered_sessions,
+                min_reward=min_reward
+            )
+        
+        statistics["total_examples"] = len(training_data)
+        
+        # Write to output file
+        output_file = Path(output_path)
+        output_file.parent.mkdir(exist_ok=True)
+        
+        with open(output_file, 'w') as f:
+            for example in training_data:
+                f.write(json.dumps(example) + '\n')
+        
+        # Get model distribution
+        model_query = """
+            SELECT data->>'model_name' as model_name, COUNT(*) as count
+            FROM events
+            WHERE event_type = 'lm_cais'
+            AND data->>'model_name' IS NOT NULL
+            GROUP BY data->>'model_name'
+        """
+        model_stats = await extractor.db_manager.query_traces(model_query)
+        for _, row in model_stats.iterrows():
+            statistics["model_distribution"][row['model_name']] = int(row['count'])
+    
+    return len(training_data), statistics
+
+
+def print_statistics(stats: Dict[str, Any]):
+    """Print filtering statistics with visualizations."""
+    print("\n" + "="*80)
+    print("FILTERING STATISTICS (OpenAI - v3)")
+    print("="*80)
+    
+    # Basic counts
+    print(f"\nTotal sessions in database: {stats['total_sessions']}")
+    print(f"Sessions after filtering: {stats['filtered_sessions']}")
+    print(f"Training examples generated: {stats['total_examples']}")
+    
+    filter_rate = (stats['filtered_sessions'] / stats['total_sessions'] * 100) if stats['total_sessions'] > 0 else 0
+    print(f"Filter pass rate: {filter_rate:.1f}%")
+    
+    # Reward distribution
+    if stats['reward_distribution'] and any(not np.isnan(x) for x in stats['reward_distribution']):
+        valid_rewards = [x for x in stats['reward_distribution'] if not np.isnan(x)]
+        if valid_rewards:
+            print(create_histogram(
+                valid_rewards,
+                bins=20,
+                title="Reward Distribution",
+                x_label="Total Reward",
+                y_label="Count"
+            ))
+            
+            print(f"\nReward statistics:")
+            print(f"  Min: {min(valid_rewards):.2f}")
+            print(f"  Max: {max(valid_rewards):.2f}")
+            print(f"  Mean: {np.mean(valid_rewards):.2f}")
+            print(f"  Median: {np.median(valid_rewards):.2f}")
+    else:
+        print("\nNo valid reward data to display.")
+    
+    # Token distribution
+    if stats['token_distribution'] and any(not np.isnan(x) for x in stats['token_distribution']):
+        valid_tokens = [x for x in stats['token_distribution'] if not np.isnan(x)]
+        if valid_tokens:
+            print(create_histogram(
+                valid_tokens,
+                bins=20,
+                title="Token Usage Distribution",
+                x_label="Total Tokens",
+                y_label="Count"
+            ))
+    
+    # Model distribution
+    if stats['model_distribution']:
+        models = list(stats['model_distribution'].keys())
+        counts = list(stats['model_distribution'].values())
+        print(create_bar_chart(
+            models,
+            counts,
+            title="Model Usage",
+            show_values=True
+        ))
+    
+    print("\n" + "="*80)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Filter traces from Turso/SQLite v3 for OpenAI fine-tuning",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Example usage:
+  # Use default config
+  python filter_traces_sft_turso.py -d sqlite:///traces.db -o ft_data/training.jsonl
+  
+  # Use custom config file
+  python filter_traces_sft_turso.py -d sqlite:///traces.db -c filter_config.toml
+  
+  # Override config parameters
+  python filter_traces_sft_turso.py -d sqlite:///traces.db --min-reward 5.0 --max-cost 0.1
+  
+  # Filter by model
+  python filter_traces_sft_turso.py -d sqlite:///traces.db --models "gpt-4" "gpt-3.5-turbo"
+        """
+    )
+    
+    parser.add_argument('-d', '--database', required=True, help='Path to Turso/SQLite database or connection URL')
+    parser.add_argument('-o', '--output', default='ft_data/training_openai.jsonl', help='Output JSONL file')
+    parser.add_argument('-c', '--config', help='Configuration TOML file')
+    
+    # Filter overrides
+    parser.add_argument('--mode', choices=['trajectory', 'window'], help='Filtering mode')
+    parser.add_argument('--min-reward', type=float, help='Minimum total reward')
+    parser.add_argument('--min-achievements', type=int, help='Minimum achievements')
+    parser.add_argument('--max-cost', type=float, help='Maximum cost')
+    parser.add_argument('--max-tokens', type=int, help='Maximum tokens')
+    parser.add_argument('--models', nargs='+', help='Filter by model names (e.g., gpt-4 gpt-3.5-turbo)')
+    
+    parser.add_argument('--dry-run', action='store_true', help='Show statistics without writing output')
+    
+    args = parser.parse_args()
+    
+    # Load config
+    config = {
+        "mode": "trajectory",
+        "filters": {
+            "min_total_reward": 1.0,
+            "min_achievements": 0,
+            "max_cost": 10.0,
+            "max_tokens": 100000,
+            "models": []  # Empty means all models
+        }
+    }
+    
+    if args.config:
+        with open(args.config, 'r') as f:
+            loaded_config = toml.load(f)
+            config.update(loaded_config)
+    
+    # Apply command-line overrides
+    if args.mode:
+        config["mode"] = args.mode
+    if args.min_reward is not None:
+        config["filters"]["min_total_reward"] = args.min_reward
+    if args.min_achievements is not None:
+        config["filters"]["min_achievements"] = args.min_achievements
+    if args.max_cost is not None:
+        config["filters"]["max_cost"] = args.max_cost
+    if args.max_tokens is not None:
+        config["filters"]["max_tokens"] = args.max_tokens
+    if args.models:
+        config["filters"]["models"] = args.models
+    
+    # Convert database path to proper URL format if needed
+    db_url = args.database
+    if db_url.startswith("sqlite:///"):
+        # Already in URL format
+        pass
+    elif db_url.endswith(".db"):
+        # Convert file path to URL
+        db_url = f"sqlite+aiosqlite:///{db_url}"
+    
+    print(f"🤖 OpenAI Fine-Tuning Data Filter (v3)")
+    print(f"Using database: {db_url}")
+    print(f"Output file: {args.output}")
+    print(f"Mode: {config['mode']}")
+    print(f"Filters: {json.dumps(config['filters'], indent=2)}")
+    
+    if args.dry_run:
+        print("\n🔍 DRY RUN - No output will be written")
+    
+    # Run filtering
+    async def run():
+        num_examples, stats = await filter_traces_from_turso(
+            db_url,
+            args.output if not args.dry_run else "/dev/null",
+            config
+        )
+        
+        # Print statistics
+        print_statistics(stats)
+        
+        if not args.dry_run:
+            print(f"\n✅ Successfully wrote {num_examples} training examples to {args.output}")
+            print(f"   Ready for OpenAI fine-tuning!")
+        else:
+            print(f"\n✅ Would write {num_examples} training examples (dry run)")
+    
+    asyncio.run(run())
+
+
+if __name__ == "__main__":
+    main()