| """Render the NEW (unbundled v3) confuser trie and compare to the OLD one.
|
|
|
| The canonical renderer (distractor_generation_2/visualize.py) builds a trie over
|
| each row's `calls` name-sequence, colouring the real prefix BLUE and confuser
|
| look-alikes ORANGE. We reuse it, but feed it our v3 split dataset so you can see
|
| how unbundling reshaped the trie:
|
|
|
| OLD: 795 confusers, each a single long mega-turn -> deep root->leaf paths.
|
| NEW: each split confuser becomes T1 (real prefix -> confuser node F, the
|
| preserved divergence) plus re-rooted tail turns (own short paths from
|
| ROOT). Result: shallower, wider trie that mirrors real tau2 turn shapes.
|
|
|
| Outputs (into this folder): trie_v3.txt, trie_v3.svg, trie_v3.png
|
| Run: python -u temp/story_remediation/unbundle/visualize_v3.py
|
| """
|
| from __future__ import annotations
|
| import json, sys
|
| from pathlib import Path
|
|
|
| HERE = Path(__file__).resolve().parent
|
| ROOT = HERE.parents[2]
|
| sys.path.insert(0, str(ROOT))
|
| from models.trie import Trie
|
| from distractor_generation_2.visualize import (
|
| _load_seqs, _load_names, _text_tree, _render_image)
|
|
|
| N100 = ROOT / "distractor_generation_2" / "datasets" / "n100"
|
| V3 = HERE / "out" / "trajectories_all_v3.jsonl"
|
| REAL_APIS = ROOT / "data" / "tau-2" / "processed" / "apis.jsonl"
|
|
|
|
|
| def seqs_from(path: Path):
|
| out = []
|
| for line in path.read_text(encoding="utf-8").splitlines():
|
| if not line.strip():
|
| continue
|
| e = json.loads(line)
|
| s = [c["name"] for c in e.get("calls", []) if c.get("name")]
|
| if s:
|
| out.append(s)
|
| return out
|
|
|
|
|
| def build(seqs):
|
| t = Trie()
|
| for s in seqs:
|
| t.insert(list(s))
|
| return t
|
|
|
|
|
| def stats(trie, classify):
|
| lines, st, cls = _text_tree(trie.root, classify, 1)
|
| root_branch = sum(1 for c in trie.root.children.values())
|
| depths = []
|
|
|
| def walk(node, d):
|
| if not node.children:
|
| depths.append(d); return
|
| for c in node.children.values():
|
| walk(c, d + 1)
|
| walk(trie.root, 0)
|
| return dict(nodes=st["nodes"], max_depth=st["max_depth"],
|
| root_branch=root_branch, leaves=len(depths),
|
| mean_leaf_depth=sum(depths) / max(len(depths), 1)), lines
|
|
|
|
|
| def main():
|
| try:
|
| sys.stdout.reconfigure(encoding="utf-8", errors="replace")
|
| except Exception:
|
| pass
|
| real_names = _load_names(REAL_APIS)
|
| conf_names = _load_names(N100 / "apis.jsonl")
|
|
|
| def classify(name: str) -> str:
|
| if name in conf_names:
|
| return "confuser"
|
| if name in real_names:
|
| return "real"
|
| return "?"
|
|
|
| old_seqs = seqs_from(N100 / "trajectories.jsonl")
|
| new_seqs = seqs_from(V3)
|
| old_trie = build(old_seqs)
|
| new_trie = build(new_seqs)
|
| old_st, _ = stats(old_trie, classify)
|
| new_st, new_lines = stats(new_trie, classify)
|
|
|
| print("=" * 74)
|
| print("CONFUSER TRIE — OLD (single mega-turn) vs NEW (unbundled v3)")
|
| print("=" * 74)
|
| print(f"{'metric':22s}{'OLD':>12s}{'NEW':>12s}")
|
| for k in ("nodes", "max_depth", "root_branch", "leaves", "mean_leaf_depth"):
|
| ov, nv = old_st[k], new_st[k]
|
| of = f"{ov:.2f}" if isinstance(ov, float) else str(ov)
|
| nf = f"{nv:.2f}" if isinstance(nv, float) else str(nv)
|
| print(f"{k:22s}{of:>12s}{nf:>12s}")
|
| print(f"{'trajectories(rows)':22s}{len(old_seqs):>12d}{len(new_seqs):>12d}")
|
|
|
| header = [
|
| "NEW UNBUNDLED CONFUSER TRIE (v3) — built over the split dataset",
|
| "=" * 72,
|
| f"rows: {len(new_seqs)} nodes: {new_st['nodes']} max depth: {new_st['max_depth']} "
|
| f"root branches: {new_st['root_branch']} mean leaf depth: {new_st['mean_leaf_depth']:.2f}",
|
| "Legend: [real] BLUE = real prefix the confuser anchors to; "
|
| "[confuser] ORANGE = retail look-alike (the divergence node F).",
|
| "=" * 72, "",
|
| ]
|
| (HERE / "trie_v3.txt").write_text("\n".join(header + new_lines), encoding="utf-8")
|
| print(f"\ntext tree -> {(HERE/'trie_v3.txt').relative_to(ROOT)} ({len(new_lines)} lines)")
|
|
|
| png = _render_image(new_trie.root, classify, HERE / "trie_v3", 1, "png")
|
| svg = _render_image(new_trie.root, classify, HERE / "trie_v3", 1, "svg")
|
| if png:
|
| print(f"PNG -> {png}")
|
| if svg:
|
| print(f"SVG -> {svg}")
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
