examples/trl/prm_eval.py

"""
PRM-guided evaluation for Playpen taboo.

Compares two agents head-to-head on the same taboo instances:
  - Baseline: greedy decoding (temperature=0, no PRM)
  - PRM-guided: best-of-N step selection using the trained PRM

Algorithm: step-level best-of-N
  At each of Player 2's (WordGuesser) turns:
    1. Generate `n_candidates` responses from the policy at temperature > 0
    2. Score each with the trained PRM (P(game success | state, response))
    3. Return the highest-scoring candidate

Usage
-----
    python examples/trl/prm_eval.py \
        --prm-path models/prm/Llama-3.1-8B-Instruct-4bit \
        --n-candidates 8 \
        --temperature 0.7

Results are written to:
    eval-results/baseline/taboo/
    eval-results/prm-guided/taboo/
"""

from __future__ import annotations

import argparse
import copy
import json
import subprocess
import sys
from pathlib import Path
from typing import Any, Dict, List, Tuple

import torch
import torch.nn.functional as F
from peft import PeftConfig, PeftModel
from transformers import AutoModelForSequenceClassification, AutoTokenizer, BitsAndBytesConfig

from clemcore.backends import ModelRegistry, BackendRegistry, ModelSpec
from clemcore.backends.model_registry import Model
from clemcore.clemgame import (
    EpochResultsFolder,
    EpochResultsFolderCallback,
    ExperimentFileSaver,
    GameBenchmark,
    GameBenchmarkCallbackList,
    GameInstances,
    GameRegistry,
    InstanceFileSaver,
    InteractionsFileSaver,
)
from clemcore.clemgame.runners import sequential
from datasets import load_dataset

from playpen import to_instances_filter


# ---------------------------------------------------------------------------
# PRM-guided Model wrapper
# ---------------------------------------------------------------------------

