synth-ai 0.2.0__py3-none-any.whl → 0.2.1.dev0__py3-none-any.whl

synth_ai/environments/examples/minigrid/agent_demos/minigrid_trace_evaluation.py

@@ -0,0 +1,220 @@
+#!/usr/bin/env python3
+"""
+Simple MiniGrid evaluation script to generate traces.
+"""
+
+import asyncio
+import json
+import os
+import sys
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+# Add parent directories to path
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent.parent))
+
+import gymnasium as gym
+import minigrid
+from minigrid.wrappers import ImgObsWrapper, RGBImgPartialObsWrapper
+import numpy as np
+import base64
+from PIL import Image
+import io
+
+
+# Environment setup
+def create_minigrid_env(env_name="MiniGrid-Empty-6x6-v0"):
+    """Create a MiniGrid environment with image observations."""
+    env = gym.make(env_name)
+    # Wrap to get RGB image observations
+    env = RGBImgPartialObsWrapper(env)
+    env = ImgObsWrapper(env)
+    return env
+
+
+def image_to_base64(image_array):
+    """Convert numpy image array to base64 string."""
+    # Convert to PIL Image
+    img = Image.fromarray(image_array.astype(np.uint8))
+    # Save to bytes buffer
+    buffer = io.BytesIO()
+    img.save(buffer, format="PNG")
+    buffer.seek(0)
+    # Encode to base64
+    img_base64 = base64.b64encode(buffer.read()).decode("utf-8")
+    return img_base64
+
+
+def get_action_name(action_idx):
+    """Map action index to name."""
+    action_names = {
+        0: "left",
+        1: "right",
+        2: "forward",
+        3: "pickup",
+        4: "drop",
+        5: "toggle",
+        6: "done",
+    }
+    return action_names.get(action_idx, f"action_{action_idx}")
+
+
+async def run_simple_minigrid_eval(
+    model_name="simple-agent",
+    env_name="MiniGrid-Empty-6x6-v0",
+    num_episodes=3,
+    max_steps=50,
+):
+    """Run a simple evaluation to generate MiniGrid traces."""
+
+    print(f"\n🎮 Running MiniGrid Evaluation")
+    print(f"   Environment: {env_name}")
+    print(f"   Episodes: {num_episodes}")
+    print(f"   Max steps: {max_steps}")
+
+    # Create output directory
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_id = f"run_{int(datetime.now().timestamp())}"
+    output_dir = Path(f"src/evals/minigrid/{run_id}")
+    traces_dir = output_dir / "traces"
+    traces_dir.mkdir(parents=True, exist_ok=True)
+
+    results = []
+
+    for episode in range(num_episodes):
+        print(f"\n📍 Episode {episode + 1}/{num_episodes}")
+
+        # Create environment
+        env = create_minigrid_env(env_name)
+        obs, info = env.reset()
+
+        # Initialize trace
+        trace_id = str(uuid.uuid4())
+        trace_data = {
+            "trace": {
+                "metadata": {
+                    "model_name": model_name,
+                    "env_name": env_name,
+                    "difficulty": "easy",
+                    "seed": episode,
+                    "max_steps": max_steps,
+                },
+                "partition": [],
+            },
+            "dataset": {"reward_signals": []},
+        }
+
+        total_reward = 0.0
+        done = False
+        step = 0
+
+        while not done and step < max_steps:
+            # Simple policy: random actions with bias towards forward
+            if np.random.random() < 0.6:
+                action = 2  # forward
+            else:
+                action = env.action_space.sample()
+
+            # Take action
+            next_obs, reward, terminated, truncated, info = env.step(action)
+            done = terminated or truncated
+            total_reward += reward
+
+            # Create partition for this step
+            partition = {
+                "events": [
+                    {
+                        "environment_compute_steps": [
+                            {
+                                "compute_output": [
+                                    {
+                                        "outputs": {
+                                            "observation": {
+                                                "mission": getattr(
+                                                    env.unwrapped,
+                                                    "mission",
+                                                    "Reach the goal",
+                                                ),
+                                                "image_base64": image_to_base64(
+                                                    obs
+                                                    if isinstance(obs, np.ndarray)
+                                                    else obs["image"]
+                                                ),
+                                            },
+                                            "action": action,
+                                            "reward": float(reward),
+                                            "terminated": terminated,
+                                            "truncated": truncated,
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+
+            trace_data["trace"]["partition"].append(partition)
+
+            obs = next_obs
+            step += 1
+
+            if done and reward > 0:
+                print(f"   ✅ Success! Reached goal in {step} steps")
+
+        if not done:
+            print(f"   ⏰ Timeout after {step} steps")
+
+        # Update trace metadata
+        trace_data["trace"]["metadata"]["success"] = reward > 0
+        trace_data["trace"]["metadata"]["num_steps"] = step
+        trace_data["dataset"]["reward_signals"].append({"reward": float(total_reward)})
+
+        # Save trace
+        trace_file = traces_dir / f"minigrid_trace_{trace_id}.json"
+        with open(trace_file, "w") as f:
+            json.dump(trace_data, f, indent=2)
+
+        results.append(
+            {
+                "trace_id": trace_id,
+                "success": reward > 0,
+                "steps": step,
+                "total_reward": total_reward,
+            }
+        )
+
+        print(f"   💾 Saved trace: {trace_file.name}")
+
+    # Save evaluation summary
+    summary = {
+        "run_id": run_id,
+        "timestamp": timestamp,
+        "environment": env_name,
+        "model_name": model_name,
+        "num_episodes": num_episodes,
+        "results": results,
+        "success_rate": sum(1 for r in results if r["success"]) / len(results),
+        "avg_steps": sum(r["steps"] for r in results) / len(results),
+        "models_evaluated": [model_name],
+        "difficulties_evaluated": ["easy"],
+    }
+
+    summary_file = output_dir / "evaluation_summary.json"
+    with open(summary_file, "w") as f:
+        json.dump(summary, f, indent=2)
+
+    print(f"\n✅ Evaluation complete!")
+    print(f"   Success rate: {summary['success_rate']:.1%}")
+    print(f"   Average steps: {summary['avg_steps']:.1f}")
+    print(f"   Output directory: {output_dir}")
+
+    return summary
+
+
+if __name__ == "__main__":
+    # Run evaluation
+    asyncio.run(
+        run_simple_minigrid_eval(env_name="MiniGrid-Empty-6x6-v0", num_episodes=3, max_steps=30)
+    )

synth_ai/environments/examples/minigrid/agent_demos/test_minigrid_react_agent.py

@@ -0,0 +1,393 @@
+#!/usr/bin/env python3
+"""
+Test script to run ReAct agents against MiniGrid environment on synth service (port 8901)
+Tests on multiple easy MiniGrid instances with enhanced debugging
+"""
+
+import asyncio
+import json
+import uuid
+from datetime import datetime
+from typing import Dict, Any, Optional, List
+from pydantic import BaseModel, Field
+from httpx import AsyncClient
+import sys
+import os
+
+# Add the src directory to the path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from synth_ai.zyk import LM
+from synth_ai.zyk.lms.tools.base import BaseTool
+
+
+# --- Service Configuration ---
+SERVICE_BASE_URL = "http://localhost:8901"
+MODEL_NAME = "o3"
+NUM_INSTANCES = 1
+MAX_TURNS = 20
+DIFFICULTY = "ultra_easy"
+
+
+# --- Tool Definitions ---
+class NavigationActionArgs(BaseModel):
+    """Arguments for navigation actions."""
+
+    action: str = Field(
+        description="The action to take: left, right, forward, pickup, drop, toggle, done"
+    )
+    reasoning: str = Field(description="Brief explanation of why this action was chosen")
+
+
+class TerminateArgs(BaseModel):
+    """Arguments for termination."""
+
+    reason: str = Field(description="Reason for termination")
+
+
+class NavigationActionTool(BaseTool):
+    """Tool for performing an action in the MiniGrid environment."""
+
+    name: str = "navigation_action"
+    arguments: type[BaseModel] = NavigationActionArgs
+    description: str = "Perform a navigation action in the MiniGrid environment."
+
+
+class TerminateTool(BaseTool):
+    """Tool to terminate the episode."""
+
+    name: str = "terminate"
+    arguments: type[BaseModel] = TerminateArgs
+    description: str = "End the episode when finished or no progress can be made."
+
+
+# --- Base ReAct Agent ---
+class BaseReActAgent:
+    """Base ReAct agent for environment interaction."""
+
+    def __init__(self, llm: LM, max_turns: int = 15, verbose: bool = False):
+        self.llm = llm
+        self.max_turns = max_turns
+        self.verbose = verbose
+        self.history = []
+        self.system_name = "base-react-agent"
+
+        # Define tools in OpenAI format (like Enron agent)
+        self.tools = [
+            NavigationActionTool(),
+            TerminateTool(),
+        ]
+
+    async def decide(self, obs: str, system_message: str, turn: int) -> Dict[str, Any]:
+        """Get agent decision based on observation."""
+        # Create conversation context
+        context = f"Turn {turn + 1}/{self.max_turns}\n\n{obs}"
+
+        # Generate response using LLM (same pattern as Crafter)
+        response_obj = await self.llm.respond_async(
+            system_message=system_message, user_message=context, tools=self.tools
+        )
+
+        tool_calls = response_obj.tool_calls
+
+        # Handle case where tool_calls is None or empty (graceful fallback)
+        if not tool_calls:
+            if self.verbose:
+                print(f"[WARNING] No tool calls returned by LLM, using default action")
+            return {
+                "name": "navigation_action",
+                "parameters": {
+                    "action": "forward",
+                    "reasoning": "Default action - no tool call received",
+                },
+            }
+
+        tool_call_data = tool_calls[0]
+
+        # Handle both dict and object formats (same as Crafter)
+        if isinstance(tool_call_data, dict):
+            tool_name = tool_call_data["function"]["name"]
+            tool_args_str = tool_call_data["function"]["arguments"]
+        else:
+            tool_name = tool_call_data.function.name
+            tool_args_str = tool_call_data.function.arguments
+
+        tool_arguments = json.loads(tool_args_str)
+
+        return {"name": tool_name, "parameters": tool_arguments}
+
+
+# --- MiniGrid ReAct Agent ---
+class MiniGridReActAgent(BaseReActAgent):
+    """ReAct agent for MiniGrid environment."""
+
+    def __init__(self, llm: LM, max_turns: int = 15, verbose: bool = False):
+        super().__init__(llm, max_turns, verbose)
+        self.system_name = "minigrid-react-agent"
+
+    def get_system_message(self) -> str:
+        return """You are navigating a MiniGrid environment. Your goal is to reach the goal (G) to complete the mission successfully.
+
+ACTIONS: 
+- "left": turn left (counter-clockwise)
+- "right": turn right (clockwise)  
+- "forward": move forward one step
+- "pickup": pick up object in front of you
+- "drop": drop carried object
+- "toggle": open/close door or interact with object
+- "done": complete mission when you reach the goal
+
+SYMBOLS: 
+- # = wall (blocks movement)
+- . = empty space (can move through)
+- G = goal (your destination)
+- K = key (pick up to unlock doors)
+- D = door (may need key to open)
+- L = lava (avoid - will end mission)
+- @ = you (your current position)
+
+STRATEGY:
+1. Analyze the grid layout to understand the environment
+2. Plan a path to reach the goal (G)
+3. Navigate systematically - turn to face the right direction, then move forward
+4. Pick up keys (K) before trying to open doors (D)
+5. Use "toggle" to open doors when you have the key
+6. Avoid lava (L) at all costs
+7. Use "done" when you reach the goal
+
+IMPORTANT: You can only see a limited view around you. Move and explore to discover the full environment. Be systematic in your exploration."""
+
+    def format_observation(self, obs: Dict[str, Any]) -> str:
+        """Format observation for MiniGrid."""
+        parts = []
+
+        if "grid" in obs:
+            parts.append(f"Grid view:\n{obs['grid']}")
+        elif "observation" in obs:
+            parts.append(f"Observation:\n{obs['observation']}")
+
+        if "direction" in obs:
+            parts.append(f"Facing: {obs['direction']}")
+
+        if "carrying" in obs and obs["carrying"]:
+            parts.append(f"Carrying: {obs['carrying']}")
+
+        if "step_count" in obs:
+            parts.append(f"Steps: {obs['step_count']}")
+
+        if "mission" in obs:
+            parts.append(f"Mission: {obs['mission']}")
+
+        # Add more possible observation fields
+        if "terminated" in obs:
+            parts.append(f"Terminated: {obs['terminated']}")
+
+        if "success" in obs:
+            parts.append(f"Success: {obs['success']}")
+
+        if "reward_last" in obs:
+            parts.append(f"Last reward: {obs['reward_last']}")
+
+        return "\n".join(parts) if parts else "No formatted observation available"
+
+
+# --- Episode Runner ---
+async def run_single_episode(
+    client: AsyncClient, agent: MiniGridReActAgent, task_instance, instance_num: int
+) -> bool:
+    """Run a single MiniGrid episode and return success status."""
+    try:
+        # Create environment using the task instance
+        create_resp = await client.post(
+            f"/env/MiniGrid/initialize", json={"task_instance": await task_instance.serialize()}
+        )
+
+        if create_resp.status_code != 200:
+            print(
+                f"  Instance {instance_num}: Failed to create environment - {create_resp.status_code}: {create_resp.text}"
+            )
+            return False
+
+        env_id = create_resp.json()["env_id"]
+
+        # Get initial observation
+        obs = create_resp.json()["observation"]
+        formatted_obs = agent.format_observation(obs)
+
+        # DEBUG: Print initial state
+        print(f"\n  Instance {instance_num}: Starting MiniGrid mission")
+        print(f"  Environment: {task_instance.metadata.env_name}")
+        print(f"  Mission: {task_instance.impetus.instructions[:100]}...")
+        print(f"  Initial observation:")
+        print(f"    {formatted_obs}")
+
+        # Run episode
+        for turn in range(agent.max_turns):
+            # Get agent decision
+            action = await agent.decide(formatted_obs, agent.get_system_message(), turn)
+
+            # DEBUG: Print agent decision
+            print(
+                f"  Turn {turn + 1}: Agent chose '{action['parameters']['action']}' - {action['parameters'].get('reasoning', 'no reasoning')}"
+            )
+
+            # Check for termination
+            if action["name"] == "terminate":
+                print(
+                    f"  Agent terminated: {action['parameters'].get('reason', 'no reason given')}"
+                )
+                break
+
+            # Execute action in environment
+            action_name = action["parameters"]["action"]
+
+            step_resp = await client.post(
+                f"/env/MiniGrid/step",
+                json={
+                    "env_id": env_id,
+                    "request_id": str(uuid.uuid4()),
+                    "action": {
+                        "tool_calls": [{"tool": "minigrid_act", "args": {"action": action_name}}]
+                    },
+                },
+            )
+
+            if step_resp.status_code != 200:
+                print(f"  ❌ Step failed: {step_resp.status_code}: {step_resp.text}")
+                break
+
+            obs = step_resp.json()["observation"]
+            formatted_obs = agent.format_observation(obs)
+
+            # DEBUG: Print state after action
+            print(f"  After action: {formatted_obs}")
+
+            # Update history
+            agent.history.append(f"{action_name}: {action['parameters'].get('reasoning', '')[:50]}")
+
+            # Check if goal is reached
+            terminated = obs.get("terminated", False)
+            success = obs.get("success", False)
+            reward_last = obs.get("reward_last", 0.0)
+
+            # MiniGrid success is typically indicated by positive reward when terminated
+            # Success reward is usually close to 1.0 (1.0 - step_penalties)
+            actual_success = terminated and reward_last > 0.1  # Threshold for success reward
+
+            if terminated and actual_success:
+                print(
+                    f"  ✅ Instance {instance_num}: SUCCESS! Mission completed in {turn + 1} turns (reward: {reward_last:.3f})"
+                )
+                await client.post(f"/env/MiniGrid/terminate", json={"env_id": env_id})
+                return True
+
+            if terminated:
+                print(
+                    f"  ❌ Instance {instance_num}: Terminated without success (success field: {success}, reward: {reward_last:.3f})"
+                )
+                break
+
+        print(
+            f"  ❌ Instance {instance_num}: Failed to complete mission in {agent.max_turns} turns"
+        )
+
+        # Cleanup
+        await client.post(f"/env/MiniGrid/terminate", json={"env_id": env_id})
+        return False
+
+    except Exception as e:
+        print(f"  Instance {instance_num}: Error - {e}")
+        import traceback
+
+        traceback.print_exc()
+        return False
+
+
+# --- Batch Evaluation ---
+async def evaluate_minigrid_batch() -> float:
+    """Evaluate MiniGrid agent on multiple easy instances."""
+    print(f"🎯 Evaluating MiniGrid on {NUM_INSTANCES} easy instances...")
+
+    llm = LM(model_name=MODEL_NAME, formatting_model_name=MODEL_NAME, temperature=0.0)
+
+    # Get easy task instances using the taskset system
+    from synth_ai.environments.examples.minigrid.taskset import create_minigrid_task_from_seed
+
+    easy_task_instances = []
+    for seed in range(NUM_INSTANCES):
+        try:
+            task_instance = await create_minigrid_task_from_seed(DIFFICULTY, seed)
+            easy_task_instances.append(task_instance)
+        except Exception as e:
+            print(f"  ⚠️  Failed to get task instance for seed {seed}: {e}")
+            continue
+
+    print(
+        f"  📝 Generated {len(easy_task_instances)} {DIFFICULTY} task instances from seeds 0-{NUM_INSTANCES - 1}"
+    )
+
+    async with AsyncClient(base_url=SERVICE_BASE_URL, timeout=30.0) as client:
+        tasks = []
+        for i, task_instance in enumerate(easy_task_instances):
+            agent = MiniGridReActAgent(llm, max_turns=MAX_TURNS, verbose=False)
+            tasks.append(run_single_episode(client, agent, task_instance, i + 1))
+
+        results = await asyncio.gather(*tasks)
+        success_count = sum(results)
+        success_rate = success_count / len(easy_task_instances)
+
+        print(
+            f"  📊 MiniGrid Results: {success_count}/{len(easy_task_instances)} solved ({success_rate:.1%})"
+        )
+        return success_rate
+
+
+async def main():
+    """Run MiniGrid evaluation."""
+    print(f"🎮 MiniGrid ReAct Agent Evaluation")
+    print(f"Model: {MODEL_NAME}")
+    print(f"Service: {SERVICE_BASE_URL}")
+    print(f"Instances: {NUM_INSTANCES}")
+    print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    print("=" * 50)
+
+    # Test service health
+    async with AsyncClient(base_url=SERVICE_BASE_URL, timeout=10.0) as client:
+        try:
+            health_resp = await client.get("/health")
+            health_data = health_resp.json()
+
+            if "MiniGrid" not in health_data.get("supported_environments", []):
+                print("❌ MiniGrid not available on service")
+                return
+
+            print("✅ Service health check passed")
+
+        except Exception as e:
+            print(f"❌ Service health check failed: {e}")
+            return
+
+    # Run evaluation
+    try:
+        success_rate = await evaluate_minigrid_batch()
+
+        print("\n" + "=" * 50)
+        print("🏆 FINAL MINIGRID RESULTS")
+        print("=" * 50)
+        print(f"Success Rate: {success_rate:.1%}")
+
+        if success_rate > 0.5:
+            print("🎉 Excellent performance!")
+        elif success_rate > 0.3:
+            print("✅ Good performance!")
+        elif success_rate > 0.1:
+            print("⚠️  Moderate performance")
+        else:
+            print("❌ Poor performance - needs improvement")
+
+    except Exception as e:
+        print(f"❌ Evaluation failed: {e}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())