# -*- coding: utf-8 -*- """Capture genuine byte-by-byte inference internals from mini-beatrix-2.5s. The craft is the full 237.1M mini-beatrix-2s core. Every capture is taken TWICE over the SAME byte sequence — once on the bare core and once with the library's top arm mounted — so every per-byte quantity is directly comparable and the arm's contribution is a difference, not a guess. Method. The reply is generated normally (greedy, the arm's own frame). The complete sequence (prompt bytes + reply bytes) is then re-run through ONE instrumented forward pass that walks the blocks by hand, recording what each layer did at each byte position. The model is causal, so the traced state at position i is the state the decode actually had there. What is recorded, per byte, per layer: * the oriented address READ (per constellation, per anchor) * the blackboard MASS (per constellation, per anchor, cumulative) * the agreement mass (the splat denominator) per constellation * an exact effective attention row over all earlier bytes, derived from the same bilinear forms the scan sums * the residual stream norm in/out, the attention contribution, the bank trunk and dispatched-expert contributions * the three anchored experts' signed dispatch weights * the arm's patch norm and gate at that site (arm runs only) and per byte at the head: the 256-atom signed head address, the predicted byte distribution (top 8), its entropy, and the byte actually taken. Usage: python capture.py [--out DIR] [--max-bytes N] """ from __future__ import annotations import json import os import sys import numpy as np import torch import torch.nn.functional as F REPO = r"E:/mirel/alephllm-chat/mb25/repo" OUT = r"E:/mirel/alephllm-chat/mb25/captures" ARM = "rules" # the library's top row (rank 0) MAXB = 400 DEV = "cuda" if torch.cuda.is_available() else "cpu" PROMPTS = [ dict(id="rule-chain", title="Five rules about invented words", why="the arm's own domain: it reads five if-then rules about words " "the model never saw in pretraining and answers with the last " "one. The core alone does not.", text=("If someone is clea, then they are plyi. If someone is plyi, " "then they are ploym. If someone is ploym, then they are " "triu. If someone is triu, then they are tricu. If someone " "is tricu, then they are grash. Wren is clea. What follows? " "Reply with only the final answer."), gold="grash", max_new=32), dict(id="plain-question", title="An ordinary question", why="outside the arm's domain. The arm was trained with an " "abstention term, so the interesting thing here is how little " "it changes.", gold=None, text="What is a river?", max_new=96), ] # ------------------------------------------------------------- quantizing def q8(a: np.ndarray, signed: bool): """uint8 with one scale per array. Signed arrays centre on 128.""" a = np.asarray(a, dtype=np.float32) m = float(np.abs(a).max()) if signed else float(a.max()) m = m if m > 0 else 1.0 if signed: q = np.clip(np.round(a / m * 127.0) + 128, 0, 255) else: q = np.clip(np.round(a / m * 255.0), 0, 255) return q.astype(np.uint8), m def q8_dev(a: np.ndarray): """The fix for the anchor arrays: store the MEAN over bytes separately and quantize only the DEVIATION from it, with one scale per (block, constellation). Measured on the first capture: every anchor picture is dominated by a large constant component — the cosine similarity between neighbouring bytes is 1.000 — and the part that varies byte to byte is ~4% of the whole. Against ONE global scale that varying part lands below a single quantization step (0.1-0.3 of a step), so the published arrays carried almost no per-byte information at all. Splitting the constant off and giving each (block, constellation) its own scale puts the per-byte signal back in range, and the absolute value is still exactly recoverable as mean + deviation. The scale is the 99.5th percentile of |deviation|, NOT its maximum. Measured: the first two bytes of a sequence deviate ~25x more than every later byte (the blackboard is nearly empty there, so the oriented distribution is extreme), and against a max-based scale those two bytes crushed all 369 others into 25 of the 256 levels. The field is also sparse — the median |deviation| is exactly zero, a handful of anchors carrying everything — so a percentile scale spends the range where the signal is. The few cells above it clip, which is reported. a: (L, C, n, K) -> (uint8 dev, mean (L,C,K), scale (L,C), clipped frac) """ a = np.asarray(a, dtype=np.float32) mean = a.mean(axis=2) # (L, C, K) dev = a - mean[:, :, None, :] flat = np.abs(dev).reshape(dev.shape[0], dev.shape[1], -1) scale = np.percentile(flat, 99.5, axis=2) # (L, C) scale = np.where(scale > 0, scale, np.abs(dev).max() or 1.0).astype(np.float32) clipped = float((flat > scale[:, :, None]).mean()) q = np.clip(np.round(dev / scale[:, :, None, None] * 127.0) + 128, 0, 255) return q.astype(np.uint8), mean, scale, clipped def wbin(path, arr): arr.tofile(path) return os.path.getsize(path) # ------------------------------------------------------------------ trace @torch.no_grad() def trace(model, ids): """One instrumented forward. Returns numpy records, everything fp32.""" from arms import BlockWithAdapter, BlockWithDispatch # noqa: F401 n = ids.shape[1] rec = {"layers": [], "n": n} x = model.embed(ids) rec["embed_norm"] = x[0].norm(dim=-1).float().cpu().numpy() for li, wrapped in enumerate(model.blocks): blk = getattr(wrapped, "block", wrapped) adapter = getattr(wrapped, "adapter", None) armed = adapter is not None and getattr(wrapped, "enabled", False) L = {"resid_in": x[0].norm(dim=-1).float().cpu().numpy()} h = blk.n1(x) units = blk.attn._units() reads, mass, dens, att = [], [], [], None writes, shapes, used = [], [], [] for addr, qm, km in units: qp, qn = addr.oriented(qm(h)) kp, kn = addr.oriented(km(h)) zp, zn = qp.new_zeros(qp.shape), qp.new_zeros(qp.shape) torch.cumsum(kp, dim=1, out=zp) torch.cumsum(kn, dim=1, out=zn) dens.append(((qp * zp).sum(-1) + (qn * zn).sum(-1))[0]) reads.append((qp - qn)[0]) # signed read writes.append((kp - kn)[0]) # what THIS byte writes m = (zp + zn)[0] # cumulative load mass.append(m) # The load only grows, so the raw array plots position, not # behaviour. The shape of the blackboard — the load divided by # its own total at that byte — is comparable across positions, # and its effective width says how many anchors are carrying it. p = m / m.sum(-1, keepdim=True).clamp_min(1e-12) shapes.append(p) used.append(torch.exp(-(p * p.clamp_min(1e-12).log()).sum(-1))) a_c = qp[0] @ kp[0].T + qn[0] @ kn[0].T # (n, n) att = a_c if att is None else att + a_c tri = torch.tril(torch.ones(n, n, device=att.device, dtype=att.dtype)) att = att * tri att = att / att.sum(-1, keepdim=True).clamp_min(1e-12) L["read"] = torch.stack(reads).float().cpu().numpy() # (C, n, K) L["write"] = torch.stack(writes).float().cpu().numpy() # (C, n, K) L["mass"] = torch.stack(mass).float().cpu().numpy() L["massn"] = torch.stack(shapes).float().cpu().numpy() # (C, n, K) L["used"] = torch.stack(used).float().cpu().numpy() # (C, n) L["den"] = torch.stack(dens).float().cpu().numpy() # (C, n) L["attn"] = att.float().cpu().numpy() # (n, n) a = blk.attn(h) L["attn_norm"] = a[0].norm(dim=-1).float().cpu().numpy() x = x + a h2 = blk.n2(x) bank = blk.bank w = bank.addr.signed(h2) # (1, n, E) trunk = bank.t_out(F.gelu(bank.t_in(h2))) out = bank(h2) L["experts"] = w[0].float().cpu().numpy() # (n, E) L["gates"] = torch.sigmoid(bank.gates).float().cpu().numpy() L["bank_trunk"] = trunk[0].norm(dim=-1).float().cpu().numpy() L["bank_disp"] = (out - trunk)[0].norm(dim=-1).float().cpu().numpy() x = x + out if armed: B, nn_, _ = x.shape slots = adapter.proj(x).view(B, nn_, adapter.n_slots, adapter.spec.D) feats = adapter.addr.m_hat(slots).reshape(B, nn_, -1) g = torch.sigmoid(adapter.gate) patch = g * adapter.consume(feats) L["arm_patch"] = patch[0].norm(dim=-1).float().cpu().numpy() L["arm_gate"] = float(g) # the arm's own signed per-anchor weights, written out here # because the packaged arm runtime exposes only m_hat: # w_k = sinh(u_k) / sum_j cosh(u_j), u = (x_hat . A_k)/tau A = F.normalize(adapter.addr.codebook, dim=-1) u = (F.normalize(slots, dim=-1) @ A.transpose(-1, -2)) \ / adapter.addr.tau mu = u.abs().amax(dim=-1, keepdim=True) ep, en = torch.exp(u - mu), torch.exp(-u - mu) aw = (ep - en) / (ep + en).sum(dim=-1, keepdim=True) L["arm_read"] = aw.mean(dim=2)[0].float().cpu().numpy() # (n, K) x = x + patch L["resid_out"] = x[0].norm(dim=-1).float().cpu().numpy() rec["layers"].append(L) h = model.nf(x) rec["head_read"] = model.head.addr.signed( model.head.proj(h))[0].float().cpu().numpy() # (n, Kh) logits = model.head(h)[0].float() p = logits.softmax(-1) top = p.topk(8, dim=-1) rec["top_ids"] = top.indices.cpu().numpy().astype(np.int16) rec["top_p"] = top.values.cpu().numpy() rec["entropy"] = (-(p * p.clamp_min(1e-12).log()).sum(-1) ).cpu().numpy() / np.log(2.0) nxt = ids[0, 1:].cpu().numpy() rec["p_actual"] = np.concatenate( [p[np.arange(n - 1), nxt].cpu().numpy(), [0.0]]) return rec @torch.no_grad() def codebook_health(model): """Per layer, per constellation: what the frame itself looks like.""" rows = [] for li, wrapped in enumerate(model.blocks): blk = getattr(wrapped, "block", wrapped) for ci, (addr, _, _) in enumerate(blk.attn._units()): hh = addr.health(None) rows.append({"layer": li, "const": ci, "drift_mean": round(hh["drift_mean"], 5), "drift_max": round(hh["drift_max"], 5), "erank": round(hh["codebook_erank"], 3), "max_abs_cos": round(hh["anchor_max_abs_cos"], 4), "merge_pairs": hh["anchor_merge_pairs"]}) return rows # ------------------------------------------------------------------ write def emit(rec, root, cfg): d = os.path.join(root, cfg) os.makedirs(d, exist_ok=True) n = rec["n"] C, K = rec["layers"][0]["read"].shape[0], rec["layers"][0]["read"].shape[2] nl = len(rec["layers"]) read = np.stack([L["read"] for L in rec["layers"]]) # (Lr, C, n, K) write = np.stack([L["write"] for L in rec["layers"]]) mass = np.stack([L["mass"] for L in rec["layers"]]) massn = np.stack([L["massn"] for L in rec["layers"]]) attn = np.stack([L["attn"] for L in rec["layers"]]) # (Lr, n, n) qr, mean_r, sc_r, cl_r = q8_dev(read) qw, mean_w, sc_w, cl_w = q8_dev(write) qmn, mean_mn, sc_mn, cl_mn = q8_dev(massn) qm, sm = q8(mass, False) # the raw cumulative load: dataset only qa = np.zeros_like(attn, dtype=np.uint8) rowmax = attn.max(axis=-1, keepdims=True) np.divide(attn, np.clip(rowmax, 1e-12, None), out=attn) np.clip(np.round(attn * 255.0), 0, 255, out=attn) qa = attn.astype(np.uint8) hr = rec["head_read"][None, None] # (1, 1, n, Kh) qh, mean_h, sc_h, cl_h = q8_dev(hr) sizes = {"read": wbin(os.path.join(d, "read.u8"), qr), "write": wbin(os.path.join(d, "write.u8"), qw), "mass": wbin(os.path.join(d, "mass.u8"), qm), "massn": wbin(os.path.join(d, "massn.u8"), qmn), "attn": wbin(os.path.join(d, "attn.u8"), qa), "head": wbin(os.path.join(d, "head.u8"), qh)} arm_shape = arm_mean = arm_scale = None if "arm_read" in rec["layers"][0]: armr = np.stack([L["arm_read"] for L in rec["layers"]]) # (Lr, n, Ka) qar, m_a, s_a, _ = q8_dev(armr[:, None]) # (L,1,n,Ka) sizes["arm"] = wbin(os.path.join(d, "arm.u8"), qar) arm_shape = list(armr.shape) arm_mean, arm_scale = m_a[:, 0].tolist(), s_a[:, 0].tolist() per_layer = [] for L in rec["layers"]: per_layer.append({ "resid_in": [round(float(v), 3) for v in L["resid_in"]], "resid_out": [round(float(v), 3) for v in L["resid_out"]], "attn_norm": [round(float(v), 3) for v in L["attn_norm"]], "bank_trunk": [round(float(v), 3) for v in L["bank_trunk"]], "bank_disp": [round(float(v), 4) for v in L["bank_disp"]], "den": [[round(float(v), 4) for v in c] for c in L["den"]], "used": [[round(float(v), 2) for v in c] for c in L["used"]], "experts": [[round(float(v), 4) for v in row] for row in L["experts"]], "gates": [round(float(v), 4) for v in L["gates"]], "arm_patch": ([round(float(v), 4) for v in L["arm_patch"]] if "arm_patch" in L else None), "arm_gate": L.get("arm_gate"), }) summary = { "n": n, "layers": nl, "consts": C, "anchors": K, "head_atoms": int(rec["head_read"].shape[1]), # The anchor arrays are stored as MEAN + DEVIATION (see q8_dev): # value = mean[l][c][k] + (u8 - 128)/127 * scale[l][c] # `mass` alone keeps the old absolute form, scale under "mass". "form": "mean+deviation, uint8, one scale per (block, constellation), the scale being the 99.5th percentile of |deviation| so the first two bytes of a sequence do not crush the rest; values above it clip", "clipped": {"read": round(cl_r, 5), "write": round(cl_w, 5), "massn": round(cl_mn, 5), "head": round(cl_h, 5)}, "mean": {"read": mean_r.tolist(), "write": mean_w.tolist(), "massn": mean_mn.tolist(), "head": mean_h[0, 0].tolist(), "arm": arm_mean}, "scales": {"read": sc_r.tolist(), "write": sc_w.tolist(), "massn": sc_mn.tolist(), "head": float(sc_h[0, 0]), "arm": arm_scale, "mass": sm}, "shapes": {"read": [nl, C, n, K], "write": [nl, C, n, K], "mass": [nl, C, n, K], "massn": [nl, C, n, K], "attn": [nl, n, n], "arm": arm_shape, "head": [n, int(rec["head_read"].shape[1])]}, "bytes_": sizes, "embed_norm": [round(float(v), 3) for v in rec["embed_norm"]], "entropy": [round(float(v), 4) for v in rec["entropy"]], "p_actual": [round(float(v), 5) for v in rec["p_actual"]], "top_ids": rec["top_ids"].tolist(), "top_p": [[round(float(v), 5) for v in row] for row in rec["top_p"]], "per_layer": per_layer, } with open(os.path.join(d, "summary.json"), "w", encoding="utf-8", newline="\n") as f: json.dump(summary, f, separators=(",", ":")) return sizes def main(): out = sys.argv[sys.argv.index("--out") + 1] if "--out" in sys.argv else OUT global MAXB if "--max-bytes" in sys.argv: MAXB = int(sys.argv[sys.argv.index("--max-bytes") + 1]) sys.path.insert(0, REPO) from transformers import AutoModelForCausalLM m = AutoModelForCausalLM.from_pretrained(REPO, trust_remote_code=True) m = m.to(DEV).eval() print(f"[capture] {sum(p.numel() for p in m.parameters())/1e6:.1f}M on {DEV}") os.makedirs(out, exist_ok=True) card = m.arm_card(ARM) manifest = {"model": "AbstractPhil/mini-beatrix-2.5s", "core": "mini-beatrix-2s @ step 61,422 (237.1M, unchanged)", "arm": {"id": ARM, "title": card["title"], "cell": card["cell"], "score": card["score"], "status": card["status"], "params": 8565780, "sites": 20}, "precision": "fp32, greedy", "device": DEV, "captures": []} for spec in PROMPTS: root = os.path.join(out, spec["id"]) os.makedirs(root, exist_ok=True) m.mount_arm(ARM) reply_arm = m.say(spec["text"], max_new=spec["max_new"]) frame = m.default_frame() ids = m.render(spec["text"], frame=frame) seq = torch.cat([ids, torch.tensor( [list(reply_arm.encode("utf-8"))], dtype=torch.long, device=ids.device)], dim=1)[:, :MAXB] n_prompt = min(int(ids.shape[1]), int(seq.shape[1])) rec_arm = trace(m.model, seq) s_arm = emit(rec_arm, root, "arm") m.detach_arm(verify=True) reply_core = m.say(spec["text"], frame=frame, max_new=spec["max_new"]) rec_core = trace(m.model, seq) s_core = emit(rec_core, root, "core") by = seq[0].cpu().numpy().tolist() manifest["captures"].append({ "id": spec["id"], "title": spec["title"], "why": spec["why"], "prompt": spec["text"], "frame": frame, "gold": spec.get("gold"), "n": len(by), "n_prompt": n_prompt, "bytes": by, "reply_arm": reply_arm, "reply_core": reply_core, "sizes": {"arm": s_arm, "core": s_core}}) print(f"[capture] {spec['id']}: n={len(by)} prompt={n_prompt}") print(f" arm -> {reply_arm[:90]!r}") print(f" core -> {reply_core[:90]!r}") manifest["codebooks"] = codebook_health(m.model) with open(os.path.join(out, "manifest.json"), "w", encoding="utf-8", newline="\n") as f: json.dump(manifest, f, ensure_ascii=False, indent=1) tot = sum(os.path.getsize(os.path.join(dp, f)) for dp, _, fs in os.walk(out) for f in fs) print(f"[capture] written to {out} ({tot/1e6:.1f} MB)") if __name__ == "__main__": main()