Datasets:
Tasks:
Text Classification
Formats:
parquet
Languages:
Ancient Greek (to 1453)
Size:
100K - 1M
ArXiv:
License:
File size: 6,146 Bytes
1e6d8b5 | 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 | #!/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()
|