Datasets:

Modalities:
Text
Formats:
json
Languages:
Thai
ArXiv:
License:
File size: 9,171 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
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
"""Score Thai word segmentation on the benchmark.

    python score.py table                         # every published number, recomputed and checked
    python score.py units                         # the held-out choice of OpenThai2.0-LATTE-WordSeg-Lite's unit
    python score.py score SET PREDICTIONS.jsonl   # your system: {"id", "tokens": [...]} per line of data/SET.jsonl
    python score.py score SET PREDS.jsonl --vs deepcut-0.7.0.0   # + paired bootstrap against a published system

Two metrics, as in the LATTE paper, both corpus-level (counts summed over the lines of a set). Word F1 (%): a
predicted word is correct when a gold word has the same two ends. Boundary F1 (%): a cut between two
non-whitespace characters is correct when gold cuts there too; the cuts next to whitespace and the start of a
line are given to every system and are not counted (khammoon's metric). Intervals: 1,000 paired bootstrap
resamples of lines.
"""
from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path

import numpy as np

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

SETS = [("tud", "TUD"), ("pud", "PUD"), ("ws160", "WS160"), ("vistec", "VISTEC"), ("bestdd", "BEST"),
        ("orchidndd", "ORCHID"), ("khm", "khammoon test")]
PRODUCT = "openthai2.0-latte-wordseg-lite"
# its three units, coarse to fine, named after the long and short unit words of BCCWJ and the smallest units under
# them: long keeps compounds whole, short (the default) gives words, minimal gives morphemes
UNITS = ("long", "short", "minimal")
DEFAULT = "short"
COMMERCIAL = ("tud", "pud", "ws160", "vistec")     # the test sets whose licence allows commercial use
# the unit of each test set: the convention each unit was trained on, else chosen on held-out data (`units`)
RULE = {"tud": "short", "pud": "long", "ws160": "short", "vistec": "long", "bestdd": "short", "orchidndd": "long",
        "khm": "minimal", "khmdd": "minimal"}
TOOLS = ["khammoon-0.1.0", "deepcut-0.7.0.0", "sefr-cut-1.1-best", "sefr-cut-1.1-ws1000", "attacut-1.0.6-sc",
         "attacut-1.0.6-c", "oskut-1.3-ws", "oskut-1.3-scads", "tltk-1.11", "nlpo3-1.4.0", "pythainlp-5.4.0-newmm"]


def preds(system: str, s: str) -> list[dict]:
    return read_jsonl(HERE / "predictions" / system / f"{s}.words.jsonl.gz")


def table() -> None:
    expected = json.loads((HERE / "results" / "expected.json").read_text())
    rows = {f"{PRODUCT}-{u}": {s: f"{PRODUCT}-{u}" for s, _ in SETS} for u in UNITS}
    rows[f"{PRODUCT} (unit rule)"] = {s: f"{PRODUCT}-{RULE[s]}" for s, _ in SETS}
    rows.update({t: {s: t for s, _ in SETS} for t in TOOLS})
    point, boot, cache, bpoint = {}, {}, {}, {}
    for k, (s, _) in enumerate(SETS):
        data = load_set(s)
        W = bootstrap_weights(len(data), 12345 + k)
        for name, systems in rows.items():
            sy = systems[s]
            if sy not in cache:
                p = preds(sy, s)
                c = word_counts(data, p)
                cache[sy] = (float(f1(c.sum(0))), f1(W @ c), float(f1(boundary_counts(data, p).sum(0))))
            point[(name, s)], boot[(name, s)], bpoint[(name, s)] = cache[sy]
        cache.clear()
    bad = []

    def check(what, got, want):
        if abs(got - want) > 5e-4:
            bad.append(f"{what}: {got:.4f} vs expected {want:.4f}")

    def averages(vals):
        """Mean of all seven sets, of the four commercial-use sets, and of the six sets other than BEST."""
        by_set = dict(zip([s for s, _ in SETS], vals))
        return (float(np.mean(vals)), float(np.mean([by_set[s] for s in COMMERCIAL])),
                float(np.mean([v for s, v in by_set.items() if s != "bestdd"])))

    head = ("| System | " + " | ".join(h for _, h in SETS) + " | Average, all 7 sets | Average, 4 commercial-use sets |\n|---|"
            + "---|" * (len(SETS) + 2))
    print(head)
    for name in rows:
        vals = [point[(name, s)] for s, _ in SETS]
        avg7, avg4, avg6 = averages(vals)
        print(f"| {name} | " + " | ".join(f"{v:.2f}" for v in vals) + f" | {avg7:.2f} | {avg4:.2f} |")
        for (s, _), v in zip(SETS, vals):
            check(f"word F1 {name} {s}", v, expected["word_f1"][name][s])
        check(f"average {name}", avg7, expected["averages"][name]["avg7"])
        check(f"average of the commercial-use sets {name}", avg4, expected["averages"][name]["avg4_commercial"])
        check(f"average without BEST {name}", avg6, expected["averages"][name]["avg6_without_best"])
    print("\nboundary F1 (%), the second metric:")
    print(head)
    for name in rows:
        vals = [bpoint[(name, s)] for s, _ in SETS]
        avg7, avg4, avg6 = averages(vals)
        print(f"| {name} | " + " | ".join(f"{v:.2f}" for v in vals) + f" | {avg7:.2f} | {avg4:.2f} |")
        want = expected["boundary_f1_sets"][name]
        for (s, _), v in zip(SETS, vals):
            check(f"boundary F1 {name} {s}", v, want[s])
        check(f"boundary average {name}", avg7, want["avg7"])
        check(f"boundary average of the commercial-use sets {name}", avg4, want["avg4_commercial"])
        check(f"boundary average without BEST {name}", avg6, want["avg6_without_best"])
    print("\nother PyThaiNLP tokenisers (word F1 %):")
    for sy, want in expected.get("extra_word_f1", {}).items():
        vals = []
        for s, _ in SETS:
            v = float(f1(word_counts(load_set(s), preds(sy, s)).sum(0)))
            check(f"word F1 {sy} {s}", v, want[s])
            vals.append(v)
        print(f"  {sy:30s} " + " ".join(f"{v:6.2f}" for v in vals))
    print("\nkhammoon's metric (boundary F1 %, lines):")
    for s in ("khm", "khmdd"):
        if s == "khmdd" and not (HERE / "data" / "khmdd.jsonl").is_file():
            print("  khmdd skipped: not built (it needs khammoon's training text: python fetch_sources.py)")
            continue
        data = load_set(s)
        for sy in [f"{PRODUCT}-minimal"] + TOOLS:
            v = float(f1(boundary_counts(data, preds(sy, s)).sum(0)))
            check(f"boundary F1 {sy} {s}", v, expected["boundary_f1"][s][sy])
            print(f"  {s:5s} {sy:32s} {v:.2f}")
    avg_b = {n: np.mean([boot[(n, s)] for s, _ in SETS], axis=0) for n in rows}
    d = avg_b[f"{PRODUCT}-{DEFAULT}"] - avg_b["sefr-cut-1.1-best"]
    print(f"\naverage, `{DEFAULT}` on every set, minus SEFR CUT: {np.mean([point[(f'{PRODUCT}-{DEFAULT}', s)] for s, _ in SETS]) - np.mean([point[('sefr-cut-1.1-best', s)] for s, _ in SETS]):+.2f} "
          f"[{np.percentile(d, 2.5):+.2f}, {np.percentile(d, 97.5):+.2f}]")
    print("\nCHECK:", "every number equals the published one" if not bad else f"{len(bad)} differences:\n  " + "\n  ".join(bad))
    sys.exit(1 if bad else 0)