class PRMGuidedModel(Model):
    """Wraps a policy model with PRM-guided best-of-N step selection.

    For every call to generate_response() this model:
      1. Generates `n_candidates` responses from the underlying policy model
         using temperature sampling.
      2. Scores each candidate by feeding (messages + candidate) through the PRM.
      3. Returns the candidate with the highest PRM score.

    The policy model's regular generate_response() is used for Player 1
    (WordDescriber) via the `base_model` attribute so both roles share a
    single loaded copy of the weights.
    """

    def __init__(
        self,
        base_model: Model,
        prm: AutoModelForSequenceClassification,
        tokenizer: AutoTokenizer,
        n_candidates: int = 8,
        candidate_temperature: float = 0.7,
        max_length: int = 512,
        device: str = "cuda",
        on_game_end=None,
    ):
        super().__init__(base_model.model_spec)
        self.base_model = base_model
        self.prm = prm
        self.tokenizer = tokenizer
        self.n_candidates = n_candidates
        self.candidate_temperature = candidate_temperature
        self.max_length = max_length
        self.device = device
        self.on_game_end = on_game_end  # callable(turns) fired after each game

        self.prm.eval()
        # candidate_log: list of games, each game is a list of turn dicts
        self.candidate_log: List[List[Dict]] = []
        self._current_game_turns: List[Dict] = []
        self._prev_msg_len: int = 0
        self._game_index: int = 0

    def set_gen_args(self, **gen_args):
        super().set_gen_args(**gen_args)
        self.base_model.set_gen_args(**gen_args)

    def reset_game(self):
        """Call before each new game to start a fresh turn log."""
        if self._current_game_turns:
            self.candidate_log.append(self._current_game_turns)
            if self.on_game_end:
                self.on_game_end(self._game_index, self._current_game_turns)
            self._game_index += 1
        self._current_game_turns = []
        self._prev_msg_len = 0

    def flush_game(self):
        """Call after the last game to flush remaining turns."""
        if self._current_game_turns:
            self.candidate_log.append(self._current_game_turns)
            if self.on_game_end:
                self.on_game_end(self._game_index, self._current_game_turns)
            self._game_index += 1
            self._current_game_turns = []

    @staticmethod
    def _is_valid_format(text: str) -> bool:
        import re
        guess_matches = re.findall(r"(?i)^guess:\s*([a-z]{5})\s*$", text, re.MULTILINE)
        return len(guess_matches) == 1

    def generate_response(self, messages: List[Dict]) -> Tuple[Any, Any, str]:
        # Detect game reset: message history shrank or restarted
        if len(messages) < self._prev_msg_len or (self._prev_msg_len > 0 and len(messages) <= 2):
            self.reset_game()
        self._prev_msg_len = len(messages)

        # Generate N candidates with sampling. Batch them into ONE forward pass
        # (each batch row samples independently at candidate_temperature, so the
        # best-of-N distribution is unchanged — pure speedup). This is the same
        # batched-generation API the collection path uses (Player.batch_response
        # / Model.generate_batch_response). Fall back to a sequential loop for
        # backends that don't support batching.
        orig_temp = self.base_model.temperature
        self.base_model.set_gen_arg("temperature", self.candidate_temperature)
        import os
        _no_batch = os.environ.get("PRM_NO_BATCH") == "1"  # A/B escape hatch
        if self.base_model.supports_batching() and not _no_batch:
            candidates = self.base_model.generate_batch_response([messages] * self.n_candidates)
        else:
            candidates = [self.base_model.generate_response(messages)
                          for _ in range(self.n_candidates)]
        self.base_model.set_gen_arg("temperature", orig_temp)

        # Prefer candidates with valid format; fall back to all if none are valid
        valid_mask = [self._is_valid_format(c[2]) for c in candidates]
        scored_candidates = candidates
        if any(valid_mask):
            scored_candidates = [c for c, ok in zip(candidates, valid_mask) if ok]
            n_valid = sum(valid_mask)
        else:
            n_valid = 0

        # Score each candidate with the PRM
        scores = self._score_candidates(messages, [c[2] for c in scored_candidates])
        best_idx = int(scores.argmax())

        print(f"[PRM] valid={n_valid}/{self.n_candidates} | selected #{best_idx + 1} | score={scores[best_idx]:.4f}")
        for i, (cand, score) in enumerate(zip(scored_candidates, scores.tolist())):
            text = cand[2].replace('\n', ' ').strip()
            marker = ">>>" if i == best_idx else "   "
            print(f"  {marker} [{i+1}] score={score:.4f} | {text[:120]}")

        # Record this turn
        import re
        turn_record = {
            "candidates": [
                {
                    "text": c[2],
                    "score": score,
                    "valid": self._is_valid_format(c[2]),
                    "selected": i == best_idx,
                    "guess": (re.findall(r"(?i)^guess:\s*([a-z]{5})", c[2], re.MULTILINE) or [None])[0],
                }
                for i, (c, score) in enumerate(zip(scored_candidates, scores.tolist()))
            ],
            "selected_idx": best_idx,
            "n_valid": n_valid,
            "n_candidates": self.n_candidates,
        }
        self._current_game_turns.append(turn_record)

        return scored_candidates[best_idx]

    def _score_candidates(self, messages: List[Dict], candidates: List[str]) -> torch.Tensor:
        encoded = [
            self.tokenizer.apply_chat_template(
                messages + [{"role": "assistant", "content": text}],
                tokenize=False,
                add_generation_prompt=False,
            )
            for text in candidates
        ]
        inputs = self.tokenizer(
            encoded,
            return_tensors="pt",
            truncation=True,
            max_length=self.max_length,
            truncation_side="left",
            padding=True,
        ).to("cuda")
        with torch.no_grad():
            logits = self.prm(**inputs).logits  # (N, 1) or (N, 2)
        if logits.shape[-1] == 2:
            logit = logits[:, 1] - logits[:, 0]
        else:
            logit = logits[:, 0]
        return torch.sigmoid(logit).float()


# ---------------------------------------------------------------------------
# Beam-search guided model
# ---------------------------------------------------------------------------

