Blame for code/policy_dist.py

#!/usr/bin/env python
"""T4 mechanism analysis: move-level policy evolution SFT -> RL (App. H of
arXiv:2607.16097), replicated at reduced scale.

For each puzzle and each checkpoint (SFT and RL steps), estimate the
root-conditioned marginal move policy pi(a|s) by Monte Carlo over traces:
  1. Sample K thinking traces with the verl protocol (fixed 1024-token
     thinking budget, premature </T> replaced by <sep>, forced </T> at the
     budget) -- the same rollout pipeline the authors used for both SFT and
     RL checkpoints.
  2. For each trace r_k, score every legal move a by the product of token
     probabilities of a's LAN serialization given (s, r_k) (teacher-forced,
     KV-cached forward passes).
  3. pi_hat(a|s) = (1/K) * sum_k pi(a|s, r_k), normalized over legal moves.

Then categorize the SFT -> RL policy change per puzzle (Table 13, top_k=3,
eps_tail=0.05): ground-truth amplification, tail discovery, top-k correction,
ground-truth regression, wrong-mode amplification, other. Report fractions by
difficulty bin (easy B1 vs hard B4/B5).

No-arg invocation = default analysis (SFT 20m_5.3B vs RL steps 100/300/500,
puzzles from B1 + B4 + B5).
"""
import argparse
import json
import os
import re
import sys

import torch
import chess
import numpy as np
from huggingface_hub import hf_hub_download, snapshot_download
from transformers import AutoModelForCausalLM, AutoTokenizer

BENCH_REPO = "pavelslab-nyu/chess_puzzle_benchmark"
RESULTS_REPO = "ML-Intern-lab/pre2post-chess-replication"
BOS, EOS, T_END, SEP, CALL_ENV = 0, 1, 82, 83, 84

LAN_RE = re.compile(r"^([KQRBNP])([a-h][1-8])(x?)([a-h][1-8])(=([QRBN]))?$")


def load_benchmark(bins, limit_per_bin, seed=0):
    import pandas as pd
    frames = []
    for b in bins:
        f = hf_hub_download(BENCH_REPO, f"think/test_{b}.parquet", repo_type="dataset")
        df = pd.read_parquet(f)
        if limit_per_bin:
            df = df.sample(n=min(limit_per_bin, len(df)), random_state=seed)
        frames.append(df)
    df = pd.concat(frames, ignore_index=True)

    def _gt(v):
        return list(v) if isinstance(v, list) else list(eval(v))
    df["gt"] = df["reward_model"].apply(lambda r: _gt(r["ground_truth"]))
    df["fen"] = df["extra_info"].apply(lambda r: r["FEN"])
    df["bin"] = df["data_source"]
    return df


class Adapter:
    def __init__(self, tok):
        self.custom = tok.custom_tokenizer
        self.vocab = self.custom._tok2id

    def encode_prompt(self, prompt):
        return list(self.custom.encode(prompt))

    def lan_ids(self, lan):
        return [self.vocab[t] for t in self.custom._lan_move_to_tokens(lan)]

    def decode(self, ids):
        return self.custom.decode(list(ids))


def legal_lan_moves(board):
    """LAN serializations of all legal moves (piece letter as on the board)."""
    out = {}
    for mv in board.legal_moves:
        p = board.piece_at(mv.from_square)
        piece = p.symbol().upper() if p else "P"
        frm = chess.square_name(mv.from_square)
        to = chess.square_name(mv.to_square)
        cap = "x" if board.is_capture(mv) else ""
        lan = f"{piece}{frm}{cap}{to}"
        if mv.promotion:
            lan += "=" + chess.piece_symbol(mv.promotion).upper()
        out[mv.uci()] = lan
    return out


def strip_pads(ids):
    if EOS in ids:
        ids = ids[: ids.index(EOS) + 1]
    while ids and ids[-1] == BOS:
        ids = ids[:-1]
    return ids


