Datasets:
Tasks:
Text Classification
Formats:
parquet
Languages:
Ancient Greek (to 1453)
Size:
100K - 1M
ArXiv:
License:
| #!/usr/bin/env python3 | |
| """Score the machine syntax layer against an independent manual correction. | |
| The benchmark deliberately does not measure `conllu_machine` against the | |
| treebank projects, because the point of the layer is to be agnostic to their | |
| conventions. Instead a sample of published machine trees was corrected token by | |
| token by a language model annotator (Claude Fable 5.1) following the Universal | |
| Dependencies v2 guidelines and its own written conventions, without access to | |
| any other annotation of those sentences. This script compares the parser's | |
| output with that correction and reports: | |
| * UAS, LAS and label accuracy for heads and dependency relations; | |
| * precision, recall and F1 per UPOS tag, with micro and macro averages; | |
| * precision, recall and F1 per FEATS key=value pair, with micro and macro | |
| averages, treating each token's features as a set. | |
| Tokens are fixed, so every token is compared. A record appearing more than once | |
| in the corrections file is taken from its last occurrence. | |
| """ | |
| from __future__ import annotations | |
| import argparse | |
| import json | |
| from collections import Counter, defaultdict | |
| from pathlib import Path | |
| def load_jsonl(path: Path) -> dict[str, dict]: | |
| records: dict[str, dict] = {} | |
| with path.open(encoding="utf-8") as stream: | |
| for line in stream: | |
| if line.strip(): | |
| record = json.loads(line) | |
| records[record["id"]] = record | |
| return records | |
| def prf(tp: int, fp: int, fn: int) -> dict[str, float]: | |
| precision = tp / (tp + fp) if tp + fp else 0.0 | |
| recall = tp / (tp + fn) if tp + fn else 0.0 | |
| f1 = 2 * precision * recall / (precision + recall) if precision + recall else 0.0 | |
| return {"precision": round(precision, 4), "recall": round(recall, 4), "f1": round(f1, 4), | |
| "support": tp + fn} | |
| def label_scores(pairs: list[tuple[str, str]]) -> dict: | |
| """Per-label precision/recall/F1 for one gold/predicted label per token.""" | |
| tp: Counter[str] = Counter() | |
| fp: Counter[str] = Counter() | |
| fn: Counter[str] = Counter() | |
| for gold, predicted in pairs: | |
| if gold == predicted: | |
| tp[gold] += 1 | |
| else: | |
| fp[predicted] += 1 | |
| fn[gold] += 1 | |
| labels = sorted(set(tp) | set(fp) | set(fn)) | |
| per_label = {label: prf(tp[label], fp[label], fn[label]) for label in labels} | |
| present = [label for label in labels if per_label[label]["support"]] | |
| macro = { | |
| key: round(sum(per_label[label][key] for label in present) / len(present), 4) | |
| for key in ("precision", "recall", "f1") | |
| } if present else {} | |
| accuracy = sum(tp.values()) / len(pairs) if pairs else 0.0 | |
| return {"accuracy": round(accuracy, 4), "macro": macro, "per_label": per_label} | |
| def set_scores(pairs: list[tuple[set[str], set[str]]]) -> dict: | |
| """Per-value precision/recall/F1 for a set of key=value features per token.""" | |
| tp: Counter[str] = Counter() | |
| fp: Counter[str] = Counter() | |
| fn: Counter[str] = Counter() | |
| exact = 0 | |
| for gold, predicted in pairs: | |
| if gold == predicted: | |
| exact += 1 | |
| for value in gold & predicted: | |
| tp[value] += 1 | |
| for value in predicted - gold: | |
| fp[value] += 1 | |
| for value in gold - predicted: | |
| fn[value] += 1 | |
| values = sorted(set(tp) | set(fp) | set(fn)) | |
| per_value = {value: prf(tp[value], fp[value], fn[value]) for value in values} | |
| present = [value for value in values if per_value[value]["support"]] | |
| macro = { | |
| key: round(sum(per_value[value][key] for value in present) / len(present), 4) | |
| for key in ("precision", "recall", "f1") | |
| } if present else {} | |
| micro = prf(sum(tp.values()), sum(fp.values()), sum(fn.values())) | |
| by_key: dict[str, dict[str, int]] = defaultdict(Counter) | |
| for counter, name in ((tp, "tp"), (fp, "fp"), (fn, "fn")): | |
| for value, count in counter.items(): | |
| by_key[value.split("=", 1)[0]][name] += count | |
| per_key = {key: prf(c["tp"], c["fp"], c["fn"]) for key, c in sorted(by_key.items())} | |
| return { | |
| "exact_set_accuracy": round(exact / len(pairs), 4) if pairs else 0.0, | |
| "micro": micro, "macro": macro, "per_key": per_key, "per_value": per_value, | |
| } | |
| def feats_set(value) -> set[str]: | |
| if not value or value == "_": | |
| return set() | |
| return set(value.split("|")) | |
| def main() -> None: | |
| parser = argparse.ArgumentParser(description=__doc__) | |
| parser.add_argument("--machine", type=Path, required=True, help="sampled machine trees (JSONL)") | |
| parser.add_argument("--corrected", type=Path, required=True, help="manual corrections (JSONL)") | |
| parser.add_argument("--conventions", type=Path, help="the annotator's conventions file, recorded by path") | |
| parser.add_argument("--output", type=Path, required=True) | |
| args = parser.parse_args() | |
| machine = load_jsonl(args.machine) | |
| corrected = load_jsonl(args.corrected) | |
| missing = sorted(set(machine) - set(corrected)) | |
| if missing: | |
| raise SystemExit(f"{len(missing)} sampled sentences have no correction: {missing[:5]}") | |
| heads = deprels = both = tokens = 0 | |
| upos_pairs: list[tuple[str, str]] = [] | |
| deprel_pairs: list[tuple[str, str]] = [] | |
| feats_pairs: list[tuple[set[str], set[str]]] = [] | |
| changed_sentences = 0 | |
| changed_tokens = 0 | |
| by_author: dict[str, Counter] = defaultdict(Counter) | |
| for sentence_id, sample in machine.items(): | |
| gold_tokens = corrected[sentence_id]["tokens"] | |
| predicted_tokens = sample["tokens"] | |
| assert len(gold_tokens) == len(predicted_tokens), sentence_id | |
| assert [t["form"] for t in gold_tokens] == [t["form"] for t in predicted_tokens], sentence_id | |
| sentence_changed = False | |
| for gold, predicted in zip(gold_tokens, predicted_tokens): | |
| tokens += 1 | |
| head_ok = gold["head"] == predicted["head"] | |
| deprel_ok = gold["deprel"] == predicted["deprel"] | |
| heads += head_ok | |
| deprels += deprel_ok | |
| both += head_ok and deprel_ok | |
| upos_pairs.append((gold["upos"], predicted["upos"])) | |
| deprel_pairs.append((gold["deprel"], predicted["deprel"])) | |
| gold_feats, predicted_feats = feats_set(gold["feats"]), feats_set(predicted["feats"]) | |
| feats_pairs.append((gold_feats, predicted_feats)) | |
| token_changed = not (head_ok and deprel_ok and gold["upos"] == predicted["upos"] | |
| and gold_feats == predicted_feats) | |
| changed_tokens += token_changed | |
| sentence_changed = sentence_changed or token_changed | |
| author = by_author[sample["author"]] | |
| author["tokens"] += 1 | |
| author["las"] += head_ok and deprel_ok | |
| author["upos"] += gold["upos"] == predicted["upos"] | |
| changed_sentences += sentence_changed | |
| report = { | |
| "annotator": "Claude Fable 5.1, manual token-by-token correction of the sampled machine trees, " | |
| "without access to any other annotation of the sentences", | |
| "conventions": str(args.conventions) if args.conventions else None, | |
| "sentences": len(machine), | |
| "tokens": tokens, | |
| "sentences_with_any_correction": changed_sentences, | |
| "tokens_with_any_correction": changed_tokens, | |
| "dependency": { | |
| "uas": round(heads / tokens, 4), | |
| "las": round(both / tokens, 4), | |
| "label_accuracy": round(deprels / tokens, 4), | |
| "deprel": label_scores(deprel_pairs), | |
| }, | |
| "upos": label_scores(upos_pairs), | |
| "feats": set_scores(feats_pairs), | |
| "by_author": { | |
| author: { | |
| "tokens": c["tokens"], | |
| "las": round(c["las"] / c["tokens"], 4), | |
| "upos_accuracy": round(c["upos"] / c["tokens"], 4), | |
| } | |
| for author, c in sorted(by_author.items()) | |
| }, | |
| } | |
| args.output.parent.mkdir(parents=True, exist_ok=True) | |
| args.output.write_text(json.dumps(report, indent=2, ensure_ascii=False) + "\n", encoding="utf-8") | |
| summary = { | |
| "sentences": report["sentences"], "tokens": tokens, | |
| "uas": report["dependency"]["uas"], "las": report["dependency"]["las"], | |
| "upos_accuracy": report["upos"]["accuracy"], "upos_macro_f1": report["upos"]["macro"].get("f1"), | |
| "feats_micro_f1": report["feats"]["micro"]["f1"], "feats_macro_f1": report["feats"]["macro"].get("f1"), | |
| } | |
| print(json.dumps(summary, indent=2)) | |
| if __name__ == "__main__": | |
| main() | |