| """Frozen inference-only attention-bias screen; never used as an editor baseline.""" |
|
|
| import argparse |
| import contextlib |
| import json |
| import math |
| from datetime import datetime, timezone |
| from pathlib import Path |
| from types import MethodType |
|
|
| import torch |
| from torch.nn import functional as F |
|
|
| from llm_memory_editability.bios_data import write_json |
| from llm_memory_editability.bios_direction import ROOT, digest, load_parent |
| from llm_memory_editability.bios_direction_cross import cross_tasks |
|
|
| ART = ROOT / "docs/development-artifacts/direction-routing-v1" |
| OUT = ROOT / "results/bios-direction-routing-v1" |
|
|
|
|
| @contextlib.contextmanager |
| def route_bias(model, layer, positions, target, strength): |
| module = model.blocks[layer].attention |
| original = module.forward |
|
|
| def forward(self, x): |
| n, t, width = x.shape |
| q, k, v = self.qkv(x).reshape(n, t, 3, self.heads, width // self.heads).unbind(2) |
| mask = torch.full((n, 1, t, t), -torch.inf, device=x.device, dtype=x.dtype) |
| causal = ( |
| torch.arange(t, device=x.device)[:, None] >= torch.arange(t, device=x.device)[None, :] |
| ) |
| mask.masked_fill_(causal, 0) |
| source = positions - 1 if target == "relation" else torch.ones_like(positions) |
| mask[torch.arange(n, device=x.device), 0, positions, source] += math.log(strength) |
| h = F.scaled_dot_product_attention( |
| q.transpose(1, 2), k.transpose(1, 2), v.transpose(1, 2), attn_mask=mask |
| ) |
| return self.proj(h.transpose(1, 2).reshape(n, t, width)) |
|
|
| module.forward = MethodType(forward, module) |
| try: |
| yield |
| finally: |
| module.forward = original |
|
|
|
|
| @torch.no_grad() |
| def evaluate(model, task, layer, target, strength): |
| ids = task.sets["E"] + task.sets["local"] + task.sets["D_focal"] |
| tokens = task.tokens[ids].clone() |
| positions = task.positions[ids, 0] |
| context = ( |
| contextlib.nullcontext() |
| if layer < 0 |
| else route_bias(model, layer, positions, target, strength) |
| ) |
| with context: |
| logits = model(tokens[:, :5], positions[:, None])[:, 0] |
| pred = logits.argmax(-1) |
| tokens[torch.arange(len(ids), device=tokens.device), positions + 1] = pred |
| ended = model(tokens, (positions + 1)[:, None])[:, 0].argmax(-1).eq(3) |
| correct = pred.eq(task.labels[ids, 0]) & ended |
| ne, nl = len(task.sets["E"]), len(task.sets["local"]) |
| return dict( |
| E=int(correct[:ne].sum()), |
| local=int(correct[ne : ne + nl].sum()), |
| local_n=nl, |
| D=int(correct[-1]), |
| prediction=int(pred[-1]), |
| joint=bool(correct.all()), |
| margin_ab=float(logits[-1, task.metadata["a"]] - logits[-1, task.metadata["b"]]), |
| ) |
|
|
|
|
| def freeze(): |
| files = [ |
| Path(__file__), |
| ROOT / "src/llm_memory_editability/bios_direction_cross.py", |
| ROOT / "src/llm_memory_editability/bios_direction.py", |
| ] |
| write_json( |
| ART / "lock.json", |
| dict( |
| created=datetime.now(timezone.utc).isoformat(), |
| parent_editor="func-soft-adam", |
| worlds=[0, 1], |
| seeds=[0, 1], |
| layers=list(range(8)), |
| targets=["relation", "entity"], |
| strengths=[0.25, 4.0], |
| controls="Unmodified forward and a bias of 1; all edits and weights unchanged.", |
| prediction=( |
| "Underweighting the final relation predicts a selective D benefit from " |
| "amplifying relation attention, compared with amplifying entity attention." |
| ), |
| selection=( |
| "World 0: max D gains subject to no total E/local loss versus baseline. " |
| "Test selected intervention on world 1. Retain all 32 interventions." |
| ), |
| status="Exploratory on existing worlds; no independent confirmation.", |
| files={str(p.relative_to(ROOT)): digest(p) for p in files}, |
| ), |
| ) |
| (ART / "source.py").write_bytes(Path(__file__).read_bytes()) |
|
|
|
|
| def run(world, device): |
| lock = json.loads((ART / "lock.json").read_text()) |
| for p, h in lock["files"].items(): |
| assert digest(ROOT / p) == h |
| results = [] |
| for seed in (0, 1): |
| parent = ( |
| ROOT |
| / "results/bios-cross-scale-dev-v1/width-256" |
| / f"world-{world}-seed-{seed}-neither/model-15360.pt" |
| ) |
| model = load_parent(parent, device) |
| tasks = cross_tasks(world, seed, device) |
| d = ROOT / f"results/bios-direction-cross-v1/main/world-{world}-seed-{seed}/func-soft-adam" |
| state = torch.load(d / "state.pt", map_location="cpu", weights_only=False) |
| records = json.loads((d / "metrics.json").read_text()) |
| for i, task in enumerate(tasks): |
| with torch.no_grad(): |
| model.blocks[4].mlp.down.weight.copy_(state["weights"][i].to(device)) |
| baseline = evaluate(model, task, -1, "relation", 1.0) |
| assert baseline["D"] == records[i]["timeline"][-1]["sets"]["D_focal"]["correct"] |
| sham = evaluate(model, task, 5, "relation", 1.0) |
| assert all(sham[k] == baseline[k] for k in ("E", "local", "D", "prediction")) |
| result = dict(metadata=task.metadata, baseline=baseline, conditions=[]) |
| for layer in range(8): |
| for target in ("relation", "entity"): |
| for strength in (0.25, 4.0): |
| result["conditions"].append( |
| dict( |
| layer=layer, |
| target=target, |
| strength=strength, |
| **evaluate(model, task, layer, target, strength), |
| ) |
| ) |
| results.append(result) |
| write_json(OUT / f"world-{world}.json", results) |
| print(json.dumps(dict(world=world, cases=len(results), conditions=32)), flush=True) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("command", choices=("freeze", "run")) |
| parser.add_argument("--world", type=int, default=0) |
| parser.add_argument("--device", default="cuda:0") |
| args = parser.parse_args() |
| torch.set_num_threads(2) |
| torch.backends.cuda.matmul.allow_tf32 = False |
| if args.command == "freeze": |
| freeze() |
| else: |
| run(args.world, torch.device(args.device)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
