Datasets:
Modalities:
Text
Formats:
json
Size:
< 1K
Tags:
multilingual
mathematical-word-problems
natural-language-to-formal-language
multi-agent-systems
benchmark
conversational-interfaces
Download tools/ablation.py from tailot/math-stratum: direct link, hf CLI and curl.
- Browser
- Download file 10.3 kB
-
https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tools/ablation.py
- Command line
-
hf download hf://datasets/tailot/math-stratum/tools/ablation.py
-
curl -L -o ablation.py https://huggingface.co/datasets/tailot/math-stratum/resolve/main/tools/ablation.py
10.3 kB
| #!/usr/bin/env python3 | |
| """Fault injection: how many conversational nodes does the assurance ceiling need? | |
| For every configuration (a subset of the eight nodes) and every fault of the catalogue | |
| (``lgstratum/faults.py``) a probe set of the corpus is run in memory with the very same node code | |
| the orchestrator runs. A run is *activated* when the injected fault really changed a node. Each | |
| activated run is then measured against the honest result of the same item, and ends in one of: | |
| raised : the fault pushed the shown assurance above the honest ceiling -- an invariant | |
| violation, and the only outcome this topology is not allowed to produce | |
| lowered : the answer stayed what the gold asked but the confidence dropped: another node | |
| compensated by withdrawing certainty, which is the designed reaction | |
| masked : the gold still holds at the same assurance, because the fault changed nothing | |
| that the referee reads | |
| abstained : the layer withdrew the answer entirely (assurance zero) while the gold expected one | |
| caught : an answer was shown that the gold does not accept, but the session pointed at its | |
| own gap: a claim fell to the referee of its node, or the assurance sits below the | |
| honest one because the configuration itself lost a node | |
| silent_error : a wrong answer presented with confidence while nothing in the session said so | |
| Usage: python math-stratum/tools/ablation.py [--probe N] [--all] [--out math-stratum/results/ablation.json] | |
| """ | |
| import argparse | |
| import json | |
| import sys | |
| import time | |
| from pathlib import Path | |
| from typing import Any, Dict, List, Tuple | |
| ROOT = Path(__file__).resolve().parents[1] | |
| sys.path.insert(0, str(ROOT)) | |
| from lgstratum import agents, corpus, faults, pipeline # noqa: E402 | |
| FULL = list(agents.ORDER) | |
| OUT = ROOT / "results" / "ablation.json" | |
| CONFIGS: Dict[str, List[str]] = { | |
| "S1 reader_a": ["reader_a"], | |
| "S2 +reader_b": ["reader_a", "reader_b"], | |
| "S3 +equivalence": ["reader_a", "reader_b", "equivalence"], | |
| "S4 +coverage": ["reader_a", "reader_b", "equivalence", "coverage"], | |
| "S5 +invoker": ["reader_a", "reader_b", "equivalence", "coverage", "invoker"], | |
| "S6 +boundary": FULL[:6], | |
| "S7 +adversary": FULL[:7], | |
| "S8 full topology": FULL, | |
| } | |
| for _node in FULL: | |
| CONFIGS["S8 minus %s" % _node] = [node for node in FULL if node != _node] | |
| def single_faults(active: List[str]) -> List[Tuple[str, ...]]: | |
| # Not every node has a fault to commit: the invoker reads nothing and proves nothing. | |
| return [("%s:%s" % (node, kind),) for node in active for kind in faults.CATALOG.get(node, [])] | |
| def multi_faults() -> List[Tuple[str, ...]]: | |
| """The pairs that matter here: both readers wrong in the same way, and certainty forced on | |
| top of a reading that no longer holds.""" | |
| out: List[Tuple[str, ...]] = [ | |
| ("reader_a:merge_slots", "reader_b:merge_slots"), | |
| ("reader_a:shift_number", "reader_b:shift_number"), | |
| ("reader_a:drop_marker", "reader_b:drop_marker"), | |
| ("equivalence:rubber_stamp", "coverage:rubber_stamp"), | |
| ("boundary:tamper_math", "arbiter:force_assurance"), | |
| ("reader_a:shift_number", "equivalence:rubber_stamp"), | |
| ("reader_a:merge_slots", "arbiter:force_assurance"), | |
| ("boundary:tamper_math", "adversary:rubber_stamp", "arbiter:force_assurance"), | |
| ] | |
| return [spec for spec in out if all(part.split(":")[0] in faults.CATALOG for part in spec)] | |
| def honest(item: Dict[str, Any]) -> Dict[str, Any]: | |
| """The baseline the injected runs are measured against: no fault, full topology.""" | |
| faults.configure([]) | |
| result = pipeline.ask(item["question"], item["lang"], active=FULL) | |
| grade = corpus.grade(item, result) | |
| return {"ok": bool(grade["ok"]), "assurance": int(result["final"].get("assurance", 0)), | |
| "state": str(result["final"].get("state", "NONE")), "problems": grade["problems"]} | |
| def flagged(result: Dict[str, Any]) -> bool: | |
| """Did the session itself point at the problem: a claim that did not survive its own referee.""" | |
| final = result.get("final") or {} | |
| if final.get("detected"): | |
| return True | |
| return any(record["claimed"] != record["referee"] for record in result.get("records") or []) | |
| def classify(base: Dict[str, Any], item: Dict[str, Any], result: Dict[str, Any]) -> str: | |
| """What an injected fault ended up doing to what the layer shows. | |
| ``raised`` is the violation the tool exists to look for. ``silent_error`` is the narrower thing it | |
| is supposed to prevent: a wrong answer was shown, and nothing in the session said so. When a | |
| envelope claim fell to its referee, or the assurance sits below the honest one because the | |
| topology itself was weakened, the run is ``caught``: the layer still answered, but it pointed at | |
| its own gap. | |
| """ | |
| shown = int(result["final"].get("assurance", 0)) | |
| grade = corpus.grade(item, result) | |
| if shown > base["assurance"]: | |
| return "raised" | |
| if grade["ok"]: | |
| return "lowered" if shown < base["assurance"] else "masked" | |
| if shown == 0: | |
| return "abstained" | |
| return "caught" if (flagged(result) or shown < base["assurance"]) else "silent_error" | |
| def run_cell(items: List[Dict[str, Any]], active: List[str], spec: Tuple[str, ...], | |
| base: Dict[str, Dict[str, Any]], config: str = "") -> Dict[str, Any]: | |
| tally = {"runs": 0, "activated": 0, "raised": 0, "lowered": 0, "masked": 0, "caught": 0, | |
| "abstained": 0, "silent_error": 0, "details": []} | |
| for item in items: | |
| # The session itself has to carry the fault: asking for it beforehand is not enough, because | |
| # a session configures the faults it was given and leaves the others off. | |
| result = pipeline.ask(item["question"], item["lang"], active=active, fault_spec=list(spec)) | |
| tally["runs"] += 1 | |
| if not faults.FIRED: | |
| continue | |
| tally["activated"] += 1 | |
| label = classify(base[item["id"]], item, result) | |
| tally[label] += 1 | |
| if label in ("raised", "silent_error", "caught"): | |
| grade = corpus.grade(item, result) | |
| tally["details"].append({"id": item["id"], "config": config, "fault": list(spec), | |
| "label": label, "honest": base[item["id"]]["assurance"], | |
| "shown": int(result["final"].get("assurance", 0)), | |
| "flagged": flagged(result), "problems": grade["problems"]}) | |
| return tally | |
| def probe_set(items: List[Dict[str, Any]], count: int) -> List[Dict[str, Any]]: | |
| """Spread the probe across the languages instead of taking the first N of one variety.""" | |
| if count >= len(items): | |
| return list(items) | |
| by_lang: Dict[str, List[Dict[str, Any]]] = {} | |
| for item in items: | |
| by_lang.setdefault(item["lang"], []).append(item) | |
| picked: List[Dict[str, Any]] = [] | |
| rank = 0 | |
| while len(picked) < count: | |
| added = False | |
| for lang in sorted(by_lang): | |
| pool = by_lang[lang] | |
| if rank < len(pool) and len(picked) < count: | |
| picked.append(pool[rank]) | |
| added = True | |
| if not added: | |
| break | |
| rank += 1 | |
| return picked | |
| def main(argv: List[str] = None) -> int: | |
| parser = argparse.ArgumentParser(description=__doc__.splitlines()[0]) | |
| parser.add_argument("--probe", type=int, default=12, help="how many corpus items to run per cell") | |
| parser.add_argument("--all", action="store_true", help="run the whole corpus in every cell") | |
| parser.add_argument("--out", default=str(OUT), help="where to write the JSON report") | |
| args = parser.parse_args(argv) | |
| items = corpus.load() | |
| probes = items if args.all else probe_set(items, max(1, args.probe)) | |
| print("probe set: %d items over %s" % (len(probes), ", ".join(sorted({i["lang"] for i in probes})))) | |
| base = {} | |
| for item in probes: | |
| base[item["id"]] = honest(item) | |
| print("honest %-9s %-12s assurance %d %s" % (item["id"], base[item["id"]]["state"], | |
| base[item["id"]]["assurance"], | |
| "" if base[item["id"]]["ok"] else base[item["id"]]["problems"])) | |
| report: Dict[str, Any] = {"probe": [item["id"] for item in probes], "cells": {}} | |
| started = time.time() | |
| for name in sorted(CONFIGS): | |
| active = CONFIGS[name] | |
| specs = single_faults(active) | |
| if name == "S8 full topology": | |
| specs.extend(multi_faults()) | |
| for spec in specs: | |
| cell = run_cell(probes, active, spec, base, config=name) | |
| key = "%s | %s" % (name, ",".join(spec)) | |
| report["cells"][key] = cell | |
| print("%-46s runs %2d activated %2d raised %d silent %d caught %d abstained %d " | |
| "lowered %d masked %d" | |
| % (key, cell["runs"], cell["activated"], cell["raised"], cell["silent_error"], | |
| cell["caught"], cell["abstained"], cell["lowered"], cell["masked"])) | |
| totals = {"runs": 0, "activated": 0, "raised": 0, "lowered": 0, "masked": 0, "caught": 0, | |
| "abstained": 0, "silent_error": 0} | |
| for cell in report["cells"].values(): | |
| for key in totals: | |
| totals[key] += cell[key] | |
| report["totals"] = totals | |
| report["seconds"] = round(time.time() - started, 1) | |
| report["violations"] = [detail for cell in report["cells"].values() for detail in cell["details"]] | |
| destination = Path(args.out) | |
| destination.parent.mkdir(parents=True, exist_ok=True) | |
| destination.write_text(json.dumps(report, indent=1, sort_keys=True) + "\n", encoding="utf-8") | |
| print("") | |
| print("cells %d, activated %d, raised %d, silent errors %d, caught %d, abstained %d, lowered %d, " | |
| "masked %d" | |
| % (len(report["cells"]), totals["activated"], totals["raised"], totals["silent_error"], | |
| totals["caught"], totals["abstained"], totals["lowered"], totals["masked"])) | |
| print("wrote %s in %.1f seconds" % (destination, report["seconds"])) | |
| return 1 if totals["raised"] else 0 | |
| if __name__ == "__main__": | |
| raise SystemExit(main()) | |