class BeamSearchGuidedModel(PRMGuidedModel):
    """Wraps a policy model with PRM-guided beam search step selection.

    Algorithm:
      At each game turn:
        1. Start N independent beams with empty text.
        2. For up to num_iterations rounds:
           a. For all N active (non-completed) beams, generate the next step
              (one paragraph, stopping at "\\n\\n") in a single batched forward pass.
           b. Score each beam's accumulated text with the PRM — no pruning.
              All N beams continue regardless of score.
           c. Stop early once all beams have completed.
        3. Use the PRM to select the best final answer from all N completed beams.

    All beams stay alive for the full search. The PRM only selects at the end,
    not mid-search, so N diverse paths are explored throughout.
    """

    def __init__(
        self,
        base_model,
        prm,
        tokenizer,
        n_beams: int = 4,
        num_iterations: int = 20,
        candidate_temperature: float = 0.7,
        max_length: int = 512,
        step_max_tokens: int = 300,
        device: str = "cuda",
        on_game_end=None,
    ):
        super().__init__(
            base_model=base_model,
            prm=prm,
            tokenizer=tokenizer,
            n_candidates=n_beams,
            candidate_temperature=candidate_temperature,
            max_length=max_length,
            device=device,
            on_game_end=on_game_end,
        )
        self.n = n_beams
        self.num_iterations = num_iterations
        self.step_max_tokens = step_max_tokens

    def generate_response(self, messages: List[Dict]) -> Tuple[Any, Any, str]:
        # Same game-reset detection as PRMGuidedModel
        if len(messages) < self._prev_msg_len or (self._prev_msg_len > 0 and len(messages) <= 2):
            self.reset_game()
        self._prev_msg_len = len(messages)

        hf_model = self.base_model.model
        tok = self.base_model.tokenizer
        chat_kwargs = self.base_model.chat_template_kwargs

        beams = [{"text": "", "completed": False, "score": 0.0}
                 for _ in range(self.n)]

        for iteration in range(self.num_iterations):
            active = [b for b in beams if not b["completed"]]
            if not active:
                break

            is_last = (iteration == self.num_iterations - 1)

            # Build prompts — continue the assistant's partial text per beam
            rendered = []
            for beam in active:
                if beam["text"]:
                    msgs = messages + [{"role": "assistant", "content": beam["text"]}]
                    prompt = tok.apply_chat_template(
                        msgs,
                        add_generation_prompt=False,
                        continue_final_message=True,
                        tokenize=False,
                        **chat_kwargs,
                    )
                else:
                    prompt = tok.apply_chat_template(
                        messages,
                        add_generation_prompt=True,
                        tokenize=False,
                        **chat_kwargs,
                    )
                rendered.append(prompt)

            # Tokenise as a padded batch
            enc = tok(
                rendered,
                return_tensors="pt",
                padding=True,
                add_special_tokens=False,
                return_attention_mask=True,
            )
            input_ids = enc["input_ids"].to(hf_model.device)
            attn_mask = enc["attention_mask"].to(hf_model.device)

            step_max = self.max_length if is_last else self.step_max_tokens
            gen_args = {
                "attention_mask": attn_mask,
                "max_new_tokens": step_max,
                "do_sample": not is_last,
                "pad_token_id": tok.eos_token_id,
                "return_dict_in_generate": True,
            }
            if not is_last:
                gen_args["temperature"] = self.candidate_temperature

            with torch.no_grad():
                output = hf_model.generate(input_ids, **gen_args)

            prompt_len = input_ids.shape[1]
            new_ids = output.sequences[:, prompt_len:]
            step_texts = tok.batch_decode(new_ids, skip_special_tokens=True)

            for beam, step_text in zip(active, step_texts):
                if not is_last and "\n\n" in step_text:
                    step_text = step_text[: step_text.index("\n\n") + 2]
                beam["text"] += step_text
                if not step_text.strip():
                    beam["completed"] = True

            # Score all active beams — no pruning, all beams continue
            scores = self._score_candidates(messages, [b["text"] for b in active])
            for beam, score in zip(active, scores.tolist()):
                beam["score"] = score

        # Select the best final answer using the PRM scores
        best = max(beams, key=lambda b: b["score"])

        print(f"[BeamSearch] iters={iteration+1}/{self.num_iterations} | "
              f"n_beams={self.n} | best_score={best['score']:.4f}")
        for i, b in enumerate(beams):
            marker = ">>>" if b is best else "   "
            snippet = b["text"].replace("\n", " ").strip()[:100]
            print(f"  {marker} [{i+1}] score={b['score']:.4f} | {snippet}")

        turn_record = {
            "beams": [{"text": b["text"], "score": b["score"]} for b in beams],
            "selected_text": best["text"],
            "n_beams": self.n,
        }
        self._current_game_turns.append(turn_record)

        return None, None, best["text"]


# ---------------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------------


