synth-ai 0.2.4.dev7__py3-none-any.whl → 0.2.4.dev9__py3-none-any.whl

synth_ai/environments/examples/crafter_classic/agent_demos/old/crafter_env_serialization.py

@@ -0,0 +1,464 @@
+"""
+MCTS Implementation Guide for Crafter Environment
+================================================
+
+Based on analysis of Pokemon RED and Sokoban MCTS implementations, here's how we could 
+implement Monte Carlo Tree Search for the Crafter environment:
+
+1. **State Serialization & Tree Storage**
+   - Use FilesystemSnapshotStore and TrajectoryTreeStore (like RED)
+   - Serialize Crafter environment state using pickle + gzip compression
+   - Each tree node stores a complete environment snapshot
+   - Child nodes are created by taking actions from parent states
+
+2. **Action Space**
+   - Crafter has 17 discrete actions: noop, move(4), do, place_stone, place_table, 
+     place_furnace, place_plant, make_wood_pickaxe, make_stone_pickaxe, 
+     make_iron_pickaxe, make_wood_sword, make_stone_sword, make_iron_sword
+   - Much larger than Pokemon's 8 buttons, so may need action filtering
+
+3. **Heuristic Evaluation Function**
+   Key metrics to consider for Crafter:
+   - Achievements unlocked (primary objective)
+   - Health, hunger, thirst levels (survival)
+   - Inventory contents (resources, tools, weapons)
+   - Distance to nearest resources (exploration bonus)
+   - Day/night cycle position
+   - Proximity to dangers (zombies, skeletons)
+   
+   Example scoring:
+   ```python
+   score = 0.0
+   score += len(achievements) * 100  # Major reward for achievements
+   score += health * 5
+   score += (9 - hunger) * 2  # Lower hunger is better
+   score += (9 - thirst) * 2  # Lower thirst is better
+   score += inventory_value()  # Value of items
+   score -= day_count * 0.1   # Slight penalty for time
+   ```
+
+4. **Terminal State Detection**
+   - All achievements unlocked (win)
+   - Player health reaches 0 (loss)
+   - Maximum steps/days reached (timeout)
+
+5. **Rollout Policy**
+   - Random actions work poorly in Crafter due to survival mechanics
+   - Consider biased rollouts:
+     * Prioritize "do" action near resources
+     * Avoid moving into danger zones
+     * Seek food/water when low
+   - Alternatively, use a simple policy network
+
+6. **MCTS Algorithm Structure**
+   ```python
+   async def crafter_mcts_plan(tree, root_id, rollouts_per_action=10, max_depth=20):
+       plan = []
+       node_id = root_id
+       
+       for depth in range(max_depth):
+           # Load environment from node
+           env = deserialize_crafter_env(tree.load_snapshot_blob(node_id))
+           
+           if is_terminal(env):
+               break
+               
+           # Evaluate each action
+           q_values = {}
+           for action in CRAFTER_ACTIONS:
+               # Expand node if needed
+               child_id = expand_if_needed(tree, node_id, action, env)
+               
+               # Run rollouts from child state
+               scores = []
+               for _ in range(rollouts_per_action):
+                   score = await rollout(child_env, max_steps=50)
+                   scores.append(score)
+               
+               q_values[action] = np.mean(scores)
+           
+           # Select best action
+           best_action = max(q_values, key=q_values.get)
+           plan.append(best_action)
+           node_id = get_child_for_action(tree, node_id, best_action)
+       
+       return plan
+   ```
+
+7. **Optimizations for Crafter**
+   - **Action Filtering**: Not all 17 actions are valid at every state
+     * Can't craft without resources
+     * Can't place objects without them in inventory
+     * Filter invalid actions before expansion
+   
+   - **Progressive Widening**: Start with core actions (move, do), 
+     gradually add crafting actions as resources are collected
+   
+   - **Domain Knowledge Integration**:
+     * Prioritize water/food collection when low
+     * Seek shelter at night
+     * Maintain tool progression (wood � stone � iron)
+
+8. **Challenges Specific to Crafter**
+   - Long-horizon planning required (achievements need multi-step sequences)
+   - Day/night cycle adds urgency 
+   - Resource management is critical
+   - Combat situations need quick responses
+   - Much richer state space than Pokemon RED movement
+
+9. **Implementation Steps**
+   1. Create serialization methods for CrafterEnvironment
+   2. Implement heuristic scoring based on game state
+   3. Build MCTS planner with Crafter-specific optimizations
+   4. Add action filtering and validity checking
+   5. Test on simple achievement sequences first
+   6. Gradually increase complexity to full achievement set
+
+The key insight from RED's implementation is that MCTS works well for exploration
+and planning in environments with discrete actions and clear progress metrics.
+Crafter's achievement system provides natural waypoints for the search tree.
+"""
+
+# ============================================================================
+# CRAFTER ENVIRONMENT SERIALIZATION TESTS
+# ============================================================================
+
+import asyncio
+import gzip
+import pickle
+import tempfile
+from pathlib import Path
+from typing import Dict, Any
+
+import pytest
+
+from synth_ai.environments.examples.crafter_classic.environment import CrafterClassicEnvironment
+from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstance
+from synth_ai.environments.environment.tools import EnvToolCall
+from synth_ai.environments.reproducibility.tree import FilesystemSnapshotStore, TrajectoryTreeStore
+
+
+@pytest.mark.asyncio
+async def test_basic_crafter_serialization():
+    """Test basic serialization/deserialization of Crafter environment."""
+    # Create task instance
+    from synth_ai.environments.tasks.core import Impetus, Intent
+    from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstanceMetadata
+    from uuid import uuid4
+    
+    metadata = CrafterTaskInstanceMetadata(
+        difficulty="easy", 
+        seed=42,
+        num_trees_radius=5,
+        num_cows_radius=2,
+        num_hostiles_radius=0
+    )
+    task = CrafterTaskInstance(
+        id=uuid4(),
+        impetus=Impetus(instructions="Test serialization"),
+        intent=Intent(rubric={"goal": "Test"}, gold_trajectories=None, gold_state_diff={}),
+        metadata=metadata,
+        is_reproducible=True,
+        initial_engine_snapshot=None
+    )
+    
+    # Create and initialize environment
+    env = CrafterClassicEnvironment(task)
+    await env.initialize()
+    
+    # Get initial state
+    initial_snapshot = await env._serialize_engine()
+    initial_pub = env.engine._get_public_state_from_env()
+    
+    # Take a few actions
+    actions = [
+        EnvToolCall(tool="interact", args={"action": 5}),  # do
+        EnvToolCall(tool="interact", args={"action": 2}),  # right
+        EnvToolCall(tool="interact", args={"action": 5}),  # do
+    ]
+    
+    for action in actions:
+        await env.step(action)
+    
+    # Get state after actions
+    after_pub = env.engine._get_public_state_from_env()
+    after_snapshot = await env._serialize_engine()
+    
+    # Verify state changed
+    assert initial_pub.player_position != after_pub.player_position or initial_pub.inventory != after_pub.inventory
+    assert initial_snapshot.total_reward_snapshot != after_snapshot.total_reward_snapshot
+    
+    # Deserialize from initial snapshot
+    restored_env = await CrafterClassicEnvironment._deserialize_engine(initial_snapshot, task)
+    restored_pub = restored_env.engine._get_public_state_from_env()
+    
+    # Verify restoration
+    assert restored_pub.player_position == initial_pub.player_position
+    assert restored_pub.inventory == initial_pub.inventory
+    assert restored_pub.achievements_status == initial_pub.achievements_status
+    
+    print("✓ Basic serialization test passed")
+
+
+@pytest.mark.asyncio
+async def test_crafter_tree_storage():
+    """Test storing Crafter states in a trajectory tree (for MCTS)."""
+    from synth_ai.environments.tasks.core import Impetus, Intent
+    from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstanceMetadata
+    from uuid import uuid4
+    
+    metadata = CrafterTaskInstanceMetadata(
+        difficulty="medium", 
+        seed=123,
+        num_trees_radius=3,
+        num_cows_radius=1,
+        num_hostiles_radius=1
+    )
+    task = CrafterTaskInstance(
+        id=uuid4(),
+        impetus=Impetus(instructions="Test tree storage"),
+        intent=Intent(rubric={"goal": "Test"}, gold_trajectories=None, gold_state_diff={}),
+        metadata=metadata,
+        is_reproducible=True,
+        initial_engine_snapshot=None
+    )
+    env = CrafterClassicEnvironment(task)
+    await env.initialize()
+    
+    # Set up tree storage
+    with tempfile.TemporaryDirectory() as tmpdir:
+        snap_store_path = Path(tmpdir) / "crafter_tree"
+        tree = TrajectoryTreeStore(FilesystemSnapshotStore(snap_store_path))
+        
+        # Add root snapshot
+        root_snapshot = await env._serialize_engine()
+        root_blob = gzip.compress(pickle.dumps(root_snapshot))
+        root_id = tree.add_root(root_blob)
+        
+        # Expand tree with different actions
+        action_rewards = {}
+        for action_idx in [0, 1, 2, 3, 4, 5]:  # noop, move directions, do
+            # Restore from root
+            root_env_snapshot = pickle.loads(gzip.decompress(tree.load_snapshot_blob(root_id)))
+            env = await CrafterClassicEnvironment._deserialize_engine(root_env_snapshot, task)
+            
+            # Take action
+            call = EnvToolCall(tool="interact", args={"action": action_idx})
+            obs = await env.step(call)
+            
+            # Store child
+            child_snapshot = await env._serialize_engine()
+            child_blob = gzip.compress(pickle.dumps(child_snapshot))
+            child_id = tree.add_child(
+                root_id,
+                child_blob,
+                action=action_idx,
+                reward=obs.get("reward_last_step", 0.0),
+                terminated=obs.get("terminated", False),
+                info={"total_reward": obs.get("total_reward", 0.0)}
+            )
+            
+            action_rewards[action_idx] = obs.get("reward_last_step", 0.0)
+        
+        # Verify tree structure
+        children = tree.get_children(root_id)
+        assert len(children) == 6
+        
+        # Verify we can load any child state
+        for child_id in children:
+            child_snapshot = pickle.loads(gzip.decompress(tree.load_snapshot_blob(child_id)))
+            child_env = await CrafterClassicEnvironment._deserialize_engine(child_snapshot, task)
+            # Should be able to continue from this state
+            await child_env.step(EnvToolCall(tool="interact", args={"action": 0}))
+        
+        print(f"✓ Tree storage test passed - stored {len(children)} child states")
+        print(f"  Action rewards: {action_rewards}")
+
+
+@pytest.mark.asyncio
+async def test_crafter_state_consistency():
+    """Test that serialization preserves all important state components."""
+    from synth_ai.environments.tasks.core import Impetus, Intent
+    from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstanceMetadata
+    from uuid import uuid4
+    
+    metadata = CrafterTaskInstanceMetadata(
+        difficulty="medium", 
+        seed=777,
+        num_trees_radius=4,
+        num_cows_radius=2,
+        num_hostiles_radius=1
+    )
+    task = CrafterTaskInstance(
+        id=uuid4(),
+        impetus=Impetus(instructions="Test consistency"),
+        intent=Intent(rubric={"goal": "Test"}, gold_trajectories=None, gold_state_diff={}),
+        metadata=metadata,
+        is_reproducible=True,
+        initial_engine_snapshot=None
+    )
+    env = CrafterClassicEnvironment(task)
+    await env.initialize()
+    
+    # Perform various actions to create a complex state
+    action_sequence = [
+        5,  # do (gather resource)
+        2,  # right
+        5,  # do
+        1,  # up
+        5,  # do
+        10, # make_wood_pickaxe (if resources available)
+    ]
+    
+    for action_idx in action_sequence:
+        try:
+            await env.step(EnvToolCall(tool="interact", args={"action": action_idx}))
+        except:
+            pass  # Some actions may fail if resources not available
+    
+    # Get current state details
+    original_pub = env.engine._get_public_state_from_env()
+    original_priv = env.engine._get_private_state_from_env(0, False, False)
+    original_total_reward = env.engine._total_reward
+    
+    # Serialize
+    snapshot = await env._serialize_engine()
+    
+    # Create new environment and deserialize
+    new_env = await CrafterClassicEnvironment._deserialize_engine(snapshot, task)
+    restored_pub = new_env.engine._get_public_state_from_env()
+    restored_priv = new_env.engine._get_private_state_from_env(0, False, False)
+    
+    # Check public state consistency
+    assert restored_pub.player_position == original_pub.player_position
+    assert restored_pub.inventory == original_pub.inventory
+    assert restored_pub.achievements_status == original_pub.achievements_status
+    assert restored_pub.num_steps_taken == original_pub.num_steps_taken
+    
+    # Check private state consistency
+    assert restored_priv.player_internal_stats == original_priv.player_internal_stats
+    assert new_env.engine._total_reward == original_total_reward
+    
+    # Verify we can continue playing from restored state
+    before_step = restored_pub.num_steps_taken
+    await new_env.step(EnvToolCall(tool="interact", args={"action": 0}))
+    after_pub = new_env.engine._get_public_state_from_env()
+    assert after_pub.num_steps_taken == before_step + 1
+    
+    print("✓ State consistency test passed")
+
+
+@pytest.mark.asyncio
+async def test_crafter_mcts_ready_serialization():
+    """Test serialization patterns needed for MCTS implementation."""
+    from synth_ai.environments.tasks.core import Impetus, Intent
+    from synth_ai.environments.examples.crafter_classic.taskset import CrafterTaskInstanceMetadata
+    from uuid import uuid4
+    
+    metadata = CrafterTaskInstanceMetadata(
+        difficulty="easy", 
+        seed=999,
+        num_trees_radius=6,
+        num_cows_radius=3,
+        num_hostiles_radius=0
+    )
+    task = CrafterTaskInstance(
+        id=uuid4(),
+        impetus=Impetus(instructions="Test MCTS"),
+        intent=Intent(rubric={"goal": "Test"}, gold_trajectories=None, gold_state_diff={}),
+        metadata=metadata,
+        is_reproducible=True,
+        initial_engine_snapshot=None
+    )
+    
+    # Helper function to create heuristic score
+    def heuristic_score(env: CrafterClassicEnvironment) -> float:
+        pub = env.engine._get_public_state_from_env()
+        priv = env.engine._get_private_state_from_env(0, False, False)
+        
+        score = 10.0  # Base score
+        
+        # Achievement bonus
+        achievements_unlocked = sum(1 for v in pub.achievements_status.values() if v)
+        score += achievements_unlocked * 100.0
+        
+        # Survival metrics
+        health = priv.player_internal_stats.get("health", 0)
+        hunger = priv.player_internal_stats.get("_hunger", 0)
+        thirst = priv.player_internal_stats.get("_thirst", 0)
+        
+        score += health * 5.0
+        score += (9 - hunger) * 2.0  # Lower is better
+        score += (9 - thirst) * 2.0   # Lower is better
+        
+        # Inventory value
+        for item, count in pub.inventory.items():
+            if "pickaxe" in item:
+                score += count * 20.0
+            elif "sword" in item:
+                score += count * 15.0
+            else:
+                score += count * 2.0
+        
+        return score
+    
+    # Initialize environment
+    env = CrafterClassicEnvironment(task)
+    await env.initialize()
+    initial_score = heuristic_score(env)
+    
+    # Simulate MCTS-style exploration
+    with tempfile.TemporaryDirectory() as tmpdir:
+        snap_store = FilesystemSnapshotStore(Path(tmpdir) / "mcts_test")
+        tree = TrajectoryTreeStore(snap_store)
+        
+        # Create root
+        root_snapshot = await env._serialize_engine()
+        root_blob = gzip.compress(pickle.dumps(root_snapshot))
+        root_id = tree.add_root(root_blob)
+        
+        # Explore a few actions and track scores
+        action_scores: Dict[int, float] = {}
+        
+        for action_idx in [0, 1, 2, 3, 4, 5]:
+            # Restore from root for fair comparison
+            root_snapshot = pickle.loads(gzip.decompress(tree.load_snapshot_blob(root_id)))
+            test_env = await CrafterClassicEnvironment._deserialize_engine(root_snapshot, task)
+            
+            # Take action
+            await test_env.step(EnvToolCall(tool="interact", args={"action": action_idx}))
+            
+            # Calculate score after action
+            action_scores[action_idx] = heuristic_score(test_env)
+        
+        # Find best action
+        best_action = max(action_scores, key=action_scores.get)
+        
+        print("✓ MCTS-ready serialization test passed")
+        print(f"  Initial score: {initial_score:.2f}")
+        print(f"  Action scores: {action_scores}")
+        print(f"  Best action: {best_action} (score: {action_scores[best_action]:.2f})")
+
+
+# Run all tests
+if __name__ == "__main__":
+    async def main():
+        print("Running Crafter Serialization Tests...")
+        print("=" * 50)
+        
+        await test_basic_crafter_serialization()
+        print()
+        
+        await test_crafter_tree_storage()
+        print()
+        
+        await test_crafter_state_consistency()
+        print()
+        
+        await test_crafter_mcts_ready_serialization()
+        print()
+        
+        print("=" * 50)
+        print("🎉 All tests passed!")
+    
+    asyncio.run(main())

