Scoring is now features x weights (Features.swift / features.py), with the old hand-tuned values as defaults. training/ generates synthetic mixed Chinese/English buffers from the lexicon and word lists and trains the weights with an averaged structured perceptron over the same segmentation DP the input method runs. On 10,000 test buffers commit-time accuracy goes from 97.58% to 99.62%; typing-time (prefix) accuracy from 86.15% to 87.81%. Both apps load Resources/classifier-weights.json. A parity test checks the Swift segmentation matches the Python one on 400 fixtures. Also fixes space after a toned syllable being scored as an extra stray tone, which could turn short Chinese like "u4 " into English. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
156 lines
5.6 KiB
Python
156 lines
5.6 KiB
Python
#!/usr/bin/env python3
|
|
"""Learns the classifier weights from synthetic typing data (averaged structured
|
|
perceptron over the same segmentation DP the input method runs) and reports
|
|
accuracy against the hand-tuned defaults.
|
|
|
|
Usage (from the repo root, after windows/tools/build_data.py):
|
|
python3 training/train.py # train, evaluate, write Resources/classifier-weights.json
|
|
python3 training/train.py --eval-only # just evaluate the current weights file
|
|
"""
|
|
import argparse
|
|
import datetime
|
|
import json
|
|
import os
|
|
import random
|
|
import sys
|
|
import time
|
|
from collections import defaultdict
|
|
|
|
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
|
|
|
from common import DATA, WEIGHTS_PATH, core, load_models # noqa: E402
|
|
from synth import Generator, gold_segments # noqa: E402
|
|
|
|
MAX_KEYS = 28
|
|
FIXED = {"lit.upper"} # hard rule (Shift = English), not learned
|
|
|
|
|
|
def make_set(gen, n):
|
|
out = []
|
|
while len(out) < 2 * n:
|
|
ex = gen.example()
|
|
if len(ex["keys"]) > MAX_KEYS:
|
|
continue
|
|
out.append(ex)
|
|
if len(ex["keys"]) > 1:
|
|
out.append(gen.prefix_of(ex))
|
|
return out
|
|
|
|
|
|
def labels_of(segs, n):
|
|
lab = [""] * n
|
|
for s, e, m in segs:
|
|
for i in range(s, e):
|
|
lab[i] = "z" if m == core.ZHUYIN else "l"
|
|
return "".join(lab)
|
|
|
|
|
|
def seg_features(clf, keys, segs, finishing):
|
|
"""Summed features of a segmentation, or None if any segment is impossible."""
|
|
total = defaultdict(float)
|
|
n = len(keys)
|
|
for idx, (s, e, m) in enumerate(segs):
|
|
fz, fl = clf.segment_features(keys[s:e], e == n, idx > 0, finishing)
|
|
f = fz if m == core.ZHUYIN else fl
|
|
if f is None:
|
|
return None
|
|
for k, v in f.items():
|
|
total[k] += v
|
|
return total
|
|
|
|
|
|
def evaluate(clf, weights, data):
|
|
by_kind = defaultdict(lambda: [0, 0])
|
|
for ex in data:
|
|
segs = clf.segment(list(ex["keys"]), ex["finishing"], None, weights)
|
|
ok = labels_of(segs, len(ex["keys"])) == ex["labels"]
|
|
bucket = by_kind["prefix" if ex["kind"].endswith("/prefix") else ex["kind"]]
|
|
bucket[0] += ok
|
|
bucket[1] += 1
|
|
commit = [v for k, v in by_kind.items() if k != "prefix"]
|
|
summary = {
|
|
"commit": sum(c for c, _ in commit) / max(1, sum(t for _, t in commit)),
|
|
"prefix": by_kind["prefix"][0] / max(1, by_kind["prefix"][1]),
|
|
"by_kind": {k: round(c / t, 4) for k, (c, t) in sorted(by_kind.items())},
|
|
}
|
|
return summary
|
|
|
|
|
|
def show(name, s):
|
|
kinds = " ".join("%s %.1f%%" % (k, 100 * v) for k, v in s["by_kind"].items())
|
|
print("%-9s commit %.2f%% typing %.2f%% [%s]" % (name, 100 * s["commit"], 100 * s["prefix"], kinds))
|
|
|
|
|
|
def train(clf, data, epochs, lr, seed):
|
|
rng = random.Random(seed)
|
|
w = dict(clf.weights)
|
|
total = defaultdict(float)
|
|
steps = 0
|
|
for epoch in range(epochs):
|
|
rng.shuffle(data)
|
|
mistakes = 0
|
|
t0 = time.time()
|
|
for ex in data:
|
|
keys = list(ex["keys"])
|
|
pred = clf.segment(keys, ex["finishing"], None, w)
|
|
if labels_of(pred, len(keys)) != ex["labels"]:
|
|
gold = gold_segments(ex["labels"])
|
|
fg = seg_features(clf, keys, gold, ex["finishing"])
|
|
fp = seg_features(clf, keys, pred, ex["finishing"])
|
|
if fg is not None and fp is not None:
|
|
mistakes += 1
|
|
scale = lr * (0.5 if ex["kind"].endswith("/prefix") else 1.0)
|
|
for k in set(fg) | set(fp):
|
|
if k not in FIXED:
|
|
w[k] = w.get(k, 0.0) + scale * (fg.get(k, 0.0) - fp.get(k, 0.0))
|
|
steps += 1
|
|
for k, v in w.items():
|
|
total[k] += v
|
|
print("epoch %d: %d updates (%.0fs)" % (epoch + 1, mistakes, time.time() - t0), flush=True)
|
|
return {k: round(v / steps, 4) for k, v in total.items()}
|
|
|
|
|
|
def main():
|
|
ap = argparse.ArgumentParser()
|
|
ap.add_argument("--train", type=int, default=3000, help="full examples (plus as many prefixes)")
|
|
ap.add_argument("--test", type=int, default=1500)
|
|
ap.add_argument("--epochs", type=int, default=6)
|
|
ap.add_argument("--lr", type=float, default=0.1)
|
|
ap.add_argument("--eval-only", action="store_true")
|
|
args = ap.parse_args()
|
|
|
|
lexicon, english = load_models()
|
|
paths = (os.path.join(DATA, "lexicon.txt"), os.path.join(DATA, "english-common.txt"),
|
|
os.path.join(DATA, "english-dict.txt"))
|
|
test = make_set(Generator(*paths, seed=2), args.test)
|
|
|
|
clf = core.Classifier(lexicon, english) # default (hand-tuned) weights
|
|
show("default", evaluate(clf, clf.weights, test))
|
|
if os.path.exists(WEIGHTS_PATH):
|
|
current = dict(clf.weights)
|
|
current.update(core.Classifier.load_weights(WEIGHTS_PATH))
|
|
show("current", evaluate(clf, current, test))
|
|
if args.eval_only:
|
|
return
|
|
|
|
data = make_set(Generator(*paths, seed=1), args.train)
|
|
print("training on %d buffers (%d test)" % (len(data), len(test)), flush=True)
|
|
learned = train(clf, data, args.epochs, args.lr, seed=3)
|
|
result = evaluate(clf, learned, test)
|
|
show("learned", result)
|
|
|
|
with open(WEIGHTS_PATH, "w", encoding="utf-8") as f:
|
|
json.dump({
|
|
"about": "AutoZhuyin classifier weights, learned by training/train.py",
|
|
"trained": datetime.date.today().isoformat(),
|
|
"examples": len(data),
|
|
"test_accuracy": {"commit": round(result["commit"], 4), "typing": round(result["prefix"], 4)},
|
|
"weights": dict(sorted(learned.items())),
|
|
}, f, ensure_ascii=False, indent=2)
|
|
f.write("\n")
|
|
print("wrote", WEIGHTS_PATH)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|