Upload folder using huggingface_hub

examples/trl/data_utils.py

@@ -0,0 +1,102 @@
+import argparse
+import json
+import os.path
+import random
+from glob import glob
+from tqdm import tqdm
+
+from clemcore.clemgame.resources import load_json
+
+
+def create_conversational_dataset_for(top_dir):
+    """NOTE: This script requires interactions generated with clemcore >=2.4.0 !"""
+    interactions_files = glob(f"{top_dir}/**/interactions.json", recursive=True)
+    dataset_file = "results.jsonl"
+    dataset_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), dataset_file)
+    print(f"Writing dataset file to {dataset_path} interactions")
+    exceptions = set()
+    with open(dataset_path, "w", encoding="utf-8") as f:
+        print(f"Collecting {len(interactions_files)} interactions")
+        for interactions_file in tqdm(interactions_files):
+            interactions = load_json(interactions_file)
+            # read from meta info (since clemcore 2.4)
+            game_name = interactions["meta"]["game_name"]
+            experiment_name = interactions["meta"]["experiment_name"]
+            game_id = interactions["meta"]["game_id"]
+            outcome = None  # this should also become part of the meta in later clemcore versions
+            try:
+                scores = load_json(os.path.join(os.path.dirname(interactions_file), "scores.json"))
+                episodes_scores = scores["episode scores"]
+                if episodes_scores["Aborted"]:
+                    outcome = "aborted"
+                if episodes_scores["Success"]:
+                    outcome = "success"
+                if episodes_scores["Lose"]:
+                    outcome = "failure"
+            except Exception as e:  # cannot determine outcome
+                pass
+            # We collect each episode from the perspective of all players individually
+            for player_name, player_details in interactions["players"].items():
+                try:  # since clemcore 2.4
+                    player_name = player_details["player_name"]
+                    game_role = player_details["game_role"]
+                    model_name = player_details["model_name"]
+                except Exception as e:
+                    exceptions.add((game_name, player_details))
+                    continue
+                if player_name == "GM":
+                    continue  # ignore game master perspective (we dont want to learn that here)
+                if model_name == "programmatic":
+                    continue  # do not train on programmatic behaviors
+                # print(f"Going through {len(interactions['turns'])} rounds")
+                messages = []
+                for events in interactions["turns"]:
+                    # print(f"Scanning {len(events)} round events")
+                    for event in events:
+                        if event["to"] == player_name:  # a message to the player (assistant)
+                            messages.append(dict(role="user", content=event["action"]["content"]))
+                        if event["from"] == player_name:  # a message from the player (assistant)
+                            messages.append(dict(role="assistant", content=event["action"]["content"]))
+                if messages:  # ignore episodes where player had no turn because of initial failures of the other
+                    f.write(json.dumps({
+                        "messages": messages,
+                        "meta": {
+                            "game": game_name,
+                            "experiment": experiment_name,
+                            "task_id": game_id,
+                            "player_name": player_name,
+                            "game_role": game_role,
+                            "model": model_name,
+                            "outcome": outcome
+                        }
+                    }) + '\n')
+    for ex in exceptions:
+        print(ex)
+    counter = 0
+    random_examples = []
+    with open(dataset_path, "r", encoding="utf-8") as file:
+        for line in file:
+            counter += 1
+            if random.randint(0, 100) < 1:
+                random_examples.append(json.loads(line))
+    print(f"Written {counter} examples to {dataset_path}")
+    print()
+    print(f"See {len(random_examples)} examples:")
+    for example in random_examples:
+        print("Meta:", example["meta"])
+        print("Messages:")
+        for message in example["messages"]:
+            print(f"  {message}")
+    print()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("top_dir",
+                        help="The directory containing benchmark results for one or more models")
+    args = parser.parse_args()
+    create_conversational_dataset_for(args.top_dir)
+
+
+if __name__ == "__main__":
+    main()

examples/trl/eval_validation_one.py

@@ -0,0 +1,102 @@
+"""Evaluate ONE policy model on the playpen `validation` split (all games).
+
+Plain gameplay only — no PRM, no candidate search. Loads the policy once, plays
+every game present in the split via self-play (`[policy]*n_players`), then runs
+`clem score` per game so scores.json files are populated. Pair two of these
+(one per GPU) with run_sft_vs_base_eval.sh to compare an SFT model vs its base.
+
+Reuses _run_game / _clem_score from prm_eval.py so the results layout and scoring
+match the existing PRM harness exactly.
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from datasets import load_dataset
+
+from clemcore.backends import ModelRegistry, BackendRegistry, ModelSpec
+from clemcore.clemgame import GameRegistry
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from prm_eval import _run_game, _clem_score, _shard_instances  # noqa: E402
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Eval one model on the validation split (all games).")
+    ap.add_argument("--model", required=True, help="Registered model name (policy).")
+    ap.add_argument("--results-dir", required=True)
+    ap.add_argument("--split", default="validation")
+    ap.add_argument("--temperature", type=float, default=0.0)
+    ap.add_argument("--max-tokens", type=int, default=1024)
+    ap.add_argument("--dataset", default="colab-potsdam/playpen-data")
+    # data-parallel sharding: run N workers over the same results dir, each taking
+    # a game-balanced slice of instances. Score once (elsewhere) after all finish.
+    ap.add_argument("--shard-id", type=int, default=None)
+    ap.add_argument("--num-shards", type=int, default=None)
+    ap.add_argument("--skip-score", action="store_true",
+                    help="Run gameplay only; score separately after all shards finish.")
+    # smoke-test knobs
+    ap.add_argument("--only-games", nargs="*", default=None, help="Restrict to these games.")
+    ap.add_argument("--limit-per-game", type=int, default=None)
+    args = ap.parse_args()
+
+    rows = list(load_dataset(args.dataset, "instances", split=args.split))
+    if args.only_games:
+        keep = set(args.only_games)
+        rows = [r for r in rows if r["game"] in keep]
+    if args.limit_per_game:
+        seen = defaultdict(int)
+        capped = []
+        for r in rows:
+            if seen[r["game"]] < args.limit_per_game:
+                capped.append(r)
+                seen[r["game"]] += 1
+        rows = capped
+
+    tag = args.model if args.shard_id is None else f"{args.model} shard {args.shard_id}/{args.num_shards}"
+    if args.shard_id is not None:
+        rows = _shard_instances(rows, args.shard_id, args.num_shards)
+
+    games = sorted({r["game"] for r in rows})
+    print(f"[{args.model}] {len(rows)} instances across {len(games)} game(s): {games}", flush=True)
+
+    # Load the policy ONCE and reuse across every game.
+    mr = ModelRegistry.from_packaged_and_cwd_files()
+    br = BackendRegistry.from_packaged_and_cwd_files()
+    spec = mr.get_first_model_spec_that_unify_with(ModelSpec.from_string(args.model))
+    policy = br.get_backend_for(spec.backend).get_model_for(spec)
+    policy.set_gen_args(temperature=args.temperature, max_tokens=args.max_tokens)
+
+    gr = GameRegistry.from_directories_and_cwd_files()
+    results_dir = Path(args.results_dir)
+
+    failed = []
+    for g in games:
+        g_rows = [r for r in rows if r["game"] == g]
+        try:
+            n_players = gr.get_game_specs_that_unify_with(g)[0].players
+        except Exception as e:
+            print(f"  !! {g}: no runnable game spec ({e}) — skipping", flush=True)
+            failed.append(g)
+            continue
+        print(f"\n=== {tag} | {g} | {len(g_rows)} instances | {n_players} player(s) ===", flush=True)
+        try:
+            _run_game(game_name=g, players=[policy] * n_players, results_dir=results_dir, instances=g_rows)
+        except Exception as e:
+            print(f"  !! {g} gameplay failed: {type(e).__name__}: {e}", flush=True)
+            failed.append(g)
+
+    if not args.skip_score:
+        print(f"\n[{tag}] scoring {len(games)} game(s)...", flush=True)
+        for g in games:
+            _clem_score(results_dir, g)
+
+    print(f"[{tag}] DONE -> {results_dir}"
+          + (f"  (failed games: {failed})" if failed else "  (all games ran)"), flush=True)
+
+
+if __name__ == "__main__":
+    main()

examples/trl/prm_eval.py

@@ -0,0 +1,880 @@
+"""
+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()

examples/trl/prm_train_from_records.py

