Datasets:
Tasks:
Text Classification
Formats:
parquet
Languages:
Ancient Greek (to 1453)
Size:
100K - 1M
ArXiv:
License:
| #!/usr/bin/env python3 | |
| """Compare the two manual audits of the machine syntax layer with each other. | |
| The first audit *corrected* the parser's trees token by token; the second | |
| annotated the same 100 sentences from scratch, without seeing the parser's | |
| output or the first audit. Their agreement is the inter-annotator agreement | |
| of one annotator (Claude Fable 5.1) in two conditions, and the difference | |
| between the parser's score against each is the anchoring effect of correcting | |
| rather than annotating: a corrector who leaves a parser decision alone unless | |
| it is clearly wrong will agree with the parser more than an independent | |
| annotator does. | |
| Writes one JSON report with, for every pair among {parser, corrected, | |
| scratch}: UAS, LAS, label accuracy, UPOS accuracy, FEATS micro-F1 and the | |
| per-label agreement, plus the three-way counts (all agree, parser agrees with | |
| one audit only, the audits agree against the parser, all differ) for heads. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from collections import Counter | |
| from itertools import combinations | |
| from pathlib import Path | |
| try: | |
| from scripts.machine_syntax_audit import feats_set, label_scores, load_jsonl, set_scores | |
| except ModuleNotFoundError: # Direct execution from the scripts directory. | |
| from machine_syntax_audit import feats_set, label_scores, load_jsonl, set_scores | |
| def pairwise(a: dict[str, dict], b: dict[str, dict]) -> dict: | |
| heads = deprels = both = tokens = 0 | |
| upos_pairs, deprel_pairs, feats_pairs = [], [], [] | |
| for sentence_id in sorted(set(a) & set(b)): | |
| ta, tb = a[sentence_id]["tokens"], b[sentence_id]["tokens"] | |
| assert [t["form"] for t in ta] == [t["form"] for t in tb], sentence_id | |
| for x, y in zip(ta, tb): | |
| tokens += 1 | |
| head_ok = x["head"] == y["head"] | |
| deprel_ok = x["deprel"] == y["deprel"] | |
| heads += head_ok | |
| deprels += deprel_ok | |
| both += head_ok and deprel_ok | |
| upos_pairs.append((x["upos"], y["upos"])) | |
| deprel_pairs.append((x["deprel"], y["deprel"])) | |
| feats_pairs.append((feats_set(x["feats"]), feats_set(y["feats"]))) | |
| return { | |
| "tokens": tokens, | |
| "uas": round(heads / tokens, 4), | |
| "las": round(both / tokens, 4), | |
| "label_accuracy": round(deprels / tokens, 4), | |
| "upos_accuracy": round(label_scores(upos_pairs)["accuracy"], 4), | |
| "upos_macro_f1": label_scores(upos_pairs)["macro"].get("f1"), | |
| "feats_micro_f1": set_scores(feats_pairs)["micro"]["f1"], | |
| "feats_exact_set_accuracy": set_scores(feats_pairs)["exact_set_accuracy"], | |
| "deprel_per_label_f1": { | |
| label: values["f1"] for label, values in label_scores(deprel_pairs)["per_label"].items() | |
| }, | |
| } | |
| def three_way(parser: dict, corrected: dict, scratch: dict, field: str) -> dict: | |
| counts: Counter = Counter() | |
| for sentence_id in sorted(set(parser) & set(corrected) & set(scratch)): | |
| for p, c, s in zip(parser[sentence_id]["tokens"], corrected[sentence_id]["tokens"], | |
| scratch[sentence_id]["tokens"]): | |
| pc, ps, cs = p[field] == c[field], p[field] == s[field], c[field] == s[field] | |
| if pc and ps: | |
| counts["all_three_agree"] += 1 | |
| elif cs: | |
| counts["audits_agree_against_parser"] += 1 | |
| elif pc: | |
| counts["parser_agrees_with_corrected_only"] += 1 | |
| elif ps: | |
| counts["parser_agrees_with_scratch_only"] += 1 | |
| else: | |
| counts["all_three_differ"] += 1 | |
| total = sum(counts.values()) | |
| return {key: {"count": value, "share": round(value / total, 4)} for key, value in sorted(counts.items())} | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--machine", type=Path, required=True) | |
| parser.add_argument("--corrected", type=Path, required=True) | |
| parser.add_argument("--scratch", type=Path, required=True) | |
| parser.add_argument("--output", type=Path, required=True) | |
| args = parser.parse_args() | |
| machine = load_jsonl(args.machine) | |
| corrected = load_jsonl(args.corrected) | |
| scratch = load_jsonl(args.scratch) | |
| assert set(machine) == set(corrected) == set(scratch), "the three files must cover the same sentences" | |
| sets = {"parser": machine, "corrected": corrected, "scratch": scratch} | |
| report = { | |
| "annotators": { | |
| "corrected": "Claude Fable 5.1 correcting the parser's trees token by token (2026-09-18)", | |
| "scratch": "Claude Fable 5.1 annotating the same sentences from forms alone, without the " | |
| "parser's trees or the first audit (2026-09-22)", | |
| }, | |
| "sentences": len(machine), | |
| "pairs": { | |
| f"{a}_vs_{b}": pairwise(sets[a], sets[b]) for a, b in combinations(sets, 2) | |
| }, | |
| "three_way": { | |
| "head": three_way(machine, corrected, scratch, "head"), | |
| "deprel": three_way(machine, corrected, scratch, "deprel"), | |
| "upos": three_way(machine, corrected, scratch, "upos"), | |
| }, | |
| } | |
| p_c = report["pairs"]["parser_vs_corrected"] | |
| p_s = report["pairs"]["parser_vs_scratch"] | |
| report["anchoring"] = { | |
| "description": "how much more the parser agrees with the audit that started from its " | |
| "trees than with the one that did not", | |
| "uas": round(p_c["uas"] - p_s["uas"], 4), | |
| "las": round(p_c["las"] - p_s["las"], 4), | |
| "upos_accuracy": round(p_c["upos_accuracy"] - p_s["upos_accuracy"], 4), | |
| "feats_micro_f1": round(p_c["feats_micro_f1"] - p_s["feats_micro_f1"], 4), | |
| } | |
| args.output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") | |
| summary = { | |
| key: {k: v for k, v in values.items() if k != "deprel_per_label_f1"} | |
| for key, values in report["pairs"].items() | |
| } | |
| print(json.dumps({"pairs": summary, "anchoring": report["anchoring"], | |
| "three_way_head": report["three_way"]["head"]}, indent=2)) | |
| if __name__ == "__main__": | |
| main() | |