alea/rl_env.py

"""Environment-driver RL for Alea: GRPO over decision points.

Maintains parallel episodes across registered envs. At every decision point
the env emits (state, questions); the action question (qid="act") is policy-
sampled, report questions are scored supervised against env oracle targets.

Dense envs (env.dense): exact per-action reward vector -> GRPO group of k
samples per decision, advantage = (r - mean)/std, no branching needed.
Outcome envs: single-sample actions; when an episode ends its stored
decisions are REPLAYED in a fresh forward and the (normalized) episode
return is applied as advantage on each taken-action logp. Replay terms are
backwarded separately from same-step terms to keep graphs disjoint.

Usage:
  python -m alea.rl_env --envs hmm,kelly,newsvendor,bandit,nim \
      --init runs/sft_v1/final.pt --steps 2000 --eps-per-env 6
"""
import argparse
import os
import random
import time

import numpy as np
import torch
import torch.nn.functional as F

from .envs import make, ACT_QID
from .losses import bernoulli_brier, choice_loss, crps_loss, pinball_loss
from .heads import TAUS
from .model import AleaModel, collate_segments, mask_from_segments
from .packing import pack_request
from .train import load_into, save_ckpt, set_freeze

_ANOM = os.environ.get("ANOMALY")


class _Args:
    pass


def report_loss(qres_list, oracle, report_w):
    """Supervised proper-scoring loss on non-action questions."""
    losses = []
    for r in qres_list:
        if r["qid"] == ACT_QID or r["qid"] not in oracle:
            continue
        q = oracle[r["qid"]]
        dev = r.get("logits", r.get("p_yes")).device
        if r["qtype"] in ("choice", "score"):
            qt = torch.tensor(q, device=dev).float()
            fn = choice_loss if r["qtype"] == "choice" else crps_loss
            losses.append(report_w * fn(r["logits"][None], qt[None]))
        elif r["qtype"] == "noul":
            qt = torch.tensor(float(q), device=dev)
            losses.append(report_w * bernoulli_brier(
                torch.logit(r["p_yes"].clamp(1e-6, 1 - 1e-6))[None],
                qt[None]))
        elif r["qtype"] == "regress":
            qt = torch.tensor(q, device=dev).float()
            losses.append(report_w * pinball_loss(
                r["quantiles"][None], qt[None], TAUS))
    return losses


