File size: 6,118 Bytes
dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 5fd0620 dcc3a31 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 | """Offline acceptance simulator and feature-shard helpers.
Given target hidden states for a token sequence, `simulate` replays greedy speculative
decoding with K draft tokens exactly as the engine's proposer does (recursive use of the
head's own hidden state, verified keys/values for the prefix) and returns the acceptance
length tau = 1 + accepted / rounds - the same quantity the kit reads from the engine's
counters. It needs no server start, so it is used for validation during training.
"""
from __future__ import annotations
import json
from collections import defaultdict
from pathlib import Path
import numpy as np
import torch
import torch.nn.functional as F
from .head import unroll, walk
DOMAINS = ("chat", "code", "math", "longform")
def save_shard(stem: str, seqs: list[dict]):
"""seqs: dicts with tokens [T] (long), hidden [T-1, H] (bf16), P, domain, optional id."""
toks = torch.cat([s["tokens"] for s in seqs]).to(torch.int32).cpu().numpy()
hid = torch.cat([s["hidden"] for s in seqs]).to(torch.bfloat16).cpu()
np.save(stem + ".tok.npy", toks)
np.save(stem + ".hid.npy", hid.view(torch.int16).numpy())
meta = {"T": [int(s["tokens"].numel()) for s in seqs], "P": [int(s["P"]) for s in seqs],
"domain": [s["domain"] for s in seqs], "id": [s.get("id", "") for s in seqs]}
Path(stem + ".json").write_text(json.dumps(meta))
def shards_bytes(data_dir) -> int:
return sum(p.stat().st_size for p in Path(data_dir).glob("*.hid.npy"))
def load_shards(data_dir, device, max_tokens: int | None = None) -> list[dict]:
"""Every sequence of the shards in `data_dir` (sorted by name), with the extraction part it
came from (shards g... are part 1, appended shards p<k>g... part k)."""
seqs, total = [], 0
for meta_path in sorted(Path(data_dir).glob("*.json")):
stem = str(meta_path)[:-5]
name = meta_path.stem
part = int(name[1:name.index("g")]) if name.startswith("p") else 1
meta = json.loads(meta_path.read_text())
tok = torch.from_numpy(np.load(stem + ".tok.npy").astype(np.int64)).to(device)
hid = torch.from_numpy(np.load(stem + ".hid.npy")).view(torch.bfloat16).to(device)
to = ho = 0
for T, P, dom, sid in zip(meta["T"], meta["P"], meta["domain"], meta["id"]):
seqs.append({"tokens": tok[to:to + T], "hidden": hid[ho:ho + T - 1], "P": P, "T": T,
"domain": dom, "id": sid, "part": part})
to, ho, total = to + T, ho + T - 1, total + T
if max_tokens and total >= max_tokens:
break
return seqs
def collate(seqs: list[dict], pad: int = 0, device=None):
"""Pad a group into (tokens, hidden, P, T); built where the data lives, then moved to `device`."""
B, Tm = len(seqs), max(s["T"] for s in seqs)
dev = seqs[0]["tokens"].device
H = seqs[0]["hidden"].shape[-1]
tokens = torch.full((B, Tm), pad, dtype=torch.long, device=dev)
hidden = torch.zeros((B, Tm - 1, H), dtype=seqs[0]["hidden"].dtype, device=dev)
for b, s in enumerate(seqs):
tokens[b, :s["T"]] = s["tokens"]
hidden[b, :s["T"] - 1] = s["hidden"]
P = torch.tensor([s["P"] for s in seqs], device=dev)
T = torch.tensor([s["T"] for s in seqs], device=dev)
if device is not None and torch.device(device) != torch.device(dev):
tokens, hidden, P, T = (x.to(device) for x in (tokens, hidden, P, T))
return tokens, hidden, P, T
def batches(seqs: list[dict], max_tokens: int, shuffle_rng=None) -> list[list[dict]]:
"""Length-bucketed batches with at most `max_tokens` padded positions each."""
order = sorted(seqs, key=lambda s: s["T"])
out, cur, cur_max = [], [], 0
for s in order:
if cur and max(cur_max, s["T"]) * (len(cur) + 1) > max_tokens:
out.append(cur)
cur, cur_max = [], 0
cur.append(s)
cur_max = max(cur_max, s["T"])
if cur:
out.append(cur)
if shuffle_rng is not None:
shuffle_rng.shuffle(out)
return out
def argmax_logits(h: torch.Tensor, W: torch.Tensor, chunk: int = 4096) -> torch.Tensor:
return torch.cat([F.linear(h[i:i + chunk], W).float().argmax(-1) for i in range(0, h.shape[0], chunk)])
@torch.no_grad()
def simulate(head, embed, W, seqs: list[dict], K: int = 3, max_tokens: int = 12000) -> dict:
"""Acceptance length per domain and overall, plus per-step conditional accuracies."""
was_training = head.training
head.eval()
acc, drafts = defaultdict(int), defaultdict(int)
hit, tot = [0] * K, [0] * K
cuda = W.is_cuda
for group in batches(seqs, max_tokens):
tokens, hidden, P, T = collate(group, device=W.device)
B, Tm = tokens.shape
N = Tm - 1
base = torch.arange(N, device=tokens.device)
flags = []
with torch.autocast("cuda" if cuda else "cpu", dtype=torch.bfloat16, enabled=cuda):
for k, out in unroll(head, embed, tokens, hidden, K):
lab = tokens[:, (base + 1 + k).clamp(max=Tm - 1)]
pred = argmax_logits(out.reshape(B * N, -1), W).view(B, N)
flags.append(pred == lab)
prev = None
for k in range(K):
valid = (base[None] >= (P[:, None] - 1)) & ((base[None] + 2 + k) <= (T[:, None] - 1))
reach = valid if prev is None else valid & prev
hit[k] += int((flags[k] & reach).sum())
tot[k] += int(reach.sum())
prev = flags[k] if prev is None else prev & flags[k]
cpu_flags = [f.cpu() for f in flags]
for b, s in enumerate(group):
a, d = walk([f[b].tolist() for f in cpu_flags], s["P"], s["T"], K)
acc[s["domain"]] += a
drafts[s["domain"]] += d
head.train(was_training)
res = {"acceptance_by_domain": {d: 1 + acc[d] / drafts[d] for d in acc if drafts[d]},
"acceptance_length": 1 + sum(acc.values()) / max(1, sum(drafts.values())),
"step_accuracy": [hit[k] / max(1, tot[k]) for k in range(K)],
"rounds": sum(drafts.values()), "sequences": len(seqs)}
return res
|