def _run_game(game_name: str, players: List[Model], results_dir: Path, instances):
    """Run a game with given players and save interactions to results_dir."""
    game_registry = GameRegistry.from_directories_and_cwd_files()
    game_spec = game_registry.get_game_specs_that_unify_with(game_name)[0]

    prm_guided = next((p for p in players if isinstance(p, (PRMGuidedModel, BeamSearchGuidedModel))), None)
    instance_list = list(instances)

    if prm_guided is not None:
        model_id = Model.to_identifier([prm_guided])

        def _on_game_end(game_idx: int, turns: List[Dict]):
            if game_idx >= len(instance_list):
                return
            inst = instance_list[game_idx]
            game_id = inst.get("task_id") if isinstance(inst, dict) else getattr(inst, "task_id", None)
            exp = inst.get("experiment") if isinstance(inst, dict) else getattr(inst, "experiment", "unknown")
            if game_id is None:
                return
            instance_dir = results_dir / model_id / "epoch_00001" / game_name / exp / f"instance_{int(game_id):05d}"
            instance_dir.mkdir(parents=True, exist_ok=True)
            (instance_dir / "prm_candidates.json").write_text(
                json.dumps({"game_id": game_id, "turns": turns}, indent=2)
            )

        prm_guided.on_game_end = _on_game_end

    with GameBenchmark.load_from_spec(game_spec) as game_benchmark:
        game_instances = GameInstances.from_game_spec(game_benchmark.game_spec)
        game_instances = game_instances.filter(to_instances_filter(instances))

        results_folder = EpochResultsFolder(results_dir, Model.to_identifier(players))
        model_infos = Model.to_infos(players)
        callbacks = GameBenchmarkCallbackList([
            EpochResultsFolderCallback(results_folder),
            InstanceFileSaver(results_folder),
            ExperimentFileSaver(results_folder, player_model_infos=model_infos),
            InteractionsFileSaver(results_folder, player_model_infos=model_infos),
        ])

        sequential.run(game_benchmark, game_instances, players, callbacks=callbacks)

    # Flush the last game
    if prm_guided is not None:
        prm_guided.flush_game()


def _run_baseline(game_name: str, model_name: str, results_dir: Path, temperature: float,
                  max_tokens: int, instances=None):
    """Run baseline (greedy, no PRM).

    When `instances` is provided the baseline is run via _run_game so the same
    instance filter applies.  Without it the full playpen eval CLI is used.
    """
    if instances is not None:
        model_registry = ModelRegistry.from_packaged_and_cwd_files()
        backend_registry = BackendRegistry.from_packaged_and_cwd_files()
        policy_spec = model_registry.get_first_model_spec_that_unify_with(
            ModelSpec.from_string(model_name)
        )
        backend = backend_registry.get_backend_for(policy_spec.backend)
        policy_model = backend.get_model_for(policy_spec)
        policy_model.set_gen_args(temperature=temperature, max_tokens=max_tokens)

        game_registry = GameRegistry.from_directories_and_cwd_files()
        game_spec = game_registry.get_game_specs_that_unify_with(game_name)[0]
        n_players = game_spec.players
        players = [policy_model] * n_players

        _run_game(game_name=game_name, players=players, results_dir=results_dir, instances=instances)
    else:
        subprocess.run(
            ["playpen", "eval", model_name,
             "-g", game_name,
             "-T", str(temperature),
             "-r", str(results_dir)],
            check=True,
        )


def _clem_score(results_dir: Path, game_name: str):
    """Run clem score on a results directory to populate scores.json files."""
    subprocess.run(
        [sys.executable, "-m", "clemcore.cli", "score", "-g", game_name, "-r", str(results_dir)],
        check=False,
    )


def _score_results(results_dir: Path) -> dict:
    """Parse saved scores.json files and return aggregate metrics."""
    score_files = list(results_dir.rglob("scores.json"))
    wins = losses = aborts = total = 0
    for f in score_files:
        d = json.loads(f.read_text())
        ep = d.get("episode scores", {})
        if not ep:
            continue
        total += 1
        if ep.get("Aborted", 0):
            aborts += 1
        elif ep.get("Success", 0):
            wins += 1
        else:
            losses += 1
    played = wins + losses
    return {
        "total": total,
        "success": wins,
        "loss": losses,
        "abort": aborts,
        "pct_played": 100 * played / total if total else 0,
        "pct_success": 100 * wins / played if played else 0,
    }


