| |
| """Score turns through the trainer's own forward and, optionally, through a pw-decide |
| launcher, so a head can be checked before the engine is blamed: the two paths agree |
| to the fourth decimal when the engine is right, and a head that scores nothing here |
| was never trained, whatever its training log said. |
| |
| The head must record the encoding settings it trained with, and they must be the |
| ones the engine serves at. Exit 0 when they match and the engine agrees within |
| --tolerance, 1 on a mismatch or a larger gap, 2 when the head records no settings |
| or nothing was compared (no --engine, or no complete turns). |
| |
| Usage: parity_probe.py --model ID --head FILE --examples FILE [--engine LAUNCHER] [--n 6] |
| [--corpus <decide dir>/corpus.json] [--tolerance 0.001] |
| """ |
| import argparse |
| import json |
| import os |
| import subprocess |
| import sys |
|
|
| os.environ.setdefault("TRANSFORMERS_OFFLINE", "1") |
| os.environ.setdefault("TOKENIZERS_PARALLELISM", "false") |
|
|
| import torch |
| import laya |
| from safetensors.torch import load_file |
|
|
| sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) |
| import headfile |
| import rows as rowfile |
| from corpus import Corpus, decide_dir |
| from train import forward_head, multi_item, precompute, state_text |
|
|
|
|
| def torch_probs(agent, model, corpus, ex, device): |
| context = int(agent.cfg.get("max_len", 512)) |
| head_max_len = min(int(corpus.state_spec.get("head_tokens", 512)), context - 64) |
| tools_q = corpus.multi_question("tool", ex["offered"]["loadable"]) |
| item = multi_item(agent.tok, state_text(ex["state"]), tools_q, {k: 0 for k in tools_q["options"]}, context, head_max_len, "tools") |
| names = list(tools_q["options"].keys())[: len(item["markers"])] |
| f = precompute(agent, [item], device)[0] |
| with torch.no_grad(): |
| logits = forward_head(model, f["h"][None].to(device), f["att"][None].to(device), f["marker_pos"][None].to(device), |
| f["marker_mask"][None].to(device), torch.tensor([item["qtype"]], device=device))[0].cpu() |
| return dict(zip(names, torch.sigmoid(logits[: len(names)]).tolist())) |
|
|
|
|
| def engine_probs(proc, corpus, ex): |
| req = {"method": "decide", "head": "turn-load", "state": ex["state"], "questions": corpus.row_questions(ex)} |
| proc.stdin.write(json.dumps(req) + "\n") |
| proc.stdin.flush() |
| return json.loads(proc.stdout.readline())["answers"]["tools"]["probabilities"] |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--model", required=True) |
| ap.add_argument("--head", required=True) |
| ap.add_argument("--examples", required=True) |
| ap.add_argument("--engine", default=os.environ.get("LYCAON_DECIDE_ENGINE")) |
| ap.add_argument("--corpus", default=str(decide_dir() / "corpus.json")) |
| ap.add_argument("--n", type=int, default=6) |
| ap.add_argument("--tolerance", type=float, default=1e-3, help="the largest engine-trainer probability gap that passes") |
| args = ap.parse_args() |
| device = os.environ.get("LAYA_DEVICE") or ("mps" if torch.backends.mps.is_available() else "cpu") |
| agent = laya.load(args.model, device=device) |
| model = agent.model |
| tensors = load_file(args.head, device=device) |
| for module in ("head", "scorer", "type_emb"): |
| state = {k[len(module) + 1:]: v for k, v in tensors.items() if k.startswith(module + ".")} |
| if state: |
| getattr(model, module).load_state_dict(state) |
| model.eval() |
| |
| |
| meta = headfile.read_metadata(args.head)[0] |
| context = int(agent.cfg.get("max_len", 512)) |
| budget = min(int(Corpus.load(args.corpus).state_spec.get("head_tokens", 512)), context - 64) |
| if "max_len" not in meta or "head_max_len" not in meta: |
| print("parity: unverified; the head records no encoding settings") |
| return 2 |
| if (int(meta["max_len"]), int(meta["head_max_len"])) != (context, budget): |
| print("parity: the head was trained at max_len %s, head budget %s; the engine encodes at %d, %d" % ( |
| meta["max_len"], meta["head_max_len"], context, budget)) |
| return 1 |
| corpus = Corpus.load(args.corpus) |
| proc = None |
| if args.engine: |
| proc = subprocess.Popen([args.engine], stdin=subprocess.PIPE, stdout=subprocess.PIPE, text=True, bufsize=1) |
| proc.stdin.write(json.dumps({"method": "hello"}) + "\n") |
| proc.stdin.flush() |
| proc.stdout.readline() |
| worst = 0.0 |
| examples = [ex for ex in rowfile.load(args.examples) if not ex["partial"]][: args.n] |
| for ex in examples: |
| pt = torch_probs(agent, model, corpus, ex, device) |
| top = sorted(pt.items(), key=lambda kv: -kv[1])[:5] |
| truth = sorted(rowfile.truth_tools(ex)) |
| print("truth", truth) |
| print(" trainer top", [(k, round(v, 3)) for k, v in top], "| truth p", [(t, round(pt.get(t, -1), 3)) for t in truth]) |
| if proc is not None: |
| pe = engine_probs(proc, corpus, ex) |
| gap = max(abs(pe.get(k, 0.0) - v) for k, v in pt.items()) |
| worst = max(worst, gap) |
| print(" engine top", [(k, round(pe.get(k, 0.0), 3)) for k, _ in top], "| max |engine - trainer| %.4f" % gap) |
| if proc is not None: |
| proc.stdin.close() |
| proc.wait() |
| print("parity: worst gap %.4f over %d turns" % (worst, len(examples))) |
| if worst > args.tolerance: |
| return 1 |
| if proc is None or not examples: |
| print("parity: unverified; no engine answers were compared") |
| return 2 |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
