| """Score every option of a turn head with the trainer's own forward, tools and guides alike. |
| |
| Writes one row per complete example: the row's key, offered candidates and labels, and |
| the head's probability for every tool and guide option, encoded exactly as the engine |
| encodes them (one option per row for an independent head, the roster for a joint one). |
| The output feeds `guide_audit.py` and `turn_score.py` without an engine build. |
| |
| Usage: turn_probe.py --trainer DIR --corpus FILE --rows FILE --head FILE --out FILE [--limit N] |
| """ |
| import argparse |
| import hashlib |
| import json |
| import os |
| import sys |
| from pathlib import Path |
|
|
|
|
| def option_probs(agent, model, corpus, ex, device, kind, qid, family, torch, multi_item, precompute, forward_head, state_text): |
| """Probabilities per option of one multi question, encoded as the engine would.""" |
| context = int(agent.cfg.get("max_len", 512)) |
| head_max_len = min(int(corpus.state_spec.get("head_tokens", 512)), context - 64) |
| question = corpus.multi_question(kind, ex["offered"]["loadable" if kind == "tool" else "guides"]) |
| if not question["options"]: |
| return {} |
| state = state_text(ex["state"]) |
| if question.get("independent"): |
| items, names = [], [] |
| for name, text in question["options"].items(): |
| one = dict(question, options={name: text}) |
| items.append(multi_item(agent.tok, state, one, {name: 0}, context, head_max_len, family)) |
| names.append(name) |
| else: |
| item = multi_item(agent.tok, state, question, {k: 0 for k in question["options"]}, context, head_max_len, family) |
| items, names = [item], list(question["options"].keys())[: len(item["markers"])] |
| features = precompute(agent, items, device, batch_size=64) |
| out = {} |
| with torch.no_grad(): |
| for f, item in zip(features, items): |
| 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() |
| probs = torch.sigmoid(logits[: len(item["markers"])]).tolist() |
| if question.get("independent"): |
| out[names[len(out)]] = probs[0] |
| else: |
| out.update(zip(names, probs)) |
| return out |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| for name in ("trainer", "corpus", "rows", "head", "out"): |
| parser.add_argument("--" + name, required=True) |
| parser.add_argument("--model", default="convaiinnovations/laya-multilingual") |
| parser.add_argument("--limit", type=int, default=0, help="complete rows to score; 0 scores every complete row") |
| args = parser.parse_args() |
| sys.path.insert(0, str(Path(args.trainer) / "scripts/decide")) |
| import laya |
| import torch |
| from corpus import Corpus |
| from headfile import read_metadata |
| from rows import load |
| from safetensors.torch import load_file |
| from train import forward_head, multi_item, precompute, state_text |
|
|
| torch.set_num_threads(8) |
| device = os.environ.get("LYCAON_DECIDE_DEVICE", "cpu") |
| corpus = Corpus.load(args.corpus) |
| agent = laya.load(args.model, device=device) |
| meta = read_metadata(args.head)[0] |
| context = int(agent.cfg.get("max_len", 512)) |
| budget = min(int(corpus.state_spec.get("head_tokens", 512)), context - 64) |
| encoding = "independent" if corpus.independent() else "joint" |
| if (meta.get("max_len"), meta.get("head_max_len"), meta.get("tool_encoding", "joint")) != (str(context), str(budget), encoding): |
| raise ValueError("head encoding metadata does not match inference: %s" % {k: meta.get(k) for k in ("max_len", "head_max_len", "tool_encoding")}) |
| tensors = load_file(args.head, device=device) |
| for name in ("head", "scorer", "type_emb"): |
| getattr(agent.model, name).load_state_dict({k[len(name) + 1:]: v for k, v in tensors.items() if k.startswith(name + ".")}) |
| agent.model.eval() |
| examples = [r for r in load(args.rows) if not r["partial"]] |
| if args.limit: |
| examples = examples[: args.limit] |
| families = set((meta.get("families") or "tools,guides").split(",")) |
| signature = {name: hashlib.sha256(Path(getattr(args, name)).read_bytes()).hexdigest() for name in ("head", "corpus", "rows")} |
| helpers = (torch, multi_item, precompute, forward_head, state_text) |
| with Path(args.out).open("x") as out: |
| for n, row in enumerate(examples, 1): |
| answers = {} |
| if "tools" in families: |
| answers["tools"] = {"probabilities": option_probs(agent, agent.model, corpus, row, device, "tool", "tools", "tools", *helpers)} |
| if "guides" in families: |
| answers["guides"] = {"probabilities": option_probs(agent, agent.model, corpus, row, device, "guide", "guides", "guides", *helpers)} |
| json.dump({"key": "%s:%s" % (row["session"], row["receipt"]), "host": row["host"], "offered": row["offered"], |
| "labels": {"tools": row["labels"].get("tools", []), "guides": row["labels"].get("guides", {})}, |
| "answers": answers}, out) |
| out.write("\n") |
| if n % 100 == 0: |
| out.flush() |
| sys.stderr.write("scored %d/%d\n" % (n, len(examples))) |
| Path(args.out + ".meta.json").write_text(json.dumps({"sha256": signature, "encoding": meta, "device": device, "rows": len(examples)}, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