def _print_comparison(baseline: dict, guided: dict):
    print("\n" + "=" * 55)
    print(f"{'Metric':<20} {'Baseline':>15} {'PRM-guided':>15}")
    print("-" * 55)
    for key in ("total", "success", "loss", "abort", "pct_played", "pct_success"):
        b = baseline[key]
        g = guided[key]
        fmt = f"{key:<20} {b:>14.1f} {g:>14.1f}" if isinstance(b, float) else \
              f"{key:<20} {b:>15} {g:>15}"
        print(fmt)
    print("=" * 55)
    delta = guided["pct_success"] - baseline["pct_success"]
    print(f"\nSuccess rate delta: {delta:+.1f} pp")


# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

# Rough per-instance cost weights so the LPT partitioner below spreads the slow,
# long multi-turn games instead of clustering them on one shard. Values are
# RELATIVE wall-clock estimates (clean_up's 28-round 2-player games are the
# worst); anything unlisted defaults to 1. Only ordering/relative size matters.
_GAME_COST = {
    "clean_up": 8.0,
    "adventuregame": 5.0,
    "imagegame": 4.0,
    "textmapworld": 3.0,
    "textmapworld_graphreasoning": 3.0,
    "textmapworld_specificroom": 3.0,
    "privateshared": 3.0,
    "hot_air_balloon": 2.0,
}


def _instance_cost(inst: dict) -> float:
    """Relative runtime estimate for one eval instance (game base x size)."""
    import re
    w = _GAME_COST.get(inst.get("game", ""), 1.0)
    m = re.search(r"(\d+)obj", str(inst.get("experiment", "")))
    if m:
        w *= int(m.group(1)) / 3.0  # e.g. clean_up 7obj is ~2.3x a 3obj instance
    return w


def _shard_instances(instances: list, shard_id: int, num_shards: int) -> list:
    """Assign instances to a shard, balanced by ESTIMATED RUNTIME (LPT greedy).

    Count-based round-robin balanced the *number* of each game per shard but not
    per-instance runtime, so the slow instances (e.g. clean_up 7obj, 28 rounds)
    could still stack on one shard and straggle for hours behind the barrier.
    Here we sort all instances by estimated cost (descending) and greedily place
    each on the currently-least-loaded shard (Longest-Processing-Time-first) —
    the heaviest instances land on different shards and run first. Deterministic:
    every shard process sorts the same list with the same tie-break and computes
    the same assignment, so partitions stay disjoint and their union is the full
    list (the rsync merge step relies on this).
    """
    ranked = sorted(
        instances,
        key=lambda x: (-_instance_cost(x), x.get("game", ""),
                       str(x.get("experiment", "")), str(x.get("task_id", ""))),
    )
    loads = [0.0] * num_shards
    buckets: "list[list]" = [[] for _ in range(num_shards)]
    for inst in ranked:
        s = min(range(num_shards), key=lambda k: (loads[k], k))  # least-loaded; low id wins ties
        buckets[s].append(inst)
        loads[s] += _instance_cost(inst)
    print(f"[shard {shard_id}/{num_shards}] LPT est-load per shard="
          f"{[round(x, 1) for x in loads]}; this shard: {len(buckets[shard_id])} instances")
    return buckets[shard_id]


def _merge_results(results_dir: Path, num_shards: int):
    """Copy shard subdirectory trees into the main results dir."""
    import shutil
    for shard_id in range(num_shards):
        shard_dir = results_dir.parent / f"{results_dir.name}_shard{shard_id}" / results_dir.name
        if not shard_dir.exists():
            continue
        for src in shard_dir.rglob("*"):
            if src.is_file():
                rel = src.relative_to(shard_dir)
                dst = results_dir / rel
                dst.parent.mkdir(parents=True, exist_ok=True)
                shutil.copy2(src, dst)
        shutil.rmtree(shard_dir.parent)


def _run_worker(shard_id: int, num_shards: int, argv: list, log_dir: Path):
    """Re-invoke this script as a subprocess for one shard."""
    cmd = [sys.executable, __file__] + argv + [
        "--num-workers=1",          # prevent recursion even if --num-workers leaked through
        f"--shard-id={shard_id}",
        f"--num-shards={num_shards}",
        "--skip-score",
    ]
    log_dir.mkdir(parents=True, exist_ok=True)
    log_path = log_dir / f"shard{shard_id}.log"
    log_file = open(log_path, "w")
    print(f"[worker {shard_id}] shard {shard_id}/{num_shards} -> {log_path}")
    return subprocess.Popen(cmd, stdout=log_file, stderr=log_file), log_file


