scripts/evaluate.py

#!/usr/bin/env python3
"""ShopRLVE Evaluation Script -- compare performance across collections.

Usage:
    python scripts/evaluate.py --episodes 50 --seed 42
    python scripts/evaluate.py --episodes 200 --output results/eval_results.json

Runs episodes across all collections (C1, C2, C4, C8) and compares:
    - Success rate per env
    - Average reward per env
    - Average turns per env
    - Hallucination rate per env

Prints a comparison table using rich and saves results as JSON for plotting.
"""

from __future__ import annotations

import argparse
import json
import logging
import time
from collections import defaultdict
from pathlib import Path
from typing import Any

import numpy as np
from rich.console import Console
from rich.table import Table

from shop_rlve.server.openenv import ShopRLVEEnv
from shop_rlve.training.collections import COLLECTIONS, get_collection
from shop_rlve.training.rollout import DummyModelFn, RolloutResult, run_rollout

logger = logging.getLogger(__name__)
console = Console()


def evaluate_collection(
    collection: str,
    n_episodes: int,
    seed: int,
) -> dict[str, dict[str, Any]]:
    """Run evaluation episodes for a single collection.

    Args:
        collection: Collection name (C1, C2, C4, C8).
        n_episodes: Total episodes (distributed across envs in the collection).
        seed:       Random seed.

    Returns:
        Dict mapping env_id -> stats dict with keys:
            n_episodes, mean_reward, std_reward, success_rate,
            mean_turns, hallucination_rate.
    """
    env = ShopRLVEEnv(collection=collection, seed=seed)
    env.dump_dir = ""

    env_ids = get_collection(collection)
    product_ids = [p.id for p in env._products[:30]]

    per_env: dict[str, list[RolloutResult]] = defaultdict(list)

    for i in range(n_episodes):
        ep_env_id = env_ids[i % len(env_ids)]
        ep_seed = seed + i

        dummy = DummyModelFn(
            env_id=ep_env_id,
            product_ids=product_ids,
            seed=ep_seed,
        )

        result = run_rollout(
            env=env,
            model_fn=dummy,
            env_id=ep_env_id,
            seed=ep_seed,
            collect_trace=True,
        )
        per_env[ep_env_id].append(result)

    env.close()

    # Aggregate
    stats: dict[str, dict[str, Any]] = {}
    for eid in env_ids:
        results = per_env.get(eid, [])
        if not results:
            stats[eid] = {
                "n_episodes": 0,
                "mean_reward": 0.0,
                "std_reward": 0.0,
                "success_rate": 0.0,
                "mean_turns": 0.0,
                "hallucination_rate": 0.0,
            }
            continue

        rewards = np.array([r.reward for r in results], dtype=np.float64)
        turns = [r.turns for r in results]
        correct = sum(1 for r in results if r.is_correct)

        # Hallucination rate from reward breakdowns
        hall_rates: list[float] = []
        for r in results:
            bd = r.reward_breakdown
            details = bd.get("details", {}) if isinstance(bd, dict) else {}
            h_rate = details.get("hallucination_rate", 0.0)
            hall_rates.append(float(h_rate))

        stats[eid] = {
            "n_episodes": len(results),
            "mean_reward": float(np.mean(rewards)),
            "std_reward": float(np.std(rewards)),
            "success_rate": correct / len(results),
            "mean_turns": float(np.mean(turns)),
            "hallucination_rate": float(np.mean(hall_rates)) if hall_rates else 0.0,
        }

    return stats


def run_evaluation(
    n_episodes: int,
    seed: int,
    output_path: str | None,
) -> dict[str, Any]:
    """Run full evaluation across all collections.

    Args:
        n_episodes: Episodes per collection.
        seed:       Random seed.
        output_path: Optional path to save results JSON.

    Returns:
        Full evaluation results dict.
    """
    all_results: dict[str, Any] = {
        "n_episodes_per_collection": n_episodes,
        "seed": seed,
        "collections": {},
    }

    t0 = time.monotonic()

    for coll_name in sorted(COLLECTIONS.keys()):
        console.print(
            f"\n[bold cyan]Evaluating collection {coll_name}[/bold cyan] "
            f"({n_episodes} episodes)"
        )
        coll_stats = evaluate_collection(coll_name, n_episodes, seed)
        all_results["collections"][coll_name] = coll_stats

    elapsed = time.monotonic() - t0
    all_results["elapsed_seconds"] = elapsed

    # Print comparison table
    comparison = Table(
        title=f"Evaluation Comparison ({n_episodes} episodes/collection, {elapsed:.1f}s)",
        show_header=True,
        header_style="bold cyan",
    )
    comparison.add_column("Collection", style="bold", width=12)
    comparison.add_column("Env", style="cyan", width=10)
    comparison.add_column("Success", justify="right", width=10)
    comparison.add_column("Avg Reward", justify="right", width=11)
    comparison.add_column("Avg Turns", justify="right", width=10)
    comparison.add_column("Hall Rate", justify="right", width=10)

    for coll_name in sorted(COLLECTIONS.keys()):
        coll_stats = all_results["collections"].get(coll_name, {})
        first_row = True
        for eid in get_collection(coll_name):
            s = coll_stats.get(eid, {})
            if not s or s.get("n_episodes", 0) == 0:
                continue

            success_rate = s.get("success_rate", 0.0)
            color = "green" if success_rate > 0.5 else ("yellow" if success_rate > 0.1 else "red")

            comparison.add_row(
                coll_name if first_row else "",
                eid,
                f"[{color}]{success_rate:.2%}[/{color}]",
                f"{s.get('mean_reward', 0.0):.4f}",
                f"{s.get('mean_turns', 0.0):.2f}",
                f"{s.get('hallucination_rate', 0.0):.4f}",
            )
            first_row = False

    console.print(comparison)

    # Save results
    if output_path:
        p = Path(output_path)
        p.parent.mkdir(parents=True, exist_ok=True)
        with open(p, "w") as f:
            json.dump(all_results, f, indent=2, default=str)
        console.print(f"\n[dim]Results saved to {output_path}[/dim]")

    return all_results


def main() -> None:
    """Entry point."""
    parser = argparse.ArgumentParser(
        description="ShopRLVE Evaluation Script",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=__doc__,
    )
    parser.add_argument(
        "--episodes",
        type=int,
        default=50,
        help="Episodes per collection (default: 50)",
    )
    parser.add_argument("--seed", type=int, default=42, help="Random seed")
    parser.add_argument(
        "--output",
        type=str,
        default="results/eval_results.json",
        help="Output JSON path",
    )

    args = parser.parse_args()
    run_evaluation(
        n_episodes=args.episodes,
        seed=args.seed,
        output_path=args.output,
    )


if __name__ == "__main__":
    main()