Upload alea/rl_env.py with huggingface_hub

alea/rl_env.py

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