def main():
    parser = argparse.ArgumentParser(description="Evaluate PRM-guided vs baseline on a clembench game")
    parser.add_argument("--prm-path", default="models/prm/Qwen3.5-27B-Instruct-4bit",
                        help="Path to trained PRM checkpoint directory")
    parser.add_argument("--policy-model", default="Qwen3.5-27B-Instruct-4bit",
                        help="Model name as listed in model registry")
    parser.add_argument("--game", default="wordle",
                        help="clembench game to evaluate on (ignored when --game-all)")
    parser.add_argument("--game-all", action="store_true",
                        help="Evaluate EVERY game present in the (sharded) split, "
                             "not just --game. Use this for a PRM trained on all games.")
    parser.add_argument("--mode", choices=["best-of-n", "beam-search"], default="best-of-n",
                        help="Guided search mode: best-of-N (default) or beam search")
    parser.add_argument("--n-candidates", type=int, default=8,
                        help="Number of candidates per step for PRM-guided agent (best-of-n mode)")
    parser.add_argument("--beam-width", type=int, default=4,
                        help="Beam width M (beam-search mode): prune to N/M survivors per step")
    parser.add_argument("--num-beam-iterations", type=int, default=20,
                        help="Max beam search steps per game turn (beam-search mode)")
    parser.add_argument("--temperature", type=float, default=0.7,
                        help="Sampling temperature for candidate generation")
    parser.add_argument("--max-tokens", type=int, default=300)
    parser.add_argument("--results-dir", default="eval-results",
                        help="Root directory for evaluation results")
    parser.add_argument("--skip-baseline", action="store_true",
                        help="Skip baseline run (use if already completed)")
    parser.add_argument("--skip-guided", action="store_true",
                        help="Skip PRM-guided run (score only)")
    parser.add_argument("--split", default="validation",
                        help="Dataset split to evaluate on (validation, test, train)")
    parser.add_argument("--instances-file", default=None,
                        help="Path to a clembench instances JSON file.")
    parser.add_argument("--skip-score", action="store_true",
                        help="Skip the scoring/comparison step.")
    parser.add_argument("--num-workers", type=int, default=1,
                        help="Number of parallel workers (each loads its own model copy). "
                             "With 96GB and ~28GB per worker, use 3.")
    parser.add_argument("--shard-id", type=int, default=None,
                        help="(Internal) which shard this worker handles.")
    parser.add_argument("--num-shards", type=int, default=None,
                        help="(Internal) total number of shards.")
    parser.add_argument("--prm-bf16", action="store_true",
                        help="Load PRM base model in bf16 instead of 4-bit. "
                             "Use when the PRM was trained with --bf16-lora.")
    args = parser.parse_args()

    # ------------------------------------------------------------------ #
    # Multi-worker orchestration                                           #
    # ------------------------------------------------------------------ #
    if args.num_workers > 1 and args.shard_id is None:
        # Orchestrator: spawn num_workers subprocesses, wait, merge, score
        # Filter out --num-workers and its value (handles both '--num-workers 6' and '--num-workers=6')
        raw = sys.argv[1:]
        passthrough = []
        skip_next = False
        for a in raw:
            if skip_next:
                skip_next = False
                continue
            if a == "--num-workers":
                skip_next = True
                continue
            if a.startswith("--num-workers="):
                continue
            passthrough.append(a)
        log_dir = Path(args.results_dir) / "worker_logs"
        pairs = [_run_worker(i, args.num_workers, passthrough, log_dir) for i in range(args.num_workers)]
        procs = [p for p, _ in pairs]
        log_files = [f for _, f in pairs]
        print(f"Launched {args.num_workers} workers, waiting...")
        print(f"Follow progress with:  tail -f {log_dir}/shard*.log")
        for p in procs:
            p.wait()
        for f in log_files:
            f.close()
        print("All workers done. Merging results...")
        results_dir = Path(args.results_dir)
        if not args.skip_baseline:
            _merge_results(results_dir / "baseline", args.num_workers)
        if not args.skip_guided:
            _merge_results(results_dir / "prm-guided", args.num_workers)
        if not args.skip_score:
            print("\n--- Scoring merged results ---")
            _clem_score(results_dir / "baseline", args.game)
            _clem_score(results_dir / "prm-guided", args.game)
            _print_comparison(
                _score_results(results_dir / "baseline"),
                _score_results(results_dir / "prm-guided"),
            )
        return

    results_dir = Path(args.results_dir)

    # If running as a shard worker, redirect results to a shard-specific dir
    if args.shard_id is not None:
        results_dir = results_dir.parent / f"{results_dir.name}_shard{args.shard_id}" / results_dir.name

    baseline_dir = results_dir / "baseline"
    guided_dir = results_dir / "prm-guided"

    # Load instances — either from a local JSON file or the HuggingFace dataset
    if args.instances_file:
        print(f"Loading instances from {args.instances_file}...")
        raw = json.loads(Path(args.instances_file).read_text())
        dataset_val = [
            {"game": args.game, "experiment": exp["name"], "task_id": gi["game_id"]}
            for exp in raw["experiments"]
            for gi in exp["game_instances"]
        ]
        print(f"  {len(dataset_val)} instances loaded")
    else:
        print(f"Loading {args.split} instances...")
        dataset_val = load_dataset("colab-potsdam/playpen-data", "instances", split=args.split)
        dataset_val = list(dataset_val)

    if args.shard_id is not None:
        dataset_val = _shard_instances(dataset_val, args.shard_id, args.num_shards)
        print(f"[shard {args.shard_id}/{args.num_shards}] handling {len(dataset_val)} instances")

    # Evaluate EVERY game present in the (sharded) instance set — the PRM was
    # trained across all games, so a single-game eval (the old --game default)
    # is both too narrow AND nearly empty once instances are sharded. Each game's
    # run below filters dataset_val to that game's instances internally.
    if args.game_all:
        games = sorted({inst["game"] for inst in dataset_val}) if dataset_val else []
    else:
        games = [args.game]
    print(f"Evaluating {len(games)} game(s): {', '.join(games) if games else '(none in this shard)'}")

    # ------------------------------------------------------------------ #
    # 1. Baseline run                                                      #
    # ------------------------------------------------------------------ #
    if not args.skip_baseline and games:
        # Sharded/instances path: load the policy ONCE and reuse it across all
        # games. (Reloading per game — the old _run_baseline-per-game path — left
        # each game's weights on the GPU, so device_map="auto" accumulated memory
        # and eventually CPU-offloaded the 4-bit model: "Some modules dispatched
        # on the CPU".) Without a sharded list, fall back to the playpen-eval CLI.
        base_instances = dataset_val if (args.instances_file or args.shard_id is not None) else None
        if base_instances is not None:
            print(f"Loading policy model: {args.policy_model}")
            model_registry = ModelRegistry.from_packaged_and_cwd_files()
            backend_registry = BackendRegistry.from_packaged_and_cwd_files()
            policy_spec = model_registry.get_first_model_spec_that_unify_with(
                ModelSpec.from_string(args.policy_model)
            )
            backend = backend_registry.get_backend_for(policy_spec.backend)
            policy_model = backend.get_model_for(policy_spec)
            policy_model.set_gen_args(temperature=args.temperature, max_tokens=args.max_tokens)
            game_registry = GameRegistry.from_directories_and_cwd_files()
            for game in games:
                print(f"\n--- Baseline run [{game}] (T={args.temperature}, no PRM) ---")
                game_spec = game_registry.get_game_specs_that_unify_with(game)[0]
                _run_game(
                    game_name=game,
                    players=[policy_model] * game_spec.players,
                    results_dir=baseline_dir,
                    instances=dataset_val,
                )
        else:
            for game in games:
                print(f"\n--- Baseline run [{game}] (T={args.temperature}, no PRM) ---")
                _run_baseline(
                    game_name=game, model_name=args.policy_model, results_dir=baseline_dir,
                    temperature=args.temperature, max_tokens=args.max_tokens, instances=None,
                )

    # ------------------------------------------------------------------ #
    # 2. PRM-guided run                                                    #
    # ------------------------------------------------------------------ #
    if not args.skip_guided:
        mode_label = (f"beam-search (N={args.n_candidates}, M={args.beam_width}, "
                      f"iters={args.num_beam_iterations})"
                      if args.mode == "beam-search"
                      else f"best-of-{args.n_candidates}")
        print(f"\n--- PRM-guided run ({mode_label}, T={args.temperature}) ---")

        print(f"Loading policy model: {args.policy_model}")
        model_registry = ModelRegistry.from_packaged_and_cwd_files()
        backend_registry = BackendRegistry.from_packaged_and_cwd_files()
        policy_spec = model_registry.get_first_model_spec_that_unify_with(
            ModelSpec.from_string(args.policy_model)
        )
        backend = backend_registry.get_backend_for(policy_spec.backend)
        policy_model = backend.get_model_for(policy_spec)
        policy_model.set_gen_args(temperature=0.0, max_tokens=args.max_tokens)

        print(f"Loading PRM from: {args.prm_path}")
        prm_tokenizer = AutoTokenizer.from_pretrained(args.prm_path)
        if prm_tokenizer.pad_token is None:
            prm_tokenizer.pad_token = prm_tokenizer.eos_token

        # PRM is a PEFT/LoRA adapter — load base model then attach adapter.
        # When a single GPU is visible (the sharded eval case), pin the model to
        # it ({"": 0}) instead of device_map="auto": "auto" intermittently decides
        # the card is too full and offloads layers to CPU, which a 4-bit model
        # can't do -> "Some modules dispatched on the CPU" ValueError. The
        # policy(~14GB)+PRM(~14GB) fit a 46GB card, so forcing on-GPU is correct.
        prm_device_map = {"": 0} if torch.cuda.device_count() == 1 else "auto"
        peft_cfg = PeftConfig.from_pretrained(args.prm_path)
        if args.prm_bf16:
            print("Loading PRM base in bf16 (--prm-bf16)")
            prm_base = AutoModelForSequenceClassification.from_pretrained(
                peft_cfg.base_model_name_or_path,
                num_labels=1,
                torch_dtype=torch.bfloat16,
                device_map=prm_device_map,
            )
        else:
            bnb_config = BitsAndBytesConfig(
                load_in_4bit=True,
                bnb_4bit_compute_dtype=torch.bfloat16,
                bnb_4bit_use_double_quant=True,
                bnb_4bit_quant_type="nf4",
            )
            prm_base = AutoModelForSequenceClassification.from_pretrained(
                peft_cfg.base_model_name_or_path,
                num_labels=1,
                quantization_config=bnb_config,
                device_map=prm_device_map,
            )
        prm_base.config.pad_token_id = prm_tokenizer.pad_token_id
        prm_model = PeftModel.from_pretrained(prm_base, args.prm_path)
        device = "cuda" if torch.cuda.is_available() else "cpu"

        if args.mode == "beam-search":
            prm_guided = BeamSearchGuidedModel(
                base_model=policy_model,
                prm=prm_model,
                tokenizer=prm_tokenizer,
                n_beams=args.n_candidates,
                beam_width=args.beam_width,
                num_iterations=args.num_beam_iterations,
                candidate_temperature=args.temperature,
                max_length=args.max_tokens,
                device=device,
            )
        else:
            prm_guided = PRMGuidedModel(
                base_model=policy_model,
                prm=prm_model,
                tokenizer=prm_tokenizer,
                n_candidates=args.n_candidates,
                candidate_temperature=args.temperature,
                device=device,
            )
        prm_guided.set_gen_args(temperature=0.0, max_tokens=args.max_tokens)

        game_registry = GameRegistry.from_directories_and_cwd_files()
        for game in games:
            print(f"\n--- PRM-guided run [{game}] (best-of-{args.n_candidates}) ---")
            game_spec = game_registry.get_game_specs_that_unify_with(game)[0]
            n_players = game_spec.players
            players = [policy_model] * (n_players - 1) + [prm_guided]
            _run_game(
                game_name=game,
                players=players,
                results_dir=guided_dir,
                instances=dataset_val,
            )

    # ------------------------------------------------------------------ #
    # 3. Score and compare                                                 #
    # ------------------------------------------------------------------ #
    if args.skip_score:
        print("\n--skip-score set — skipping scoring/comparison.")
        return

    print("\n--- Scoring results ---")
    for game in games:
        _clem_score(baseline_dir, game)
        _clem_score(guided_dir, game)

    baseline_scores = _score_results(baseline_dir)   # rglobs scores.json -> all games
    guided_scores = _score_results(guided_dir)

    _print_comparison(baseline_scores, guided_scores)


if __name__ == "__main__":
    main()