@torch.no_grad()
def gen_round(model, contexts, max_new, stop_ids, temp, device):
    maxlen = max(len(c) for c in contexts)
    input_ids = torch.full((len(contexts), maxlen), BOS, dtype=torch.long)
    attn = torch.zeros((len(contexts), maxlen), dtype=torch.long)
    for j, c in enumerate(contexts):
        input_ids[j, maxlen - len(c):] = torch.tensor(c)
        attn[j, maxlen - len(c):] = 1
    input_ids, attn = input_ids.to(device), attn.to(device)
    out = model.generate(input_ids=input_ids, attention_mask=attn,
                         max_new_tokens=max_new, do_sample=temp > 0,
                         temperature=max(temp, 1e-5), use_cache=True,
                         pad_token_id=BOS,
                         eos_token_id=stop_ids if stop_ids else None)
    return [strip_pads(out[j, maxlen:].tolist()) for j in range(len(contexts))]


@torch.no_grad()
def sample_traces(model, adapter, prompt, K, thinking_budget, round_sz, temp, device):
    """K thinking traces via the verl forced-budget procedure."""
    base = adapter.encode_prompt(prompt)
    ctx = [list(base) for _ in range(K)]
    used = [0] * K
    done = [False] * K
    while not all(done):
        act = [i for i in range(K) if not done[i]]
        gens = gen_round(model, [ctx[i] for i in act], round_sz, [T_END, EOS], temp, device)
        for j, i in enumerate(act):
            toks = gens[j][: thinking_budget - used[i]]
            if not toks:
                ctx[i] += [T_END]; used[i] += 1; done[i] = True; continue
            used[i] += len(toks)
            if toks[-1] == T_END:
                if used[i] < thinking_budget:
                    ctx[i] += toks[:-1] + [SEP]
                else:
                    ctx[i] += toks
                    done[i] = True
            elif toks[-1] == EOS:
                ctx[i] += toks + [T_END]
                done[i] = True
            else:
                ctx[i] += toks
                if used[i] >= thinking_budget:
                    ctx[i] += [T_END]
                    done[i] = True
    for i in range(K):
        if ctx[i][-1] != T_END:
            ctx[i] += [T_END]
    return [ctx[i][len(base):] for i in range(K)]  # trace token lists


@torch.no_grad()
def move_probs_given_trace(model, adapter, base_ids, trace_ids, board, device):
    """pi(a|s,r) for all legal moves: one teacher-forced forward per move
    (prefix + move tokens, batch=1), gathering the move tokens' logprobs."""
    vocab = adapter.vocab
    prefix = list(base_ids) + list(trace_ids)
    prefix_t = torch.tensor([prefix], dtype=torch.long, device=device)
    moves = legal_lan_moves(board)
    logps = {}
    for uci, lan in moves.items():
        toks = [vocab[t] for t in adapter.custom._lan_move_to_tokens(lan)]
        ids = torch.tensor([prefix + toks], dtype=torch.long, device=device)
        logits = model(input_ids=ids).logits[0]  # (L, V)
        # logprob of token t at position i comes from logits at position i-1
        lp = 0.0
        for j, t in enumerate(toks):
            pos = len(prefix) - 1 + j
            lp += torch.log_softmax(logits[pos].float(), dim=-1)[t].item()
        logps[uci] = lp
    ucis = list(logps)
    arr = np.array([logps[u] for u in ucis])
    arr = arr - arr.max()
    p = np.exp(arr)
    p = p / p.sum()
    return {u: float(pi) for u, pi in zip(ucis, p)}


def categorize(p_sft, p_rl, gt_uci, top_k=3, eps_tail=0.05):
    def topk(p):
        return set(u for u, _ in sorted(p.items(), key=lambda kv: -kv[1])[:top_k])
    t0, t1 = topk(p_sft), topk(p_rl)
    gt = gt_uci
    d = p_rl.get(gt, 0.0) - p_sft.get(gt, 0.0)
    wrong0 = max(p_sft, key=p_sft.get)
    if gt in t0 and gt in t1 and d > 0:
        return "gt_amplification"
    if gt not in t0 and gt in t1 and p_sft.get(gt, 0.0) < eps_tail:
        return "tail_discovery"
    if gt not in t0 and gt in t1:
        return "topk_correction"
    if gt in t0 and gt not in t1:
        return "gt_regression"
    if gt not in t0 and gt not in t1 and wrong0 in t1 and d != 0 and \
            p_rl.get(wrong0, 0.0) > p_sft.get(wrong0, 0.0):
        return "wrong_mode_amplification"
    return "other"


