"""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()