def units() -> None:
    expected = json.loads((HERE / "results" / "expected.json").read_text())["unit_choice"]
    pud = load_set("pud")
    halves = {h: [r["src_id"] for r in load_set(f"pud{h}")] for h in "AB"}
    bad = []
    for name in ("bestdev", "orchiddev", "pudA", "pudB"):
        scores = {}
        for u in UNITS:
            if name.startswith("pud"):
                p = preds(f"{PRODUCT}-{u}", "pud")
                ids = halves[name[-1]]
                rows, pp = [pud[i] for i in ids], [p[i] for i in ids]
            else:
                rows, pp = load_set(name), preds(f"{PRODUCT}-{u}", name)
            scores[u] = float(f1(word_counts(rows, pp).sum(0)))
        best = max(scores.values())
        chosen = DEFAULT if scores[DEFAULT] == best else max(scores, key=scores.get)
        print(f"{name:10s} " + "  ".join(f"{u} {v:.2f}" for u, v in scores.items()) + f"  -> {chosen}")
        if chosen != expected["chosen"][name] or any(abs(scores[u] - expected["heldout_f1"][name][u]) > 5e-4 for u in scores):
            bad.append(name)
    print("CHECK:", "same choices and scores as published" if not bad else f"differences: {bad}")
    sys.exit(1 if bad else 0)


def score(s: str, path: str, vs: str | None) -> None:
    data = load_set(s)
    mine = read_jsonl(Path(path))
    c = word_counts(data, mine)
    print(f"{s}: word F1 {float(f1(c.sum(0))):.2f} (P {100 * c[:, 0].sum() / max(c[:, 1].sum(), 1):.2f}, "
          f"R {100 * c[:, 0].sum() / max(c[:, 2].sum(), 1):.2f})")
    print(f"{s}: boundary F1 {float(f1(boundary_counts(data, mine).sum(0))):.2f} (khammoon's metric)")
    if vs:
        r = word_counts(data, preds(vs, s))
        W = bootstrap_weights(len(data), 20261114)
        d = f1(W @ c) - f1(W @ r)
        print(f"minus {vs}: {float(f1(c.sum(0)) - f1(r.sum(0))):+.2f} [{np.percentile(d, 2.5):+.2f}, {np.percentile(d, 97.5):+.2f}]")


if __name__ == "__main__":
    ap = argparse.ArgumentParser()
    sub = ap.add_subparsers(dest="cmd", required=True)
    sub.add_parser("table")
    sub.add_parser("units")
    p = sub.add_parser("score")
    p.add_argument("set")
    p.add_argument("predictions")
    p.add_argument("--vs", default=None)
    a = ap.parse_args()
    {"table": lambda: table(), "units": lambda: units(), "score": lambda: score(a.set, a.predictions, a.vs)}[a.cmd]()