def act_kl(logits_p, logits_r):
    logp = F.log_softmax(logits_p.float(), -1)
    logr = F.log_softmax(logits_r.float(), -1)
    p = logp.exp()
    return (p * (logp - logr)).sum()


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--envs", default="hmm,kelly,newsvendor,bandit,nim")
    ap.add_argument("--init", required=True)
    ap.add_argument("--out", default="runs/rl_env")
    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
    ap.add_argument("--steps", type=int, default=800)
    ap.add_argument("--eps-per-env", type=int, default=16,
                    help="parallel episodes per env type")
    ap.add_argument("--max-batch", type=int, default=24,
                    help="cap decisions packed into a single forward")
    ap.add_argument("--k", type=int, default=8,
                    help="GRPO samples per dense decision")
    ap.add_argument("--beta", type=float, default=0.05)
    ap.add_argument("--report-w", type=float, default=1.0,
                    help="weight of supervised report-question loss")
    ap.add_argument("--lr", type=float, default=5e-6)
    ap.add_argument("--lr-head", type=float, default=2e-5)
    ap.add_argument("--lr-aux", type=float, default=1e-4)
    ap.add_argument("--train-mode", default="tail",
                    choices=["heads", "tail", "full"])
    ap.add_argument("--tail-k", type=int, default=8)
    ap.add_argument("--use-aux-embed", action="store_true")
    ap.add_argument("--use-ngram", action="store_true")
    ap.add_argument("--use-ngram2", action="store_true")
    ap.add_argument("--attn", default="sdpa", choices=["eager", "sdpa"])
    ap.add_argument("--max-len", type=int, default=2048)
    ap.add_argument("--save-every", type=int, default=200)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    if _ANOM:
        torch.autograd.set_detect_anomaly(True)
    torch.manual_seed(args.seed)
    random.seed(args.seed)
    rng = np.random.default_rng(args.seed)
    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")

    from transformers import AutoTokenizer
    tok = AutoTokenizer.from_pretrained(args.model)

    model = AleaModel(args.model, attn_impl=args.attn,
                      use_aux_embed=args.use_aux_embed,
                      use_ngram=args.use_ngram,
                      use_ngram2=args.use_ngram2).to(dev)
    load_into(model, args.init)
    set_freeze(model, args.train_mode, args.tail_k)
    model.backbone.gradient_checkpointing_enable()
    model.train()

    ref = AleaModel(args.model, attn_impl=args.attn,
                    use_aux_embed=args.use_aux_embed,
                    use_ngram=args.use_ngram,
                    use_ngram2=args.use_ngram2).to(dev)
    load_into(ref, args.init)
    for p in ref.parameters():
        p.requires_grad_(False)
    ref.eval()

    heads = [model.choice_head, model.score_head, model.noul_head,
             model.regress_head]
    head_params = [p for m in heads for p in m.parameters()]
    bb_params = [p for p in model.backbone.parameters() if p.requires_grad]
    groups = [{"params": head_params, "lr": args.lr_head}]
    if bb_params:
        groups.append({"params": bb_params, "lr": args.lr})
    aux = [p for m in (model.aux_embed, model.ngram, model.ngram2)
           if m is not None
           for p in m.parameters()]
    if aux:
        groups.append({"params": aux, "lr": args.lr_aux})
    opt = torch.optim.AdamW(groups, weight_decay=0.0)

    env_names = [e.strip() for e in args.envs.split(",") if e.strip()]
    episodes = []
    for name in env_names:
        for _ in range(args.eps_per_env):
            episodes.append({"env": make(name).reset(rng), "outcome": []})
    pad_id = tok.pad_token_id if tok.pad_token_id is not None else tok.eos_token_id
    os.makedirs(args.out, exist_ok=True)
    targs = _Args(); targs.__dict__.update(vars(args))

    step = 0
    t0 = time.time()
    stat = {"pg": 0.0, "rep": 0.0, "kl": 0.0, "ret": [], "nb": 0}

    while step < args.steps:
        # --- gather one decision per live episode (capped, round-robin) ---
        live = [e for e in episodes if not e["env"].done]
        if not live:
            episodes = [{"env": make(n).reset(rng), "outcome": []}
                        for n in env_names for _ in range(args.eps_per_env)]
            live = episodes
        random.shuffle(live)            # fair scheduling across envs
        live = live[: args.max_batch]

        packeds, metas, live2 = [], [], []
        for e in live:
            try:
                d = e["env"].observe()
                pk = pack_request(tok, d.state, d.questions,
                                  max_len=args.max_len)
            except ValueError:
                e["env"].reset(rng)
                e["outcome"] = []
                e["ret_acc"] = 0.0
                continue
            packeds.append(pk)
            metas.append(d)
            live2.append(e)
        live = live2
        if not live:
            continue

        ids, pos, seg, qof, oof = collate_segments(packeds, pad_id)
        ids, pos = ids.to(dev), pos.to(dev)
        mask = mask_from_segments(seg.to(dev), qof.to(dev),
                                  oof.to(dev)).to(torch.bfloat16)
        out_pol = model(ids, mask, pos, packeds)
        with torch.no_grad():
            out_ref = ref(ids, mask, pos, packeds)

        pg_terms, sup_terms, kl_terms = [], [], []
        returns = []

        for i, e in enumerate(live):
            env, d = e["env"], metas[i]
            rp = next(r for r in out_pol[i] if r["qid"] == ACT_QID)
            rr = next(r for r in out_ref[i] if r["qid"] == ACT_QID)
            n = d.n_legal
            logits = rp["logits"][:n].float()
            logp = F.log_softmax(logits, -1)
            kl_terms.append(act_kl(rp["logits"][:n], rr["logits"][:n]))

            sup_terms += report_loss(out_pol[i], env.oracle_targets(),
                                     args.report_w)

            R = env.action_rewards() if env.dense else None
            if R is not None:
                Rt = torch.tensor(R[:n], device=dev).float()
                kk = min(args.k, n)
                a = torch.multinomial(logp.exp(), kk, replacement=True)
                r = Rt[a]
                sd = r.std(unbiased=False)
                if sd > 1e-4:
                    adv = (r - r.mean()) / (sd + 1e-4)
                    pg_terms.append(-(adv.detach() * logp[a]).mean())
                # best-of-k among sampled actions keeps episodes on-policy-
                # favorable; PG term above is what trains
                a_pick = int(a[r.argmax()].item())
            else:
                a = torch.multinomial(logp.exp(), 1)
                a_pick = int(a.item())
                # store the decision for replay — its graph is freed by this
                # step"s backward, so outcome envs replay decisions in a
                # fresh forward when the episode ends
                e["outcome"].append((d, a_pick))

            rew, done = env.step(a_pick)
            e["ret_acc"] = e.get("ret_acc", 0.0) + float(rew)
            if not env.dense and done:
                returns.append((e, e["ret_acc"]))

        n_dense = len(pg_terms)

        # outcome-mode: replay each finished episode"s decisions in one
        # fresh forward -> backprop-able logps for the taken actions
        if returns:
            vals = torch.tensor([r for _, r in returns])
            mu, sd = vals.mean(), vals.std(unbiased=False)
            replay = []
            for e, r in returns:
                e["adv"] = float((r - mu) / (sd + 1e-4))
                for d, a_pick in e.get("outcome", []):
                    replay.append((e, pack_request(tok, d.state, d.questions,
                                                   max_len=args.max_len),
                                   d.n_legal, a_pick))
            if replay:
                rp2 = [p for _, p, _, _ in replay]
                ids2, pos2, seg2, qof2, oof2 = collate_segments(rp2, pad_id)
                ids2, pos2 = ids2.to(dev), pos2.to(dev)
                mask2 = mask_from_segments(seg2.to(dev), qof2.to(dev),
                                           oof2.to(dev)).to(torch.bfloat16)
                out2 = model(ids2, mask2, pos2, rp2)
                for i, (e, pk, n, a_pick) in enumerate(replay):
                    rp = next(r for r in out2[i] if r["qid"] == ACT_QID)
                    lp = F.log_softmax(rp["logits"][:n].float(), -1)[a_pick]
                    pg_terms.append(-e["adv"] * lp)
            for e, _ in returns:
                e["outcome"] = []

        # recycle finished episodes immediately (keep batch full)
        for e in episodes:
            if e["env"].done:
                stat["ret"].append(e.get("ret_acc", 0.0))
                e["env"].reset(rng)
                e["outcome"] = []
                e["ret_acc"] = 0.0

        parts = []
        if sup_terms:
            parts.append(torch.stack(sup_terms).mean())
        if kl_terms:
            parts.append(args.beta * torch.stack(kl_terms).mean())
        dense_pg = pg_terms[:n_dense]
        replay_pg = pg_terms[n_dense:]
        if dense_pg:
            parts.append(torch.stack(dense_pg).mean())
        if not parts and not replay_pg:
            continue
        if parts:
            sum(parts).backward()
        if replay_pg:
            torch.stack(replay_pg).mean().backward()
        torch.nn.utils.clip_grad_norm_(
            [p for g in groups for p in g["params"]], 1.0)
        opt.step()
        opt.zero_grad(set_to_none=True)
        step += 1

        stat["pg"] += float(pg_terms[-1].item()) if pg_terms else 0.0
        stat["nb"] += 1
        if step % 10 == 0:
            nb = max(stat["nb"], 1)
            mr = sum(stat["ret"]) / max(len(stat["ret"]), 1)
            print(f"step {step}/{args.steps} pg={stat['pg']/nb:.4f} "
                  f"ep_ret={mr:.3f} ({len(stat['ret'])} eps) "
                  f"live={len(live)} {(time.time()-t0)/step:.2f}s/step",
                  flush=True)
            stat = {"pg": 0.0, "rep": 0.0, "kl": 0.0, "ret": [], "nb": 0}
        if step % args.save_every == 0 or step >= args.steps:
            ck = os.path.join(args.out, f"step{step}.pt")
            save_ckpt(model, heads, targs, ck)
            print(f"saved {ck}", flush=True)

    save_ckpt(model, heads, targs, os.path.join(args.out, "final.pt"))
    print("done")


if __name__ == "__main__":
    main()