EMC / emcdraft /train.py
mudassiruddin21's picture
LoRA recipe and low-rank analysis
0ec358a verified
Raw History Blame Contribute Delete
19.6 kB
"""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()