alea/rl.py

"""GRPO/DPO-style RL for Alea decision outputs.

The model emits a full action distribution per question in one forward pass,
so RL here is a contextual bandit — no autoregressive rollout needed:

  choice/score: policy = softmax over options/levels; sample k actions,
                reward r_i = q[a_i] (expected correctness under the target
                distribution — equals 0/1 accuracy for one-hot targets).
  noul:         policy = Bernoulli(p_yes); sample k binary actions,
                r_i = a*q + (1-a)*(1-q)  (prob the sampled answer is right).
  regress:      skipped (quantile outputs stay supervised).

GRPO: group-relative advantage A_i = (r_i - mean_k r) / (std_k r + eps),
loss = -mean_i A_i * log pi(a_i) + beta * KL(pi || pi_ref)  (analytic KL).
Optional PPO clip when --ppo-epochs > 1.

DPO (--mode dpo): for choice questions, chosen = argmax q, rejected = option
sampled from policy != chosen; standard sigmoid preference loss on logits.

Usage:
  python -m alea.rl --init runs/loop_r4/final.pt --data data/loop_train_r0.jsonl \
      --steps 500 --k 8 --batch 16 --beta 0.05 --lr 5e-6
"""
import argparse
import json
import math
import os
import random
import time

import torch
import torch.nn.functional as F

from .dataset import DecisionDataset, row_to_specs
from .model import AleaModel, collate_segments, mask_from_segments
from .packing import pack_request
from .train import load_into, save_ckpt, set_freeze


class _Args:
    """Shim so save_ckpt (which reads args.train_mode / vars(args)) works."""


def _to_args(ns):
    a = _Args()
    a.__dict__.update(vars(ns))
    return a


def kl_categorical(logits_p, logits_r):
    """KL(p || ref) for categorical logits, [n] each."""
    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 kl_bernoulli(p, pr):
    """KL(Bern(p) || Bern(pr))."""
    p = p.float().clamp(1e-6, 1 - 1e-6)
    pr = pr.float().clamp(1e-6, 1 - 1e-6)
    return p * (p.log() - pr.log()) + (1 - p) * ((1 - p).log() - (1 - pr).log())


def forward_packed(model, items, pad_id, dev):
    packeds = [it[0] for it in items]
    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)
    return model(ids, mask, pos, packeds)


def grpo_step(out_pol, out_ref, items, k, beta, eps=1e-4):
    """Build GRPO loss for one micro-batch.

    Returns (loss, stats dict)."""
    pg_terms, kl_terms = [], []
    n_q = n_skip = 0
    rew_sum, rew_n = 0.0, 0

    for b, (qres_p, qres_r) in enumerate(zip(out_pol, out_ref)):
        targets = items[b][1]
        for rp, rr in zip(qres_p, qres_r):
            q = targets.get(rp["qid"])
            if q is None:
                continue
            qt = rp["qtype"]

            if qt in ("choice", "score"):
                logits = rp["logits"].float()
                logits_r = rr["logits"].float()
                n_opt = logits.numel()
                qt_t = torch.tensor(q, device=logits.device).float()
                logp = F.log_softmax(logits, -1)
                p = logp.exp()
                kk = min(k, n_opt)
                a = torch.multinomial(p, kk, replacement=True)      # [kk]
                r = qt_t[a]                                          # [kk]
                adv = (r - r.mean()) / (r.std(unbiased=False) + eps)
                if not torch.isfinite(adv).all() or r.std() < eps:
                    n_skip += 1
                else:
                    pg_terms.append(-(adv.detach() * logp[a]).mean())
                    kl_terms.append(kl_categorical(logits, logits_r))
                    rew_sum += r.mean().item(); rew_n += 1
                    n_q += 1

            elif qt == "noul":
                p = rp["p_yes"].float().clamp(1e-6, 1 - 1e-6)
                pr = rr["p_yes"].float().clamp(1e-6, 1 - 1e-6)
                qf = float(q)
                a = torch.bernoulli(p.expand(k))                     # [k]
                r = a * qf + (1 - a) * (1 - qf)
                adv = (r - r.mean()) / (r.std(unbiased=False) + eps)
                if not torch.isfinite(adv).all() or r.std() < eps:
                    n_skip += 1
                else:
                    logp_a = torch.where(a > 0.5, p.log(), (1 - p).log())
                    pg_terms.append(-(adv.detach() * logp_a).mean())
                    kl_terms.append(kl_bernoulli(p, pr))
                    rew_sum += r.mean().item(); rew_n += 1
                    n_q += 1
            # regress: supervised-only for now

    if not pg_terms:
        return None, {"n_q": 0, "n_skip": n_skip, "rew": 0.0}
    loss = torch.stack(pg_terms).mean()
    if kl_terms:
        loss = loss + beta * torch.stack(kl_terms).mean()
    return loss, {"n_q": n_q, "n_skip": n_skip,
                  "rew": rew_sum / max(rew_n, 1)}