@@ -0,0 +1,577 @@
+"""
+Train a PRM from pre-collected rollout data stored in checkpoint JSONL files.
+
+Reads checkpoint files written by prm_trainer.py during rollout collection and
+builds a soft-label PRM training dataset without re-running any games.
+
+Each checkpoint JSONL row has the form:
+    {"checkpoint_id": "<uuid>", "prompt": [...], "response": "...", "outcomes": [0,1,0,0]}
+
+Rows with the same checkpoint_id are grouped and their outcomes averaged into
+a true Monte Carlo soft label — the same label that would have been computed
+during live training.
+
+Usage:
+    python examples/trl/prm_train_from_records.py \\
+        --checkpoint-dir prm-checkpoints/Qwen3.5-27B-Instruct-4bit \\
+        --epochs 1 2 \\
+        --model /nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B \\
+        --output models/prm/Qwen3.5-27B-Instruct-4bit
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import shutil
+from collections import defaultdict
+from pathlib import Path
+import sys
+
+import torch
+import torch.nn.functional as F
+from transformers import (
+    AutoConfig,
+    AutoModelForSequenceClassification,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    DataCollatorWithPadding,
+    EarlyStoppingCallback,
+    Trainer,
+    TrainingArguments,
+)
+from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training
+from datasets import Dataset
+
+# Reuse the static loader from prm_trainer
+sys.path.insert(0, str(Path(__file__).parent))
+
+
+# ---------------------------------------------------------------------------
+# BCE trainer (identical to prm_trainer.py)
+# ---------------------------------------------------------------------------
+
+class _SoftBCETrainer(Trainer):
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.pop("labels").float()
+        outputs = model(**inputs)
+        logits = outputs.logits
+        # Handle both num_labels=1 → [batch,1] and num_labels=2 → [batch,2]
+        if logits.dim() == 2 and logits.shape[-1] == 2:
+            logits = logits[:, 1] - logits[:, 0]  # log-odds for binary
+        else:
+            logits = logits.squeeze(-1)
+        loss = F.binary_cross_entropy_with_logits(logits, labels)
+        return (loss, outputs) if return_outputs else loss
+
+
+# ---------------------------------------------------------------------------
+# Data loading
+# ---------------------------------------------------------------------------
+
+def resolve_checkpoint_dir(checkpoint_dir: Path, reward_mode: str | None) -> Path:
+    """Resolve --checkpoint-dir to the directory that actually holds the JSONL.
+
+    The PRM collector writes per-reward-mode subdirs:
+        prm-checkpoints/<model>/success/epoch_*.jsonl
+        prm-checkpoints/<model>/bench/epoch_*.jsonl
+    so that the two label sets (binary success vs graded bench) never mix. This
+    accepts any of:
+      * a dir that already has epoch_*.jsonl  -> used as-is (subdir or flat)
+      * --reward-mode given                   -> <checkpoint_dir>/<mode>
+      * exactly one mode subdir has files     -> auto-pick it (with a note)
+      * both modes present, no --reward-mode  -> hard error (must disambiguate),
+        because training on a mix of the two label semantics is wrong.
+    """
+    if list(checkpoint_dir.glob("epoch_*.jsonl")):
+        return checkpoint_dir
+    if reward_mode is not None:
+        return checkpoint_dir / reward_mode
+    modes = [m for m in ("success", "bench")
+             if list((checkpoint_dir / m).glob("epoch_*.jsonl"))]
+    if len(modes) == 1:
+        print(f"Auto-detected reward-mode subdir: {checkpoint_dir / modes[0]}")
+        return checkpoint_dir / modes[0]
+    if len(modes) > 1:
+        raise SystemExit(
+            f"\n{checkpoint_dir} holds multiple reward modes {modes} with different "
+            f"label semantics (binary 'success' vs graded 'bench') — training a mix "
+            f"is wrong.\nRe-run with --reward-mode <success|bench>, or point "
+            f"--checkpoint-dir at one subdir (e.g. {checkpoint_dir / 'bench'})."
+        )
+    return checkpoint_dir  # nothing found; load_prm_dataset prints the empty-dir notice
+
+
+def load_prm_dataset(checkpoint_dir: Path, epoch_nums: list[int] | None,
+                     game: str | None = None) -> Dataset:
+    """Load checkpoint JSONL files and build a true-MC soft-label PRM dataset.
+
+    Checkpoint files are named ``epoch_NNNNN_shardSS_<game>.jsonl``. Passing
+    ``game`` restricts the load to that game's files (for a per-game PRM); the
+    default pools every game into one PRM.
+    """
+    scores_by_id: dict[str, list[float]] = defaultdict(list)
+    meta_by_id: dict[str, dict] = {}
+
+    if game is not None:
+        # Same sanitisation the collector applies to game names in filenames.
+        g = re.sub(r"[^A-Za-z0-9._-]", "_", game)
+        # The game token is the full suffix before .jsonl, so no game name can
+        # be a false prefix of another (e.g. wordle vs wordle_withclue).
+        available = sorted(checkpoint_dir.glob(f"epoch_*_{g}.jsonl"))
+    else:
+        available = sorted(checkpoint_dir.glob("epoch_*.jsonl"))
+    if epoch_nums is not None:
+        available = [p for p in available if int(p.stem.split("_")[1]) in epoch_nums]
+
+    if not available:
+        print(f"No checkpoint files found in {checkpoint_dir}")
+        return Dataset.from_list([])
+
+    for path in available:
+        n_rows = 0
+        with open(path) as f:
+            for line in f:
+                if not line.strip():
+                    continue
+                row = json.loads(line)
+                cid = row["checkpoint_id"]
+                scores_by_id[cid].extend(row["outcomes"])
+                if cid not in meta_by_id:
+                    meta_by_id[cid] = {
+                        "prompt": row["prompt"],
+                        "response": row["response"],
+                    }
+                n_rows += 1
+        print(f"  {path.name}: {n_rows} checkpoint rows")
+
+    examples = []
+    for cid, scores in scores_by_id.items():
+        info = meta_by_id[cid]
+        examples.append({
+            "prompt": info["prompt"],
+            "completion": [{"role": "assistant", "content": info["response"]}],
+            "label": sum(scores) / len(scores),
+            "n_rollouts": len(scores),
+        })
+
+    print(f"\nTotal unique (state, response) pairs: {len(examples)}")
+    _print_label_distribution(examples)
+    return Dataset.from_list(examples)
+
+
+def load_prm_dataset_from_interactions(
+    records_dir: Path,
+    epoch_nums: list[int] | None,
+    player_name: str,
+    branching_factor: int,
+) -> Dataset:
+    """Load from interactions.json files using sequential branch grouping.
+
+    Branches are written in order: checkpoint 0 → branches 1-N,
+    checkpoint 1 → branches N+1-2N, etc.  Grouping by N recovers the true
+    MC groups without needing the checkpoint_id field.
+    """
+    examples = []
+
+    available_epochs = sorted(records_dir.glob("epoch_*"))
+    if epoch_nums is not None:
+        available_epochs = [
+            p for p in available_epochs
+            if p.is_dir() and int(p.name.split("_")[1]) in epoch_nums
+        ]
+
+    for epoch_dir in available_epochs:
+        # Collect all branch files grouped by instance directory
+        instance_dirs = sorted({
+            f.parent.parent
+            for f in epoch_dir.rglob("interactions.json")
+        })
+
+        for instance_dir in instance_dirs:
+            branch_files = sorted(instance_dir.glob("branch_*/interactions.json"),
+                                  key=lambda p: int(p.parent.name.split("_")[1]))
+            if not branch_files:
+                continue
+
+            # Load all branches for this instance
+            branches = []
+            for bf in branch_files:
+                d = json.loads(bf.read_text())
+                outcome = 1.0 if d.get("Success", 0) else 0.0
+
+                # Extract player turns as (gm_prompt, player_response) pairs
+                turns = []
+                for turn in d.get("turns", []):
+                    gm_prompt = player_response = None
+                    for msg in turn:
+                        act = msg.get("action", {})
+                        if (msg.get("from") == "GM" and msg.get("to") == player_name
+                                and act.get("type") == "send message"):
+                            gm_prompt = act["content"]
+                        elif (msg.get("from") == player_name and msg.get("to") == "GM"
+                              and act.get("type") == "get message"):
+                            player_response = act["content"]
+                    if gm_prompt is not None and player_response is not None:
+                        turns.append((gm_prompt, player_response))
+
+                branches.append({"turns": turns, "outcome": outcome})
+
+            # Group sequentially by branching_factor
+            n = branching_factor
+            n_groups = len(branches) // n
+            for g in range(n_groups):
+                group = branches[g * n: (g + 1) * n]
+                outcomes = [b["outcome"] for b in group]
+
+                # The shared prefix is turns 0..g from any branch (they're identical)
+                # The diverging step is turn g; prompt = conversation before turn g
+                ref = group[0]["turns"]
+                if g >= len(ref):
+                    continue  # base game was shorter than expected
+
+                # Build conversation history up to (not including) turn g
+                prompt: list[dict] = []
+                for t in range(g):
+                    gm_msg, player_resp = ref[t]
+                    prompt.append({"role": "user", "content": gm_msg})
+                    prompt.append({"role": "assistant", "content": player_resp})
+                # Add the GM message that precedes the diverging response
+                prompt.append({"role": "user", "content": ref[g][0]})
+                response = ref[g][1]
+
+                examples.append({
+                    "prompt": prompt,
+                    "completion": [{"role": "assistant", "content": response}],
+                    "label": sum(outcomes) / len(outcomes),
+                    "n_rollouts": len(outcomes),
+                })
+
+        print(f"  {epoch_dir.name}: done")
+
+    print(f"\nTotal checkpoint groups: {len(examples)}")
+    _print_label_distribution(examples)
+    return Dataset.from_list(examples)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _print_label_distribution(examples: list[dict]):
+    labels = [e["label"] for e in examples]
+    buckets = {"0.0": 0, "(0,0.5)": 0, "0.5": 0, "(0.5,1)": 0, "1.0": 0}
+    for l in labels:
+        if l == 0.0:     buckets["0.0"] += 1
+        elif l < 0.5:    buckets["(0,0.5)"] += 1
+        elif l == 0.5:   buckets["0.5"] += 1
+        elif l < 1.0:    buckets["(0.5,1)"] += 1
+        else:            buckets["1.0"] += 1
+    avg = sum(labels) / len(labels) if labels else 0
+    print(f"Label distribution (n={len(labels)}, mean={avg:.3f}):")
+    for bucket, count in buckets.items():
+        bar = "#" * min(count, 60)
+        print(f"  {bucket:>10}  {bar} ({count})")
+
+
+def _tokenize_batch(batch, tokenizer, max_length=1024):
+    texts = []
+    for prompt, completion in zip(batch["prompt"], batch["completion"]):
+        messages = prompt + completion
+        text = tokenizer.apply_chat_template(
+            messages, tokenize=False, add_generation_prompt=False
+        )
+        texts.append(text)
+    encoded = tokenizer(
+        texts,
+        truncation=True,
+        max_length=max_length,     # left-truncate keeps the response (scored end)
+        truncation_side="left",
+        padding=False,
+    )
+    encoded["labels"] = batch["label"]
+    return encoded
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Train PRM from pre-collected rollout checkpoint files"
+    )
+    parser.add_argument(
+        "--checkpoint-dir",
+        default="prm-checkpoints/Qwen3.5-27B-Instruct-4bit",
+        help="Directory with epoch_NNNNN.jsonl files. May be a per-reward-mode "
+             "subdir (e.g. .../success or .../bench) or the parent dir (then use "
+             "--reward-mode, or it auto-picks if only one mode is present).",
+    )
+    parser.add_argument(
+        "--reward-mode", choices=["success", "bench"], default=None,
+        help="Which reward-mode subdir under --checkpoint-dir to train on "
+             "(success = Math-Shepherd binary; bench = graded eval score). "
+             "Output is placed under <output>/<reward-mode> unless --output is set.",
+    )
+    parser.add_argument(
+        "--game", default=None,
+        help="Train a PER-GAME PRM from only this game's checkpoints "
+             "(e.g. 'taboo'). Default: pool all games into one PRM. Output is "
+             "nested under <output>/.../<game> unless --output is set.",
+    )
+    parser.add_argument(
+        "--epochs", nargs="+", type=int, default=None,
+        help="Epoch numbers to include (default: all available)",
+    )
+    parser.add_argument(
+        "--legacy", action="store_true",
+        help="Load from interactions.json files instead of JSONL checkpoints "
+             "(use for data collected before checkpoint saving was added)",
+    )
+    parser.add_argument(
+        "--branching-factor", type=int, default=4,
+        help="Number of rollouts per checkpoint (used with --legacy)",
+    )
+    parser.add_argument(
+        "--player-name", default="Player 1",
+        help="Player name for turn extraction (used with --legacy)",
+    )
+    parser.add_argument(
+        "--model",
+        default="/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B",
+        help="HuggingFace model ID or local path to use as PRM base",
+    )
+    parser.add_argument(
+        "--output", default="models/prm/Qwen3.5-27B-Instruct-4bit",
+        help="Directory to save the trained PRM",
+    )
+    parser.add_argument(
+        "--min-rollouts", type=int, default=1,
+        help="Minimum number of rollouts for a training example to be included",
+    )
+    parser.add_argument(
+        "--no-4bit", action="store_true",
+        help="Disable 4-bit quantization + LoRA (trains full model, not recommended)",
+    )
+    parser.add_argument(
+        "--bf16-lora", action="store_true",
+        help="Load model in bf16 (no quantization) but still apply LoRA. "
+             "Uses ~18GB for 9B model but works with torchrun DDP.",
+    )
+    parser.add_argument(
+        "--per-device-batch-size", type=int, default=4,
+        help="Per-GPU batch size. Increase to fill GPU memory (default: 4).",
+    )
+    parser.add_argument(
+        "--gradient-accumulation-steps", type=int, default=32,
+        help="Gradient accumulation steps. Reduce proportionally when increasing "
+             "batch size to keep the same effective batch size (default: 32).",
+    )
+    parser.add_argument(
+        "--resume", action="store_true",
+        help="Resume training from the latest checkpoint in --output (if any). "
+             "Safe to pass on a fresh run: if no checkpoint exists, trains from "
+             "scratch. Relies on save_strategy='epoch' checkpoints.",
+    )
+    parser.add_argument(
+        "--max-length", type=int, default=1024,
+        help="Max tokens of (prompt+response) the PRM reads per example "
+             "(left-truncated to keep the scored response). Default 1024.",
+    )
+    args = parser.parse_args()
+
+    checkpoint_dir = resolve_checkpoint_dir(Path(args.checkpoint_dir), args.reward_mode)
+    print(f"Using checkpoint dir: {checkpoint_dir}")
+
+    # Keep success/bench PRMs in separate output dirs so they never overwrite
+    # each other. If the resolved dir is a reward-mode subdir and --output was
+    # left at its default, nest the output under that mode.
+    resolved_mode = checkpoint_dir.name if checkpoint_dir.name in ("success", "bench") else None
+    default_output = parser.get_default("output")
+    if args.output == default_output:
+        # Keep success/bench and per-game PRMs in separate output dirs so they
+        # never overwrite each other: <output>/<mode>/<game>.
+        suffix = Path("")
+        if resolved_mode:
+            suffix = suffix / resolved_mode
+        if args.game:
+            suffix = suffix / args.game
+        if str(suffix):
+            args.output = str(Path(args.output) / suffix)
+            print(f"Output dir set to: {args.output}")
+
+    if args.legacy:
+        print("=== Loading dataset from interactions.json (legacy, group-by-N MC) ===")
+        dataset = load_prm_dataset_from_interactions(
+            checkpoint_dir, args.epochs, args.player_name, args.branching_factor
+        )
+    else:
+        scope = f"game='{args.game}'" if args.game else "all games (pooled)"
+        print(f"=== Loading dataset from checkpoint JSONL files (true MC) — {scope} ===")
+        dataset = load_prm_dataset(checkpoint_dir, args.epochs, args.game)
+
+    if args.min_rollouts > 1:
+        before = len(dataset)
+        dataset = dataset.filter(lambda row: row["n_rollouts"] >= args.min_rollouts)
+        print(f"After min_rollouts={args.min_rollouts} filter: {len(dataset)} / {before}")
+
+    if len(dataset) == 0:
+        print("No training examples after filtering. Exiting.")
+        return
+
+    print(f"\n=== Tokenising ({len(dataset)} examples) ===")
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    tokenized = dataset.map(
+        lambda batch: _tokenize_batch(batch, tokenizer, args.max_length),
+        batched=True,
+        remove_columns=dataset.column_names,
+        desc="Tokenising",
+    )
+
+    split = tokenized.train_test_split(test_size=0.1, seed=42)
+    print(f"Train: {len(split['train'])}  Val: {len(split['test'])}")
+
+    prm_config = AutoConfig.from_pretrained(args.model, num_labels=1)
+    if hasattr(prm_config, "classifier_dropout"):
+        prm_config.classifier_dropout = 0.05
+    prm_config.pad_token_id = tokenizer.pad_token_id
+
+    if args.no_4bit:
+        print(f"\n=== Loading PRM classifier (full bf16, no LoRA) from: {args.model} ===")
+        prm_classifier = AutoModelForSequenceClassification.from_pretrained(
+            args.model, config=prm_config, torch_dtype=torch.bfloat16
+        )
+    elif args.bf16_lora:
+        print(f"\n=== Loading PRM classifier (bf16 + LoRA) from: {args.model} ===")
+        prm_classifier = AutoModelForSequenceClassification.from_pretrained(
+            args.model, config=prm_config, torch_dtype=torch.bfloat16
+        )
+        lora_config = LoraConfig(
+            task_type=TaskType.SEQ_CLS,
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            target_modules=["q_proj", "v_proj"],
+        )
+        prm_classifier = get_peft_model(prm_classifier, lora_config)
+        prm_classifier.config.pad_token_id = tokenizer.pad_token_id
+        prm_classifier.print_trainable_parameters()
+    else:
+        print(f"\n=== Loading PRM classifier (4-bit + LoRA) from: {args.model} ===")
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+        # Under DDP (launched via torchrun), each rank must load a FULL copy of
+        # the model on its OWN single GPU — `device_map="auto"` would shard one
+        # model across all visible GPUs, which is incompatible with DDP. When
+        # LOCAL_RANK is set, pin to that rank's GPU; otherwise fall back to the
+        # single-process "auto" placement.
+        local_rank = int(os.environ.get("LOCAL_RANK", -1))
+        device_map = {"": local_rank} if local_rank != -1 else "auto"
+        prm_classifier = AutoModelForSequenceClassification.from_pretrained(
+            args.model,
+            config=prm_config,
+            quantization_config=bnb_config,
+            device_map=device_map,
+        )
+        # use_reentrant=False is required for gradient checkpointing under DDP
+        # (the reentrant variant breaks DDP's autograd hooks); harmless otherwise.
+        prm_classifier = prepare_model_for_kbit_training(
+            prm_classifier,
+            use_gradient_checkpointing=True,
+            gradient_checkpointing_kwargs={"use_reentrant": False},
+        )
+        lora_config = LoraConfig(
+            task_type=TaskType.SEQ_CLS,
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            target_modules=["q_proj", "v_proj"],
+        )
+        prm_classifier = get_peft_model(prm_classifier, lora_config)
+        prm_classifier.config.pad_token_id = tokenizer.pad_token_id
+        prm_classifier.print_trainable_parameters()
+
+    training_args = TrainingArguments(
+        output_dir=args.output,
+        per_device_train_batch_size=args.per_device_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=3e-5,
+        adam_beta1=0.9,
+        adam_beta2=0.95,
+        weight_decay=0.0,
+        num_train_epochs=50,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        # load_best_model_at_end=False on purpose: under multi-node DDP its
+        # end-of-train GPU reload intermittently throws CUDA "device busy/
+        # unavailable" (cudaErrorDevicesUnavailable) during teardown and fails
+        # the whole job AFTER training already succeeded. We instead copy the
+        # best checkpoint (by eval_loss, still tracked below) on rank 0 after
+        # train() — a pure file copy, no GPU op, so it can't crash.
+        load_best_model_at_end=False,
+        metric_for_best_model="eval_loss",
+        greater_is_better=False,
+        bf16=True,
+        logging_steps=1,
+        report_to="none",
+        # Under DDP, only the LoRA adapter params require grad and all are used
+        # in the forward, so disabling the unused-param search is both correct
+        # and faster. Ignored when not running distributed.
+        ddp_find_unused_parameters=False,
+    )
+
+    trainer = _SoftBCETrainer(
+        model=prm_classifier,
+        args=training_args,
+        train_dataset=split["train"],
+        eval_dataset=split["test"],
+        data_collator=DataCollatorWithPadding(tokenizer),
+        # Scaling-LLM-Test-Time-Compute (App. D) selects the checkpoint with the
+        # LOWEST val loss. With only ~373 val examples and ~26 steps/epoch, val
+        # loss is noisy, so patience=5 avoids stopping on a transient uptick
+        # before the true minimum (we copy that best checkpoint out below).
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=5)],
+    )
+
+    print("\n=== Training ===")
+    # Resume from the latest epoch checkpoint if --resume and one exists;
+    # otherwise train from scratch (passing resume on a checkpoint-less dir errors,
+    # so guard on an existing checkpoint-* subdir).
+    resume = bool(args.resume) and any(Path(args.output).glob("checkpoint-*"))
+    if resume:
+        print(f"Resuming from latest checkpoint in {args.output}")
+    trainer.train(resume_from_checkpoint=resume)
+
+    # Save the final PRM on rank 0 ONLY, by copying the BEST checkpoint's adapter
+    # (no GPU reload -> avoids the cudaErrorDevicesUnavailable crash). Falls back
+    # to save_model() if no best checkpoint was recorded (e.g. no eval ran).
+    if trainer.is_world_process_zero():
+        out = Path(args.output)
+        out.mkdir(parents=True, exist_ok=True)
+        best = trainer.state.best_model_checkpoint
+        if best and Path(best).is_dir():
+            print(f"Best checkpoint (lowest eval_loss): {best}")
+            for fn in ("adapter_model.safetensors", "adapter_config.json",
+                       "adapter_model.bin", "README.md", "chat_template.jinja"):
+                src = Path(best) / fn
+                if src.exists():
+                    shutil.copy2(src, out / fn)
+        else:
+            print("No best checkpoint recorded; saving current model state.")
+            trainer.save_model()
+        tokenizer.save_pretrained(args.output)
+        print(f"\nPRM saved to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

examples/trl/prm_trainer.py

@@ -0,0 +1,1316 @@
+"""
+Process Reward Model (PRM) Trainer for Playpen Games.
+
+Based on: "Scaling LLM Test-Time Compute Optimally" (Snell et al., 2024)
+           https://arxiv.org/abs/2408.03314
+
+Training methodology (MATH-SHEPHERD style, Section 3.2 / Appendix D)
+----------------------------------------------------------------------
+* The PRM is a binary classifier whose output (after sigmoid) estimates the
+  probability that a game will succeed from the current step onwards.
+* Training uses **soft labels** derived from Monte-Carlo rollouts, not human
+  annotations or hard 0/1 flags.
+* Loss: binary cross-entropy  -( y·log(σ(z)) + (1-y)·log(1-σ(z)) )
+  where y ∈ [0,1] is the fraction of MC rollouts that succeeded from this
+  step, and z is the model's raw logit.
+
+Rollout collection (linear K×N, NOT exponential N^K)
+-----------------------------------------------------
+For each game instance the collector runs in two phases:
+
+  Phase 1 — Base trajectory (1 game):
+    Play one complete game. At each target-player turn, record
+    (game_snapshot, response, game_state_AFTER_response).
+
+  Phase 2 — Independent rollouts (K × N games):
+    For each of the K recorded steps, fork the saved game state (the state
+    AFTER that step was committed) and run N independent completions to the
+    end using temperature sampling.  The N completions share the *same*
+    prefix including the base response; they only differ in what happens next.
+
+Total game plays per instance = 1 + K×N  (linear in K and N).
+
+Two reward signals / two PRMs (PRM_REWARD_MODE)
+-----------------------------------------------
+Each rollout is scored two ways, and you can train a PRM on either (or both,
+collected in a single pass — both labels come from the *same* rollouts):
+
+  * ``success`` (MATH-SHEPHERD): per-rollout outcome ∈ {0,1} = did the game
+    reach its SUCCESS outcome (``reward > 0``).  Soft label for a step =
+    successes / N = **P(game succeeds from this step)**.  This is the original
+    Math-Shepherd Soft-Estimation target.
+
+  * ``bench``: per-rollout outcome ∈ [0,1] = the game's own ``BENCH_SCORE``
+    (the 0–100 quality metric used to *evaluate* these models) / 100, with
+    aborts → 0.  Soft label for a step = mean over N rollouts = **expected
+    normalized eval score from this step**.  For graded games (e.g. dond's
+    Pareto efficiency, hot_air_balloon's harmonic-mean utility) this aligns
+    the PRM with what the benchmark actually rewards, not just "did it work".
+
+``PRM_REWARD_MODE`` selects which to collect: ``success`` (default), ``bench``,
+or ``success,bench`` (both, recommended — same rollouts, two datasets). Each
+mode's checkpoints land in ``prm-checkpoints/<model>/<mode>/`` and train into a
+separate PRM under ``models/prm/<model>/<mode>/``.
+
+Loss (both modes): binary cross-entropy against the soft target y ∈ [0,1],
+``-( y·log σ(z) + (1-y)·log(1-σ(z)) )``; BCE handles soft targets directly.
+
+Truncating long-game rollouts (PRM_MAX_ROLLOUT_ROUNDS)
+------------------------------------------------------
+A few games run for dozens of rounds (adventuregame up to 100, imagegame up to
+50), which makes full rollouts to game end very expensive. ``PRM_MAX_ROLLOUT_
+ROUNDS`` caps how many rounds a rollout may add past its branch point; a rollout
+cut short is labelled with the game's PARTIAL clembench score at the round it
+stopped (and ``success`` outcome 0 — it never reached a terminal success).
+
+The cap applies only to ``PRM_TRUNCATE_GAMES`` (default ``imagegame,
+adventuregame``) and is ignored if it is ≥ the game's max possible rounds (it
+could never bite). The partial score is computed by the game's OWN GameScorer:
+imagegame already reports the last turn's grid F1; adventuregame's end-of-game
+``game_result`` is synthesized from the final per-turn ``goal_status`` (proven
+value-identical) so its scorer yields goals_achieved / goal_count. Both are thus
+the exact clembench metric evaluated at the truncation round.
+
+The rollout-round cap bounds each rollout's *length*; the complementary
+``PRM_MAX_STEPS_PER_INSTANCE`` bounds the *number* of branch points per instance
+(a long game makes one per model step — adventuregame ~60). When a base game has
+more, they are subsampled EVENLY across the trajectory. 0 = unlimited; applies
+to all games but only bites those with more steps than the cap.
+
+All LMPlayschool games at once
+------------------------------
+``game_name="all"`` (the default) collects rollouts across **every** game in
+the playpen-data train split, pooling all of them into a single PRM. Pass a
+single game name or a comma-separated list to restrict the set.
+
+Throughput / GPU memory: batched rollouts
+-----------------------------------------
+Both phases drive *many* game environments concurrently and generate their
+responses in batches via clemcore's ``Player.batch_response`` (the same engine
+the ``batchwise`` runner uses). A window of ``PRM_INSTANCE_WINDOW`` instances
+is collected at a time; all of their base games and all of their K×N rollouts
+are pooled and stepped in lockstep, so each model forward pass runs up to
+``PRM_ROLLOUT_BATCH_SIZE`` sequences at once. Forked environments share the one
+loaded model (patched ``__deepcopy__``), so on a 96 GB GPU the headroom of a
+4-bit model goes into a large KV-cache batch instead of sitting idle. Turn the
+batch size up until you approach the card's memory limit.
+
+To span *both* GPUs, shard across worker processes (see ``run_prm.sh``):
+``CUDA_VISIBLE_DEVICES`` pins each worker to a card and ``PRM_NUM_SHARDS`` /
+``PRM_SHARD_ID`` partition the (game, instance) work units across them.
+
+Usage (same model as both policy and PRM base)
+-----------------------------------------------
+    playpen run examples/trl/prm_trainer.py -l <model-name>
+
+Usage (separate policy for rollout collection)
+-----------------------------------------------
+    playpen run examples/trl/prm_trainer.py -l <prm-model> -t <policy-model>
+
+After training, use the saved checkpoint with ``PRMGuidedClemAgent``
+(examples/trl/prm_inference.py) for test-time best-of-N step selection.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+import re
+import types
+from copy import deepcopy
+from pathlib import Path
+from collections import defaultdict
+from typing import List, Optional, Tuple
+import time
+
+import torch
+import torch.nn.functional as F
+from transformers import (
+    AutoModelForSequenceClassification,
+    DataCollatorWithPadding,
+    EarlyStoppingCallback,
+    Trainer,
+    TrainingArguments,
+)
+from tqdm import tqdm
+from clemcore.backends import Model
+from clemcore.backends.huggingface_local_api import HuggingfaceLocalModel
+from clemcore.clemgame import (
+    GameBenchmark,
+    GameBenchmarkCallback,
+    GameBenchmarkCallbackList,
+    GameInstances,
+    GameRegistry,
+    GameSnapshot,
+    GameStep,
+    Player,
+)
+from clemcore.clemgame.envs.pettingzoo.master import GameMasterEnv
+from clemcore.clemgame.recorder import GameInteractionsRecorder
+from clemcore.clemgame.legacy.scorer import KEY_EPISODE_SCORES
+from clemcore.clemgame.metrics import BENCH_SCORE
+from datasets import Dataset, load_dataset
+
+from playpen import (
+    BasePlaypenTrainer,
+    BranchingEpisodeBuffer,
+    to_instances_filter,
+)
+
+
+# Maximum possible rounds a game can run (its configured ceiling). Used only to
+# disable rollout truncation when the cap is >= this value (the cap could never
+# bite, so the game just plays to completion). See PRM_MAX_ROLLOUT_ROUNDS.
+MAX_POSSIBLE_ROUNDS = {
+    "adventuregame": 100,   # max_turns is 50 or 100 per instance
+    "imagegame": 50,        # max_rounds = grid^2 * 2; all instances are 5x5
+}
+
+
+def _patch_model_deepcopy(model: HuggingfaceLocalModel):
+    """Make ``deepcopy`` of a model (and its weights) return the same object.
+
+    The collector deepcopies whole game environments at every branch point and
+    for every rollout fork. Those envs reference the policy model. Without this
+    patch, deepcopy would try to clone the weights to GPU (which OOMs for a
+    4-bit bitsandbytes model that already fills VRAM) and would give every fork
+    its own model — defeating batched generation, which groups players by the
+    *same* model object/name.
+
+    The model is stateless during inference, so identity copy is safe. We patch
+    both the wrapper (so forked players share one ``HuggingfaceLocalModel``) and
+    every submodule of the underlying ``nn.Module`` (belt and braces).
+    """
+    model.__deepcopy__ = types.MethodType(lambda self, memo: self, model)
+    for module in model.model.modules():
+        module.__deepcopy__ = types.MethodType(lambda self, memo: self, module)
+
+
+# ---------------------------------------------------------------------------
+# Custom Trainer: replaces TRL's Bradley-Terry loss with per-step BCE
+# ---------------------------------------------------------------------------
+
+class _RecorderAttachCallback(GameBenchmarkCallback):
+    """Registers a fresh interactions recorder on each game's master.
+
+    Crucially this runs in ``on_game_start``, which ``GameMasterEnv.reset`` calls
+    *before* ``before_game()`` — so keys logged in ``_on_before_game`` (e.g.
+    adventuregame's ``adventure_info``, which its scorer requires) are captured.
+    Attaching the recorder *after* ``reset()`` would miss them and silently zero
+    those games' bench scores. The recorder lives in the game master's logger
+    list, so it rides along through the branch/rollout deepcopies.
+    """
+
+    def on_game_start(self, game_master, game_instance):
+        recorder = GameInteractionsRecorder(
+            game_master.game_spec.game_name,
+            game_master.experiment["name"],
+            game_instance["game_id"],
+            "prm",   # run-dir label (unused; never written to disk)
+            [],      # player model infos (unused for scoring)
+        )
+        for player in game_master.get_players():
+            recorder.log_player(player.name, player.game_role, player.model.name)
+        game_master.register(recorder)
+
+
+class _SoftBCETrainer(Trainer):
+    """Trainer subclass that computes per-step BCE loss against soft MC labels."""
+
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.pop("labels").float()   # soft MC estimates in [0, 1]
+        outputs = model(**inputs)
+        # AutoModelForSequenceClassification with num_labels=1 outputs shape (B, 1)
+        logits = outputs.logits
+        if logits.dim() == 2 and logits.shape[-1] == 2:
+            logits = logits[:, 1] - logits[:, 0]  # log-odds for binary
+        else:
+            logits = logits.squeeze(-1)
+        loss = F.binary_cross_entropy_with_logits(logits, labels)
+        return (loss, outputs) if return_outputs else loss
+
+
+# ---------------------------------------------------------------------------
+# Batched rollout session
+# ---------------------------------------------------------------------------
+
+class _Sess:
+    """One game environment driven through the batched scheduler.
+
+    Holds the env, its own response iterator, the trajectory built so far, and
+    (for base games) the branching checkpoints captured at target-player steps.
+    """
+
+    __slots__ = (
+        "env", "it", "trajectory", "done", "outcome", "bench", "snap",
+        "checkpoints", "tag", "start_round", "truncated", "save_label",
+    )
+
+    def __init__(self, env: GameMasterEnv, trajectory: Optional[list] = None, tag=None):
+        self.env = env
+        self.it = iter(env.agent_iter())
+        self.trajectory = list(trajectory) if trajectory else []
+        self.done = False
+        self.outcome = 0.0          # success label: 1.0 once a terminal success reward is seen
+        self.bench = 0.0            # bench label: normalized BENCH_SCORE in [0,1] (filled at game end)
+        self.snap = None            # pending pre-step snapshot (capture mode)
+        self.checkpoints: list = [] # (snapshot, env_copy, prefix, turn_idx, player_name)
+        self.tag = tag              # opaque grouping key (e.g. (inst_idx, ckpt_idx))
+        self.save_label = None      # transcript filename label ("base" / "branch_..."); None = don't save
+        # Round counter at the branch point, so a rollout's *continuation* length
+        # can be measured as current_round - start_round (see PRM_MAX_ROLLOUT_ROUNDS).
+        self.start_round = getattr(getattr(env, "game_master", None), "current_round", 0)
+        self.truncated = False      # set if the rollout was cut at the round cap
+
+
+# ---------------------------------------------------------------------------
+# PRMTrainer
+# ---------------------------------------------------------------------------
+
+class PRMTrainer(BasePlaypenTrainer):
+    """Trains a Process Reward Model with soft MC labels and BCE loss.
+
+    Args:
+        prm_model: Model used as the base for PRM training AND (when no
+                   separate ``policy_model`` is given) as the rollout policy.
+                   Must be a ``HuggingfaceLocalModel``.
+        policy_model: Optional separate model to generate game rollouts.
+                      Defaults to ``prm_model`` (standard RLHF warm-start).
+        game_name: Which clemcore games to collect rollouts from. ``"all"``
+                   (default) uses every game in the playpen-data train split;
+                   otherwise a single name or a comma-separated list.
+        player_name: Player perspective whose steps are labelled by the PRM.
+                     ``None`` / ``"all"`` (default) labels *every* model
+                     player's step — the natural choice across heterogeneous
+                     games where the policy fills different roles. Pass e.g.
+                     ``"Player 1"`` to restrict to one role.
+        branching_factor: Independent continuations per branching point (N).
+        num_epochs: Epochs over all game instances for rollout collection.
+        min_rollouts: Steps with fewer MC rollouts than this are excluded from
+                      training (set to 1 to keep all).
+    """
+
+    def __init__(
+        self,
+        prm_model: HuggingfaceLocalModel,
+        policy_model: HuggingfaceLocalModel | None = None,
+        game_name: str = "all",
+        player_name: str | None = None,
+        branching_factor: int = 4,
+        num_epochs: int = 10,
+        min_rollouts: int = 2,
+        reward_mode: str = "success",
+        max_rollout_rounds: int = 0,
+        truncate_games: str = "imagegame,adventuregame",
+        max_steps_per_instance: int = 0,
+    ):
+        policy = policy_model if policy_model is not None else prm_model
+        super().__init__(learner=prm_model, teacher=policy)
+
+        # `playpen run` only forwards model flags (-l/-t/-T/-L), so the rollout
+        # knobs are also overridable via env vars for use from run_prm.sh:
+        #   PRM_GAMES            : game_name override ("all", or "a,b,c")
+        #   PRM_BRANCHING_FACTOR : N rollouts per branching point
+        #   PRM_NUM_EPOCHS       : epochs over all instances
+        #   PRM_MIN_ROLLOUTS     : min rollouts to keep a step for training
+        #   PRM_REWARD_MODE      : "success" | "bench" | "success,bench"
+        self.game_name = os.environ.get("PRM_GAMES", game_name)
+        player_name = os.environ.get("PRM_PLAYER_NAME", player_name)
+        # None / "all" / "*"  => label every model player's step
+        self.player_name = None if player_name in (None, "all", "*") else player_name
+        self.branching_factor = int(os.environ.get("PRM_BRANCHING_FACTOR", branching_factor))
+        self.num_epochs = int(os.environ.get("PRM_NUM_EPOCHS", num_epochs))
+        self.min_rollouts = int(os.environ.get("PRM_MIN_ROLLOUTS", min_rollouts))
+
+        # Which reward signal(s) to label rollouts with — both are derived from
+        # the SAME rollouts in one pass, so collecting both is nearly free.
+        #   success : Math-Shepherd binary P(game succeeds from here)
+        #   bench   : normalized BENCH_SCORE (the eval metric) from here
+        raw_modes = os.environ.get("PRM_REWARD_MODE", reward_mode)
+        self.reward_modes = [m.strip() for m in raw_modes.split(",") if m.strip()]
+        valid = {"success", "bench"}
+        bad = set(self.reward_modes) - valid
+        if bad or not self.reward_modes:
+            raise ValueError(
+                f"PRM_REWARD_MODE must be a comma-separated subset of {sorted(valid)}, "
+                f"got {raw_modes!r}"
+            )
+        # Whether to attach interaction recorders + run game scorers (only needed
+        # for the graded 'bench' label).
+        self.collect_bench = "bench" in self.reward_modes
+
+        # Save the FULL game transcript (every GM message + player response) for
+        # the base game AND every rollout, so you can replay/inspect any game.
+        #   PRM_SAVE_INTERACTIONS=1 : write interactions.json per game/rollout
+        # Layout: prm-records/<model>/epoch_NNNNN/<game>/<exp>__gid<id>/
+        #            base/interactions.json
+        #            branch_ckpt<NN>_r<N>/interactions.json
+        # WARNING: this writes a lot of files (1 + branching_factor x kept-steps
+        # per instance) and slows collection — it is opt-in for that reason.
+        self.save_interactions = os.environ.get("PRM_SAVE_INTERACTIONS", "0") == "1"
+        self.records_dir = Path(os.environ.get(
+            "PRM_RECORDS_DIR", f"prm-records/{self.learner.name}"))
+        # Recorders are needed for bench scoring OR for saving transcripts.
+        self.need_recorder = self.collect_bench or self.save_interactions
+
+        # ------------------------------------------------------------------
+        # Rollout truncation for long games (cap each rollout's continuation
+        # length so adventuregame/imagegame don't blow up the rollout budget).
+        #   PRM_MAX_ROLLOUT_ROUNDS : max game rounds a rollout may add past its
+        #       branch point before it is cut short (0 = disabled, no cap).
+        #   PRM_TRUNCATE_GAMES     : comma list of games the cap applies to
+        #       (default: imagegame,adventuregame — the only games whose ceiling
+        #       exceeds a typical 20-round cap and which expose a partial score).
+        # A truncated (unfinished) rollout is labelled with the game's PARTIAL
+        # clembench score at the round it stopped — imagegame: last-turn grid F1;
+        # adventuregame: goal-achievement ratio at that round. The binary
+        # 'success' outcome of a truncated rollout is 0 (it never reached a
+        # terminal success).
+        # Guard: if the cap is >= the game's maximum possible rounds it can never
+        # bite, so truncation (and partial scoring) is disabled for that game and
+        # rollouts simply play to natural completion.
+        # ------------------------------------------------------------------
+        self.max_rollout_rounds = int(os.environ.get("PRM_MAX_ROLLOUT_ROUNDS", max_rollout_rounds))
+        truncate_games = os.environ.get("PRM_TRUNCATE_GAMES", truncate_games)
+        self.truncate_games = {g.strip() for g in truncate_games.split(",") if g.strip()}
+
+        # Branch-point cap (complementary lever to the rollout-round cap). Long
+        # games produce one branching point per model step — adventuregame has
+        # ~60, so 60 x N rollouts per instance. PRM_MAX_STEPS_PER_INSTANCE caps
+        # how many branching points are kept per instance; when a base game has
+        # more, they are SUBSAMPLED EVENLY across the trajectory (so the PRM sees
+        # states spread over the whole game, not just the opening). 0 = unlimited.
+        # Applies to all games, but only bites those with more steps than the cap.
+        self.max_steps_per_instance = int(
+            os.environ.get("PRM_MAX_STEPS_PER_INSTANCE", max_steps_per_instance))
+
+        # ------------------------------------------------------------------
+        # Batched-generation knobs (env-tunable so they compose with
+        # `playpen run`, which only forwards -l/-t/-T/-L).
+        #   PRM_ROLLOUT_BATCH_SIZE : max sequences per model forward pass.
+        #       Bigger => more GPU memory used and higher throughput. Turn it
+        #       up toward the card's limit (96 GB cards comfortably take many
+        #       dozens of concurrent ~1-2k-token sequences for a 4-bit ~27B).
+        #   PRM_INSTANCE_WINDOW    : instances collected together before their
+        #       pooled rollouts are played. Larger windows make the rollout
+        #       pool (and therefore the batches) bigger.
+        # ------------------------------------------------------------------
+        self.rollout_batch_size = max(1, int(os.environ.get("PRM_ROLLOUT_BATCH_SIZE", "48")))
+        self.instance_window = max(1, int(os.environ.get("PRM_INSTANCE_WINDOW", "8")))
+
+        # ------------------------------------------------------------------
+        # Data-parallel sharding across worker processes (one per GPU; see
+        # run_prm.sh). Work units are (game, instance) pairs flattened over a
+        # deterministic game order, so the partition stays balanced across
+        # games of very different sizes and covers every unit exactly once for
+        # ANY worker count (the count may change between resumes without gaps).
+        #   PRM_NUM_SHARDS   : total cooperating workers
+        #   PRM_SHARD_ID     : this worker's index in [0, PRM_NUM_SHARDS)
+        #   PRM_COLLECT_ONLY=1 : collect rollouts only, skip PRM training
+        # ------------------------------------------------------------------
+        self.num_shards = max(1, int(os.environ.get("PRM_NUM_SHARDS", "1")))
+        self.shard_id = int(os.environ.get("PRM_SHARD_ID", "0"))
+        self.collect_only = os.environ.get("PRM_COLLECT_ONLY", "0") == "1"
+        if not (0 <= self.shard_id < self.num_shards):
+            raise ValueError(
+                f"PRM_SHARD_ID={self.shard_id} out of range for "
+                f"PRM_NUM_SHARDS={self.num_shards}"
+            )
+
+        # Kept for API compatibility; the batched collector computes labels
+        # directly from rollout rewards rather than via callback state.
+        self.episode_buffer = BranchingEpisodeBuffer()
+        self.callbacks = GameBenchmarkCallbackList([])
+
+    # ------------------------------------------------------------------
+    # Public interface
+    # ------------------------------------------------------------------
+
+    def _resolve_game_names(self, dataset_train, game_registry) -> List[str]:
+        """Expand ``self.game_name`` into a concrete, registry-backed list.
+
+        ``"all"`` => every distinct game in the train split that also has a
+        locally registered game spec. A comma-separated value selects a subset.
+        """
+        available = sorted({row["game"] for row in dataset_train})
+        if self.game_name in ("all", "*"):
+            requested = available
+        else:
+            requested = [g.strip() for g in self.game_name.split(",") if g.strip()]
+
+        resolved = []
+        for g in requested:
+            if g not in available:
+                print(f"  [skip] '{g}' has no instances in the playpen-data train split")
+                continue
+            if not game_registry.get_game_specs_that_unify_with(g):
+                print(f"  [skip] '{g}' is not registered locally (no game spec found)")
+                continue
+            resolved.append(g)
+        if not resolved:
+            raise ValueError(f"No collectable games resolved from game_name={self.game_name!r}")
+        return resolved
+
+    def learn(self):
+        game_registry = GameRegistry.from_directories_and_cwd_files()
+        dataset_train = load_dataset("colab-potsdam/playpen-data", "instances", split="train")
+
+        self.game_names = self._resolve_game_names(dataset_train, game_registry)
+        print(f"PRM rollout collection over {len(self.game_names)} game(s): "
+              f"{', '.join(self.game_names)}")
+
+        # Checkpoint dir is overridable so a new run (e.g. with different token
+        # budget / settings) can write to a separate directory without touching
+        # or resuming a prior run's data. Default: prm-checkpoints/<learner>.
+        self.checkpoint_dir = Path(os.environ.get(
+            "PRM_CHECKPOINT_DIR", f"prm-checkpoints/{self.learner.name}"))
+        self.checkpoint_dir.mkdir(parents=True, exist_ok=True)
+        # Resume is tracked per (epoch, game, instance) via marker files. This
+        # lets you resume an interrupted run with a *different* number of
+        # workers/GPUs: any instance already collected is skipped and the rest
+        # are re-partitioned across whatever workers you launch.
+        self.done_dir = self.checkpoint_dir / "done"
+        self.done_dir.mkdir(parents=True, exist_ok=True)
+
+        # Identity-deepcopy the policy so env/rollout forks share one model and
+        # batch together. Done once: the same model object is reused throughout.
+        _patch_model_deepcopy(self.teacher.model)
+        torch.cuda.empty_cache()
+
+        for epoch in range(1, self.num_epochs + 1):
+            print(f"\n=== Epoch {epoch}/{self.num_epochs}: rollout collection ===")
+            # Running offset so (game, instance) units are sharded over a single
+            # global index across all games (sorted order == self.game_names).
+            global_offset = 0
+            for game_name in self.game_names:
+                specs = game_registry.get_game_specs_that_unify_with(game_name)
+                game_spec = specs[0]
+                try:
+                    with GameBenchmark.load_from_spec(game_spec) as game_benchmark:
+                        global_offset = self._collect_rollouts(
+                            game_benchmark, game_name, dataset_train, epoch, global_offset
+                        )
+                except Exception as exc:  # keep collecting the other games
+                    print(f"  [error] game '{game_name}' failed: {exc!r} — skipping")
+                    # Still advance the global offset by this game's instance
+                    # count so sharding stays aligned across resumes.
+                    n = self._count_instances(game_spec, dataset_train)
+                    global_offset += n
+
+        if self.collect_only:
+            modes = ", ".join(f"prm-checkpoints/{self.learner.name}/{m}" for m in self.reward_modes)
+            print(
+                f"\n[shard {self.shard_id}/{self.num_shards}] PRM_COLLECT_ONLY=1 "
+                f"set — rollout collection done (modes: {', '.join(self.reward_modes)}), "
+                "skipping PRM training. Train once per mode over all shards with "
+                f"prm_train_from_records.py --checkpoint-dir {{{modes}}}."
+            )
+            return
+
+        self._train_prm()
+
+    # ------------------------------------------------------------------
+    # Rollout collection (batched)
+    # ------------------------------------------------------------------
+
+    def _count_instances(self, game_spec, dataset_train) -> int:
+        instances = GameInstances.from_game_spec(game_spec)
+        return len(list(instances.filter(to_instances_filter(dataset_train))))
+
+    def _resolve_rollout_cap(self, game_name: str) -> int:
+        """Per-game rollout-round cap, or 0 if this game is not truncated.
+
+        Returns 0 (no truncation) when: the cap is unset, the game is not in
+        truncate_games, or the cap is >= the game's maximum possible rounds (in
+        which case it can never bite and rollouts just play to completion).
+        """
+        cap = self.max_rollout_rounds
+        if cap <= 0 or game_name not in self.truncate_games:
+            return 0
+        ceiling = MAX_POSSIBLE_ROUNDS.get(game_name)
+        if ceiling is not None and cap >= ceiling:
+            print(f"  [{game_name}] cap={cap} >= max possible rounds ({ceiling}); "
+                  "truncation disabled (rollouts play to completion).")
+            return 0
+        return cap
+
+    @staticmethod
+    def _subsample_evenly(items: list, k: int) -> list:
+        """Pick k items evenly spaced across ``items`` (including both ends).
+
+        Used to cap branch points per instance: a long base game's checkpoints
+        are thinned to k states distributed over the whole trajectory.
+        """
+        n = len(items)
+        if k <= 0 or k >= n:
+            return items
+        if k == 1:
+            return [items[n // 2]]
+        idxs = sorted({round(i * (n - 1) / (k - 1)) for i in range(k)})
+        return [items[i] for i in idxs]
+
+    def _collect_rollouts(self, game_benchmark, game_name, dataset_train, epoch, global_offset) -> int:
+        """Collect MATH-SHEPHERD linear rollouts for one game, batched.
+
+        Returns the updated global sharding offset (offset + this game's
+        instance count) so the caller keeps the cross-game partition aligned.
+        """
+        all_instances = GameInstances.from_game_spec(game_benchmark.game_spec)
+        all_instances = list(all_instances.filter(to_instances_filter(dataset_train)))
+        n_total = len(all_instances)
+
+        # Assign by GLOBAL index (offset + local) % num_shards, then drop the
+        # instances already collected for this (epoch, game) by any prior run.
+        assigned = [
+            (lidx, row) for lidx, row in enumerate(all_instances)
+            if (global_offset + lidx) % self.num_shards == self.shard_id
+        ]
+        todo = [
+            (lidx, row) for (lidx, row) in assigned
+            if not self._marker_path(epoch, game_name, row).exists()
+        ]
+        n_skip = len(assigned) - len(todo)
+        print(
+            f"  [{game_name}] shard {self.shard_id}/{self.num_shards}: "
+            f"{len(assigned)}/{n_total} instances"
+            + (f" ({n_skip} done, {len(todo)} to collect)" if n_skip else f" ({len(todo)} to collect)")
+        )
+        if not todo:
+            return global_offset + n_total
+
+        n_players = game_benchmark.game_spec.players
+        # Make the benchmark + game name reachable to the scorer (bench mode)
+        # without threading them through every helper.
+        self._cur_benchmark = game_benchmark
+        self._cur_game_name = game_name
+        # Resolve this game's rollout-round cap (0 = uncapped). Only the games
+        # listed in truncate_games are capped, and the cap is disabled if it is
+        # >= the game's maximum possible rounds (it could never bite).
+        self._rollout_cap = self._resolve_rollout_cap(game_name)
+        self._trunc_count = 0
+        self._rollout_count = 0
+        self._steps_dropped = 0
+        if self._rollout_cap:
+            print(f"  [{game_name}] rollout truncation ON: cap={self._rollout_cap} "
+                  f"rounds/branch (partial clembench score for cut rollouts)")
+        if self.max_steps_per_instance:
+            print(f"  [{game_name}] branch cap ON: <= {self.max_steps_per_instance} "
+                  f"branch points/instance (evenly subsampled)")
+
+        epoch_start = time.time()
+        total_steps = 0
+        total_paths = 0
+        all_outcomes: list = []
+
+        # Process instances in windows so each batched rollout pool is large.
+        pbar = tqdm(total=len(todo), desc=f"  {game_name}", unit="inst", ncols=100)
+        for w_start in range(0, len(todo), self.instance_window):
+            window = todo[w_start:w_start + self.instance_window]
+            steps, paths, outcomes = self._collect_window(
+                game_benchmark, game_name, epoch, window, n_players
+            )
+            total_steps += steps
+            total_paths += paths
+            all_outcomes.extend(outcomes)
+            win_rate = (sum(all_outcomes) / len(all_outcomes)) if all_outcomes else 0.0
+            pbar.update(len(window))
+            pbar.set_postfix({
+                "steps": total_steps,
+                "paths": total_paths,
+                "win%": f"{100 * win_rate:.0f}",
+            })
+        pbar.close()
+
+        elapsed = time.time() - epoch_start
+        trunc_note = ""
+        if self._rollout_cap and self._rollout_count:
+            trunc_note = (f"; {self._trunc_count}/{self._rollout_count} rollouts truncated "
+                          f"at {self._rollout_cap} rounds (partial-scored)")
+        if self.max_steps_per_instance and self._steps_dropped:
+            trunc_note += f"; {self._steps_dropped} branch points dropped (cap {self.max_steps_per_instance})"
+        print(
+            f"  [{game_name}] done: {total_steps} steps × {self.branching_factor} rollouts "
+            f"({total_paths} paths) from {len(todo)} instances in {elapsed / 60:.1f} min{trunc_note}"
+        )
+        return global_offset + n_total
+
+    def _collect_window(self, game_benchmark, game_name, epoch, window, n_players):
+        """Collect one window of instances: batched Phase 1 then batched Phase 2."""
+        players = [self.teacher] * n_players
+        self.teacher.reset()
+        self._cur_epoch = epoch  # for interaction-saving paths
+
+        # ---- Phase 1: play base games (batched), capturing branch points -----
+        base_sessions: list[_Sess] = []
+        for inst_idx, (lidx, row) in enumerate(window):
+            try:
+                # For the graded 'bench' label, attach an interactions recorder
+                # via on_game_start (fires inside reset BEFORE before_game, so
+                # _on_before_game keys like adventuregame's 'adventure_info' are
+                # captured). It rides along through the env deepcopies at each
+                # branch point and into every rollout fork (it lives in the game
+                # master's logger list), so each finished rollout carries the
+                # full episode and can be scored with the game's own scorer.
+                cbs = (GameBenchmarkCallbackList([_RecorderAttachCallback()])
+                       if self.need_recorder else self.callbacks)
+                env = GameMasterEnv(game_benchmark, callbacks=cbs)
+                env.reset(options={
+                    "player_models": players,
+                    "experiment": row["experiment"],
+                    "game_instance": row["game_instance"],
+                })
+                s = _Sess(env, tag=inst_idx)
+                s.save_label = "base"   # full base-game transcript
+                base_sessions.append(s)
+            except Exception as exc:
+                print(f"    [warn] could not start {game_name} instance "
+                      f"{row['game_instance'].get('game_id', '?')}: {exc!r}")
+        if not base_sessions:
+            return 0, 0, []
+
+        self._play_sessions(base_sessions, capture=True)
+
+        # Cap branch points per instance (subsample evenly across the base game)
+        # so long games (e.g. adventuregame ~60 steps) don't spawn N rollouts per
+        # step. States are spread over the whole trajectory, not just the opening.
+        if self.max_steps_per_instance:
+            for base in base_sessions:
+                if len(base.checkpoints) > self.max_steps_per_instance:
+                    kept = self._subsample_evenly(base.checkpoints, self.max_steps_per_instance)
+                    self._steps_dropped += len(base.checkpoints) - len(kept)
+                    base.checkpoints = kept
+
+        # ---- Phase 2: fork N rollouts per branch point, play them batched ----
+        # Pool every rollout across every instance in the window into one set so
+        # the model forward passes run as wide as possible.
+        rollout_sessions: list[_Sess] = []
+        # checkpoints[inst_idx] -> list of (snapshot, prefix, turn_idx, player_name)
+        checkpoints_by_inst: dict[int, list] = {}
+        for base in base_sessions:
+            inst_idx = base.tag
+            ckpts = []
+            for ckpt_idx, (snap, env_copy, prefix, turn_idx, p_name) in enumerate(base.checkpoints):
+                ckpts.append((snap, prefix, turn_idx, p_name))
+                for r in range(self.branching_factor):
+                    rs = _Sess(deepcopy(env_copy), trajectory=prefix,
+                               tag=(inst_idx, ckpt_idx))
+                    rs.save_label = f"branch_ckpt{ckpt_idx:03d}_r{r}"  # full rollout transcript
+                    rollout_sessions.append(rs)
+            checkpoints_by_inst[inst_idx] = ckpts
+            base.env = None  # free the base env; checkpoint copies retain state
+
+        if rollout_sessions:
+            self._play_sessions(rollout_sessions, capture=False,
+                                rollout_cap=self._rollout_cap)
+            if self._rollout_cap:
+                n_trunc = sum(1 for s in rollout_sessions if s.truncated)
+                self._trunc_count += n_trunc
+                self._rollout_count += len(rollout_sessions)
+
+        # ---- Aggregate per-rollout outcomes -> soft labels (per mode) --------
+        # Both modes draw from the SAME rollouts: each rollout contributes a
+        # binary success outcome and a normalized BENCH_SCORE outcome.
+        #   outcomes_by_ckpt[mode][(inst_idx, ckpt_idx)] = [o1, o2, ...]
+        outcomes_by_ckpt: dict[str, dict[tuple, list]] = {
+            m: defaultdict(list) for m in self.reward_modes
+        }
+        for s in rollout_sessions:
+            if "success" in outcomes_by_ckpt:
+                outcomes_by_ckpt["success"][s.tag].append(s.outcome)
+            if "bench" in outcomes_by_ckpt:
+                outcomes_by_ckpt["bench"][s.tag].append(s.bench)
+
+        window_steps = 0
+        window_paths = 0
+        window_outcomes: list = []  # success outcomes for the progress bar (or first mode)
+        progress_mode = "success" if "success" in self.reward_modes else self.reward_modes[0]
+        for inst_idx, (lidx, row) in enumerate(window):
+            ckpts = checkpoints_by_inst.get(inst_idx, [])
+            # Build per-mode rows for this instance.
+            rows_by_mode: dict[str, list] = {m: [] for m in self.reward_modes}
+            for ckpt_idx, (snap, prefix, turn_idx, p_name) in enumerate(ckpts):
+                # Count steps/paths once, from the progress mode.
+                prog_outcomes = outcomes_by_ckpt[progress_mode].get((inst_idx, ckpt_idx), [])
+                if not prog_outcomes:
+                    continue
+                window_steps += 1
+                window_paths += len(prog_outcomes)
+                window_outcomes.extend(prog_outcomes)
+                for mode in self.reward_modes:
+                    step_outcomes = outcomes_by_ckpt[mode].get((inst_idx, ckpt_idx), [])
+                    if step_outcomes:
+                        rows_by_mode[mode].append(
+                            self._build_checkpoint_row(snap, prefix, turn_idx, p_name, step_outcomes)
+                        )
+            # Commit every mode's rows, then mark the instance done (shared across
+            # modes — collection is one pass). A crash before the marker leaves no
+            # marker, so the instance is cleanly redone.
+            for mode in self.reward_modes:
+                self._write_checkpoint_rows(epoch, game_name, mode, rows_by_mode[mode])
+            self._marker_path(epoch, game_name, row).touch()
+
+        return window_steps, window_paths, window_outcomes
+
+    # ------------------------------------------------------------------
+    # Batched scheduler
+    # ------------------------------------------------------------------
+
+    def _is_target(self, player) -> bool:
+        """Whether this player's steps should become PRM branching points.
+
+        Only the *policy's own* steps are valid PRM targets. Several games seat
+        a hardwired scripted partner alongside the model under test — e.g.
+        privateshared's Questioner and the textmapworld map oracle (Describer)
+        are ``CustomResponseModel`` players whose replies are canned, not
+        generated. Those (and any human players) are skipped so their steps
+        never enter the training set, even though the game still steps them.
+        """
+        if player is None:
+            return False
+        model_spec = getattr(getattr(player, "model", None), "model_spec", None)
+        if model_spec is not None and (model_spec.is_programmatic() or model_spec.is_human()):
+            return False
+        if self.player_name is None:
+            return True
+        return player.name == self.player_name
+
+    def _advance_to_decision(self, s: _Sess):
+        """Advance one session to its next model decision.
+
+        Performs the free terminal "None" steps (dead-agent cleanup) inline,
+        recording the success outcome when a terminal reward is observed, and
+        returns ``(agent_id, player, context)`` for the next turn needing
+        generation — or ``None`` once the game is over.
+        """
+        # Note: envs are left OPEN on completion so the 'bench' scorer can read
+        # each finished game's interactions; they are closed in _play_sessions.
+        while True:
+            try:
+                agent_id = next(s.it)
+            except StopIteration:
+                s.done = True
+                return None
+            try:
+                context, reward, term, trunc, info = s.env.last(observe=True)
+            except Exception:
+                s.done = True
+                return None
+            if term or trunc:
+                if reward is not None and reward > 0:   # terminal team reward
+                    s.outcome = 1.0
+                try:
+                    s.env.step(None)                    # cleanup, no generation
+                except Exception:
+                    s.done = True
+                    return None
+                continue
+            player = s.env.player_by_agent_id.get(agent_id)
+            return agent_id, player, context
+
+    @staticmethod
+    def _close_env(s: _Sess):
+        try:
+            if s.env is not None:
+                s.env.close()
+        except Exception:
+            pass
+
+    def _bench_score(self, env: GameMasterEnv) -> float:
+        """Normalized BENCH_SCORE ∈ [0,1] for a finished rollout's env.
+
+        Runs the game's own GameScorer on the rollout's recorded interactions —
+        the same metric used to evaluate these models — and maps the 0–100
+        Main Score to [0,1]. Aborts / missing / NaN scores map to 0.0 (a failed
+        continuation, consistent with the success label's abort handling).
+        """
+        recorder = self._find_recorder(env)
+        if recorder is None:
+            return 0.0
+        try:
+            scorer = self._cur_benchmark.create_game_scorer(env.experiment, env.game_instance)
+            scorer.compute_scores(recorder.interactions)
+            value = scorer.scores.get(KEY_EPISODE_SCORES, {}).get(BENCH_SCORE)
+        except Exception:
+            return 0.0
+        if value is None or (isinstance(value, float) and math.isnan(value)):
+            return 0.0
+        return max(0.0, min(1.0, float(value) / 100.0))
+
+    @staticmethod
+    def _find_recorder(env: GameMasterEnv) -> Optional[GameInteractionsRecorder]:
+        if env is None or getattr(env, "game_master", None) is None:
+            return None
+        return next((lg for lg in env.game_master._loggers
+                     if isinstance(lg, GameInteractionsRecorder)), None)
+
+    def _partial_bench_score(self, game_name: str, env: GameMasterEnv) -> float:
+        """Partial clembench score ∈ [0,1] for a rollout truncated mid-game.
+
+        Always defers to the game's OWN GameScorer, so the partial score tracks
+        the official metric exactly (one uniform scoring path for every game):
+
+          * imagegame: its scorer reports the *last turn's* grid F1 as the Main
+            Score, so a truncated transcript already scores correctly.
+
+          * adventuregame: its scorer reads goals from an end-of-game
+            ``game_result`` event a truncated game never logged. We first
+            synthesize that event from the final per-turn ``goal_status`` —
+            value-identical (verified: last goal_status == game_result, 10/10) —
+            then the standard scorer computes goals_achieved / goal_count.
+        """
+        if game_name == "adventuregame":
+            recorder = self._find_recorder(env)
+            if recorder is not None:
+                self._synthesize_adventure_game_result(recorder.interactions)
+        return self._bench_score(env)
+
+    @staticmethod
+    def _synthesize_adventure_game_result(interactions: dict) -> None:
+        """Append a ``game_result`` event built from the last ``goal_status`` so
+        the adventuregame scorer can score a truncated (unfinished) transcript.
+
+        No-op if a ``game_result`` already exists (game actually finished) or no
+        ``goal_status`` was ever logged (scorer then yields 0, which is correct).
+        Mutates ``interactions`` in place; the env is discarded right after.
+        """
+        turns = interactions.get("turns") or []
+        last_goal_status = None
+        for turn in turns:
+            for event in turn:
+                etype = event.get("action", {}).get("type")
+                if etype == "game_result":
+                    return  # game finished normally — nothing to synthesize
+                if etype == "goal_status":
+                    last_goal_status = event
+        if last_goal_status is None or not turns:
+            return
+        # Copy a real event (preserving wrapper fields) and rewrite its action.
+        synthetic = deepcopy(last_goal_status)
+        goals = synthetic["action"]["content"]["goal_states_achieved"]
+        synthetic["action"] = {
+            "type": "game_result",
+            "content": {"goal_states_achieved": goals,
+                        "game_successfully_finished": False},
+        }
+        turns[-1].append(synthetic)
+
+    def _play_sessions(self, sessions: List[_Sess], capture: bool, rollout_cap: int = 0):
+        """Drive many game environments to completion in lockstep.
+
+        Each round advances every live session by exactly one model decision;
+        the pending generations are issued in chunks of ``rollout_batch_size``
+        through ``Player.batch_response`` (one batched forward pass per chunk,
+        grouping by the shared model). When ``capture`` is set, target-player
+        steps are recorded as branching checkpoints (snapshot + forked env).
+
+        ``rollout_cap`` (>0) truncates a rollout once it has added that many game
+        rounds past its branch point; such a session is flagged ``truncated`` and
+        later labelled with the game's PARTIAL clembench score. Only applies to
+        rollout play (``capture=False``); base games always run to completion.
+        """
+        round_pbar = tqdm(desc=("    base" if capture else "    rollouts"),
+                          unit="round", leave=False, ncols=100)
+        while True:
+            # Truncate rollouts that have reached the per-branch round cap before
+            # advancing them further (rollout phase only).
+            if rollout_cap and not capture:
+                for s in sessions:
+                    if s.done:
+                        continue
+                    gm = getattr(s.env, "game_master", None)
+                    if gm is not None and (gm.current_round - s.start_round) >= rollout_cap:
+                        s.done = True
+                        s.truncated = True
+
+            live = [s for s in sessions if not s.done]
+            if not live:
+                break
+
+            # 1) Advance each live session to its next decision (free terminal
+            #    steps happen inline; sessions may finish here).
+            decisions: list[tuple] = []  # (sess, agent_id, player, context)
+            for s in live:
+                d = self._advance_to_decision(s)
+                if d is not None:
+                    decisions.append((s, d[0], d[1], d[2]))
+            if not decisions:
+                continue
+
+            # 2) Capture pre-step snapshots for target players (Phase 1 only).
+            if capture:
+                for (s, agent_id, player, context) in decisions:
+                    s.snap = (GameSnapshot.create_from(s.env.game_master)
+                              if self._is_target(player) else None)
+
+            # 3) Generate + step, batched in chunks.
+            for start in range(0, len(decisions), self.rollout_batch_size):
+                chunk = decisions[start:start + self.rollout_batch_size]
+                chunk_players = [d[2] for d in chunk]
+                chunk_contexts = [d[3] for d in chunk]
+                try:
+                    response_by_row = Player.batch_response(
+                        chunk_players, chunk_contexts, row_ids=list(range(len(chunk)))
+                    )
+                except Exception:
+                    # A failed batch aborts those games (counts as failure).
+                    for (s, _aid, _p, _ctx) in chunk:
+                        s.done = True
+                    continue
+
+                for row_id, (s, agent_id, player, context) in enumerate(chunk):
+                    _ctx, response = response_by_row[row_id]
+                    try:
+                        s.env.step(response)
+                    except Exception:
+                        s.done = True
+                        continue
+                    s.trajectory.append(GameStep(
+                        context=context,
+                        response=response,
+                        player_name=player.name if player else None,
+                    ))
+                    if capture and s.snap is not None:
+                        turn_idx = len(s.trajectory) - 1
+                        env_copy = deepcopy(s.env)
+                        s.checkpoints.append(
+                            (s.snap, env_copy, list(s.trajectory), turn_idx,
+                             player.name if player else None)
+                        )
+                        s.snap = None
+            round_pbar.update(1)
+        round_pbar.close()
+
+        # Graded 'bench' label: score each rollout with the game's own
+        # GameScorer (only for rollout sessions — base games aren't labelled).
+        # Truncated rollouts get the game's PARTIAL clembench score at the round
+        # they stopped; completed ones get the normal full-game score.
+        if self.collect_bench and not capture:
+            for s in sessions:
+                if s.truncated:
+                    s.bench = self._partial_bench_score(self._cur_game_name, s.env)
+                else:
+                    s.bench = self._bench_score(s.env)
+        # Save the FULL transcript of every game/rollout (opt-in) before the env
+        # is freed — captures every GM message and player response.
+        if self.save_interactions:
+            for s in sessions:
+                self._write_interactions(s)
+        # Release envs now that both labels have been read.
+        for s in sessions:
+            self._close_env(s)
+
+    def _write_interactions(self, s: _Sess) -> None:
+        """Write a session's full interactions.json (every GM + player event).
+
+        Path: prm-records/<model>/epoch_NNNNN/<game>/<exp>__gid<id>/<label>/interactions.json
+        where <label> is 'base' or 'branch_ckptNN_rN'. Finalises the recorder
+        (meta round_count/completed) so the file is the canonical clembench
+        transcript format.
+        """
+        if s.save_label is None:
+            return
+        recorder = self._find_recorder(s.env)
+        if recorder is None or s.env is None:
+            return
+        try:
+            recorder.log_game_end(auto_count_logging=False)  # finalise meta
+        except Exception:
+            pass
+        try:
+            exp_name = re.sub(r"[^A-Za-z0-9._-]", "_", str(s.env.experiment.get("name", "exp")))
+            gid = s.env.game_instance.get("game_id", "?")
+            g = re.sub(r"[^A-Za-z0-9._-]", "_", self._cur_game_name)
+            d = (self.records_dir / f"epoch_{self._cur_epoch:05d}" / g
+                 / f"{exp_name}__gid{gid}" / s.save_label)
+            d.mkdir(parents=True, exist_ok=True)
+            with open(d / "interactions.json", "w") as f:
+                json.dump(recorder.interactions, f)
+        except Exception as exc:
+            print(f"    [warn] could not save interactions ({s.save_label}): {exc!r}")
+
+    # ------------------------------------------------------------------
+    # Checkpoint save / load
+    # ------------------------------------------------------------------
+
+    def _instance_key(self, row) -> str:
+        """Stable, filesystem-safe id for a game instance, independent of shard
+        count or list order — used to track per-instance collection progress."""
+        exp = str(row["experiment"].get("name", "exp"))
+        gid = row["game_instance"].get("game_id", "?")
+        return re.sub(r"[^A-Za-z0-9._-]", "_", f"{exp}__gid{gid}")
+
+    def _marker_path(self, epoch: int, game_name: str, row) -> Path:
+        """Path of the 'this (epoch, game, instance) is fully collected' marker.
+        Each marker is written by exactly one worker, so there is no contention
+        across concurrent shards."""
+        g = re.sub(r"[^A-Za-z0-9._-]", "_", game_name)
+        return self.done_dir / f"epoch{epoch:05d}__{g}__{self._instance_key(row)}.done"
+
+    def _build_checkpoint_row(self, snapshot, prefix_trajectory, turn_idx, player_name, outcomes) -> dict:
+        """Build one checkpoint record (not yet written).
+
+        Format (one JSON object per line once flushed):
+            {
+                "checkpoint_id": "<uuid>",   # groups all N rollouts from the same fork
+                "prompt":   [{"role": ..., "content": ...}, ...],
+                "response": "<base-game response at turn_idx>",
+                "outcomes": [0.0, 1.0, 0.0, 0.0]   # one per rollout
+            }
+
+        The diverging step is ``prefix_trajectory[turn_idx]`` — the base game's
+        response at the fork point. The prompt is reconstructed from the
+        *diverging player's* own prior turns (so it works for any role / game).
+        """
+        diverging_step = prefix_trajectory[turn_idx]
+
+        prompt: list[dict] = []
+        for step in prefix_trajectory[:turn_idx]:
+            if step.player_name == player_name:
+                prompt.append(step.context)
+                prompt.append({"role": "assistant", "content": step.response})
+        prompt.append(diverging_step.context)  # final GM message before the fork
+
+        return {
+            "checkpoint_id": str(snapshot.origin),
+            "prompt": prompt,
+            "response": diverging_step.response,
+            "outcomes": outcomes,
+        }
+
+    def _mode_dir(self, mode: str) -> Path:
+        """Per-reward-mode checkpoint directory: ``<checkpoint_dir>/<mode>/``."""
+        d = self.checkpoint_dir / mode
+        d.mkdir(parents=True, exist_ok=True)
+        return d
+
+    def _write_checkpoint_rows(self, epoch: int, game_name: str, mode: str, rows: list[dict]):
+        """Append a finished instance's checkpoint rows to this shard's JSONL.
+
+        Files are flat within the per-mode dir (one per epoch/shard/game) so the
+        downstream ``epoch_*.jsonl`` glob in prm_train_from_records.py pools all
+        games into a single PRM per mode. Point that script at
+        ``prm-checkpoints/<model>/success`` or ``.../bench``.
+        """
+        if not rows:
+            return
+        g = re.sub(r"[^A-Za-z0-9._-]", "_", game_name)
+        path = self._mode_dir(mode) / f"epoch_{epoch:05d}_shard{self.shard_id:02d}_{g}.jsonl"
+        with open(path, "a") as f:
+            for row in rows:
+                f.write(json.dumps(row) + "\n")
+
+    @staticmethod
+    def load_prm_dataset_from_checkpoints(checkpoint_dir: Path, epochs: list[int] | None = None) -> Dataset:
+        """Load saved checkpoint JSONL files and build a soft-label PRM dataset.
+
+        Groups rows by checkpoint_id, averages their outcomes → true MC labels.
+        If epochs is None, loads all available epoch files.
+        """
+        scores_by_id: dict[str, list[float]] = defaultdict(list)
+        meta_by_id: dict[str, dict] = {}
+
+        checkpoint_dir = Path(checkpoint_dir)
+        available = sorted(checkpoint_dir.glob("epoch_*.jsonl"))
+        if epochs is not None:
+            available = [p for p in available if int(p.stem.split("_")[1]) in epochs]
+
+        if not available:
+            return Dataset.from_list([])
+
+        for path in available:
+            with open(path) as f:
+                for line in f:
+                    if not line.strip():
+                        continue
+                    row = json.loads(line)
+                    cid = row["checkpoint_id"]
+                    scores_by_id[cid].extend(row["outcomes"])
+                    if cid not in meta_by_id:
+                        meta_by_id[cid] = {
+                            "prompt": row["prompt"],
+                            "response": row["response"],
+                        }
+
+        examples = []
+        for cid, scores in scores_by_id.items():
+            info = meta_by_id[cid]
+            examples.append({
+                "prompt": info["prompt"],
+                "completion": [{"role": "assistant", "content": info["response"]}],
+                "label": sum(scores) / len(scores),
+                "n_rollouts": len(scores),
+            })
+
+        return Dataset.from_list(examples)
+
+    # ------------------------------------------------------------------
+    # PRM training
+    # ------------------------------------------------------------------
+
+    def _train_prm(self):
+        """Train one PRM per reward mode (success / bench)."""
+        for mode in self.reward_modes:
+            print(f"\n=== Training '{mode}' PRM ===")
+            self._train_one_prm(mode)
+
+    def _train_one_prm(self, mode: str):
+        """Build soft-label dataset for one mode, tokenise, and train the PRM."""
+        prm_dataset = self.load_prm_dataset_from_checkpoints(self._mode_dir(mode))
+
+        if len(prm_dataset) == 0:
+            print(f"No '{mode}' PRM examples collected — check game_name and player_name.")
+            return
+
+        # Filter steps with too few MC rollouts for a reliable soft label
+        if self.min_rollouts > 1:
+            prm_dataset = prm_dataset.filter(
+                lambda row: row["n_rollouts"] >= self.min_rollouts
+            )
+
+        print(f"PRM training examples: {len(prm_dataset)} "
+              f"(after min_rollouts={self.min_rollouts} filter)")
+
+        if len(prm_dataset) == 0:
+            print(
+                "All examples filtered out by min_rollouts. "
+                "Try reducing min_rollouts or increasing branching_factor."
+            )
+            return
+
+        self._print_label_distribution(prm_dataset)
+        self._print_example(prm_dataset)
+
+        # Tokenise: concatenate prompt + completion via the model's chat template
+        tokenizer = self.learner.tokenizer
+        # Llama has no pad token by default; use EOS as padding (left-pad for decoder).
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+            tokenizer.pad_token_id = tokenizer.eos_token_id
+        tokenized = prm_dataset.map(
+            lambda batch: self._tokenize_batch(batch, tokenizer),
+            batched=True,
+            remove_columns=prm_dataset.column_names,
+            desc="Tokenising PRM dataset",
+        )
+
+        split = tokenized.train_test_split(test_size=0.1, seed=42)
+        print(f"Train: {len(split['train'])}  Val: {len(split['test'])}")
+
+        # Load as 4-bit sequence classifier + LoRA so it fits alongside the
+        # already-loaded teacher model.
+        from transformers import AutoConfig, BitsAndBytesConfig
+        from peft import LoraConfig, TaskType, get_peft_model, prepare_model_for_kbit_training
+
+        base_id = self.learner.model.config.name_or_path
+        print(f"Loading PRM classifier (4-bit + LoRA) from: {base_id}")
+
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+        prm_config = AutoConfig.from_pretrained(base_id, num_labels=1)
+        if hasattr(prm_config, "classifier_dropout"):
+            prm_config.classifier_dropout = 0.05
+        prm_config.pad_token_id = tokenizer.pad_token_id
+        prm_classifier = AutoModelForSequenceClassification.from_pretrained(
+            base_id,
+            config=prm_config,
+            quantization_config=bnb_config,
+            device_map="auto",
+        )
+        prm_classifier = prepare_model_for_kbit_training(prm_classifier)
+        lora_config = LoraConfig(
+            task_type=TaskType.SEQ_CLS,
+            r=16,
+            lora_alpha=32,
+            lora_dropout=0.05,
+            target_modules=["q_proj", "v_proj"],
+        )
+        prm_classifier = get_peft_model(prm_classifier, lora_config)
+        prm_classifier.config.pad_token_id = tokenizer.pad_token_id
+        prm_classifier.print_trainable_parameters()
+
+        output_dir = f"models/prm/{self.learner.name}/{mode}"
+        training_args = TrainingArguments(
+            output_dir=output_dir,
+            per_device_train_batch_size=4,
+            gradient_accumulation_steps=32,
+            learning_rate=3e-5,
+            adam_beta1=0.9,
+            adam_beta2=0.95,
+            weight_decay=0.0,
+            num_train_epochs=50,
+            eval_strategy="epoch",
+            save_strategy="epoch",
+            load_best_model_at_end=True,
+            metric_for_best_model="eval_loss",
+            greater_is_better=False,
+            bf16=True,
+            logging_steps=1,
+            report_to="none",
+        )
+
+        trainer = _SoftBCETrainer(
+            model=prm_classifier,
+            args=training_args,
+            train_dataset=split["train"],
+            eval_dataset=split["test"],
+            data_collator=DataCollatorWithPadding(tokenizer),
+            callbacks=[EarlyStoppingCallback(early_stopping_patience=3)],
+        )
+
+        trainer.train()
+        trainer.save_model()
+        tokenizer.save_pretrained(output_dir)
+        print(f"PRM saved to {output_dir}")
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _tokenize_batch(batch, tokenizer):
+        """Apply chat template to (prompt + completion) and preserve soft labels."""
+        texts = []
+        for prompt, completion in zip(batch["prompt"], batch["completion"]):
+            messages = prompt + completion
+            text = tokenizer.apply_chat_template(
+                messages,
+                tokenize=False,
+                add_generation_prompt=False,
+            )
+            texts.append(text)
+        # Left-truncate so the scored response (at the end) is always kept.
+        encoded = tokenizer(texts, truncation=True, max_length=1024,
+                            truncation_side="left", padding=False)
+        encoded["labels"] = batch["label"]
+        return encoded
+
+    @staticmethod
+    def _print_label_distribution(dataset):
+        labels = dataset["label"]
+        buckets = {"0.0": 0, "(0, 0.5)": 0, "0.5": 0, "(0.5, 1)": 0, "1.0": 0}
+        for l in labels:
+            if l == 0.0:      buckets["0.0"] += 1
+            elif l < 0.5:     buckets["(0, 0.5)"] += 1
+            elif l == 0.5:    buckets["0.5"] += 1
+            elif l < 1.0:     buckets["(0.5, 1)"] += 1
+            else:             buckets["1.0"] += 1
+        avg = sum(labels) / len(labels)
+        print(f"  Label distribution (n={len(labels)}, mean={avg:.3f}):")
+        for bucket, count in buckets.items():
+            bar = "#" * count
+            print(f"    {bucket:>10}  {bar} ({count})")
+        print()
+
+    @staticmethod
+    def _print_example(dataset):
+        row = dataset[0]
+        n = row["n_rollouts"]
+        label = row["label"]
+        print(f"  Example — label={label:.3f} ({n} rollouts)")
+        print(f"  prompt: {row['prompt']}")
+        print(f"  completion: {row['completion']}")
+        print()

examples/trl/sft_train_from_filtered.py

@@ -0,0 +1,279 @@
+"""
+Supervised fine-tune a causal LM on the pre-filtered playpen SFT data.
+
+Reads the on-disk, already-filtered + already-split HuggingFace dataset produced
+by the sft-filtered pipeline (e.g. .../sft-filtered/positive_score/{train,dev}),
+and trains with TRL's SFTTrainer using 4-bit QLoRA — the SAME recipe as
+examples/trl/sft_trainer_lora.py (conversational `messages`, packing=False,
+completion_only_loss=True, LoRA r=16/alpha=32 over all-linear), just sourced from
+the verified positive_score split instead of re-filtering the raw HF dataset, and
+made torchrun/DDP-friendly so run_sft.sh can fan it across the whole allocation.
+
+The `positive_score` route keeps episodes with `outcome != 'aborted'` AND
+`Main Score > 0` (verified equal to non_aborted ∩ {score>0}); `non_aborted`
+keeps every non-aborted episode. Both ship `train/` and `dev/` saved with
+datasets.save_to_disk, grouped by (game, experiment, task_id) so there is no
+task leakage across the split — so we load those splits directly rather than
+re-splitting here.
+
+Usage (single GPU):
+    python examples/trl/sft_train_from_filtered.py \\
+        --data-dir scaling_LLM_search_methods/playpen-sft-data/sft-filtered/positive_score \\
+        --model /nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B \\
+        --output models/sft/Qwen3.5-27B-Instruct-4bit-positive_score
+
+Usage (DDP, via run_sft.sh): launched under torchrun; each rank loads a full
+4-bit copy on its own GPU and trains on a different data shard.
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shutil
+from pathlib import Path
+
+import torch
+import trl
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    BitsAndBytesConfig,
+    EarlyStoppingCallback,
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
+from datasets import load_from_disk
+
+
+def _load_split(data_dir: Path, split: str):
+    """Load a save_to_disk split and keep only the `messages` column.
+
+    SFTTrainer reads conversational data from the `messages` column; the extra
+    columns (meta, source_row_id, main_score, ...) are dropped so the chat-
+    template formatting path is unambiguous.
+    """
+    path = data_dir / split
+    if not path.exists():
+        raise SystemExit(f"Split not found: {path}  (expected a datasets.save_to_disk dir)")
+    ds = load_from_disk(str(path))
+    drop = [c for c in ds.column_names if c != "messages"]
+    if drop:
+        ds = ds.remove_columns(drop)
+    return ds
+
+
+def main():
+    p = argparse.ArgumentParser(description="QLoRA SFT on the pre-filtered playpen SFT data")
+    p.add_argument(
+        "--data-dir",
+        default="scaling_LLM_search_methods/playpen-sft-data/sft-filtered/positive_score",
+        help="Dir holding train/ and dev/ (datasets.save_to_disk). Default: the "
+             "positive_score route. Use .../non_aborted to train on all non-aborted episodes.",
+    )
+    p.add_argument(
+        "--model",
+        default="/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B",
+        help="HuggingFace model ID or local path to fine-tune.",
+    )
+    p.add_argument(
+        "--output", default="models/sft/Qwen3.5-27B-Instruct-4bit-positive_score",
+        help="Directory to save the trained LoRA adapter.",
+    )
+    p.add_argument("--per-device-batch-size", type=int, default=8,
+                   help="Per-GPU batch size (default: 8; fits a 46GB A40 at max-length 1024).")
+    p.add_argument("--gradient-accumulation-steps", type=int, default=2,
+                   help="Gradient accumulation steps (run_sft.sh auto-derives this).")
+    p.add_argument("--max-length", type=int, default=1024,
+                   help="Max tokens per example; longer conversations are truncated (default 1024).")
+    p.add_argument("--max-epochs", type=float, default=50.0,
+                   help="Hard cap on epochs (default 50). Training runs until the val "
+                        "loss converges (early stopping) and rarely reaches this cap.")
+    p.add_argument("--early-stopping-patience", type=int, default=3,
+                   help="Stop after this many consecutive epochs with no val-loss "
+                        "improvement; the best (lowest-val-loss) epoch is kept (default 3).")
+    p.add_argument("--learning-rate", type=float, default=2e-4,
+                   help="LoRA learning rate (default 2e-4, the usual QLoRA value).")
+    p.add_argument("--report-to", default="wandb",
+                   help="Trainer logging backend: 'wandb' (default) or 'none'. "
+                        "run_sft.sh sets WANDB_PROJECT/WANDB_MODE and falls back to "
+                        "'none' if wandb isn't importable.")
+    p.add_argument("--run-name", default=None,
+                   help="W&B run name (default: the output dir's basename).")
+    p.add_argument("--limit-train-samples", type=int, default=0,
+                   help="If >0, train on only this many examples (and a small eval subset). "
+                        "For a fast smoke test of the full load->train->eval->save path.")
+    p.add_argument("--no-4bit", action="store_true",
+                   help="Disable 4-bit quantization (load bf16 + LoRA). Not recommended for 27B on A40.")
+    p.add_argument("--resume", action="store_true",
+                   help="Resume from the latest checkpoint-* in --output if one exists.")
+    args = p.parse_args()
+
+    data_dir = Path(args.data_dir)
+    is_rank0 = int(os.environ.get("RANK", os.environ.get("LOCAL_RANK", 0))) == 0
+
+    # --- data -------------------------------------------------------------
+    train_ds = _load_split(data_dir, "train")
+    eval_ds = _load_split(data_dir, "dev")
+    if args.limit_train_samples and args.limit_train_samples > 0:
+        n = min(args.limit_train_samples, len(train_ds))
+        train_ds = train_ds.select(range(n))
+        eval_ds = eval_ds.select(range(min(max(8, n // 10), len(eval_ds))))
+        if is_rank0:
+            print(f"[smoke test] limiting to {len(train_ds)} train / {len(eval_ds)} eval examples")
+    if is_rank0:
+        print(f"=== SFT data from {data_dir} ===")
+        print(f"  train: {len(train_ds)} episodes")
+        print(f"  dev:   {len(eval_ds)} episodes")
+
+    # --- tokenizer --------------------------------------------------------
+    tokenizer = AutoTokenizer.from_pretrained(args.model)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+        tokenizer.pad_token_id = tokenizer.eos_token_id
+
+    # --- model: 4-bit QLoRA (one full copy per rank under DDP) -------------
+    # Under torchrun, each rank must load its OWN full copy onto its OWN GPU.
+    # device_map="auto" would shard one model across all visible GPUs, which is
+    # incompatible with DDP; pin to LOCAL_RANK when set.
+    local_rank = int(os.environ.get("LOCAL_RANK", -1))
+    device_map = {"": local_rank} if local_rank != -1 else "auto"
+
+    model_kwargs = dict(torch_dtype=torch.bfloat16, device_map=device_map)
+    if not args.no_4bit:
+        model_kwargs["quantization_config"] = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+        )
+    if is_rank0:
+        print(f"=== Loading {'4-bit QLoRA' if not args.no_4bit else 'bf16 + LoRA'} model: {args.model} ===")
+    # Mirror the PROVEN prm_train_from_records.py setup that trains this same 27B
+    # 4-bit on these 46GB A40s: load the model ourselves, then explicitly prep for
+    # kbit training + wrap with LoRA. Doing the prep ourselves (rather than letting
+    # SFTTrainer do it from peft_config) guarantees gradient checkpointing + input-
+    # require-grads are actually enabled, which keeps activation memory in check.
+    model = AutoModelForCausalLM.from_pretrained(args.model, **model_kwargs)
+    model.config.pad_token_id = tokenizer.pad_token_id
+    if not args.no_4bit:
+        # use_reentrant=False is required for gradient checkpointing under DDP.
+        model = prepare_model_for_kbit_training(
+            model,
+            use_gradient_checkpointing=True,
+            gradient_checkpointing_kwargs={"use_reentrant": False},
+        )
+    else:
+        # bf16 path: prepare_model_for_kbit_training isn't called, so enable
+        # gradient checkpointing OURSELVES — without it, activations for the full
+        # transformer aren't freed and even a small model OOMs at training batch
+        # sizes. enable_input_require_grads() is required for grad-checkpointing to
+        # propagate grads into the LoRA adapters past the frozen, no-grad base.
+        model.gradient_checkpointing_enable(
+            gradient_checkpointing_kwargs={"use_reentrant": False}
+        )
+        model.enable_input_require_grads()
+
+    # Pure LoRA over all linear layers — NO modules_to_save. Fully training
+    # lm_head/embed_tokens (~778M params each) would add the trainable copy +
+    # grads + Adam states (~9GB/GPU) and OOM a 46GB A40 on a 27B model. We're not
+    # adding tokens, so LoRA adapters alone are the right (and standard QLoRA) choice.
+    lora_config = LoraConfig(
+        r=16, lora_alpha=32,
+        lora_dropout=0.05,
+        target_modules="all-linear",
+        task_type="CAUSAL_LM",
+    )
+    model = get_peft_model(model, lora_config)
+    model.config.pad_token_id = tokenizer.pad_token_id
+    if is_rank0:
+        model.print_trainable_parameters()
+
+    # --- TRL SFT config — same knobs as examples/trl/sft_trainer_lora.py ---
+    config = trl.SFTConfig(
+        output_dir=args.output,
+        max_length=args.max_length,
+        packing=False,
+        completion_only_loss=True,
+        # Run UNTIL CONVERGENCE: a high epoch cap + per-epoch eval + early stopping
+        # on val loss (callback below). The cap is just a backstop; training stops
+        # when the val loss stops improving.
+        num_train_epochs=args.max_epochs,
+        per_device_train_batch_size=args.per_device_batch_size,
+        gradient_accumulation_steps=args.gradient_accumulation_steps,
+        learning_rate=args.learning_rate,
+        eval_strategy="epoch",
+        save_strategy="epoch",
+        metric_for_best_model="eval_loss",
+        greater_is_better=False,
+        # load_best_model_at_end=False on purpose (mirrors prm_train_from_records):
+        # its end-of-train GPU reload intermittently crashes multi-node DDP during
+        # teardown AFTER training already converged. We instead copy the best
+        # checkpoint (by eval_loss, tracked in trainer.state) on rank 0 below — a
+        # pure file copy, no GPU op. save_total_limit keeps enough recent epochs
+        # that the best one (within `patience` epochs of the stop) is still on disk.
+        load_best_model_at_end=False,
+        save_total_limit=args.early_stopping_patience + 2,
+        bf16=True,
+        logging_steps=10,
+        # W&B logging. Under DDP the HF Trainer only inits the run on rank 0, so
+        # there's exactly one run regardless of GPU/node count. run_sft.sh sets
+        # WANDB_PROJECT / WANDB_MODE (and falls back to 'none' if wandb is absent).
+        report_to=args.report_to,
+        run_name=args.run_name or Path(args.output).name,
+        # Gradient checkpointing is already enabled via prepare_model_for_kbit_training
+        # above (with use_reentrant=False for DDP), so it's NOT set here to avoid a
+        # double-enable. Only LoRA params require grad and all are used in the
+        # forward, so the unused-param search is unneeded (and faster off).
+        ddp_find_unused_parameters=False,
+    )
+
+    # Model is already LoRA-wrapped above, so DON'T pass peft_config (that would
+    # re-wrap / re-prepare and undo the kbit gradient-checkpointing setup).
+    trainer = trl.SFTTrainer(
+        model=model,
+        args=config,
+        train_dataset=train_ds,
+        eval_dataset=eval_ds,
+        processing_class=tokenizer,
+        # Converge: stop once val loss hasn't improved for `patience` epochs.
+        callbacks=[EarlyStoppingCallback(early_stopping_patience=args.early_stopping_patience)],
+    )
+
+    if is_rank0:
+        print("\n=== Training ===")
+
+    # Resume only if a checkpoint actually exists (passing resume on a
+    # checkpoint-less dir errors); safe to pass --resume on a fresh run.
+    resume = bool(args.resume) and any(Path(args.output).glob("checkpoint-*"))
+    if resume and is_rank0:
+        print(f"Resuming from latest checkpoint in {args.output}")
+    trainer.train(resume_from_checkpoint=resume)
+
+    # Save the converged adapter on rank 0 ONLY, by copying the BEST checkpoint's
+    # adapter (lowest eval_loss) — a pure file copy, no GPU reload, so it can't hit
+    # the cudaErrorDevicesUnavailable teardown crash. peft writes modules_to_save
+    # weights into adapter_model.safetensors too, so the copy is complete. Falls
+    # back to save_model() if no best checkpoint was recorded (e.g. eval disabled).
+    if trainer.is_world_process_zero():
+        out = Path(args.output)
+        out.mkdir(parents=True, exist_ok=True)
+        best = trainer.state.best_model_checkpoint
+        if best and Path(best).is_dir():
+            print(f"Best checkpoint (lowest eval_loss): {best}")
+            for fn in ("adapter_model.safetensors", "adapter_config.json",
+                       "adapter_model.bin", "README.md", "chat_template.jinja"):
+                src = Path(best) / fn
+                if src.exists():
+                    shutil.copy2(src, out / fn)
+        else:
+            print("No best checkpoint recorded; saving current model state.")
+            trainer.save_model()
+        tokenizer.save_pretrained(args.output)
+        # Keep the base-model chat template alongside the adapter for inference.
+        ct = Path(args.model) / "chat_template.jinja"
+        if ct.exists():
+            shutil.copy2(ct, out / "chat_template.jinja")
+        print(f"\nConverged SFT adapter saved to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

examples/trl/sft_trainer_lora.py

@@ -0,0 +1,61 @@
+import trl
+from peft import LoraConfig
+from datasets import load_dataset
+
+from clemcore.backends.huggingface_local_api import HuggingfaceLocalModel
+
+from playpen import BasePlaypenTrainer
+
+
+class PeftSftTrainer(BasePlaypenTrainer):
+
+    def __init__(self, learner: HuggingfaceLocalModel):
+        super().__init__(learner)
+        # Note: We configure the proper chat template for the tokenizer already during model loading in the backend
+
+    def learn(self):
+        # Load a conversational dataset for SFT, that is, a list of "messages" -- basically tuples of role and content.
+        # The role can be "user" or "assistant" and typically alternates within the list.
+        # During training, everything up to the last assistant message becomes the prefix for prediction.
+        # The loss is calculated based on the differences to the last assistant message.
+        # Here we load the canonical training split as available in the huggingface playpen-data repository.
+        # By default, the dataset is stored in ~/.cache/huggingface/datasets/ on your machine. This might take a while.
+        dataset = load_dataset("colab-potsdam/playpen-data", "interactions", split="train")
+
+        # Only use the episodes we are interested to train on: here all episodes with successful outcome
+        dataset = dataset.filter(lambda episode: episode["meta"]["outcome"] == "success")
+
+        # We shuffle and split the remaining filtered samples to receive a test split
+        dataset = dataset.train_test_split(0.2, shuffle=True, seed=42)
+
+        # Initialize training configuration
+        config = trl.SFTConfig(  # inherits TrainingArguments
+            max_length=300,
+            output_dir=f"models/sft+lora/{self.learner.name}",
+            eval_strategy="epoch",
+            packing=False,
+            completion_only_loss=True
+        )
+
+        # Initialize trainer context
+        trainer = trl.SFTTrainer(
+            model=self.learner.model,
+            train_dataset=dataset["train"],
+            eval_dataset=dataset["test"],
+            args=config,
+            # see https://huggingface.co/docs/trl/sft_trainer#training-adapters
+            peft_config=LoraConfig(
+                r=16, lora_alpha=32,
+                lora_dropout=0.05,
+                target_modules="all-linear",
+                modules_to_save=["lm_head", "embed_token"],
+                task_type="CAUSAL_LM",
+            )
+        )
+
+        # Train on the dataset; this will save only the adapters to the checkpoints directory
+        trainer.train()
+
+        # Optional: Uncomment these lines to merge and save directly
+        # merged_model = trainer.model.merge_and_unload()
+        # merged_model.save_pretrained(f"models/sft+lora/{self.learner.get_name()}")

model_registry.json

@@ -0,0 +1,453 @@
+[
+  {
+    "model_name": "smol-135m",
+    "backend": "huggingface_local",
+    "huggingface_id": "HuggingFaceTB/SmolLM-135M-Instruct",
+    "release_date": "2024-09-04",
+    "open_weight": true,
+    "parameters": "135M",
+    "languages": [
+      "en"
+    ],
+    "context_size": "2048",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>"
+    }
+  },
+  {
+    "model_name": "smol-135m-sft",
+    "backend": "huggingface_local",
+    "huggingface_id": "models/sft/smol-135m/checkpoint-63",
+    "release_date": "2024-09-04",
+    "open_weight": true,
+    "parameters": "135M",
+    "languages": [
+      "en"
+    ],
+    "context_size": "2048",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>"
+    }
+  },
+  {
+    "model_name": "Llama-3.1-8B-Instruct",
+    "backend": "huggingface_local",
+    "huggingface_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "release_date": "2024-07-23",
+    "open_weight": true,
+    "parameters": "8B",
+    "languages": [
+      "en",
+      "de",
+      "fr",
+      "it",
+      "pt",
+      "hi",
+      "es",
+      "th"
+    ],
+    "context_size": "128k",
+    "license": {
+      "name": "Meta",
+      "url": "https://github.com/meta-llama/llama-models/blob/main/models/llama3_1/LICENSE"
+    },
+    "model_config": {
+      "requires_api_key": true,
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|eot_id\\|>"
+    }
+  },
+  {
+    "model_name": "Llama-3.1-8B-Instruct-4bit",
+    "backend": "huggingface_local",
+    "huggingface_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "release_date": "2024-07-23",
+    "open_weight": true,
+    "parameters": "8B",
+    "languages": [
+      "en",
+      "de",
+      "fr",
+      "it",
+      "pt",
+      "hi",
+      "es",
+      "th"
+    ],
+    "context_size": "128k",
+    "license": {
+      "name": "Meta",
+      "url": "https://github.com/meta-llama/llama-models/blob/main/models/llama3_1/LICENSE"
+    },
+    "model_config": {
+      "requires_api_key": true,
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|eot_id\\|>",
+      "load_in_4bit": true
+    }
+  },
+  {
+    "model_name": "llama3-8b-sft",
+    "backend": "huggingface_local",
+    "huggingface_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "release_date": "2024-07-23",
+    "open_weight": true,
+    "parameters": "8B",
+    "languages": [
+      "en",
+      "de",
+      "fr",
+      "it",
+      "pt",
+      "hi",
+      "es",
+      "th"
+    ],
+    "context_size": "128k",
+    "license": {
+      "name": "Meta",
+      "url": "https://github.com/meta-llama/llama-models/blob/main/models/llama3_1/LICENSE"
+    },
+    "model_config": {
+      "peft_model": "models/sft+lora/llama3-8b/checkpoint-78",
+      "requires_api_key": true,
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|eot_id\\|>"
+    }
+  },
+  {
+    "model_name": "gpt4o-mini",
+    "model_id": "gpt-4o-mini-2024-07-18",
+    "backend": "openai",
+    "release_date": "2024-07-18",
+    "open_weight": false,
+    "parameters": "",
+    "languages": [
+      "en",
+      "es",
+      "fr",
+      "de",
+      "it",
+      "pt",
+      "ru",
+      "zh",
+      "ja",
+      "ko",
+      "ar",
+      "hi",
+      "bn",
+      "te",
+      "ta",
+      "ml",
+      "kn",
+      "gu",
+      "mr",
+      "pa",
+      "ur",
+      "vi",
+      "th",
+      "id",
+      "ms",
+      "tl",
+      "sw",
+      "yo",
+      "zu",
+      "tr",
+      "he",
+      "fa",
+      "uk",
+      "pl",
+      "cs",
+      "hu",
+      "ro",
+      "nl",
+      "sv",
+      "no",
+      "da",
+      "fi",
+      "el",
+      "bg",
+      "sr",
+      "hr",
+      "sk",
+      "is"
+    ],
+    "context_size": "128k",
+    "license": {
+      "name": "OpenAI",
+      "url": "https://openai.com/policies/row-terms-of-use/"
+    },
+    "model_config": {
+      "multimodality": {
+        "single_image": true,
+        "multiple_images": true,
+        "audio": false,
+        "video": false
+      }
+    }
+  },
+  {
+    "model_name": "Llama-3.1-8B-Instruct-4bit",
+    "backend": "huggingface_local",
+    "huggingface_id": "meta-llama/Meta-Llama-3.1-8B-Instruct",
+    "release_date": "2024-07-23",
+    "open_weight": true,
+    "parameters": "8B",
+    "languages": [
+      "en",
+      "de",
+      "fr",
+      "it",
+      "pt",
+      "hi",
+      "es",
+      "th"
+    ],
+    "context_size": "128k",
+    "license": {
+      "name": "Meta",
+      "url": "https://github.com/meta-llama/llama-models/blob/main/models/llama3_1/LICENSE"
+    },
+    "model_config": {
+      "requires_api_key": true,
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|eot_id\\|>",
+      "load_in_4bit": true
+    }
+  },
+  {
+    "model_name": "Qwen3.5-27B-Instruct-4bit",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "27B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "load_in_4bit": true,
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-0.8B-Instruct",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-0.8B",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "0.8B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-9B-Instruct",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/pre-trained-weights/Qwen3.5-9B-Instruct",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "9B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-9B-Instruct-4bit",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/pre-trained-weights/Qwen3.5-9B-Instruct",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "9B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "load_in_4bit": true,
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-2B-Instruct",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-2B",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "2B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-2B-base",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/models/base/Qwen3.5-2B-genfix",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "2B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>|<\\|im_start\\|>",
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      }
+    }
+  },
+  {
+    "model_name": "Qwen3.5-2B-sft-ep1",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/models/base/Qwen3.5-2B-genfix",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "2B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>|<\\|im_start\\|>",
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      },
+      "peft_model": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/models/sft/Qwen3.5-2B-Instruct-bf16-positive_score/checkpoint-150"
+    }
+  },
+  {
+    "model_name": "gemini-3.1-pro",
+    "model_id": "publishers/google/models/gemini-3.1-pro-preview",
+    "backend": "gemini_vertex",
+    "open_weight": false,
+    "parameters": "",
+    "context_size": "1000k",
+    "license": {
+      "name": "Gemini",
+      "url": "https://ai.google.dev/gemini-api/terms"
+    },
+    "model_config": {}
+  },
+  {
+    "model_name": "gemini-2.5-pro",
+    "model_id": "gemini-2.5-pro",
+    "backend": "gemini_vertex",
+    "open_weight": false,
+    "parameters": "",
+    "context_size": "1000k",
+    "license": {
+      "name": "Gemini",
+      "url": "https://ai.google.dev/gemini-api/terms"
+    },
+    "model_config": {
+      "thinking_mode": true
+    }
+  },
+  {
+    "model_name": "Qwen3.5-27B-sft-ep1-4bit",
+    "backend": "huggingface_local",
+    "huggingface_id": "/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B",
+    "release_date": "2025-01-01",
+    "open_weight": true,
+    "parameters": "27B",
+    "languages": [
+      "en",
+      "zh"
+    ],
+    "context_size": "262k",
+    "license": {
+      "name": "Apache 2.0",
+      "url": "https://www.apache.org/licenses/LICENSE-2.0"
+    },
+    "model_config": {
+      "premade_chat_template": true,
+      "eos_to_cull": "<\\|im_end\\|>",
+      "load_in_4bit": true,
+      "chat_template_kwargs": {
+        "enable_thinking": false
+      },
+      "peft_model": "/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/models/sft/Qwen3.5-27B-Instruct-4bit-positive_score/checkpoint-150"
+    }
+  }
+]

run_27b_beam_search_eval.sh

@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=27b_beam_eval
+#SBATCH --mail-user=josuetf@umich.edu
+#SBATCH --mail-type=ALL
+#SBATCH --output=/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/slurm/%x_%j.out
+#SBATCH --partition=spgpu
+#SBATCH --time=3-0:00:00
+#SBATCH --gpus=8
+#SBATCH --cpus-per-gpu=4
+#SBATCH --mem-per-gpu=48GB
+#SBATCH --account=chaijy0
+
+# Produces the same clemscore + statscore as `playpen eval --suite all` for two models:
+#   - Baseline: Qwen3.5-27B-Instruct-4bit (greedy, no PRM)
+#   - Guided:   Qwen3.5-27B-sft-ep1-4bit + PRM (beam search N=4, M=4, 20 iters)
+#
+# Beam search parameters (SAL paper low-budget config):
+#   N = 4 total beams; M = beam_width = 4; prune to N/M = 1 survivor per step.
+#   Survivor is expanded back to N=4 for the next step. Max 20 steps per turn.
+#   Steps are delimited by \n\n (reasoning paragraph → action line).
+#
+# GPU layout (dynamic — handles any node count and uneven GPU splits):
+#   Phase 1 (all GPUs in parallel across all nodes):
+#     Global shards 0 .. HALF-1:             baseline (greedy, first half of GPUs)
+#     Global shards HALF .. WORLD_GPUS-1:    beam-search guided (second half of GPUs)
+#   Phase 2 (2 GPUs on head node, after Phase 1):
+#     GPU 0: static eval for baseline
+#     GPU 1: static eval for guided
+#   Phase 3 (CPU): merge shards, score, compute clemscore, print comparison
+
+set -euo pipefail
+
+WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
+CONDA_ENV="playpen"
+
+export BASE_MODEL="${BASE_MODEL:-Qwen3.5-27B-Instruct-4bit}"
+export GUIDED_MODEL="${GUIDED_MODEL:-Qwen3.5-27B-sft-ep1-4bit}"
+export PRM_PATH="${PRM_PATH:-models/prm/Qwen3.5-27B-sft-ep1-4bit-1024-full/bench}"
+export N_BEAMS="${N_BEAMS:-4}"
+export NUM_BEAM_ITERS="${NUM_BEAM_ITERS:-20}"
+export RESULTS_DIR="${RESULTS_DIR:-eval-results-27b-beam}"
+
+export BASE_RESULTS_DIR="${RESULTS_DIR}-base"
+export GUIDED_RESULTS_DIR="${RESULTS_DIR}-guided"
+
+cd "$WORKDIR"
+mkdir -p slurm logs
+
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$CONDA_ENV"
+export PYTHONNOUSERSITE=1
+export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"
+
+# -----------------------------------------------------------------------
+# Topology detection
+# -----------------------------------------------------------------------
+if [ -n "${SLURM_JOB_ID:-}" ]; then
+    NNODES="${SLURM_NNODES:-1}"
+    total_gpus=""
+    if command -v scontrol &>/dev/null; then
+        total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
+                      | grep -oE 'gres/gpu=[0-9]+' | head -1 \
+                      | grep -oE '[0-9]+' || true)"
+    fi
+    [ -z "$total_gpus" ] && total_gpus="${SLURM_GPUS:-}"
+    total_gpus="${total_gpus##*:}"
+    case "$total_gpus" in
+        ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;;
+    esac
+else
+    NNODES=1
+    total_gpus=$(nvidia-smi -L 2>/dev/null | wc -l)
+fi
+[ "${total_gpus:-0}" -ge 1 ] || total_gpus=1
+GPUS_PER_NODE=$(( total_gpus / NNODES ))
+[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1
+
+NODE_OFFSETS=""
+WORLD_GPUS=0
+if [ "$NNODES" -gt 1 ]; then
+    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+                 bash -c 'echo "$SLURM_NODEID $(nvidia-smi -L 2>/dev/null | wc -l)"' \
+                 2>/dev/null | sort -n || true)"
+    _acc=0
+    while read -r _nid _cnt; do
+        [ -n "${_cnt:-}" ] || continue
+        NODE_OFFSETS="$NODE_OFFSETS $_acc"
+        _acc=$(( _acc + _cnt ))
+    done <<< "$_probe"
+    WORLD_GPUS="$_acc"
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+fi
+if [ -z "$NODE_OFFSETS" ] || [ "$WORLD_GPUS" -lt 1 ]; then
+    _acc=0
+    for (( _n=0; _n<NNODES; _n++ )); do
+        NODE_OFFSETS="$NODE_OFFSETS $_acc"
+        _acc=$(( _acc + GPUS_PER_NODE ))
+    done
+    WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+fi
+
+HALF=$(( WORLD_GPUS / 2 ))
+[ "$HALF" -ge 1 ] || { echo "ERROR: need at least 2 GPUs total (got $WORLD_GPUS)"; exit 1; }
+BASE_SHARDS=$HALF
+GUIDED_SHARDS=$(( WORLD_GPUS - HALF ))
+
+export NODE_OFFSETS WORLD_GPUS HALF BASE_SHARDS GUIDED_SHARDS WORKDIR
+
+echo "=============================="
+echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
+echo "Nodes:     $NNODES  ($WORLD_GPUS total GPUs)"
+echo "Offsets:   $NODE_OFFSETS"
+echo "Baseline:  $BASE_MODEL  ($BASE_SHARDS shards, greedy)"
+echo "Guided:    $GUIDED_MODEL + PRM  ($GUIDED_SHARDS shards, beam-search N=$N_BEAMS iters=$NUM_BEAM_ITERS)"
+echo "PRM:       $PRM_PATH"
+echo "Base dir:  $BASE_RESULTS_DIR"
+echo "Guided dir:$GUIDED_RESULTS_DIR"
+echo "Started:   $(date)"
+echo "=============================="
+
+# -----------------------------------------------------------------------
+# Phase 1: Clem gameplay — all GPUs in parallel across all nodes.
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 1: Clem gameplay ($WORLD_GPUS GPU(s) across $NNODES node(s)) ==="
+
+fail=0
+srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+     bash -c '
+        cd "$WORKDIR"
+        lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+        off=$(echo "$NODE_OFFSETS" | cut -d" " -f$((SLURM_NODEID+1))); [ -n "$off" ] || off=0
+        pids=()
+        for (( g=0; g<lg; g++ )); do
+            gsid=$(( off + g ))
+            if (( gsid < HALF )); then
+                log="logs/eval_27b_base_shard$(printf "%02d" $gsid).log"
+                echo "  [node $SLURM_NODEID gpu $g] baseline shard $gsid/$BASE_SHARDS -> $log"
+                CUDA_VISIBLE_DEVICES=$g \
+                    python examples/trl/prm_eval.py \
+                        --policy-model "$BASE_MODEL" \
+                        --temperature 0.0 \
+                        --max-tokens 300 \
+                        --game-all \
+                        --results-dir "$BASE_RESULTS_DIR" \
+                        --shard-id "$gsid" --num-shards "$BASE_SHARDS" \
+                        --skip-guided --skip-score \
+                    > "$log" 2>&1 &
+            else
+                guided_sid=$(( gsid - HALF ))
+                log="logs/eval_27b_beam_shard$(printf "%02d" $guided_sid).log"
+                echo "  [node $SLURM_NODEID gpu $g] beam-search shard $guided_sid/$GUIDED_SHARDS -> $log"
+                CUDA_VISIBLE_DEVICES=$g \
+                    python examples/trl/prm_eval.py \
+                        --prm-path "$PRM_PATH" \
+                        --policy-model "$GUIDED_MODEL" \
+                        --mode beam-search \
+                        --n-candidates "$N_BEAMS" \
+                        --num-beam-iterations "$NUM_BEAM_ITERS" \
+                        --temperature 0.7 \
+                        --max-tokens 2048 \
+                        --game-all \
+                        --results-dir "$GUIDED_RESULTS_DIR" \
+                        --shard-id "$guided_sid" --num-shards "$GUIDED_SHARDS" \
+                        --skip-baseline --skip-score \
+                    > "$log" 2>&1 &
+            fi
+            pids+=($!)
+        done
+        rc=0
+        for p in "${pids[@]}"; do wait "$p" || rc=1; done
+        exit $rc
+     ' || fail=$?
+
+echo "Phase 1 done (fail=$fail) at $(date)"
+
+# -----------------------------------------------------------------------
+# Phase 2: Static eval — head node GPU 0 and GPU 1
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 2: Static eval (GPUs 0,1 on head node) ==="
+CUDA_VISIBLE_DEVICES=0 playpen eval "$BASE_MODEL"   --suite static -r "$RESULTS_DIR/base-static" \
+    > "logs/eval_27b_base_static.log" 2>&1 &
+CUDA_VISIBLE_DEVICES=1 playpen eval "$GUIDED_MODEL" --suite static -r "$RESULTS_DIR/guided-static" \
+    > "logs/eval_27b_guided_static.log" 2>&1 &
+wait
+echo "Phase 2 done at $(date)"
+
+# -----------------------------------------------------------------------
+# Phase 3: Merge + score + clemscore
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 3: Merge + score ==="
+python - <<'PY'
+import sys, json, os
+from pathlib import Path
+
+sys.path.insert(0, "examples/trl")
+from prm_eval import _merge_results, _clem_score
+import clemcore.clemeval as clemeval
+
+RESULTS_DIR         = os.environ["RESULTS_DIR"]
+BASE_RESULTS_DIR    = os.environ["BASE_RESULTS_DIR"]
+GUIDED_RESULTS_DIR  = os.environ["GUIDED_RESULTS_DIR"]
+BASE_SHARDS         = int(os.environ["BASE_SHARDS"])
+GUIDED_SHARDS       = int(os.environ["GUIDED_SHARDS"])
+BASE_MODEL          = os.environ["BASE_MODEL"]
+GUIDED_MODEL        = os.environ["GUIDED_MODEL"]
+N_BEAMS             = os.environ.get("N_BEAMS", "4")
+
+base_dir   = Path(BASE_RESULTS_DIR)
+guided_dir = Path(GUIDED_RESULTS_DIR)
+
+print(f"Merging {BASE_SHARDS} baseline shard(s) into {base_dir} ...")
+_merge_results(base_dir, BASE_SHARDS)
+
+print(f"Merging {GUIDED_SHARDS} guided shard(s) into {guided_dir} ...")
+_merge_results(guided_dir, GUIDED_SHARDS)
+
+baseline_clem = base_dir   / "baseline"
+guided_clem   = guided_dir / "prm-guided"
+
+for label, results in [("baseline", baseline_clem), ("guided", guided_clem)]:
+    if not results.exists():
+        print(f"WARNING: {results} not found, skipping scoring")
+        continue
+    games = sorted({p.name for p in results.glob("*/epoch_00001/*") if p.is_dir()})
+    print(f"Scoring {label}: {games}")
+    for g in games:
+        _clem_score(results, g)
+
+def get_clemscore(results_path):
+    if not results_path.exists():
+        return float("nan")
+    try:
+        df = clemeval.perform_evaluation(str(results_path), return_dataframe=True)
+        return round(df["-, clemscore"][0], 2)
+    except Exception as e:
+        print(f"  clemeval failed on {results_path}: {e}")
+        return float("nan")
+
+base_clemscore   = get_clemscore(baseline_clem)
+guided_clemscore = get_clemscore(guided_clem)
+
+def get_statscore(static_results_dir, model_name):
+    val_json = static_results_dir / f"{model_name}.val.json"
+    if val_json.exists():
+        data = json.loads(val_json.read_text())
+        return round(data.get("statscore", float("nan")), 2)
+    return float("nan")
+
+static_base   = Path(RESULTS_DIR) / "base-static"
+static_guided = Path(RESULTS_DIR) / "guided-static"
+base_statscore   = get_statscore(static_base,   BASE_MODEL)
+guided_statscore = get_statscore(static_guided, GUIDED_MODEL)
+
+print()
+print("=" * 60)
+print(f"{'':30s}  {'Baseline':>10}  {'Beam-guided':>11}  {'Δ':>6}")
+print(f"{'Model':30s}  {BASE_MODEL[-10:]:>10}  {GUIDED_MODEL[-11:]:>11}")
+print(f"{'Search':30s}  {'greedy':>10}  {f'beam N={N_BEAMS}':>11}")
+print("-" * 60)
+print(f"{'clemscore':30s}  {base_clemscore:>10.2f}  {guided_clemscore:>11.2f}  {guided_clemscore - base_clemscore:>+6.2f}")
+print(f"{'statscore':30s}  {base_statscore:>10.2f}  {guided_statscore:>11.2f}  {guided_statscore - base_statscore:>+6.2f}")
+print("=" * 60)
+
+for model, clem_s, stat_s, static_dir in [
+    (BASE_MODEL,   base_clemscore,   base_statscore,   static_base),
+    (GUIDED_MODEL, guided_clemscore, guided_statscore, static_guided),
+]:
+    out = static_dir / f"{model}.val.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps({"clemscore": clem_s, "statscore": stat_s}, indent=2))
+    print(f"Wrote {out}")
+PY
+
+echo ""
+echo "=============================="
+echo "Done: $(date)"
+echo "=============================="
+
+exit $fail

run_27b_prm_eval.sh

@@ -0,0 +1,285 @@
+#!/usr/bin/env bash
+#SBATCH --job-name=27b_prm_eval
+#SBATCH --mail-user=josuetf@umich.edu
+#SBATCH --mail-type=ALL
+#SBATCH --output=/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/slurm/%x_%j.out
+#SBATCH --partition=spgpu
+#SBATCH --time=3-0:00:00
+#SBATCH --gpus=8
+#SBATCH --cpus-per-gpu=4
+#SBATCH --mem-per-gpu=48GB
+#SBATCH --account=chaijy2
+
+# Produces the same clemscore + statscore as `playpen eval --suite all` for two models:
+#   - Baseline: Qwen3.5-27B-Instruct-4bit (greedy, no PRM)
+#   - Guided:   Qwen3.5-27B-sft-ep1-4bit + PRM (best-of-N)
+#
+# GPU layout (dynamic — handles any node count and uneven GPU splits):
+#   Phase 1 (all GPUs in parallel across all nodes):
+#     Global shards 0 .. HALF-1:             baseline (first half of GPUs)
+#     Global shards HALF .. WORLD_GPUS-1:    guided   (second half of GPUs)
+#   Phase 2 (2 GPUs on head node, after Phase 1):
+#     GPU 0: static eval for baseline
+#     GPU 1: static eval for guided
+#   Phase 3 (CPU): merge shards, score, compute clemscore via clemeval, print comparison
+
+set -euo pipefail
+
+WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
+CONDA_ENV="playpen"
+
+export BASE_MODEL="${BASE_MODEL:-Qwen3.5-27B-Instruct-4bit}"
+export GUIDED_MODEL="${GUIDED_MODEL:-Qwen3.5-27B-sft-ep1-4bit}"
+export PRM_PATH="${PRM_PATH:-models/prm/Qwen3.5-27B-sft-ep1-4bit-1024-full/bench}"
+export N_CANDIDATES="${N_CANDIDATES:-4}"
+export RESULTS_DIR="${RESULTS_DIR:-eval-results-27b-cmp}"
+
+# Separate shard dirs per side to avoid shard-dir naming conflicts.
+# prm_eval.py redirects each shard to {RESULTS_DIR}_shard{N}/{RESULTS_DIR}/
+export BASE_RESULTS_DIR="${RESULTS_DIR}-base"
+export GUIDED_RESULTS_DIR="${RESULTS_DIR}-guided"
+
+cd "$WORKDIR"
+mkdir -p slurm logs
+
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$CONDA_ENV"
+export PYTHONNOUSERSITE=1
+export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"
+
+# -----------------------------------------------------------------------
+# Topology detection — works for single-node and multi-node allocations
+# with uniform or uneven GPU counts per node.
+# -----------------------------------------------------------------------
+if [ -n "${SLURM_JOB_ID:-}" ]; then
+    NNODES="${SLURM_NNODES:-1}"
+    # Try scontrol first; fall back to SLURM_GPUS env vars
+    total_gpus=""
+    if command -v scontrol &>/dev/null; then
+        total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
+                      | grep -oE 'gres/gpu=[0-9]+' | head -1 \
+                      | grep -oE '[0-9]+' || true)"
+    fi
+    [ -z "$total_gpus" ] && total_gpus="${SLURM_GPUS:-}"
+    total_gpus="${total_gpus##*:}"  # strip optional "type:" prefix
+    case "$total_gpus" in
+        ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;;
+    esac
+else
+    NNODES=1
+    total_gpus=$(nvidia-smi -L 2>/dev/null | wc -l)
+fi
+[ "${total_gpus:-0}" -ge 1 ] || total_gpus=1
+GPUS_PER_NODE=$(( total_gpus / NNODES ))
+[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1
+
+# Probe actual GPU count on each node (handles uneven configs: e.g. 3+5).
+# NODE_OFFSETS is a space-separated list: offset[i] = sum of GPUs on nodes 0..(i-1).
+NODE_OFFSETS=""
+WORLD_GPUS=0
+if [ "$NNODES" -gt 1 ]; then
+    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+                 bash -c 'echo "$SLURM_NODEID $(nvidia-smi -L 2>/dev/null | wc -l)"' \
+                 2>/dev/null | sort -n || true)"
+    _acc=0
+    while read -r _nid _cnt; do
+        [ -n "${_cnt:-}" ] || continue
+        NODE_OFFSETS="$NODE_OFFSETS $_acc"
+        _acc=$(( _acc + _cnt ))
+    done <<< "$_probe"
+    WORLD_GPUS="$_acc"
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+fi
+# Single-node fallback (or if probe returned nothing)
+if [ -z "$NODE_OFFSETS" ] || [ "$WORLD_GPUS" -lt 1 ]; then
+    _acc=0
+    for (( _n=0; _n<NNODES; _n++ )); do
+        NODE_OFFSETS="$NODE_OFFSETS $_acc"
+        _acc=$(( _acc + GPUS_PER_NODE ))
+    done
+    WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+fi
+
+# Split global GPU IDs: first half → baseline, second half → guided
+HALF=$(( WORLD_GPUS / 2 ))
+[ "$HALF" -ge 1 ] || { echo "ERROR: need at least 2 GPUs total (got $WORLD_GPUS)"; exit 1; }
+BASE_SHARDS=$HALF
+GUIDED_SHARDS=$(( WORLD_GPUS - HALF ))
+
+export NODE_OFFSETS WORLD_GPUS HALF BASE_SHARDS GUIDED_SHARDS WORKDIR
+
+echo "=============================="
+echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
+echo "Nodes:     $NNODES  ($WORLD_GPUS total GPUs)"
+echo "Offsets:   $NODE_OFFSETS"
+echo "Baseline:  $BASE_MODEL  ($BASE_SHARDS shards, global IDs 0..$((HALF-1)))"
+echo "Guided:    $GUIDED_MODEL + PRM  ($GUIDED_SHARDS shards, global IDs $HALF..$((WORLD_GPUS-1)))"
+echo "PRM:       $PRM_PATH  (n-candidates=$N_CANDIDATES, max-tokens=2048)"
+echo "Base dir:  $BASE_RESULTS_DIR"
+echo "Guided dir:$GUIDED_RESULTS_DIR"
+echo "Started:   $(date)"
+echo "=============================="
+
+# -----------------------------------------------------------------------
+# Phase 1: Clem gameplay — all GPUs across all nodes in parallel.
+# One srun task per node; each task splits its local GPUs between baseline
+# (global shard IDs 0..HALF-1) and guided (global shard IDs HALF..WORLD-1).
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 1: Clem gameplay ($WORLD_GPUS GPU(s) across $NNODES node(s)) ==="
+
+fail=0
+srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+     bash -c '
+        cd "$WORKDIR"
+        lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+        off=$(echo "$NODE_OFFSETS" | cut -d" " -f$((SLURM_NODEID+1))); [ -n "$off" ] || off=0
+        pids=()
+        for (( g=0; g<lg; g++ )); do
+            gsid=$(( off + g ))
+            if (( gsid < HALF )); then
+                log="logs/eval_27b_base_shard$(printf "%02d" $gsid).log"
+                echo "  [node $SLURM_NODEID gpu $g] baseline shard $gsid/$BASE_SHARDS -> $log"
+                CUDA_VISIBLE_DEVICES=$g \
+                    python examples/trl/prm_eval.py \
+                        --policy-model "$BASE_MODEL" \
+                        --temperature 0.0 \
+                        --max-tokens 300 \
+                        --game-all \
+                        --results-dir "$BASE_RESULTS_DIR" \
+                        --shard-id "$gsid" --num-shards "$BASE_SHARDS" \
+                        --skip-guided --skip-score \
+                    > "$log" 2>&1 &
+            else
+                guided_sid=$(( gsid - HALF ))
+                log="logs/eval_27b_guided_shard$(printf "%02d" $guided_sid).log"
+                echo "  [node $SLURM_NODEID gpu $g] guided shard $guided_sid/$GUIDED_SHARDS -> $log"
+                CUDA_VISIBLE_DEVICES=$g \
+                    python examples/trl/prm_eval.py \
+                        --prm-path "$PRM_PATH" \
+                        --policy-model "$GUIDED_MODEL" \
+                        --temperature 0.7 \
+                        --max-tokens 2048 \
+                        --game-all \
+                        --results-dir "$GUIDED_RESULTS_DIR" \
+                        --shard-id "$guided_sid" --num-shards "$GUIDED_SHARDS" \
+                        --skip-baseline --n-candidates "$N_CANDIDATES" --skip-score \
+                    > "$log" 2>&1 &
+            fi
+            pids+=($!)
+        done
+        rc=0
+        for p in "${pids[@]}"; do wait "$p" || rc=1; done
+        exit $rc
+     ' || fail=$?
+
+echo "Phase 1 done (fail=$fail) at $(date)"
+
+# -----------------------------------------------------------------------
+# Phase 2: Static eval — runs on head node GPU 0 and GPU 1.
+# playpen eval --suite static plays static benchmark games and writes
+# statscore to {dir}/{model_name}.val.json
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 2: Static eval (GPUs 0,1 on head node) ==="
+CUDA_VISIBLE_DEVICES=0 playpen eval "$BASE_MODEL"   --suite static -r "$RESULTS_DIR/base-static" \
+    > "logs/eval_27b_base_static.log" 2>&1 &
+CUDA_VISIBLE_DEVICES=1 playpen eval "$GUIDED_MODEL" --suite static -r "$RESULTS_DIR/guided-static" \
+    > "logs/eval_27b_guided_static.log" 2>&1 &
+wait
+echo "Phase 2 done at $(date)"
+
+# -----------------------------------------------------------------------
+# Phase 3: Merge shard results, score clem games, compute clemscore
+# -----------------------------------------------------------------------
+echo ""
+echo "=== Phase 3: Merge + score ==="
+python - <<'PY'
+import sys, json, os
+from pathlib import Path
+
+sys.path.insert(0, "examples/trl")
+from prm_eval import _merge_results, _clem_score
+import clemcore.clemeval as clemeval
+
+RESULTS_DIR         = os.environ["RESULTS_DIR"]
+BASE_RESULTS_DIR    = os.environ["BASE_RESULTS_DIR"]
+GUIDED_RESULTS_DIR  = os.environ["GUIDED_RESULTS_DIR"]
+BASE_SHARDS         = int(os.environ["BASE_SHARDS"])
+GUIDED_SHARDS       = int(os.environ["GUIDED_SHARDS"])
+BASE_MODEL          = os.environ["BASE_MODEL"]
+GUIDED_MODEL        = os.environ["GUIDED_MODEL"]
+
+base_dir   = Path(BASE_RESULTS_DIR)
+guided_dir = Path(GUIDED_RESULTS_DIR)
+
+print(f"Merging {BASE_SHARDS} baseline shard(s) into {base_dir} ...")
+_merge_results(base_dir, BASE_SHARDS)
+
+print(f"Merging {GUIDED_SHARDS} guided shard(s) into {guided_dir} ...")
+_merge_results(guided_dir, GUIDED_SHARDS)
+
+# prm_eval.py with --skip-guided writes to baseline/ subdir; --skip-baseline writes to prm-guided/
+baseline_clem = base_dir   / "baseline"
+guided_clem   = guided_dir / "prm-guided"
+
+for label, results in [("baseline", baseline_clem), ("guided", guided_clem)]:
+    if not results.exists():
+        print(f"WARNING: {results} not found, skipping scoring")
+        continue
+    games = sorted({p.name for p in results.glob("*/epoch_00001/*") if p.is_dir()})
+    print(f"Scoring {label}: {games}")
+    for g in games:
+        _clem_score(results, g)
+
+def get_clemscore(results_path):
+    if not results_path.exists():
+        return float("nan")
+    try:
+        df = clemeval.perform_evaluation(str(results_path), return_dataframe=True)
+        return round(df["-, clemscore"][0], 2)
+    except Exception as e:
+        print(f"  clemeval failed on {results_path}: {e}")
+        return float("nan")
+
+base_clemscore   = get_clemscore(baseline_clem)
+guided_clemscore = get_clemscore(guided_clem)
+
+def get_statscore(static_results_dir, model_name):
+    val_json = static_results_dir / f"{model_name}.val.json"
+    if val_json.exists():
+        data = json.loads(val_json.read_text())
+        return round(data.get("statscore", float("nan")), 2)
+    return float("nan")
+
+static_base   = Path(RESULTS_DIR) / "base-static"
+static_guided = Path(RESULTS_DIR) / "guided-static"
+base_statscore   = get_statscore(static_base,   BASE_MODEL)
+guided_statscore = get_statscore(static_guided, GUIDED_MODEL)
+
+print()
+print("=" * 60)
+print(f"{'':30s}  {'Baseline':>10}  {'PRM-guided':>10}  {'Δ':>6}")
+print(f"{'Model':30s}  {BASE_MODEL[-10:]:>10}  {GUIDED_MODEL[-10:]:>10}")
+print("-" * 60)
+print(f"{'clemscore':30s}  {base_clemscore:>10.2f}  {guided_clemscore:>10.2f}  {guided_clemscore - base_clemscore:>+6.2f}")
+print(f"{'statscore':30s}  {base_statscore:>10.2f}  {guided_statscore:>10.2f}  {guided_statscore - base_statscore:>+6.2f}")
+print("=" * 60)
+
+for model, clem_s, stat_s, static_dir in [
+    (BASE_MODEL,   base_clemscore,   base_statscore,   static_base),
+    (GUIDED_MODEL, guided_clemscore, guided_statscore, static_guided),
+]:
+    out = static_dir / f"{model}.val.json"
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps({"clemscore": clem_s, "statscore": stat_s}, indent=2))
+    print(f"Wrote {out}")
+PY
+
+echo ""
+echo "=============================="
+echo "Done: $(date)"
+echo "=============================="
+
+exit $fail

run_prm.sh

@@ -0,0 +1,550 @@
+#!/bin/bash
+
+#SBATCH --job-name=run_prm_eval
+#SBATCH --mail-user=josuetf@umich.edu
+#SBATCH --mail-type=ALL
+#SBATCH --output=/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/slurm/%x_%j.out
+#SBATCH --partition=spgpu
+#SBATCH --time=14-0:00:00
+#SBATCH --gpus=4
+#SBATCH --cpus-per-gpu=2
+#SBATCH --mem-per-gpu=48GB
+#SBATCH --account=chaijy2
+# Account chaijy2 cap: gpu=20, cpu=80, mem=960G (shared across the account).
+# Requesting 4 A40s on one spgpu node (every spgpu node has 8x A40). CPUs kept
+# at 16 (not 32) to stay under the account's free CPU headroom so it doesn't
+# pend on AssocGrpCpuLimit. DDP is single-node, so all 4 GPUs are on one node.
+# COMMAND: TRAIN_BATCH_SIZE=8 TRAIN_GRAD_ACCUM=2 TRAIN_GPU_SETS="0,1,2,3,4,5,6,7" EVAL_GUIDED_GPUS="0,1,2,3" EVAL_BASELINE_GPUS="4,5,6,7" sbatch run_prm.sh
+# ============================================================================
+# Parallel PRM rollout collection + training + evaluation.
+#
+# Collection (prm_trainer.py) now covers ALL LMPlayschool games (PRM_GAMES=all)
+# and is BATCHED: within each worker, a window of instances and all of their
+# K×N rollouts are pooled and generated together via Player.batch_response, so
+# each forward pass runs up to PRM_ROLLOUT_BATCH_SIZE sequences at once. This
+# fills a 96 GB card's headroom with KV-cache batch instead of idle VRAM.
+#
+# Two memory levers, used together:
+#   * within a worker  -> PRM_ROLLOUT_BATCH_SIZE / PRM_INSTANCE_WINDOW (batching)
+#   * across both GPUs -> SHARD_GPUS (one model replica per worker process)
+#
+# Because each worker now batches, prefer FEWER, BIGGER workers than before:
+# a 27B 4-bit replica is ~16-18 GB, leaving ~75 GB/card for the batch. Set
+# SHARD_GPUS to one GPU id per worker:
+#   - Both GPUs free (recommended):    SHARD_GPUS=(0 0 1 1)   # 2 replicas/GPU
+#   - Max batch headroom:              SHARD_GPUS=(0 1)       # 1 replica/GPU
+#   - Leave GPU0 alone:                SHARD_GPUS=(1 1)       # GPU1 only
+# NUM_SHARDS is derived from the array length — change only this one line.
+# If you hit CUDA OOM, lower PRM_ROLLOUT_BATCH_SIZE (or use fewer workers);
+# if VRAM sits idle, raise it.
+#
+# RESUME (incl. with a DIFFERENT number of GPUs/workers):
+#   Just re-run this script. Collection progress is tracked per (epoch, game,
+#   instance) via marker files in prm-checkpoints/<learner>/done/. Already-
+#   collected instances are skipped and the rest are re-partitioned across
+#   whatever workers you launch — so you can stop a 2-worker run and resume with
+#   4, or vice versa, with no gaps or duplicate rollouts. To recollect from
+#   scratch, delete the prm-checkpoints/<learner>/ directory.
+# ============================================================================
+
+set -euo pipefail
+
+WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
+CONDA_ENV="playpen"
+# Policy model that generates the rollouts. Override via env to collect with a
+# different learner, e.g. the SFT epoch-1 checkpoint:
+#   LEARNER=Qwen3.5-27B-sft-ep1-4bit sbatch run_prm.sh
+# (that registry entry = 27B 4-bit base + the epoch-1 LoRA adapter checkpoint-150).
+LEARNER="${LEARNER:-Qwen3.5-27B-Instruct-4bit}"
+HF_BASE="/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B"
+
+# Output tag: keeps THIS run's data (checkpoints, transcripts, models) in its own
+# directory so a prior run is untouched. Change it to start a clean parallel run.
+RUN_TAG="${RUN_TAG:-1024-full}"
+RUN_NAME="${LEARNER}-${RUN_TAG}"          # e.g. Qwen3.5-27B-Instruct-4bit-1024-full
+CKPT_DIR="prm-checkpoints/${RUN_NAME}"     # rollout JSONL + resume markers
+RECORDS_DIR="prm-records/${RUN_NAME}"      # full game transcripts
+MODEL_OUT="models/prm/${RUN_NAME}"         # trained PRMs
+
+# Which games to collect (default: every game in the playpen-data train split).
+# Override with a comma-separated subset, e.g. PRM_GAMES_SEL="taboo,wordle".
+PRM_GAMES_SEL="${PRM_GAMES_SEL:-all}"
+# Batched-generation knobs (per worker). Tune ROLLOUT_BATCH_SIZE to the card:
+# bigger => more VRAM used and faster, until OOM.
+ROLLOUT_BATCH_SIZE="${ROLLOUT_BATCH_SIZE:-64}"
+INSTANCE_WINDOW="${INSTANCE_WINDOW:-16}"
+# Generation token budget per response. 300 truncates ~10-12% of wordle guesses
+# (and verbose games) mid-answer -> spurious aborts; 1024 matches the eval budget.
+MAX_TOKENS="${MAX_TOKENS:-1024}"
+# PRM tokenization length (how much of prompt+response the classifier reads).
+TRAIN_MAX_LENGTH="${TRAIN_MAX_LENGTH:-1024}"
+# Save the FULL game transcript (every GM + player message) for the base game
+# and every rollout, under prm-records/<learner>/. 1=on (lots of files), 0=off.
+SAVE_INTERACTIONS="${SAVE_INTERACTIONS:-1}"
+# Epochs over all instances (each re-plays them to make MORE training examples).
+# Start with 1; raise once a single epoch finishes cleanly.
+NUM_EPOCHS="${NUM_EPOCHS:-1}"
+# Long-game controls so adventuregame/imagegame finish (else rollouts never
+# commit). Cap each rollout's continuation length; cut rollouts get the game's
+# PARTIAL clembench score. Also cap branch points/instance (evenly subsampled).
+MAX_ROLLOUT_ROUNDS="${MAX_ROLLOUT_ROUNDS:-20}"
+TRUNCATE_GAMES="${TRUNCATE_GAMES:-imagegame,adventuregame}"
+MAX_STEPS_PER_INSTANCE="${MAX_STEPS_PER_INSTANCE:-10}"
+# Reward signal(s) to collect & train, from the SAME rollouts (one pass):
+#   success      -> Math-Shepherd P(game succeeds from here)
+#   bench        -> normalized BENCH_SCORE (the eval metric) from here
+#   success,bench-> both (recommended); trains one PRM per mode.
+REWARD_MODE="${REWARD_MODE:-bench}"
+# Which PRM to use for the guided evaluation below (the eval-aligned one).
+EVAL_MODE="${EVAL_MODE:-bench}"
+# Per-device train batch. 8 fits a 46GB A40 (16+ OOMs on these cards). grad-accum
+# is AUTO-derived after topology detection so the effective batch stays constant
+# (TRAIN_EFFECTIVE_BATCH) no matter how many GPUs/nodes Slurm gives us. Set
+# TRAIN_GRAD_ACCUM explicitly only if you want to override that.
+TRAIN_BATCH_SIZE="${TRAIN_BATCH_SIZE:-8}"
+TRAIN_GRAD_ACCUM="${TRAIN_GRAD_ACCUM:-}"
+TRAIN_EFFECTIVE_BATCH="${TRAIN_EFFECTIVE_BATCH:-128}"
+
+# GPU id per collection worker. Length = number of parallel worker processes.
+# 3 replicas/card balances a ~20GB 27B-4bit replica against KV-cache batch
+# headroom on a 96GB card (2/card = bigger batches; 4/card = more overlap but
+# batch-starved). Re-run to resume — markers re-partition over any worker count.
+#
+# NOTE: each worker is a separate process and peaks at ~20-25GB *host* RAM
+# (CUDA context + tokenizer + the in-flight batch of forked game states &
+# interaction recorders). On a memory-tight node the kernel OOM-killer will
+# SIGKILL the largest workers if total host RAM is over-subscribed (this is
+# NOT a CUDA OOM — it leaves no traceback). Rule of thumb: keep
+# NUM_SHARDS * 25GB under the allocation's --mem. e.g. a 192GB node fits ~4-6.
+# Override the default 8-worker layout by exporting SHARD_GPUS as a space-
+# separated string, e.g.  SHARD_GPUS="0 0 1 1"  (4 workers, 2/GPU).
+read -r -a SHARD_GPUS <<< "${SHARD_GPUS:-0 0 1 1 2 2 3 3}"
+NUM_SHARDS=${#SHARD_GPUS[@]}
+
+cd "$WORKDIR"
+mkdir -p logs
+
+# Activate conda
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$CONDA_ENV"
+
+# Use ONLY the env's packages. Without this, ~/.local (user-site) shadows the
+# env: clemcore imports nltk -> nltk.classify.scikitlearn -> the user-site
+# sklearn built against numpy<2, which is ABI-incompatible with the env's
+# numpy 2.2.6 -> "numpy.dtype size changed" at import (killed job 52646400).
+export PYTHONNOUSERSITE=1
+
+# Curb CUDA reserved-pool bloat/fragmentation so a worker's high-water mark
+# tracks live usage more tightly. Matters most when >1 worker shares a card
+# (each process keeps its OWN reserved pool and won't lend idle slack to the
+# other), which is how GPU VRAM gets over-subscribed even below the live total.
+export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"
+
+# ------------------------------------------------------------------
+# Cluster topology — adapt to WHATEVER Slurm granted (1 node or many). Nothing
+# below is hard-coded to a node/GPU count: collection, training (DDP) and eval
+# all fan out over $WORLD_GPUS = $NNODES x $GPUS_PER_NODE. When the allocation
+# spans >1 node we use `srun` to reach the other nodes (bash `&` can't); on a
+# single node we keep the original local fan-out. Outside Slurm -> 1 local node.
+# ------------------------------------------------------------------
+if [ -n "${SLURM_JOB_ID:-}" ]; then
+    NNODES="${SLURM_NNODES:-1}"
+    # Derive the TOTAL GPU count from scontrol (AllocTRES gres/gpu=N), not
+    # SLURM_GPUS_ON_NODE — with `--gpus=N` (a per-JOB total) the latter is
+    # unreliable (often 1), which silently under-uses GPUs and shrinks the
+    # effective batch. WORLD_GPUS = this total drives grad-accum, so the
+    # effective batch is correct for ANY split. GPUS_PER_NODE below is just the
+    # even-split average for display/single-node; the multi-node training/eval
+    # paths read each node's ACTUAL local GPU count, so UNEVEN splits (5+3) work.
+    total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
+                   | grep -oE 'gres/gpu=[0-9]+' | head -1 | grep -oE '[0-9]+')"
+    [ -n "$total_gpus" ] || total_gpus="${SLURM_GPUS:-}"
+    total_gpus="${total_gpus##*:}"   # "a40:8" -> "8"
+    case "$total_gpus" in ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;; esac
+    GPUS_PER_NODE=$(( total_gpus / NNODES ))
+    HEAD_NODE="$(scontrol show hostnames "${SLURM_JOB_NODELIST:-}" 2>/dev/null | head -1)"
+else
+    NNODES=1
+    GPUS_PER_NODE="$(nvidia-smi -L 2>/dev/null | wc -l)"
+    HEAD_NODE="$(hostname)"
+fi
+case "$GPUS_PER_NODE" in ''|*[!0-9]*) GPUS_PER_NODE=1 ;; esac
+[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1
+[ -n "$HEAD_NODE" ] || HEAD_NODE="$(hostname)"
+WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
+RDZV_PORT="${RDZV_PORT:-29500}"
+if [ "$NNODES" -gt 1 ]; then MULTINODE=1; else MULTINODE=0; fi
+
+# For multi-node: probe each node's ACTUAL allocated GPU count using the SAME
+# srun pattern training uses (one task/node, --gpu-bind=none, NO --gpus-per-task
+# — that flag fails under a `--gpus=N` job-total allocation with "Insufficient
+# GRES"). Build a per-node cumulative offset (indexed by SLURM_NODEID) so the
+# collection/eval fan-outs can give each GPU a unique CONTIGUOUS global shard id
+# even when the split is UNEVEN (e.g. 5+3). Falls back to an even split.
+NODE_OFFSETS=""
+if [ "$MULTINODE" -eq 1 ]; then
+    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+                 bash -c 'echo "$SLURM_NODEID $(nvidia-smi -L 2>/dev/null | wc -l)"' \
+                 2>/dev/null | sort -n || true)"
+    _acc=0
+    while read -r _nid _cnt; do
+        [ -n "${_cnt:-}" ] || continue
+        NODE_OFFSETS="$NODE_OFFSETS $_acc"; _acc=$(( _acc + _cnt ))
+    done <<< "$_probe"
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+    [ "$_acc" -ge 1 ] && WORLD_GPUS="$_acc"   # authoritative total from the probe
+fi
+if [ -z "$NODE_OFFSETS" ]; then   # even-split fallback (or single node)
+    for (( _n=0; _n<NNODES; _n++ )); do NODE_OFFSETS="$NODE_OFFSETS $(( _n * GPUS_PER_NODE ))"; done
+    NODE_OFFSETS="${NODE_OFFSETS# }"
+fi
+export NODE_OFFSETS WORLD_GPUS GPUS_PER_NODE
+
+# Hold the effective batch constant across any GPU count:
+#   effective = per_device_batch * WORLD_GPUS * grad_accum
+# Derive grad_accum to hit TRAIN_EFFECTIVE_BATCH unless the user pinned it.
+if [ -z "$TRAIN_GRAD_ACCUM" ]; then
+    TRAIN_GRAD_ACCUM=$(( TRAIN_EFFECTIVE_BATCH / (TRAIN_BATCH_SIZE * WORLD_GPUS) ))
+    [ "$TRAIN_GRAD_ACCUM" -ge 1 ] || TRAIN_GRAD_ACCUM=1
+fi
+
+echo "=============================="
+echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
+echo "RUN_NAME=${RUN_NAME}"   # machine-readable; prm_progress.sh JOB_ID= mode greps this
+echo "Node:      ${SLURMD_NODENAME:-$(hostname)}"
+echo "GPUs:"
+nvidia-smi --query-gpu=index,name,memory.total,memory.used,memory.free --format=csv
+echo "Topology:  ${NNODES} node(s) x ${GPUS_PER_NODE} GPU = ${WORLD_GPUS} GPUs  (multinode=${MULTINODE}, head=${HEAD_NODE})"
+echo "Train:     per_device=${TRAIN_BATCH_SIZE} x world=${WORLD_GPUS} x grad_accum=${TRAIN_GRAD_ACCUM} = $(( TRAIN_BATCH_SIZE * WORLD_GPUS * TRAIN_GRAD_ACCUM )) effective batch"
+echo "Started:   $(date)"
+echo "=============================="
+
+# EVAL_ONLY=1 -> skip collection AND training, go straight to evaluating the
+# already-trained PRM at $MODEL_OUT/$EVAL_MODE. Use this to (re)run eval without
+# recollecting or retraining (e.g. after a run whose training finished but whose
+# eval didn't). Eval needs no collection data — it generates fresh rollouts.
+if [ "${EVAL_ONLY:-0}" = "1" ]; then
+    echo ""
+    echo "EVAL_ONLY=1 -> skipping collection & training; evaluating $MODEL_OUT/$EVAL_MODE"
+    if [ ! -f "$MODEL_OUT/$EVAL_MODE/adapter_model.safetensors" ]; then
+        echo "ERROR: no trained PRM at $MODEL_OUT/$EVAL_MODE — cannot eval. Train first."
+        exit 1
+    fi
+else
+
+# TRAIN_ONLY=1 -> skip collection and train on the rollouts already in
+# $CKPT_DIR (e.g. a partial collection you want a PRM from right now).
+if [ "${TRAIN_ONLY:-0}" = "1" ]; then
+    echo ""
+    echo "TRAIN_ONLY=1 -> skipping collection; training on existing rollouts in $CKPT_DIR"
+    _have=$(find "$CKPT_DIR" -name 'epoch_*.jsonl' -print -quit 2>/dev/null || true)
+    if [ -z "$_have" ]; then
+        echo "ERROR: TRAIN_ONLY=1 but no rollouts found in $CKPT_DIR — nothing to train."
+        echo "       Collect first (drop TRAIN_ONLY), or check LEARNER/RUN_TAG."
+        exit 1
+    fi
+else
+
+# ------------------------------------------------------------------
+# 1. PRM rollout collection — parallel, sharded across GPUs
+# ------------------------------------------------------------------
+echo ""
+echo "=== PRM Rollout Collection ($NUM_SHARDS parallel workers) ==="
+
+# Static collection config — exported so srun tasks (possibly on other nodes)
+# inherit it; only PRM_SHARD_ID/PRM_NUM_SHARDS differ per worker.
+export PRM_COLLECT_ONLY=1 PRM_GAMES="$PRM_GAMES_SEL" PRM_REWARD_MODE="$REWARD_MODE" \
+       PRM_NUM_EPOCHS="$NUM_EPOCHS" PRM_ROLLOUT_BATCH_SIZE="$ROLLOUT_BATCH_SIZE" \
+       PRM_INSTANCE_WINDOW="$INSTANCE_WINDOW" PRM_MAX_ROLLOUT_ROUNDS="$MAX_ROLLOUT_ROUNDS" \
+       PRM_TRUNCATE_GAMES="$TRUNCATE_GAMES" PRM_MAX_STEPS_PER_INSTANCE="$MAX_STEPS_PER_INSTANCE" \
+       PRM_SAVE_INTERACTIONS="$SAVE_INTERACTIONS" PRM_CHECKPOINT_DIR="$CKPT_DIR" \
+       PRM_RECORDS_DIR="$RECORDS_DIR" LEARNER="$LEARNER" MAX_TOKENS="$MAX_TOKENS"
+
+if [ "$MULTINODE" -eq 1 ]; then
+    # One srun task PER NODE (NO --gpus-per-task — that fails under a --gpus=N
+    # job-total allocation). Each task forks one worker per LOCAL GPU and assigns
+    # a contiguous global shard id from NODE_OFFSETS, so ANY per-node GPU count
+    # works, including uneven (5+3). All referenced vars are exported above.
+    echo "  multi-node: $WORLD_GPUS workers via srun (per-node fork; offsets: $NODE_OFFSETS)"
+    cfail=0
+    srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+         bash -c '
+            lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+            off=$(echo "$NODE_OFFSETS" | cut -d" " -f$((SLURM_NODEID+1))); [ -n "$off" ] || off=0
+            pids=()
+            for (( g=0; g<lg; g++ )); do
+                sid=$((off+g))
+                CUDA_VISIBLE_DEVICES=$g PRM_SHARD_ID=$sid PRM_NUM_SHARDS=$WORLD_GPUS \
+                    playpen run examples/trl/prm_trainer.py -l "$LEARNER" -T 0.7 -L "$MAX_TOKENS" \
+                    > "logs/collect_proc$(printf "%02d" $sid).log" 2>&1 &
+                pids+=("$!")
+            done
+            rc=0; for p in "${pids[@]}"; do wait "$p" || rc=1; done; exit $rc' || cfail=$?
+    [ "$cfail" -eq 0 ] && echo "  collection: OK" \
+        || echo "  WARNING: some collection workers failed (srun rc=$cfail); see logs/collect_proc*.log"
+else
+    declare -a PIDS=()
+    for i in "${!SHARD_GPUS[@]}"; do
+        gpu="${SHARD_GPUS[$i]}"
+        log="logs/collect_shard${i}_gpu${gpu}.log"
+        echo "  launching shard $i/$NUM_SHARDS on GPU $gpu  ->  $log"
+        CUDA_VISIBLE_DEVICES="$gpu" PRM_NUM_SHARDS="$NUM_SHARDS" PRM_SHARD_ID="$i" \
+            playpen run examples/trl/prm_trainer.py -l "$LEARNER" -T 0.7 -L "$MAX_TOKENS" \
+            > "$log" 2>&1 &
+        PIDS+=("$!")
+    done
+    echo "  waiting for $NUM_SHARDS collection workers..."
+    fail=0
+    for i in "${!PIDS[@]}"; do
+        if wait "${PIDS[$i]}"; then
+            echo "  shard $i: OK"
+        else
+            echo "  shard $i: FAILED (see logs/collect_shard${i}_*.log)"
+            fail=1
+        fi
+    done
+    if [ "$fail" -ne 0 ]; then
+        # A single bad shard/game must not waste all the collected data. Warn and
+        # continue to training as long as SOME rollouts were committed; re-running
+        # the script later resumes and fills any gaps (markers make it idempotent).
+        echo "WARNING: one or more collection workers failed (see logs). Continuing"
+        echo "         to training on whatever was collected. Re-run to fill gaps."
+    fi
+fi
+# NOTE: `find ... | head -1` ABORTS under `set -euo pipefail`: head closes the
+# pipe after one line, find dies with SIGPIPE (exit 141), and pipefail+errexit
+# then kill the whole script *silently* right here — before training ever runs.
+# This is why collection kept finishing but no PRM was ever trained. Use
+# `-print -quit` (stops at the first match, clean exit 0) and guard with || true.
+collected=$(find "$CKPT_DIR" -name 'epoch_*.jsonl' -print -quit 2>/dev/null || true)
+if [ -z "$collected" ]; then
+    echo "ERROR: no rollouts were collected at all — nothing to train. Aborting."
+    exit 1
+fi
+
+echo ""
+echo "Collection finished at: $(date)"
+
+# COLLECT_ONLY=1 -> stop after rollout collection (skip PRM training + eval).
+# Use this to just gather rollouts for a given LEARNER (e.g. the SFT epoch-1
+# checkpoint) without training/evaluating a PRM on them.
+if [ "${COLLECT_ONLY:-0}" = "1" ]; then
+    echo ""
+    echo "COLLECT_ONLY=1 -> stopping after collection. Rollouts in: $CKPT_DIR"
+    echo "  (transcripts in: $RECORDS_DIR)"
+    exit 0
+fi
+
+fi   # end collection (skipped when TRAIN_ONLY=1)
+
+# ------------------------------------------------------------------
+# 2. PRM training — DATA-PARALLEL (DDP) across the WHOLE allocation: every GPU on
+#    every node holds a full model copy and trains on a different data shard.
+#    Modes are trained SEQUENTIALLY, each using all $WORLD_GPUS GPUs (so multi-
+#    node spans nodes via srun+torchrun; single-node uses torchrun --standalone;
+#    a lone GPU uses plain python). --resume continues from the latest epoch
+#    checkpoint if present. Effective batch (= per_device * WORLD_GPUS * grad_accum)
+#    is held at TRAIN_EFFECTIVE_BATCH by the auto-derived grad_accum above, so the
+#    optimization is identical no matter how many GPUs/nodes you were granted.
+# ------------------------------------------------------------------
+IFS=',' read -r -a MODES <<< "$REWARD_MODE"
+train_fail=0
+for mode in "${MODES[@]}"; do
+    echo ""
+    echo "=== PRM Training: '$mode' as DDP across $WORLD_GPUS GPU(s) on $NNODES node(s) ==="
+    ls -1 "$CKPT_DIR/$mode"/epoch_*_shard*.jsonl 2>/dev/null | sed 's/^/  /' || true
+    train_args=(
+        --checkpoint-dir "$CKPT_DIR/$mode"
+        --model "$HF_BASE"
+        --output "$MODEL_OUT/$mode"
+        --per-device-batch-size "$TRAIN_BATCH_SIZE"
+        --gradient-accumulation-steps "$TRAIN_GRAD_ACCUM"
+        --max-length "$TRAIN_MAX_LENGTH"
+        --resume
+    )
+    if [ "$MULTINODE" -eq 1 ]; then
+        # One agent per node (srun -> 1 task/node, --gpu-bind=none so the task
+        # sees ALL that node's GPUs). Each node runs torchrun with ITS OWN local
+        # GPU count (nvidia-smi), so an UNEVEN split (e.g. 5+3) works: the c10d
+        # rendezvous sums the per-node counts into the global world size. The
+        # training args after the -c script arrive as "$@" in the task (no
+        # re-quoting); $lg/$@ stay single-quoted to expand inside each task.
+        srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+            bash -c 'lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+                     exec torchrun --nnodes='"$NNODES"' --nproc-per-node="$lg" \
+                          --rdzv-backend=c10d --rdzv-id='"$SLURM_JOB_ID"' \
+                          --rdzv-endpoint='"$HEAD_NODE:$RDZV_PORT"' \
+                          examples/trl/prm_train_from_records.py "$@"' \
+            bash "${train_args[@]}" \
+            > "logs/train_${mode}.log" 2>&1 || train_fail=1
+    elif [ "$WORLD_GPUS" -gt 1 ]; then
+        # Single node, multiple GPUs: standalone DDP.
+        torchrun --standalone --nnodes=1 --nproc-per-node="$GPUS_PER_NODE" \
+                 examples/trl/prm_train_from_records.py "${train_args[@]}" \
+            > "logs/train_${mode}.log" 2>&1 || train_fail=1
+    else
+        python examples/trl/prm_train_from_records.py "${train_args[@]}" \
+            > "logs/train_${mode}.log" 2>&1 || train_fail=1
+    fi
+    if [ "$train_fail" -eq 0 ]; then
+        echo "  train '$mode': OK"
+    else
+        echo "  train '$mode': FAILED (see logs/train_${mode}.log)"
+        break
+    fi
+done
+if [ "$train_fail" -ne 0 ]; then
+    echo "ERROR: a training run failed. Aborting before evaluation."
+    exit 1
+fi
+
+echo ""
+echo "Training finished at: $(date)"
+
+fi   # end: collection + training (skipped entirely when EVAL_ONLY=1)
+
+# TRAIN_ONLY=1 -> stop after training; skip the (expensive) evaluation phase.
+if [ "${TRAIN_ONLY:-0}" = "1" ]; then
+    echo ""
+    echo "TRAIN_ONLY=1 -> PRM training complete; skipping evaluation. Model(s) in: $MODEL_OUT"
+    exit 0
+fi
+
+# ------------------------------------------------------------------
+# 3. PRM evaluation — DATA-PARALLEL across GPUs by INSTANCE SHARD. Generation is
+#    single-GPU compute (a device_map="auto" set only pools VRAM, one card active
+#    at a time — no throughput gain), so the real speedup is splitting instances
+#    across GPUs: N workers, ONE GPU each, each handling 1/N of the instances.
+#
+#    Run in TWO phases (baseline, then guided) rather than one process doing
+#    both: each eval process loads policy(~14GB)+PRM(~14GB)≈28GB, and a single
+#    process doing baseline THEN guided would hold two policy copies and OOM a
+#    46GB A40. One model set per process keeps it safe.
+#
+#    Shards = WORLD_GPUS (one per GPU across all nodes): multi-node fans out via
+#    srun, single-node via local background processes. Knob: EVAL_N_CANDIDATES
+#    (best-of-N for the guided run; 4 is ~2x faster than 8).
+# ------------------------------------------------------------------
+EVAL_N_CANDIDATES="${EVAL_N_CANDIDATES:-4}"
+EVAL_NUM_SHARDS="$WORLD_GPUS"   # one instance-shard per GPU across all nodes
+# Game selection. Default: evaluate EVERY game in the validation split
+# (--game-all). For a focused, statistically meaningful SINGLE-game eval, set
+# EVAL_GAME (and optionally EVAL_INSTANCES_FILE to a clembench instances JSON
+# that has many instances). EVAL_RESULTS keeps a focused run's shard dirs
+# separate so it doesn't clobber an all-games run. Example — dedicated wordle:
+#   EVAL_ONLY=1 EVAL_GAME=wordle \
+#     EVAL_INSTANCES_FILE=clembench/wordle/in/instances_extra.json \
+#     EVAL_RESULTS=eval-results-wordle sbatch ... run_prm.sh
+EVAL_GAME="${EVAL_GAME:-}"
+EVAL_INSTANCES_FILE="${EVAL_INSTANCES_FILE:-}"
+EVAL_RESULTS="${EVAL_RESULTS:-eval-results}"
+if [ -n "$EVAL_GAME" ]; then EVAL_GAME_OPT="--game $EVAL_GAME"; else EVAL_GAME_OPT="--game-all"; fi
+if [ -n "$EVAL_INSTANCES_FILE" ]; then EVAL_GAME_OPT="$EVAL_GAME_OPT --instances-file $EVAL_INSTANCES_FILE"; fi
+export EVAL_GAME_OPT EVAL_RESULTS
+echo ""
+echo "=== PRM Evaluation: $EVAL_NUM_SHARDS instance-shards across $NNODES node(s) (best-of-$EVAL_N_CANDIDATES; ${EVAL_GAME:+game=$EVAL_GAME}${EVAL_GAME:-all games}) ==="
+
+# $1 = phase label (baseline|guided); $2... = extra args for that phase.
+run_eval_phase() {
+    local phase="$1"; shift
+    echo ""
+    echo "--- eval phase: $phase ($EVAL_NUM_SHARDS shards) ---"
+    if [ "$MULTINODE" -eq 1 ]; then
+        # One srun task PER NODE (NO --gpus-per-task — fails under --gpus=N).
+        # Each task forks one eval shard per LOCAL GPU with a contiguous global
+        # shard id from NODE_OFFSETS, so uneven per-node counts (5+3) work.
+        export EVAL_PHASE="$phase" EVAL_EXTRA="$*" \
+               EVAL_PRM="$MODEL_OUT/$EVAL_MODE" EVAL_POLICY="$LEARNER"
+        local rc=0
+        srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+             bash -c '
+                lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+                off=$(echo "$NODE_OFFSETS" | cut -d" " -f$((SLURM_NODEID+1))); [ -n "$off" ] || off=0
+                pids=()
+                for (( g=0; g<lg; g++ )); do
+                    sid=$((off+g))
+                    CUDA_VISIBLE_DEVICES=$g python examples/trl/prm_eval.py \
+                        --prm-path "$EVAL_PRM" --policy-model "$EVAL_POLICY" --temperature 0.7 \
+                        $EVAL_GAME_OPT --results-dir "$EVAL_RESULTS" \
+                        --shard-id "$sid" --num-shards "$WORLD_GPUS" --skip-score $EVAL_EXTRA \
+                        > "logs/eval_${EVAL_PHASE}_shard$(printf "%02d" $sid).log" 2>&1 &
+                    pids+=("$!")
+                done
+                rc=0; for p in "${pids[@]}"; do wait "$p" || rc=1; done; exit $rc' || rc=$?
+        [ "$rc" -eq 0 ] && echo "  $phase: OK" || echo "  $phase: FAILED (rc=$rc; see logs/eval_${phase}_shard*.log)"
+        return $rc
+    fi
+    # Single node: one local process per GPU (0..GPUS_PER_NODE-1).
+    local -a pids=(); local s rc=0 i
+    for (( s=0; s<EVAL_NUM_SHARDS; s++ )); do
+        echo "  $phase shard $s/$EVAL_NUM_SHARDS on GPU $s  ->  logs/eval_${phase}_shard${s}.log"
+        CUDA_VISIBLE_DEVICES="$s" python examples/trl/prm_eval.py \
+            --prm-path "$MODEL_OUT/$EVAL_MODE" \
+            --policy-model "$LEARNER" \
+            --temperature 0.7 \
+            $EVAL_GAME_OPT --results-dir "$EVAL_RESULTS" \
+            --shard-id "$s" --num-shards "$EVAL_NUM_SHARDS" \
+            --skip-score "$@" \
+            > "logs/eval_${phase}_shard${s}.log" 2>&1 &
+        pids+=("$!")
+    done
+    for i in "${!pids[@]}"; do
+        if wait "${pids[$i]}"; then echo "  $phase shard $i: OK"
+        else echo "  $phase shard $i: FAILED (see logs/eval_${phase}_shard${i}.log)"; rc=1; fi
+    done
+    return $rc
+}
+
+eval_fail=0
+run_eval_phase baseline --skip-guided                                  || eval_fail=1
+run_eval_phase guided   --skip-baseline --n-candidates "$EVAL_N_CANDIDATES" || eval_fail=1
+if [ "$eval_fail" -ne 0 ]; then
+    echo "ERROR: an evaluation shard failed. Skipping final scoring."
+    exit 1
+fi
+
+# ------------------------------------------------------------------
+# 4. Merge per-shard results -> HTML transcripts + scores + comparison.
+#    Each eval shard wrote to eval-results_shard<N>/eval-results/ (with baseline/
+#    and prm-guided/ subtrees). Instances are disjoint, so rsync-merge them into
+#    one tree, render HTML transcripts (clem transcribe), then score & compare
+#    across ALL shards/games. (The merged dir is what to point a viewer at.)
+# ------------------------------------------------------------------
+MERGED="eval-results-merged/${RUN_NAME}-${EVAL_GAME:-allgames}"
+echo ""
+echo "--- Merging per-shard eval results -> $MERGED ---"
+rm -rf "$MERGED"; mkdir -p "$MERGED"
+merged_any=0
+for d in ${EVAL_RESULTS}_shard*/${EVAL_RESULTS}; do
+    [ -d "$d" ] || continue
+    if rsync -a "$d/" "$MERGED/"; then merged_any=1; fi
+done
+[ "$merged_any" -eq 1 ] || echo "WARNING: no per-shard eval results (${EVAL_RESULTS}_shard*/) found to merge."
+
+echo ""
+echo "--- Generating HTML transcripts (clem transcribe) ---"
+for sub in baseline prm-guided; do
+    [ -d "$MERGED/$sub" ] && python -m clemcore.cli transcribe -g all -r "$MERGED/$sub" || true
+done
+
+echo ""
+echo "--- Scoring & comparison (all shards) ---"
+python examples/trl/prm_eval.py \
+    --prm-path "$MODEL_OUT/$EVAL_MODE" \
+    --policy-model "$LEARNER" \
+    $EVAL_GAME_OPT \
+    --results-dir "$MERGED" \
+    --skip-baseline --skip-guided \
+    || echo "WARNING: scoring/comparison failed (HTML transcripts were still generated)."
+
+# Clean single-page HTML dashboard (summary + clickable per-instance transcripts).
+python examples/trl/make_eval_summary.py "$MERGED" || true
+
+echo ""
+echo "HTML summary:     $MERGED/index.html"
+echo "HTML transcripts: $MERGED/{baseline,prm-guided}/<model>/epoch_00001/<game>/<exp>/instance_*/transcript.html"
+
+echo ""
+echo "=============================="
+echo "Done: $(date)"
+echo "=============================="

run_sft.sh

@@ -0,0 +1,270 @@
+#!/bin/bash
+
+#SBATCH --job-name=run_sft
+#SBATCH --mail-user=josuetf@umich.edu
+#SBATCH --mail-type=ALL
+#SBATCH --output=/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen/slurm/%x_%j.out
+#SBATCH --partition=spgpu
+#SBATCH --time=14-0:00:00
+#SBATCH --gpus=2
+#SBATCH --cpus-per-gpu=2
+#SBATCH --mem-per-gpu=48GB
+#SBATCH --account=chaijy2
+# Account chaijy2 cap: gpu=20, cpu=80, mem=960G (shared across the account).
+# Every spgpu node has 8x A40 (46GB). Training is data-parallel (DDP): every GPU
+# holds a full 4-bit copy of the model and trains on a different data shard.
+# COMMAND: sbatch run_sft.sh        (override knobs as VAR=… sbatch run_sft.sh)
+# ============================================================================
+# Supervised fine-tuning (QLoRA, 4-bit + LoRA) of Qwen3.5-27B on the pre-filtered
+# playpen SFT data (scaling_LLM_search_methods/playpen-sft-data/sft-filtered).
+#
+# This mirrors the TRAINING half of run_prm.sh: detect whatever topology Slurm
+# granted (1 node or many), hold the effective batch constant across any GPU
+# count by auto-deriving grad-accum, and launch the trainer as DDP via torchrun
+# (multi-node spans nodes with srun+torchrun; single-node uses torchrun
+# --standalone; a lone GPU uses plain python).
+#
+# Data route (DATA_ROUTE): which filtered split to train on. Both were verified
+# equal to their filter predicate and pre-split train/dev with no task leakage:
+#   positive_score -> outcome != 'aborted' AND Main Score > 0   (19,143 train)
+#   non_aborted    -> outcome != 'aborted'                      (24,711 train)
+#
+# RESUME: re-run with RESUME=1 to continue from the latest epoch checkpoint in
+# the output dir (save_strategy='epoch'). Safe on a fresh run (trains from
+# scratch if no checkpoint exists).
+# ============================================================================
+
+set -euo pipefail
+
+WORKDIR="/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/playpen"
+CONDA_ENV="playpen"
+# Model to fine-tune. Override LEARNER + HF_BASE to train a different one.
+#   default:  Qwen3.5-27B in 4-bit QLoRA.
+#   bf16 2B:  LEARNER=Qwen3.5-2B-Instruct-bf16 \
+#             HF_BASE=/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-2B \
+#             PRECISION=bf16 TRAIN_BATCH_SIZE=8 sbatch --gpus=1 run_sft.sh
+# (Keep batch modest even for small models: the causal-LM loss materializes a
+#  full-vocab logits tensor [batch x seq x ~152k], which dominates memory and
+#  scales with batch regardless of model size — batch 16 OOMs a 46GB A40.)
+LEARNER="${LEARNER:-Qwen3.5-27B-Instruct-4bit}"
+HF_BASE="${HF_BASE:-/nfs/turbo/coe-chaijy-unreplicated/pre-trained-weights/Qwen3.5-27B}"
+# Weights precision: 4bit (QLoRA, for big models on 46GB cards) or bf16 (no
+# quantization + LoRA; right for small models like the 2B that fit comfortably).
+PRECISION="${PRECISION:-4bit}"
+
+# Which filtered route to train on (positive_score | non_aborted).
+DATA_ROUTE="${DATA_ROUTE:-positive_score}"
+DATA_DIR="${DATA_DIR:-/nfs/turbo/coe-chaijy-unreplicated/josuetf/LMPlayschool/scaling_LLM_search_methods/playpen-sft-data/sft-filtered/${DATA_ROUTE}}"
+
+# Output tag: keeps THIS run's adapter in its own dir so a prior run is untouched.
+RUN_TAG="${RUN_TAG:-${DATA_ROUTE}}"
+RUN_NAME="${LEARNER}-${RUN_TAG}"          # e.g. Qwen3.5-27B-Instruct-4bit-positive_score
+MODEL_OUT="${MODEL_OUT:-models/sft/${RUN_NAME}}"
+
+# Training knobs.
+MAX_LENGTH="${MAX_LENGTH:-1024}"          # tokens/example; longer convos truncated
+# Run UNTIL CONVERGENCE: evaluate every epoch and early-stop when the val loss
+# stops improving for EARLY_STOPPING_PATIENCE epochs; the best epoch is kept.
+# MAX_EPOCHS is just a backstop cap — training almost always stops well before it.
+MAX_EPOCHS="${MAX_EPOCHS:-50}"
+EARLY_STOPPING_PATIENCE="${EARLY_STOPPING_PATIENCE:-5}"
+LEARNING_RATE="${LEARNING_RATE:-2e-4}"    # standard QLoRA LR
+# Per-device train batch. 4 fits a 27B 4-bit + LoRA on a 46GB A40 at max-length
+# 1024 (the full-vocab logits for causal-LM loss are the memory driver; batch 8
+# OOMs). grad-accum is AUTO-derived after topology detection so the effective
+# batch stays constant (TRAIN_EFFECTIVE_BATCH) for any GPU/node count.
+TRAIN_BATCH_SIZE="${TRAIN_BATCH_SIZE:-4}"
+TRAIN_GRAD_ACCUM="${TRAIN_GRAD_ACCUM:-}"
+TRAIN_EFFECTIVE_BATCH="${TRAIN_EFFECTIVE_BATCH:-128}"
+
+# Weights & Biases logging. WANDB=0 disables it (report_to=none). WANDB_PROJECT
+# groups runs; WANDB_RUN_NAME defaults to the run tag + job id. If no API key /
+# credentials are found we drop to OFFLINE mode (logs to ./wandb, sync later with
+# `wandb sync`) so a multi-day job never blocks or dies on a missing login.
+WANDB="${WANDB:-1}"
+WANDB_PROJECT="${WANDB_PROJECT:-playpen-sft}"
+WANDB_RUN_NAME="${WANDB_RUN_NAME:-${RUN_NAME}-${SLURM_JOB_ID:-local}}"
+
+cd "$WORKDIR"
+mkdir -p logs slurm
+
+# Activate conda
+source "$(conda info --base)/etc/profile.d/conda.sh"
+conda activate "$CONDA_ENV"
+
+# Ignore ~/.local user-site packages. A stale/broken `wandb` lives there and
+# user-site SHADOWS the conda env on sys.path, so without this every rank imports
+# that broken wandb when TRL calls is_wandb_available() and dies with the
+# protobuf "Descriptors cannot be created directly" error. Everything the trainer
+# needs (torch/trl/transformers/peft/datasets/wandb) is in the env, so excluding
+# user-site is safe and uses the env's healthy wandb 0.28.0.
+export PYTHONNOUSERSITE=1
+
+# --- W&B preflight: decide report backend + mode before launching ---------
+REPORT_TO="none"
+if [ "$WANDB" = "1" ]; then
+    if python -c "import wandb" 2>/dev/null; then
+        REPORT_TO="wandb"
+        export WANDB_PROJECT
+        [ -n "${WANDB_ENTITY:-}" ] && export WANDB_ENTITY
+        # Pick a mode: honor an explicit WANDB_MODE; else online only if creds
+        # exist (env key or ~/.netrc), otherwise offline so it can't block.
+        if [ -z "${WANDB_MODE:-}" ]; then
+            if [ -n "${WANDB_API_KEY:-}" ] || grep -q 'api.wandb.ai' "${HOME}/.netrc" 2>/dev/null; then
+                export WANDB_MODE=online
+            else
+                export WANDB_MODE=offline
+                echo "NOTE: no W&B credentials found -> WANDB_MODE=offline (logs to ./wandb;"
+                echo "      run 'wandb login' then 'wandb sync wandb/offline-run-*' to upload)."
+            fi
+        else
+            export WANDB_MODE
+        fi
+        echo "W&B:       project=$WANDB_PROJECT  run=$WANDB_RUN_NAME  mode=$WANDB_MODE"
+    else
+        echo "NOTE: WANDB=1 but the 'wandb' package isn't importable -> logging disabled."
+    fi
+fi
+
+# Curb CUDA reserved-pool fragmentation so the high-water mark tracks live usage.
+export PYTORCH_CUDA_ALLOC_CONF="${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}"
+
+# ------------------------------------------------------------------
+# Cluster topology — adapt to WHATEVER Slurm granted (1 node or many). DDP fans
+# out over $WORLD_GPUS = $NNODES x $GPUS_PER_NODE. Multi-node reaches other nodes
+# via srun (bash `&` can't); single node keeps the local fan-out. Outside Slurm
+# -> 1 local node. (Same derivation as run_prm.sh.)
+# ------------------------------------------------------------------
+if [ -n "${SLURM_JOB_ID:-}" ]; then
+    NNODES="${SLURM_NNODES:-1}"
+    # Derive the TOTAL GPU count from scontrol (AllocTRES gres/gpu=N), not
+    # SLURM_GPUS_ON_NODE — with `--gpus=N` (a per-JOB total) the latter is
+    # unreliable (often 1), which silently under-uses GPUs and shrinks the
+    # effective batch.
+    total_gpus="$(scontrol show job "$SLURM_JOB_ID" 2>/dev/null \
+                   | grep -oE 'gres/gpu=[0-9]+' | head -1 | grep -oE '[0-9]+')"
+    [ -n "$total_gpus" ] || total_gpus="${SLURM_GPUS:-}"
+    total_gpus="${total_gpus##*:}"   # "a40:8" -> "8"
+    case "$total_gpus" in ''|*[!0-9]*) total_gpus=$(( ${SLURM_GPUS_ON_NODE:-$(nvidia-smi -L 2>/dev/null | wc -l)} * NNODES )) ;; esac
+    GPUS_PER_NODE=$(( total_gpus / NNODES ))
+    HEAD_NODE="$(scontrol show hostnames "${SLURM_JOB_NODELIST:-}" 2>/dev/null | head -1)"
+else
+    NNODES=1
+    GPUS_PER_NODE="$(nvidia-smi -L 2>/dev/null | wc -l)"
+    HEAD_NODE="$(hostname)"
+fi
+case "$GPUS_PER_NODE" in ''|*[!0-9]*) GPUS_PER_NODE=1 ;; esac
+[ "$GPUS_PER_NODE" -ge 1 ] || GPUS_PER_NODE=1
+[ -n "$HEAD_NODE" ] || HEAD_NODE="$(hostname)"
+WORLD_GPUS=$(( NNODES * GPUS_PER_NODE ))
+RDZV_PORT="${RDZV_PORT:-29501}"
+if [ "$NNODES" -gt 1 ]; then MULTINODE=1; else MULTINODE=0; fi
+
+# Multi-node: probe each node's ACTUAL allocated GPU count (same srun pattern the
+# training launch uses) and sum them for the AUTHORITATIVE world size. This makes
+# UNEVEN splits correct even when the total isn't divisible by NNODES (e.g. 5+3,
+# or 5+2=7): the even-split GPUS_PER_NODE above would otherwise mis-derive
+# WORLD_GPUS and skew the effective batch. torchrun still uses each node's own
+# local count ($lg) below, so the per-node nproc is always exact.
+if [ "$MULTINODE" -eq 1 ]; then
+    _probe="$(srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+                 bash -c 'nvidia-smi -L 2>/dev/null | wc -l' 2>/dev/null || true)"
+    _acc=0
+    while read -r _cnt; do
+        case "${_cnt:-}" in ''|*[!0-9]*) continue ;; esac
+        _acc=$(( _acc + _cnt ))
+    done <<< "$_probe"
+    [ "$_acc" -ge 1 ] && WORLD_GPUS="$_acc"   # authoritative total across uneven nodes
+fi
+
+# Hold the effective batch constant across any GPU count:
+#   effective = per_device_batch * WORLD_GPUS * grad_accum
+if [ -z "$TRAIN_GRAD_ACCUM" ]; then
+    TRAIN_GRAD_ACCUM=$(( TRAIN_EFFECTIVE_BATCH / (TRAIN_BATCH_SIZE * WORLD_GPUS) ))
+    [ "$TRAIN_GRAD_ACCUM" -ge 1 ] || TRAIN_GRAD_ACCUM=1
+fi
+
+echo "=============================="
+echo "Job ID:    ${SLURM_JOB_ID:-<direct>}"
+echo "Node:      ${SLURMD_NODENAME:-$(hostname)}"
+echo "GPUs:"
+nvidia-smi --query-gpu=index,name,memory.total,memory.used,memory.free --format=csv
+echo "Topology:  ${NNODES} node(s) x ${GPUS_PER_NODE} GPU = ${WORLD_GPUS} GPUs  (multinode=${MULTINODE}, head=${HEAD_NODE})"
+echo "Data:      $DATA_DIR  (route=$DATA_ROUTE)"
+echo "Model:     $LEARNER  ($PRECISION)  <- $HF_BASE"
+echo "Output:    $MODEL_OUT"
+echo "Train:     per_device=${TRAIN_BATCH_SIZE} x world=${WORLD_GPUS} x grad_accum=${TRAIN_GRAD_ACCUM} = $(( TRAIN_BATCH_SIZE * WORLD_GPUS * TRAIN_GRAD_ACCUM )) effective batch"
+echo "           max_length=${MAX_LENGTH}  max_epochs=${MAX_EPOCHS} (early-stop patience=${EARLY_STOPPING_PATIENCE})  lr=${LEARNING_RATE}"
+echo "Started:   $(date)"
+echo "=============================="
+
+[ -d "$DATA_DIR/train" ] || { echo "ERROR: no train/ split at $DATA_DIR"; exit 1; }
+
+# ------------------------------------------------------------------
+# SFT training — DATA-PARALLEL (DDP) across the WHOLE allocation. Every GPU holds
+# a full 4-bit copy and trains on a different data shard. Effective batch is held
+# at TRAIN_EFFECTIVE_BATCH by the auto-derived grad_accum, so the optimization is
+# identical no matter how many GPUs/nodes Slurm granted.
+# ------------------------------------------------------------------
+train_args=(
+    --data-dir "$DATA_DIR"
+    --model "$HF_BASE"
+    --output "$MODEL_OUT"
+    --per-device-batch-size "$TRAIN_BATCH_SIZE"
+    --gradient-accumulation-steps "$TRAIN_GRAD_ACCUM"
+    --max-length "$MAX_LENGTH"
+    --max-epochs "$MAX_EPOCHS"
+    --early-stopping-patience "$EARLY_STOPPING_PATIENCE"
+    --learning-rate "$LEARNING_RATE"
+    --report-to "$REPORT_TO"
+    --run-name "$WANDB_RUN_NAME"
+)
+# bf16 precision -> load unquantized + LoRA (no 4-bit). Right for small models.
+[ "$PRECISION" = "bf16" ] && train_args+=(--no-4bit)
+# Fast smoke test: LIMIT_TRAIN_SAMPLES=256 MAX_EPOCHS=1 sbatch --gpus=1 ... run_sft.sh
+[ -n "${LIMIT_TRAIN_SAMPLES:-}" ] && train_args+=(--limit-train-samples "$LIMIT_TRAIN_SAMPLES")
+[ "${RESUME:-0}" = "1" ] && train_args+=(--resume)
+
+echo ""
+echo "=== SFT Training: QLoRA (4-bit + LoRA) as DDP across $WORLD_GPUS GPU(s) on $NNODES node(s) ==="
+# Per-RUN log so concurrent SFT runs (e.g. 27B + 2B) don't clobber each other's
+# output. sft_progress.sh finds it from this run's Output dir.
+TRAIN_LOG="logs/sft_${RUN_NAME}.log"
+echo "Train log: $TRAIN_LOG"
+train_fail=0
+if [ "$MULTINODE" -eq 1 ]; then
+    # One agent per node (srun -> 1 task/node, --gpu-bind=none so the task sees
+    # ALL that node's GPUs). Each node runs torchrun with ITS OWN local GPU count
+    # (nvidia-smi), so an uneven split (e.g. 5+3) still rendezvous-sums to the
+    # global world size. Training args after `-c bash` arrive as "$@".
+    srun --ntasks="$NNODES" --ntasks-per-node=1 --gpu-bind=none \
+        bash -c 'lg=$(nvidia-smi -L 2>/dev/null | wc -l); [ "$lg" -ge 1 ] || lg=1
+                 exec torchrun --nnodes='"$NNODES"' --nproc-per-node="$lg" \
+                      --rdzv-backend=c10d --rdzv-id='"$SLURM_JOB_ID"' \
+                      --rdzv-endpoint='"$HEAD_NODE:$RDZV_PORT"' \
+                      examples/trl/sft_train_from_filtered.py "$@"' \
+        bash "${train_args[@]}" \
+        > "$TRAIN_LOG" 2>&1 || train_fail=1
+elif [ "$WORLD_GPUS" -gt 1 ]; then
+    # Single node, multiple GPUs: standalone DDP.
+    torchrun --standalone --nnodes=1 --nproc-per-node="$GPUS_PER_NODE" \
+             examples/trl/sft_train_from_filtered.py "${train_args[@]}" \
+        > "$TRAIN_LOG" 2>&1 || train_fail=1
+else
+    python examples/trl/sft_train_from_filtered.py "${train_args[@]}" \
+        > "$TRAIN_LOG" 2>&1 || train_fail=1
+fi
+
+if [ "$train_fail" -ne 0 ]; then
+    echo "  SFT training: FAILED (see $TRAIN_LOG)"
+    tail -n 30 "$TRAIN_LOG" 2>/dev/null | sed 's/^/    /' || true
+    exit 1
+fi
+
+echo "  SFT training: OK"
+echo ""
+echo "Training finished at: $(date)"
+echo "Adapter saved to:     $MODEL_OUT"
+echo "=============================="
+echo "Done: $(date)"
+echo "=============================="