Datasets:

Modalities:
Text
Formats:
json
Languages:
Thai
ArXiv:
License:
File size: 6,153 Bytes
b35eaa3
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
"""OpenThai2.0-WordSeg-Benchmark 1.0: score a Thai word segmenter on the seven test sets in one call.

    from benchmark import evaluate
    evaluate(segment, name="my-segmenter")          # segment(text) -> list of tokens

    python benchmark.py --module my_package:segment --name my-segmenter
    python benchmark.py --predictions my_outputs/ --name my-segmenter    # my_outputs/SET.jsonl, {"id", "tokens"}

It prints word F1 and boundary F1 on every set and their averages, next to the published systems, and saves
results-NAME.json. The first run builds the three test sets that may not be shared (BEST, ORCHID, khammoon's test):
it downloads their original files from their owners (about 50 MB), checks their SHA-256 and builds them, once.
"""
from __future__ import annotations

import argparse
import hashlib
import importlib
import json
import sys
import time
from pathlib import Path

HERE = Path(__file__).resolve().parent
sys.path.insert(0, str(HERE))
from thaiws import boundary_counts, f1, load_set, read_jsonl, word_counts  # noqa: E402

BENCHMARK, VERSION = "OpenThai2.0-WordSeg-Benchmark", "1.0"
SETS = [("tud", "TUD"), ("pud", "PUD"), ("ws160", "WS160"), ("vistec", "VISTEC"), ("bestdd", "BEST"),
        ("orchidndd", "ORCHID"), ("khm", "khm")]
DATA, RAW = HERE / "data", HERE / "raw"


def prepare() -> None:
    """Build, once, the test sets whose licence does not allow sharing them."""
    missing = [s for s, _ in SETS if not (DATA / f"{s}.jsonl").exists()]
    if not missing:
        return
    import build_testsets
    import fetch_sources
    groups = {"bestdd": build_testsets.build_best, "orchidndd": build_testsets.build_orchid,
              "khm": lambda raw: build_testsets.build_khm(raw, dedup=False)}
    unknown = [s for s in missing if s not in groups]
    if unknown:
        raise SystemExit(f"data/{unknown[0]}.jsonl is missing: download the benchmark again")
    print("First run: BEST, ORCHID and khammoon's test may not be shared, so they are downloaded from their "
          "owners and built here (about 50 MB, once).", flush=True)
    bad = fetch_sources.fetch(RAW, sets=set(missing), quiet=True)
    if bad:
        raise SystemExit(f"these source files differ from the versions the benchmark was built from: {bad}")
    want = json.loads((HERE / "checksums.json").read_text())
    for s in missing:
        for name, rows in groups[s](RAW).items():
            blob = build_testsets.dump(rows)
            if hashlib.sha256(blob).hexdigest() != want[f"{name}.jsonl"]:
                raise SystemExit(f"{name}: the built file differs from the published one")
            (DATA / f"{name}.jsonl").write_bytes(blob)
    print("Test sets ready.\n", flush=True)


def evaluate(segment=None, name: str = "my-segmenter", predictions: str | Path | None = None, batch: bool = False,
             save: bool = True) -> dict:
    """Score `segment` (a function: text -> list of tokens; with batch=True: list of texts -> list of token lists),
    or the files of a `predictions` folder (SET.jsonl, one {"id", "tokens"} per line of data/SET.jsonl)."""
    if (segment is None) == (predictions is None):
        raise ValueError("give either a segment function or a predictions folder")
    prepare()
    word, boundary = {}, {}
    print(f"{BENCHMARK} {VERSION}: {name}\n", flush=True)
    for s, label in SETS:
        rows = load_set(s)
        t0 = time.time()
        if predictions is not None:
            preds = read_jsonl(Path(predictions) / f"{s}.jsonl")
            if [p["id"] for p in preds] != [r["id"] for r in rows]:
                raise SystemExit(f"{predictions}/{s}.jsonl: one line per line of data/{s}.jsonl, in the same order")
        else:
            texts = [r["text"] for r in rows]
            tokens = list(segment(texts)) if batch else [list(segment(t)) for t in texts]
            preds = [{"id": r["id"], "tokens": list(t)} for r, t in zip(rows, tokens)]
        word[s] = round(float(f1(word_counts(rows, preds).sum(0))), 2)
        boundary[s] = round(float(f1(boundary_counts(rows, preds).sum(0))), 2)
        print(f"  {label:7s} word F1 {word[s]:6.2f}   boundary F1 {boundary[s]:6.2f}   ({len(rows):,} lines, "
              f"{time.time() - t0:.0f} s)", flush=True)
    average = round(sum(word.values()) / len(word), 2)
    average_boundary = round(sum(boundary.values()) / len(boundary), 2)
    print(f"  {'Average':7s} word F1 {average:6.2f}   boundary F1 {average_boundary:6.2f}\n")
    expected = json.loads((HERE / "results" / "expected.json").read_text())
    board = sorted([(v["avg7"], expected["boundary_f1_sets"][k]["avg7"], k) for k, v in expected["averages"].items()
                    if "(unit rule)" not in k] + [(average, average_boundary, f"> {name}")], reverse=True)
    print("Average F1 with the published systems:\n    word  boundary")
    for v, b, k in board:
        print(f"  {v:6.2f}  {b:6.2f}  {k}")
    result = {"benchmark": BENCHMARK, "version": VERSION, "system": name, "date": time.strftime("%Y-%m-%d"),
              "word_f1": word, "boundary_f1": boundary, "average_word_f1": average,
              "average_boundary_f1": average_boundary}
    if save:
        path = Path(f"results-{name}.json")
        path.write_text(json.dumps(result, indent=1, ensure_ascii=False) + "\n", encoding="utf-8")
        print(f"\nSaved {path}")
    return result


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
    src = ap.add_mutually_exclusive_group(required=True)
    src.add_argument("--module", help="MODULE:FUNCTION, a function text -> list of tokens")
    src.add_argument("--predictions", help="a folder with SET.jsonl files of {\"id\", \"tokens\"}")
    ap.add_argument("--name", default="my-segmenter")
    ap.add_argument("--batch", action="store_true", help="the function takes a list of texts")
    args = ap.parse_args()
    segment = None
    if args.module:
        mod, _, fn = args.module.partition(":")
        segment = getattr(importlib.import_module(mod), fn)
    evaluate(segment, name=args.name, predictions=args.predictions, batch=args.batch)


if __name__ == "__main__":
    main()