Datasets:
Modalities:
Text
Formats:
json
Size:
< 1K
Tags:
multilingual
mathematical-word-problems
natural-language-to-formal-language
multi-agent-systems
benchmark
conversational-interfaces
File size: 8,760 Bytes
e9dac18 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 | #!/usr/bin/env python3
"""Ask a question in a human language and get the answer of the math stratum back in that language.
python tools/ask.py --lang it "risolvi x^2 - 5*x + 6 = 0 per x"
python tools/ask.py --lang en "solve x^2 - 5*x + 6 = 0 for x" --json
python tools/ask.py --lang ar --corpus problems/corpus.jsonl --limit 6
Run from this folder (it is ``datasets/math-stratum`` inside the LingoLOGOS repository, and the
bundle root when the dataset is cloned on its own).
The script builds a throw away workspace (node datasets, seed with the question and its language,
launcher), runs the eight node processes through ``MultiInstanceOrchestrator``, and then re-derives
the verdict from the transcript: it recomputes the arbiter's decision from the evidence the envelopes
carry, and checks that the Z3 run of the orchestrator agrees with what every node claimed about its
own envelope. What is printed is that re-derived verdict, not the one the arbiter wrote.
The prose of this script and of its labels stays English, as the repository requires; the answer
block is the one piece of data that is deliberately written in the language of the question, because
that answer is the object this bundle studies.
"""
import argparse
import json
import os
import shutil
import stat
import sys
import tempfile
from pathlib import Path
from typing import Any, Dict, List
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
# Inside the repository this bundle sits at <repo>/datasets/math-stratum, so the orchestrator
# package is no longer a sibling of the bundle. Walk up the tree until an ancestor carries it.
for _parent in ROOT.parents:
_candidate = _parent / "src"
if (_candidate / "lingologos_orchestrator").is_dir():
sys.path.insert(0, str(_candidate))
break
from lgstratum import corpus, pipeline, protocol, render # noqa: E402
def _launcher(directory: Path) -> Path:
agent = ROOT / "agents" / "stratum_agent"
if os.name == "nt":
path = directory / "stratum_agent.cmd"
path.write_text('@echo off\r\n"%s" "%s" %%*\r\n' % (sys.executable, agent))
else:
path = directory / "stratum_agent.sh"
path.write_text('#!/bin/sh\nexec "%s" "%s" "$@"\n' % (sys.executable, agent))
path.chmod(path.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
return path
def ask(question: str, lang: str, faults_spec: str = "", keep: bool = False) -> Dict[str, Any]:
"""Run one question through the real orchestrator and return the checked verdict."""
from lingologos_orchestrator.orchestrator import MultiInstanceOrchestrator
from lingologos_orchestrator.schema import OrchestratorError
workspace = Path(tempfile.mkdtemp(prefix="lgstratum_"))
try:
datasets = workspace / "datasets"
shutil.copytree(ROOT / "nodes", datasets)
seed_path = datasets / "arbiter" / "seed_payload.json"
seed = json.loads(seed_path.read_text(encoding="utf-8"))
seed["payload"]["naturalLanguage"] = pipeline.seed(question, lang)["payload"]["naturalLanguage"]
seed_path.write_text(json.dumps(seed, ensure_ascii=False), encoding="utf-8")
launcher = _launcher(workspace)
topology = json.loads((ROOT / "topology.json").read_text(encoding="utf-8"))
for instance in topology["instances"]:
instance["executable"] = str(launcher)
topology_path = workspace / "topology.json"
topology_path.write_text(json.dumps(topology), encoding="utf-8")
previous = os.environ.get("LGSTRATUM_FAULTS")
os.environ["LGSTRATUM_FAULTS"] = faults_spec
try:
orchestrator = MultiInstanceOrchestrator.from_config_file(
config_path=topology_path, datasets_dir=datasets,
runtime_state_dir=workspace / "runtime_state", workspace_dir=workspace)
result = orchestrator.run_session().to_dict()
except OrchestratorError as exc:
return {"final": _unknown("orchestrator error: %s" % str(exc)[:200]), "referee": [],
"records": [], "reply": None}
finally:
if previous is None:
os.environ.pop("LGSTRATUM_FAULTS", None)
else:
os.environ["LGSTRATUM_FAULTS"] = previous
return _check(result)
finally:
if keep:
print("workspace kept at %s" % workspace, file=sys.stderr)
else:
shutil.rmtree(workspace, ignore_errors=True)
def _unknown(reason: str) -> Dict[str, Any]:
return {"state": "NONE", "assurance": 0, "ceiling": 0, "math_assurance": 0, "math_status": None,
"answer": "", "reasons": [reason], "consulted_math": False, "detected": []}
def _check(result: Dict[str, Any]) -> Dict[str, Any]:
records: List[Dict[str, Any]] = result["records"]
referee = [{"sender": r["sender"], "claimed": r["envelope"]["payload"]["smtConstraints"]["z3Status"],
"referee": r["smt_result"]["status"]} for r in records]
dossier = protocol.decode(records[-1]["envelope"]["payload"]["naturalLanguage"])
final = pipeline.checked_verdict(dossier, referee, arbiter_expected=True)
return {"final": final, "referee": referee, "records": referee, "transcript": records,
"dossier": dossier, "reply": render.reply(dossier, final, referee), "turns": result["total_turns"]}
def _describe(outcome: Dict[str, Any]) -> str:
final = outcome["final"]
lines = []
lines.append("Reading state : %s" % final["state"])
lines.append("Assurance shown : %d (reading ceiling %d, math assurance %s)"
% (final["assurance"], final.get("ceiling", 0),
final.get("math_assurance")))
lines.append("Math layer status : %s" % (final.get("math_status") or "-"))
if final["reasons"]:
lines.append("Notes : %s" % "; ".join(final["reasons"]))
if final.get("detected"):
lines.append("Detected : %s" % ", ".join(str(item) for item in final["detected"]))
if outcome["referee"]:
agree = sum(1 for r in outcome["referee"] if r["claimed"] == r["referee"])
lines.append("Orchestrator Z3 check : %d of %d envelopes confirmed" % (agree, len(outcome["referee"])))
reply = outcome.get("reply")
if reply:
lines.append("")
lines.append("Answer in the language of the question (%s):" % reply["language"])
for line in reply["lines"]:
lines.append(" %s" % line)
return "\n".join(lines)
def main() -> int:
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
parser.add_argument("question", nargs="?", help="the question, written in the language given by --lang")
parser.add_argument("--lang", default="it", help="language of the question: it, en, es, zh, hi or ar")
parser.add_argument("--json", action="store_true", help="print the full machine readable outcome")
parser.add_argument("--faults", default="", help="comma separated node:fault pairs (experiments only)")
parser.add_argument("--keep", action="store_true", help="keep the temporary workspace")
parser.add_argument("--corpus", help="run every question of a corpus file and compare with its gold expectations")
parser.add_argument("--limit", type=int, default=0, help="with --corpus: only the first N questions")
args = parser.parse_args()
if args.corpus:
rows = corpus.load(args.corpus)
rows = rows[: args.limit] if args.limit else rows
tally: Dict[str, int] = {}
for item in rows:
outcome = ask(item["question"], item["lang"], args.faults, args.keep)
verdict = corpus.grade(item, outcome)
label = "ok" if verdict["ok"] else "wrong"
tally[label] = tally.get(label, 0) + 1
print("%-8s %-6s %-14s %s" % (verdict["id"], label, verdict["state"], item["question"]))
for problem in verdict["problems"]:
print(" %s" % problem)
print(json.dumps(tally, sort_keys=True))
return 0 if tally.get("wrong", 0) == 0 else 1
if not args.question:
parser.error("a question or --corpus is required")
outcome = ask(args.question, args.lang, args.faults, args.keep)
if args.json:
printable = {key: value for key, value in outcome.items() if key != "records"}
print(json.dumps(printable, indent=2, ensure_ascii=False, default=str))
else:
print(_describe(outcome))
if outcome["final"].get("detected"):
return 3
return 0 if int(outcome["final"].get("assurance", 0) or 0) > 0 else 2
if __name__ == "__main__":
sys.exit(main())
|