"""Fine-tune the MTP head on the target's own outputs. Objective: for every position of a greedy answer, run the same K-step recursive drafting the engine runs (step k re-uses the head's own hidden state from step k-1) and train every step to produce the token the target actually emitted, plus (weight beta) the target's full next-token distribution at that position. Later steps are weighted by whether the earlier steps were right, because the engine only ever reaches them in that case. With --qat the large matrices are trained through FP8 (E4M3) rounding (straight-through), after an exact re-scaling that puts them in E4M3's relative-precision range, so the compact on-disk variant is the model that was actually optimised. """ from __future__ import annotations import argparse import json import math import os import random import time from pathlib import Path import torch import torch.nn.functional as F from .head import (FP8_TENSORS, HeadConfig, QLinear, build_head, e4m3_round, equalize_, export_submission, load_mtp_state, load_target_tensors, unroll) from .sim import DOMAINS, batches, collate, load_shards, shards_bytes, simulate def log(msg): print(f"[{time.strftime('%H:%M:%S')}] {msg}", flush=True) def head_loss(o, W, y, w, teach, beta, chunk=2048, topk=0): """Weighted CE (+ beta * soft-target CE) through the frozen LM head, in memory-bounded chunks. Returns a surrogate whose gradient w.r.t. `o` equals the loss gradient. topk > 0 restricts the soft target to the target's `topk` most likely tokens (the "harmonized objective distillation" of HASS): -sum_{t in top-k(p)} p(t) log q(t).""" n = o.shape[0] denom = w.sum().clamp(min=1.0) surrogate = torch.zeros((), device=o.device) ce_sum = 0.0 correct = torch.zeros(n, dtype=torch.bool, device=o.device) for s in range(0, n, chunk): e = min(n, s + chunk) z = o[s:e].detach().requires_grad_(True) logits = F.linear(z, W.to(z.dtype)).float() logp = F.log_softmax(logits, -1) ce = F.nll_loss(logp, y[s:e], reduction="none") loss = (ce * w[s:e]).sum() if teach is not None and beta > 0: with torch.no_grad(): tl = F.linear(teach[s:e], W.to(teach.dtype)).float() if topk: ix = tl.topk(topk, -1).indices tp = F.softmax(tl, -1).gather(-1, ix) else: tp = F.softmax(tl, -1) lq = logp.gather(-1, ix) if topk else logp loss = loss + beta * (-(tp * lq).sum(-1) * w[s:e]).sum() (g,) = torch.autograd.grad(loss / denom, z) surrogate = surrogate + (o[s:e].float() * g.float()).sum() ce_sum += float((ce.detach() * w[s:e]).sum()) correct[s:e] = logits.argmax(-1) == y[s:e] return surrogate, ce_sum / float(denom), correct def train_step(head, embed, W, batch, a, K=3): tokens, hidden, P, T = batch B, Tm = tokens.shape N = Tm - 1 base = torch.arange(N, device=tokens.device)[None] total = torch.zeros((), device=tokens.device) info, prev = {}, None cuda = tokens.is_cuda with torch.autocast("cuda" if cuda else "cpu", dtype=torch.bfloat16, enabled=cuda): for k, out in unroll(head, embed, tokens, hidden, K): valid = (base >= (P[:, None] - 1)) & ((base + 1 + k) <= (T[:, None] - 1)) labels = tokens[:, (base[0] + 1 + k).clamp(max=Tm - 1)] w = valid.float() if prev is None else valid.float() * (a.floor + (1 - a.floor) * prev.float()) bi, ni = valid.nonzero(as_tuple=True) # the target's own distribution for the same token: h_{i+k} predicts x_{i+k+1} teach = hidden[bi, (ni + k).clamp(max=N - 1)] if a.beta > 0 else None s_k, ce_k, corr = head_loss(out[bi, ni], W, labels[bi, ni], w[bi, ni], teach, a.beta, topk=getattr(a, "topk", 0)) total = total + getattr(a, "step_w_cur", a.step_w)[k - 1] * s_k full = torch.zeros(B, N, dtype=torch.bool, device=tokens.device) full[bi, ni] = corr reach = valid if prev is None else valid & prev info[f"ce{k}"] = ce_k info[f"acc{k}"] = float((full & reach).sum()) / max(1.0, float(reach.sum())) prev = full if prev is None else prev & full return total, info @torch.no_grad() def lowrank_analysis(head, embed, W, val, dev_seqs, ranks): """Acceptance when every matrix of the head is replaced by its best rank-r approximation (truncated SVD): how much a low-rank head would lose. The engine runs dense layers only, so this is an analysis; the exported files are unaffected.""" lin = {n: m for n, m in head.named_modules() if isinstance(m, QLinear)} keep = {n: m.weight.detach().clone() for n, m in lin.items()} svd = {n: torch.linalg.svd(w.float(), full_matrices=False) for n, w in keep.items()} dense = sum(w.numel() for w in keep.values()) rows = [] for r in sorted(ranks): for n, m in lin.items(): U, S, Vh = svd[n] k = min(r, S.numel()) m.weight.copy_(((U[:, :k] * S[:k]) @ Vh[:k]).to(m.weight.dtype)) factored = sum(min(r, min(w.shape)) * sum(w.shape) for w in keep.values()) row = {"rank": r, "matrix_params_factored": factored, "matrix_params_dense": dense, "val_tau": simulate(head, embed, W, val)["acceptance_length"]} if dev_seqs: row["dev_tau"] = simulate(head, embed, W, dev_seqs)["acceptance_length"] rows.append(row) log(f"low-rank r={r}: matrix parameters {factored / 1e6:.0f} M of {dense / 1e6:.0f} M, val tau " f"{row['val_tau']:.4f}" + (f", dev tau {row['dev_tau']:.4f}" if dev_seqs else "")) for n, m in lin.items(): m.weight.copy_(keep[n]) return rows def split_val(seqs, frac, rng): by = {} for s in seqs: by.setdefault(s["domain"], []).append(s) train, val = [], [] for d, v in by.items(): rng.shuffle(v) n = max(4, min(40, int(len(v) * frac))) if len(v) >= 16 else 0 val += v[:n] train += v[n:] if not val: # tiny smoke-test datasets: validate on a training slice val = train[:8] return train, val def main(): ap = argparse.ArgumentParser() ap.add_argument("--target", required=True) ap.add_argument("--init", required=True, help="folder with the starting mtp.* weights") ap.add_argument("--data", required=True) ap.add_argument("--dev", default=None) ap.add_argument("--out", required=True) ap.add_argument("--qat", action="store_true") ap.add_argument("--epochs", type=float, default=float(os.environ.get("TRAIN_EPOCHS", 2))) ap.add_argument("--max-minutes", type=float, default=float(os.environ.get("TRAIN_MINUTES", 22))) ap.add_argument("--batch-tokens", type=int, default=int(os.environ.get("TRAIN_BATCH_TOKENS", 8192))) ap.add_argument("--rel-lr", type=float, default=float(os.environ.get("TRAIN_REL_LR", 1e-3)), help="peak Adam step as a fraction of each tensor's RMS") ap.add_argument("--beta", type=float, default=float(os.environ.get("TRAIN_BETA", 0.5)), help="weight of the soft-target (distillation) term") ap.add_argument("--topk", type=int, default=int(os.environ.get("TRAIN_TOPK", 0)), help="distil only the target's top-k tokens (0: full distribution)") ap.add_argument("--floor", type=float, default=float(os.environ.get("TRAIN_FLOOR", 0.3)), help="weight of later-step positions the engine would not reach") ap.add_argument("--step-w", nargs="+", default=os.environ.get("TRAIN_STEP_W", "1 0.7 0.5").split(), help="three step weights, or 'auto': each step weighted by the derivative of the " "acceptance length with respect to its accuracy") ap.add_argument("--lora", type=int, default=int(os.environ.get("TRAIN_LORA", 0)), help="train rank-r adapters on every matrix instead of the matrices themselves (0: off)") ap.add_argument("--lowrank-ranks", default=os.environ.get("TRAIN_LOWRANK_RANKS", "256,512,1024,2048"), help="after training: acceptance with every matrix cut to these ranks (SVD), for analysis") ap.add_argument("--max-steps", type=int, default=0, help="cap on optimizer steps (short ablation runs)") ap.add_argument("--no-export", action="store_true", help="ablation run: no submission folders") ap.add_argument("--quick", action="store_true", help="ablation run: simulate the validation set only") ap.add_argument("--eval-every", type=int, default=60) ap.add_argument("--seed", type=int, default=0) ap.add_argument("--team", default=os.environ.get("TEAM_ID", "mudassiruddin")) a = ap.parse_args() auto_w = [x.lower() for x in a.step_w] == ["auto"] if not auto_w: a.step_w = [float(x) for x in a.step_w] assert len(a.step_w) == 3, "--step-w takes three numbers or 'auto'" out = Path(a.out) out.mkdir(parents=True, exist_ok=True) rng = random.Random(a.seed) torch.manual_seed(a.seed) dev = "cuda" if torch.cuda.is_available() else "cpu" t_start = time.time() cfg = HeadConfig.from_target(json.loads((Path(a.target) / "config.json").read_text())) names = ["lm_head.weight", "model.language_model.embed_tokens.weight"] tt = load_target_tensors(a.target, names) W = tt[names[0]].to(dev) E = tt[names[1]].to(dev) embed = lambda ids: F.embedding(ids, E) head = build_head(load_mtp_state(a.init), cfg, dev) # hidden states stay on the GPU while they fit comfortably, otherwise in host memory and # each batch is copied over (TRAIN_DATA_DEVICE=cpu|cuda overrides) data_dev = os.environ.get("TRAIN_DATA_DEVICE") or ("cpu" if shards_bytes(a.data) > 24e9 else dev) seqs = load_shards(a.data, data_dev) # validation comes from the first extraction only, so with appended data it is the same # hold-out set as in the earlier run (whose head may be the starting point here) train, val = split_val([s for s in seqs if s["part"] == 1], 0.05, rng) train += [s for s in seqs if s["part"] != 1] dev_seqs = load_shards(a.dev, dev) if a.dev and Path(a.dev).exists() else [] tok_by = {d: sum(s["T"] - s["P"] for s in seqs if s["domain"] == d) for d in DOMAINS} log(f"data: {len(train)} train / {len(val)} val sequences (held on {data_dev}), " f"generated tokens by domain {tok_by}") summary = {"args": vars(a), "data": {"train_sequences": len(train), "val_sequences": len(val), "generated_tokens": tok_by, "data_device": data_dev}, "sim": {}} def sims(tag): r = {"val": simulate(head, embed, W, val)} if dev_seqs and not a.quick: r["dev"] = simulate(head, embed, W, dev_seqs) summary["sim"][tag] = r log(f"[{tag}] val tau {r['val']['acceptance_length']:.4f}" + (f" | dev tau {r['dev']['acceptance_length']:.4f} " f"{ {d: round(v, 3) for d, v in r['dev']['acceptance_by_domain'].items()} } " f"steps {[round(x, 3) for x in r['dev']['step_accuracy']]}" if "dev" in r else "")) return r sims("init") if a.qat: probe = collate(val[:2], device=dev) with torch.no_grad(): ref, _ = head.step(embed(probe[0][:, 1:]).float(), probe[1].float(), torch.arange(probe[0].shape[1] - 1, device=dev)[None].expand(2, -1)) summary["equalize"] = equalize_(head) new, _ = head.step(embed(probe[0][:, 1:]).float(), probe[1].float(), torch.arange(probe[0].shape[1] - 1, device=dev)[None].expand(2, -1)) drift = float((new - ref).abs().max() / ref.abs().max()) summary["equalize"]["max_rel_drift"] = drift log(f"equalisation factors {summary['equalize']} (must be function-preserving)") if drift > 1e-2: raise SystemExit(f"equalisation changed the head's output (drift {drift:.3g})") if not a.quick: sims("equalized") head.set_fake_quant(True) sims("fp8_untrained") mods = dict(head.named_modules()) if a.lora: for m in mods.values(): if isinstance(m, QLinear): m.add_lora(a.lora) log(f"LoRA rank {a.lora}: {sum(p.numel() for p in head.parameters() if p.requires_grad) / 1e6:.1f} M " f"trainable parameters") rms = lambda t: float(t.detach().float().pow(2).mean().sqrt()) groups = [] for n, p in head.named_parameters(): if not p.requires_grad: continue if n.endswith("lora_b"): # an Adam step of size lr on B moves B @ A by about lr * sqrt(r / in) per entry; # match the relative step of full fine-tuning on the frozen matrix m = mods[n.rsplit(".", 1)[0]] base = a.rel_lr * rms(m.weight) * math.sqrt(m.weight.shape[1] / a.lora) else: eff = (1 + p.detach()) if p.ndim == 1 else p.detach() base = a.rel_lr * rms(eff) groups.append({"params": [p], "base": base, "lr": 0.0}) opt = torch.optim.AdamW(groups, betas=(0.9, 0.95), eps=1e-10, weight_decay=0.0) per_epoch = len(batches(train, a.batch_tokens)) total_steps = max(1, int(per_epoch * a.epochs)) if a.max_steps: total_steps = min(total_steps, a.max_steps) warm = max(5, total_steps // 30) key = "val" start = summary["sim"]["fp8_untrained" if a.qat else "init"][key] best = {"tau": start["acceptance_length"], "step": 0, "state": {k: v.detach().clone() for k, v in head.state_dict().items()}} # running per-step conditional accuracies, for acceptance-aware step weights acc_ema = list(start["step_accuracy"]) log(f"training: {total_steps} steps planned ({per_epoch}/epoch), qat={a.qat}, " f"step weights {'auto' if auto_w else a.step_w}, top-k {a.topk}, floor {a.floor}, rel-lr {a.rel_lr}") step, t0, hist = 0, time.time(), [] head.train() done = False while not done: for group in batches(train, a.batch_tokens, rng): if step == 12: per = (time.time() - t0) / 12 fit = int((a.max_minutes * 60 - (time.time() - t_start) - 240) / max(per, 1e-3)) if fit < total_steps - step: total_steps = max(step + 20, step + fit) log(f"{per:.2f}s/step: shortening the schedule to {total_steps} steps to fit the budget") f = (step + 1) / warm if step < warm else 0.1 + 0.9 * 0.5 * (1 + math.cos(math.pi * (step - warm) / max(1, total_steps - warm))) for g in opt.param_groups: g["lr"] = g["base"] * f if auto_w: # d tau / d a_k for tau = 1 + a1 + a1 a2 + a1 a2 a3, normalised to step 1 a1, a2, a3 = acc_ema d = [1 + a2 + a2 * a3, a1 * (1 + a3), a1 * a2] a.step_w_cur = [x / d[0] for x in d] loss, info = train_step(head, embed, W, collate(group, device=dev), a) acc_ema = [0.98 * e + 0.02 * info[f"acc{k + 1}"] for k, e in enumerate(acc_ema)] opt.zero_grad(set_to_none=True) loss.backward() torch.nn.utils.clip_grad_norm_(head.parameters(), 1.0) opt.step() step += 1 if step % 10 == 0 or step == 1: est = 1 + info["acc1"] * (1 + info["acc2"] * (1 + info["acc3"])) log(f"step {step}/{total_steps} ce {info['ce1']:.3f}/{info['ce2']:.3f}/{info['ce3']:.3f} " f"acc {info['acc1']:.3f}/{info['acc2']:.3f}/{info['acc3']:.3f} batch-tau~{est:.3f} " f"lr x{f:.2f} {(time.time() - t0) / step:.2f}s/step" + (f" w {[round(x, 2) for x in a.step_w_cur]}" if auto_w else "")) if step % a.eval_every == 0 or step >= total_steps: r = simulate(head, embed, W, val) d = simulate(head, embed, W, dev_seqs[::4]) if dev_seqs else None hist.append({"step": step, "val": r["acceptance_length"], "dev_quarter": d["acceptance_length"] if d else None}) log(f"eval step {step}: val tau {r['acceptance_length']:.4f}" + (f" | dev(1/4) tau {d['acceptance_length']:.4f}" if d else "") + f" (best {best['tau']:.4f} @ {best['step']})") if r["acceptance_length"] > best["tau"]: best = {"tau": r["acceptance_length"], "step": step, "state": {k: v.detach().clone() for k, v in head.state_dict().items()}} head.train() if step >= total_steps: done = True break head.load_state_dict(best["state"]) for m in head.modules(): if isinstance(m, QLinear): m.merge_lora() head.eval() summary["history"] = hist summary["best_step"] = best["step"] summary["train_seconds"] = round(time.time() - t0, 1) log(f"best checkpoint: step {best['step']} (val tau {best['tau']:.4f})") summary["best_val_tau"] = best["tau"] if a.no_export: summary["total_seconds"] = round(time.time() - t_start, 1) (out / "train_summary.json").write_text(json.dumps(summary, indent=2, default=str)) log("ablation run finished (no export)") return meta = {"team_id": a.team, "method_description": ("Replacement MTP head in the baseline layout, initialised from the target's " "built-in head and fine-tuned with a 3-step recursive drafting objective" + (", acceptance-aware step weights" if auto_w else "") + (f", top-{a.topk} distillation" if a.topk else "") + (f", rank-{a.lora} LoRA adapters merged into the weights" if a.lora else "") + (" and FP8 (E4M3) quantisation-aware training" if a.qat else "")), "training_data": ("Greedy answers of the target itself (with its hidden states) to public " "instruction prompts: GSM8K/Orca-Math, WritingPrompts, UltraChat/Alpaca/Dolly, " "Python instruction sets; dev prompts excluded")} tcfg = Path(a.target) / "config.json" if a.qat: sims("final_fp8") summary["export_fp8"] = export_submission(head, out / "sub_fp8", tcfg, True, meta) back = load_mtp_state(out / "sub_fp8") for n in FP8_TENSORS: want = e4m3_round(head.state_dict()[n].float().cpu()) assert torch.equal(back[n], want), f"FP8 round trip mismatch in {n}" head.set_fake_quant(False) sims("final_bf16") summary["export_bf16"] = export_submission(head, out / "sub_bf16", tcfg, False, meta) if a.lowrank_ranks: summary["lowrank"] = lowrank_analysis(head, embed, W, val, dev_seqs, [int(x) for x in a.lowrank_ranks.split(",") if x.strip()]) summary["total_seconds"] = round(time.time() - t_start, 1) (out / "train_summary.json").write_text(json.dumps(summary, indent=2, default=str)) log("training finished") if __name__ == "__main__": main()