chess-sim/code/sim/rl_train.py

"""RL fine-tuning of SmolVLA in the chess simulator (PPO over action chunks, ReinFlow-style noise).

One decision = one 50-step action chunk (sim/rl_env.py). Each iteration collects --episodes
episodes from --envs simulators in parallel on training scenes (--train-seed, episodes never used
by any test), computes advantages over the chunks of each episode (GAE), then updates the action
expert and the critic (sim/rl_policy.py; the noise sizes too with --learn-sigma) with PPO. Every
element of the denoising chain (step x timestep x joint) has its own clipped likelihood ratio, as
tokens do in language-model PPO: with the small noise of the last denoising steps, the probability
of a whole step (300 values) changes by hundreds of nats after a single small update
(sim/reports/rl/check). The first --critic-warmup iterations train only the critic.

Every --val-every iterations (and before the first update) the policy runs without noise on a
fixed set of validation scenes (--val-seed): the learning curve on scenes the updates never saw.
Checkpoints: <out>/iter_XXXX, <out>/last and <out>/best (best validation success; a later iteration
wins ties). log.jsonl has one line per iteration.

Run (pod):  MUJOCO_GL=egl PHASE2_PROFILE=baseline SIM_OFFSAMPLES=0 .venv/bin/python sim/rl_train.py \
                --policy models/baseline --out outputs/rl_pilot --iterations 30
"""
from __future__ import annotations

import argparse
import json
import sys
import time
from pathlib import Path

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))


def run_episodes(pol, venv, seed: int, indices: list[int], noise: bool, early_stop: bool, check_expert: bool,
                 record: bool, eval_noise_seeds: bool = False, measure: bool = True):
    """Run episodes (seed, index) on the vector env with the current policy. Returns the finished
    episodes: dict(info, decisions=[...], ret, ...). Each decision keeps what PPO needs when record."""
    import numpy as np
    import torch

    todo = list(indices)
    active, episodes = {}, []
    free = list(range(venv.n))
    timing = run_episodes.timing = dict(prep=0.0, sample=0.0, env=0.0, reset=0.0, rounds=0)

    def start(workers):
        jobs = {}
        for w in workers:
            if todo:
                jobs[w] = dict(seed=seed, index=todo.pop(0), check_expert=check_expert, early_stop=early_stop,
                               measure=measure)
        for w, (obs, info) in venv.reset_many(jobs).items():
            gen = None
            if eval_noise_seeds:                       # the same x_0 draws as eval_policy.py
                gen = torch.Generator(device=pol.device)
                gen.manual_seed(info["torch_seed"])
            active[w] = dict(obs=obs, info=info, decisions=[], ret=0.0, gen=gen)
        return [w for w in workers if w not in jobs]

    t = time.time()
    free = start(free)
    timing["reset"] += time.time() - t
    while active:
        ws = sorted(active)
        t0 = time.time()
        batch = pol.batch([active[w]["obs"] for w in ws])
        gens = [active[w]["gen"] for w in ws] if eval_noise_seeds else None
        x0 = pol.x0(len(ws), gens)
        t1 = time.time()
        chain, logp, value, prefix = pol.sample(batch, x0, noise=noise)
        acts = pol.actions(chain)
        t2 = time.time()
        results = venv.step_many({w: acts[j] for j, w in enumerate(ws)})
        t3 = time.time()
        timing["prep"] += t1 - t0
        timing["sample"] += t2 - t1
        timing["env"] += t3 - t2
        timing["rounds"] += 1
        for j, w in enumerate(ws):
            nxt, rew, done, info = results[w]
            ep = active[w]
            if record:
                ep["decisions"].append(dict(prefix=pol.split_prefix(prefix, j), chain=chain[j].cpu(), logp=logp[j].cpu(),
                                            value=float(value[j]), reward=float(rew)))
            ep["ret"] += float(rew)
            if done:
                ep["result"] = info
                ep.pop("obs")
                ep.pop("gen")
                episodes.append(ep)
                del active[w]
                free.append(w)
            else:
                ep["obs"] = nxt
        t = time.time()
        free = start(free)
        timing["reset"] += time.time() - t
    return episodes


def gae(episodes, gamma: float, lam: float):
    for ep in episodes:
        adv, nxt_v = 0.0, 0.0                          # every episode ends (success, failure or time limit)
        for d in reversed(ep["decisions"]):
            delta = d["reward"] + gamma * nxt_v - d["value"]
            adv = delta + gamma * lam * adv
            d["adv"], d["ret"] = adv, adv + d["value"]
            nxt_v = d["value"]