CHECKPOINTS = [
    ("sft", "pavelslab-nyu/Chess-SFT-Models", "model_20m_5.3B"),
    ("rl_100", "Pre2Post-Chess-RL/Chess-RL-Models", "model_20m_5.3B/global_step_100"),
    ("rl_300", "Pre2Post-Chess-RL/Chess-RL-Models", "model_20m_5.3B/global_step_300"),
    ("rl_500", "Pre2Post-Chess-RL/Chess-RL-Models", "model_20m_5.3B/global_step_500"),
]


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--bins", nargs="+", default=["B1", "B4", "B5"])
    ap.add_argument("--limit-per-bin", type=int, default=12)
    ap.add_argument("--k-traces", type=int, default=12)
    ap.add_argument("--thinking-budget", type=int, default=1024)
    ap.add_argument("--round", type=int, default=256)
    ap.add_argument("--temp", type=float, default=1.0)
    ap.add_argument("--seed", type=int, default=0)
    ap.add_argument("--out", default="/work/results/t4_mechanism.json")
    args = ap.parse_args()
    torch.manual_seed(args.seed)

    df = load_benchmark(args.bins, args.limit_per_bin, args.seed)
    print(f"T4: {len(df)} puzzles x {len(CHECKPOINTS)} checkpoints, "
          f"K={args.k_traces} traces", flush=True)

    policies = {}  # (ckpt, puzzle) -> {uci: prob}
    for name, repo, sub in CHECKPOINTS:
        local = snapshot_download(repo, allow_patterns=f"{sub}/*")
        path = os.path.join(local, sub)
        device = "cuda" if torch.cuda.is_available() else "cpu"
        model = AutoModelForCausalLM.from_pretrained(path, trust_remote_code=True).to(device).eval()
        tok = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
        adapter = Adapter(tok)
        for _, row in df.iterrows():
            base = adapter.encode_prompt(row["prompt"])
            traces = sample_traces(model, adapter, row["prompt"], args.k_traces,
                                   args.thinking_budget, args.round, args.temp, device)
            board = chess.Board(row["fen"])
            acc = None
            for tr in traces:
                p = move_probs_given_trace(model, adapter, base, tr, board, device)
                if acc is None:
                    acc = {u: v for u, v in p.items()}
                else:
                    for u in acc:
                        acc[u] += p.get(u, 0.0)
            acc = {u: v / len(traces) for u, v in acc.items()}
            policies[(name, row["extra_info"]["PuzzleId"])] = acc
            print(f"[{name}] {row['extra_info']['PuzzleId']} ({row['bin']}) done", flush=True)
        del model
        torch.cuda.empty_cache()

    # categorize SFT -> RL per puzzle
    cats = {}
    for _, row in df.iterrows():
        pid = row["extra_info"]["PuzzleId"]
        gt = row["gt"][0]
        p_sft = policies[("sft", pid)]
        for name, _, _ in CHECKPOINTS[1:]:
            cats.setdefault(name, {}).setdefault(row["bin"], {}).setdefault("counts", {})
            c = categorize(p_sft, policies[(name, pid)], gt)
            counts = cats[name][row["bin"]]["counts"]
            counts[c] = counts.get(c, 0) + 1

    out = {"config": vars(args), "policies": {f"{k[0]}|{k[1]}": v for k, v in policies.items()},
           "categories": cats}
    os.makedirs(os.path.dirname(args.out) or ".", exist_ok=True)
    with open(args.out, "w") as f:
        json.dump(out, f)
    print(json.dumps(cats, indent=2), flush=True)
    try:
        from huggingface_hub import HfApi
        HfApi().upload_file(path_or_fileobj=args.out, path_in_repo="results/t4_mechanism.json",
                            repo_id=RESULTS_REPO, repo_type="dataset")
        print("[upload] t4_mechanism.json", flush=True)
    except Exception as e:
        print(f"[upload] FAILED: {e}", flush=True)


if __name__ == "__main__":
    main()