synth_ai/environments/examples/crafter_classic/agent_demos/old/crafter_evaluation_browser.py

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""
+Browse existing Crafter evaluations and launch viewer for a selected run.
+"""
+
+import argparse
+import json
+from pathlib import Path
+from datetime import datetime
+import asyncio
+from tabulate import tabulate
+
+from src.synth_env.examples.crafter_classic.agent_demos.full_enchilada import (
+    set_current_eval_dir,
+    app,
+)
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+
+
+def list_evaluations(evals_dir: Path = Path("src/evals/crafter")):
+    """List all available evaluations with summary info."""
+    if not evals_dir.exists():
+        print(f"No evaluations found at {evals_dir}")
+        return []
+
+    evaluations = []
+    for run_dir in sorted(evals_dir.glob("run_*"), reverse=True):
+        if run_dir.is_dir():
+            summary_file = run_dir / "evaluation_summary.json"
+            if summary_file.exists():
+                with open(summary_file, "r") as f:
+                    summary = json.load(f)
+
+                eval_info = {
+                    "run_id": run_dir.name,
+                    "timestamp": summary["evaluation_metadata"]["timestamp"],
+                    "models": ", ".join(summary["models_evaluated"]),
+                    "difficulties": ", ".join(summary["difficulties_evaluated"]),
+                    "num_trajectories": summary["evaluation_metadata"]["num_trajectories"],
+                    "path": run_dir,
+                }
+                evaluations.append(eval_info)
+
+    return evaluations
+
+
+async def view_evaluation(eval_dir: Path):
+    """Launch viewer for a specific evaluation."""
+    if not eval_dir.exists():
+        print(f"Evaluation directory not found: {eval_dir}")
+        return
+
+    viewer_dir = eval_dir / "viewer"
+    if not viewer_dir.exists():
+        print(f"Viewer files not found in {eval_dir}")
+        return
+
+    print(f"\n📁 Viewing evaluation: {eval_dir}")
+    print("🌐 Launching viewer at http://localhost:8000")
+    print("   Press Ctrl+C to stop the viewer")
+
+    # Set the current eval directory for the viewer
+    set_current_eval_dir(eval_dir)
+
+    # Mount static files from the viewer directory
+    app.mount("/", StaticFiles(directory=str(viewer_dir), html=True), name="viewer")
+
+    # Run viewer
+    config = uvicorn.Config(app, host="0.0.0.0", port=8000, log_level="error")
+    server = uvicorn.Server(config)
+    await server.serve()
+
+
+async def main():
+    parser = argparse.ArgumentParser(description="Browse Crafter evaluations")
+    parser.add_argument(
+        "--eval-dir",
+        type=str,
+        default="src/evals/crafter",
+        help="Base directory for evaluations",
+    )
+    parser.add_argument(
+        "--run-id", type=str, help="Specific run ID to view (e.g., run_20240115_143022)"
+    )
+    parser.add_argument("--latest", action="store_true", help="View the latest evaluation")
+
+    args = parser.parse_args()
+    evals_dir = Path(args.eval_dir)
+
+    # List evaluations
+    evaluations = list_evaluations(evals_dir)
+
+    if not evaluations:
+        return
+
+    # Display table of evaluations
+    if not args.run_id and not args.latest:
+        print("\n📊 Available Crafter Evaluations:")
+        table_data = []
+        for i, eval_info in enumerate(evaluations):
+            # Parse timestamp for cleaner display
+            try:
+                ts = datetime.fromisoformat(eval_info["timestamp"])
+                ts_str = ts.strftime("%Y-%m-%d %H:%M:%S")
+            except:
+                ts_str = eval_info["timestamp"]
+
+            table_data.append(
+                [
+                    i + 1,
+                    eval_info["run_id"],
+                    ts_str,
+                    eval_info["models"],
+                    eval_info["difficulties"],
+                    eval_info["num_trajectories"],
+                ]
+            )
+
+        headers = ["#", "Run ID", "Timestamp", "Models", "Difficulties", "Trajectories"]
+        print(tabulate(table_data, headers=headers, tablefmt="grid"))
+
+        # Ask user to select
+        print("\nEnter the number of the evaluation to view (or 'q' to quit): ", end="")
+        choice = input().strip()
+
+        if choice.lower() == "q":
+            return
+
+        try:
+            idx = int(choice) - 1
+            if 0 <= idx < len(evaluations):
+                selected_eval = evaluations[idx]
+                await view_evaluation(selected_eval["path"])
+            else:
+                print("Invalid selection")
+        except ValueError:
+            print("Invalid input")
+
+    # View specific run
+    elif args.run_id:
+        eval_path = evals_dir / args.run_id
+        await view_evaluation(eval_path)
+
+    # View latest
+    elif args.latest and evaluations:
+        latest_eval = evaluations[0]
+        await view_evaluation(latest_eval["path"])
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

synth_ai/environments/examples/crafter_classic/agent_demos/old/crafter_quick_evaluation.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""
+Script to run Crafter evaluation using the standardized eval framework
+"""
+
+import asyncio
+import toml
+from pathlib import Path
+from src.synth_env.examples.crafter_classic.agent_demos.eval_framework import (
+    CrafterEvalFramework,
+    run_crafter_eval,
+)
+
+
+async def main():
+    # Load configuration
+    config_path = Path(__file__).parent / "eval_config.toml"
+    if not config_path.exists():
+        raise FileNotFoundError(f"Configuration file not found: {config_path}")
+
+    config = toml.load(config_path)
+    eval_config = config["evaluation"]
+
+    models = eval_config["models"]
+    difficulties = eval_config["difficulties"]
+    max_turns = eval_config["max_turns"]
+    n_trajectories = eval_config["trajectories_per_condition"]
+
+    print("🎯 Crafter Multi-Action Model Comparison (Eval Framework)")
+    print("=" * 60)
+    print(f"Models: {', '.join(models)}")
+    print(f"Difficulties: {', '.join(difficulties)}")
+    print(f"Max turns: {max_turns}")
+    print(f"Trajectories per condition: {n_trajectories}")
+    print("=" * 60)
+
+    # Run evaluation using the framework
+    results = await run_crafter_eval(
+        model_names=models,
+        difficulties=difficulties,
+        num_trajectories=n_trajectories,
+        max_turns=max_turns,
+    )
+
+    # The framework already prints detailed reports
+    print("\n🏆 Evaluation completed!")
+    return results
+
+
+if __name__ == "__main__":
+    asyncio.run(main())