def dpo_step(out_pol, out_ref, items, beta):
    """DPO on choice questions: chosen=argmax q, rejected=policy sample."""
    terms = []
    n = 0
    for b, (qres_p, qres_r) in enumerate(zip(out_pol, out_ref)):
        targets = items[b][1]
        for rp, rr in zip(qres_p, qres_r):
            if rp["qtype"] != "choice":
                continue
            q = targets.get(rp["qid"])
            if q is None:
                continue
            qt_t = torch.tensor(q, device=rp["logits"].device).float()
            c = int(qt_t.argmax().item())
            p = F.softmax(rp["logits"].float(), -1)
            a = int(torch.multinomial(p, 1).item())
            if a == c and p.numel() > 1:
                a = int(torch.multinomial(p, 1).item())
            if a == c:
                continue
            lp = F.log_softmax(rp["logits"].float(), -1)
            lr = F.log_softmax(rr["logits"].float(), -1)
            margin = (lp[c] - lp[a]) - (lr[c] - lr[a])
            terms.append(-F.logsigmoid(beta * margin))
            n += 1
    if not terms:
        return None, {"n_pairs": 0}
    return torch.stack(terms).mean(), {"n_pairs": n}


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("--init", required=True)
    ap.add_argument("--data", default=None,
                    help="jsonl corpus; if unset, --gen rows are synthesized")
    ap.add_argument("--gen", type=int, default=20000)
    ap.add_argument("--gen-seed", type=int, default=9000)
    ap.add_argument("--out", default="runs/rl")
    ap.add_argument("--model", default="Qwen/Qwen3-0.6B")
    ap.add_argument("--mode", default="grpo", choices=["grpo", "dpo"])
    ap.add_argument("--steps", type=int, default=500)
    ap.add_argument("--batch", type=int, default=16)
    ap.add_argument("--accum", type=int, default=1)
    ap.add_argument("--k", type=int, default=8, help="samples per question")
    ap.add_argument("--beta", type=float, default=0.05, help="KL weight")
    ap.add_argument("--lr", type=float, default=5e-6)
    ap.add_argument("--lr-head", type=float, default=1e-5)
    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("--lr-aux", type=float, default=1e-4)
    ap.add_argument("--attn", default="sdpa", choices=["eager", "sdpa"])
    ap.add_argument("--max-len", type=int, default=4096)
    ap.add_argument("--token-budget", type=int, default=24576)
    ap.add_argument("--save-every", type=int, default=250)
    ap.add_argument("--seed", type=int, default=0)
    args = ap.parse_args()

    torch.manual_seed(args.seed)
    random.seed(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).to(dev)
    load_into(model, args.init)
    set_freeze(model, args.train_mode, args.tail_k)
    model.train()

    ref = AleaModel(args.model, attn_impl=args.attn,
                    use_aux_embed=args.use_aux_embed,
                    use_ngram=args.use_ngram).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_params = [p for m in (model.aux_embed, model.ngram) if m is not None
                  for p in m.parameters()]
    if aux_params:
        groups.append({"params": aux_params, "lr": args.lr_aux})
    opt = torch.optim.AdamW(groups, weight_decay=0.0)

    # --- data ---
    data_path = args.data
    if data_path is None:
        os.makedirs("data", exist_ok=True)
        data_path = f"data/rl_gen_{args.gen_seed}.jsonl"
        if not os.path.exists(data_path):
            from . import gen_all
            from .genbase import write_jsonl
            print(f"generating {args.gen} RL rows -> {data_path}", flush=True)
            shares = {"gen_stoch": 0.9, "gen_enterprise": 1.0,
                      "gen_structured": 0.8, "gen_adversarial": 0.6,
                      "gen_numeric": 0.7, "gen_long": 0.5, "base": 0.4,
                      "gen_kaggle_cls": 1.0, "gen_kaggle_reg": 0.7,
                      "gen_hf": 1.3}
            avail = gen_all.sources()
            shares = {kk: w for kk, w in shares.items() if kk in avail}
            write_jsonl(gen_all.build(args.gen, seed=args.gen_seed,
                                      shares=shares), data_path)

    print("packing dataset...", flush=True)
    ds = DecisionDataset(data_path, tok, max_len=args.max_len)
    items, skipped = [], 0
    for row in ds.rows:
        try:
            state, qs, targets = row_to_specs(row)
            items.append((pack_request(tok, state, qs, max_len=args.max_len),
                          targets))
        except ValueError:
            skipped += 1
    print(f"packed {len(items)} (skipped {skipped})", flush=True)

    lengths = [len(p.input_ids) for p, _ in items]
    order = sorted(range(len(items)), key=lambda i: lengths[i])
    batches, cur, cur_max = [], [], 0
    for i in order:
        new_max = max(cur_max, lengths[i])
        if cur and ((len(cur) + 1) * new_max > args.token_budget
                    or len(cur) >= args.batch):
            batches.append(cur)
            cur, cur_max = [], 0
            new_max = lengths[i]
        cur.append(i)
        cur_max = new_max
    if cur:
        batches.append(cur)

    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 = _to_args(args)
    step, micro = 0, 0
    t0 = time.time()
    stats_acc = {"n_q": 0, "n_skip": 0, "rew": 0.0, "n_pairs": 0, "nb": 0}

    while step < args.steps:
        random.shuffle(batches)
        for batch_idx in batches:
            items_b = [items[i] for i in batch_idx]
            out_pol = forward_packed(model, items_b, pad_id, dev)
            with torch.no_grad():
                out_ref = forward_packed(ref, items_b, pad_id, dev)

            if args.mode == "grpo":
                res, st = grpo_step(out_pol, out_ref, items_b, args.k,
                                    args.beta)
            else:
                res, st = dpo_step(out_pol, out_ref, items_b, args.beta)
            if res is None:
                continue
            (res / args.accum).backward()
            for kk, vv in st.items():
                stats_acc[kk] = stats_acc.get(kk, 0) + vv
            stats_acc["nb"] += 1
            micro += 1

            if micro % args.accum == 0:
                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
                if step % 10 == 0:
                    nb = max(stats_acc["nb"], 1)
                    print(f"step {step}/{args.steps} "
                          f"q={stats_acc['n_q']/nb:.1f} "
                          f"skip={stats_acc['n_skip']} "
                          f"rew={stats_acc['rew']/nb:.3f} "
                          f"pairs={stats_acc.get('n_pairs',0)} "
                          f"{(time.time()-t0)/step:.2f}s/step", flush=True)
                    stats_acc = {"n_q": 0, "n_skip": 0, "rew": 0.0,
                                 "n_pairs": 0, "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)
                if step >= args.steps:
                    break

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


if __name__ == "__main__":
    main()