def summarize(episodes, prefix=""):
    import numpy as np

    n = len(episodes)
    r = [e["result"] for e in episodes]
    out = {f"{prefix}episodes": n, f"{prefix}success": round(sum(x["success"] for x in r) / max(n, 1), 4),
           f"{prefix}return": round(float(np.mean([e["ret"] for e in episodes])), 4) if n else None,
           f"{prefix}clean_lift": round(sum(x["clean_lift"] for x in r) / max(n, 1), 4),
           f"{prefix}disturbed": round(sum(x["end"] == "disturbed" for x in r) / max(n, 1), 4),
           f"{prefix}toppled": round(sum(x["end"] == "toppled" for x in r) / max(n, 1), 4)}
    for kind in ("pawn", "knight"):
        k = [e for e in episodes if e["info"]["piece"] == kind]
        out[f"{prefix}success_{kind}"] = round(sum(e["result"]["success"] for e in k) / max(len(k), 1), 4)
    close = [x["close_lateral_mm"] for x in r if x.get("close_lateral_mm") is not None]
    out[f"{prefix}close_mm_median"] = round(float(np.median(close)), 2) if close else None
    return out


def ppo_update(pol, opt, decisions, args, policy_on: bool):
    import numpy as np
    import torch

    adv = torch.tensor([d["adv"] for d in decisions], dtype=torch.float32)
    adv = (adv - adv.mean()) / (adv.std() + 1e-8)
    ret = torch.tensor([d["ret"] for d in decisions], dtype=torch.float32)
    old = torch.stack([d["logp"] for d in decisions])                      # (N, n_steps, T, A)
    stats = dict(kl=[], clipfrac=[], pg_loss=[], v_loss=[], grad_norm=[])
    trained = [p for p in pol.parameters() if p.requires_grad]
    stop = False
    for epoch in range(args.epochs):
        perm = np.random.permutation(len(decisions))
        for s in range(0, len(perm), args.minibatch):
            idx = perm[s:s + args.minibatch]
            prefix = pol.stack_prefix([decisions[i]["prefix"] for i in idx])     # as at sampling time
            chain = torch.stack([decisions[i]["chain"] for i in idx]).to(pol.device)
            logp, value = pol.evaluate(None, chain, prefix=prefix)
            a = adv[idx].to(pol.device)[:, None, None, None]
            log_ratio = (logp - old[idx].to(pol.device)).clamp(-20, 20)
            ratio = log_ratio.exp()
            pg = -torch.min(ratio * a, ratio.clamp(1 - args.clip, 1 + args.clip) * a).mean()
            v_loss = 0.5 * ((value - ret[idx].to(pol.device)) ** 2).mean()
            loss = (pg if policy_on else 0.0 * pg) + args.vf_coef * v_loss
            opt.zero_grad(set_to_none=True)
            loss.backward()
            gn = torch.nn.utils.clip_grad_norm_(trained, args.max_grad_norm)
            if not policy_on:                          # critic warm-up: leave the policy and noise untouched
                for p in pol.policy_params() + [pol.log_sigma]:
                    p.grad = None
            opt.step()
            with torch.no_grad():
                kl = ((ratio - 1) - log_ratio).mean().item()
                stats["kl"].append(kl)
                stats["clipfrac"].append(((ratio - 1).abs() > args.clip).float().mean().item())
                stats["pg_loss"].append(pg.item())
                stats["v_loss"].append(v_loss.item())
                stats["grad_norm"].append(float(gn))
        if policy_on and np.mean(stats["kl"][-max(1, len(perm) // args.minibatch):]) > args.target_kl:
            stop = True
            break
    out = {k: round(float(np.mean(v)), 5) for k, v in stats.items() if v}
    out["epochs_done"] = epoch + 1
    out["kl_stop"] = stop
    return out


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument("--policy", required=True)
    ap.add_argument("--out", required=True)
    ap.add_argument("--iterations", type=int, default=30)
    ap.add_argument("--envs", type=int, default=10)
    ap.add_argument("--episodes", type=int, default=100, help="episodes per iteration")
    ap.add_argument("--train-seed", type=int, default=7_700_003)
    ap.add_argument("--val-seed", type=int, default=9_300_003)
    ap.add_argument("--val-episodes", type=int, default=60)
    ap.add_argument("--val-every", type=int, default=5)
    ap.add_argument("--save-every", type=int, default=5)
    ap.add_argument("--seconds", type=float, default=20.0)
    ap.add_argument("--lr", type=float, default=3e-7)
    ap.add_argument("--sigma-lr", type=float, default=3e-3)
    ap.add_argument("--critic-lr", type=float, default=3e-4)
    ap.add_argument("--sigma-start", type=float, default=0.2, help="noise size at the first denoising step")
    ap.add_argument("--sigma-end", type=float, default=0.002, help="noise size at the last denoising step")
    ap.add_argument("--learn-sigma", action="store_true", help="train the noise sizes too (default: fixed schedule)")
    ap.add_argument("--expert-bf16", action="store_true", help="keep the action expert in bfloat16 (default float32)")
    ap.add_argument("--gamma", type=float, default=0.99)
    ap.add_argument("--lam", type=float, default=0.95)
    ap.add_argument("--clip", type=float, default=0.2)
    ap.add_argument("--epochs", type=int, default=2)
    ap.add_argument("--minibatch", type=int, default=16)
    ap.add_argument("--target-kl", type=float, default=0.02, help="per-element approximate KL")
    ap.add_argument("--vf-coef", type=float, default=0.5)
    ap.add_argument("--max-grad-norm", type=float, default=1.0)
    ap.add_argument("--critic-warmup", type=int, default=1)
    ap.add_argument("--torch-threads", type=int, default=2,
                    help="CPU threads of this process; its idle thread pool otherwise spins and starves the simulators")
    args = ap.parse_args()

    import numpy as np
    import torch

    torch.set_num_threads(args.torch_threads)

    from episode import load_config
    from rl_env import REWARD, VecChessEnv
    from rl_policy import FlowRL

    out = Path(args.out)
    out.mkdir(parents=True, exist_ok=True)
    (out / "args.json").write_text(json.dumps(dict(vars(args), reward=REWARD), indent=1))
    cfg = load_config()
    torch.manual_seed(0)
    np.random.seed(0)
    pol = FlowRL(args.policy, cfg["dataset"]["instruction"], args.sigma_start, args.sigma_end,
                 learn_sigma=args.learn_sigma, expert_fp32=not args.expert_bf16)
    groups = [dict(params=pol.policy_params(), lr=args.lr), dict(params=list(pol.critic.parameters()), lr=args.critic_lr)]
    if args.learn_sigma:
        groups.append(dict(params=[pol.log_sigma], lr=args.sigma_lr))
    opt = torch.optim.AdamW(groups, weight_decay=0.0)
    venv = VecChessEnv(args.envs, cfg, args.seconds)
    log = (out / "log.jsonl").open("a")
    val_indices = list(range(args.val_episodes))
    best = -1.0

    def validate(it):
        nonlocal best
        t0 = time.time()
        eps = run_episodes(pol, venv, args.val_seed, val_indices, noise=False, early_stop=False, check_expert=False,
                           record=False)
        s = summarize(eps, "val_")
        s["val_seconds"] = round(time.time() - t0, 1)
        if s["val_success"] >= best and it > 0:
            best = s["val_success"]
            pol.save(out / "best", dict(iteration=it, val=s))
        return s

    try:
        row = dict(iteration=0, **validate(0))
        print(json.dumps(row), flush=True)
        log.write(json.dumps(row) + "\n")
        log.flush()
        next_index = 0
        for it in range(1, args.iterations + 1):
            t0 = time.time()
            idx = list(range(next_index, next_index + args.episodes))
            next_index += args.episodes
            eps = run_episodes(pol, venv, args.train_seed, idx, noise=True, early_stop=True, check_expert=False, record=True,
                               measure=False)
            t_roll = time.time() - t0
            timing = {k: round(v, 1) for k, v in run_episodes.timing.items()}
            gae(eps, args.gamma, args.lam)
            decisions = [d for e in eps for d in e["decisions"]]
            upd = ppo_update(pol, opt, decisions, args, policy_on=it > args.critic_warmup)
            row = dict(iteration=it, decisions=len(decisions), rollout_s=round(t_roll, 1), rollout_parts=timing,
                       update_s=round(time.time() - t0 - t_roll, 1), sigma_mean=round(float(pol.sigma().mean()), 5),
                       **summarize(eps, "train_"), **upd)
            if it % args.val_every == 0 or it == args.iterations:
                row.update(validate(it))
            if it % args.save_every == 0:
                pol.save(out / f"iter_{it:04d}", dict(iteration=it))
            print(json.dumps(row), flush=True)
            log.write(json.dumps(row) + "\n")
            log.flush()
        pol.save(out / "last", dict(iteration=args.iterations))
    finally:
        venv.close()


if __name__ == "__main__":
    main()