TL;DR — We released ja-reading-tagger-v1, a small tagger that assigns context-appropriate Japanese readings span by span — a written reading for ruby text and a pronunciation reading for text-to-speech. On a sealed test of 5,000 sentences it edges the dictionary baseline overall (0.9354 vs Sudachi's 0.9308), and on sentences built around context-dependent homographs it wins clearly (0.7230 vs 0.5570). On real prose alone, Sudachi still beats it, slightly — 0.9432 vs 0.9360 — and we print that on the card. Personal names are out of scope. Apache 2.0, ONNX included, ~18 ms per sentence on CPU.
- The problem is a closed set of words with open readings. Japanese has homographs whose reading only context can settle — 人気 (ninki / hitoke), 上手 (jouzu / uwate / kamite), 明日 (ashita / asu / myounichi). Our catalog covers 135 such words with 289 readings. A dictionary must pick one default; a tagger can read the sentence. That is the entire reason this model exists.
- The headline comparison, all three slices: overall sealed test 0.9354 vs Sudachi Mode C 0.9308 and UniDic 0.9276 — a tie for practical purposes. Homograph-focused set (1,000 sentences): 0.7230 vs 0.5570, the model's home ground. Real prose only, inside the sealed test: 0.9360 vs Sudachi's 0.9432 — the dictionary wins. Which slice describes your text decides whether this model helps you.
- An honest internal result: a lighter pilot build (1 epoch) scored 0.7520 on the homograph set, above the production model's 0.7230. Production traded some homograph sharpness for balance on general text. We shipped the balanced one and wrote the trade on the card.
What it returns
Not a rewrite — spans. For each span of the original text, the tagger returns its position, its surface form, a written reading (for ruby/furigana display), and a pronunciation reading (what a speech synthesizer should actually say; the two differ in Japanese more often than outsiders expect). Personal names are explicitly out of scope: name readings are a different, harder problem, and guessing them wrong is worse than not guessing.
Use it
from transformers import AutoModelForTokenClassification, AutoTokenizer repo = "japan-opendata/ja-reading-tagger-v1" tok = AutoTokenizer.from_pretrained(repo) model = AutoModelForTokenClassification.from_pretrained(repo) model.eval() # Span extraction and pronunciation conversion are handled by the bundled # reference implementation, examples/reading_tagger.py (PyTorch and ONNX), # driven by inference_config.json and pron_map.json — it runs standalone. The ONNX build (fp32, opset 17) produced readings identical to PyTorch on 200 development and 200 sealed items. End-to-end speed, tokenization and pronunciation conversion included: ~17.9 ms per sentence on a Core i7-11700F. No INT8 build is shipped.
Measured results (sealed test, 5,000 sentences, single final run)
Sentence-level reading accuracy, works split from training at the work level, real texts (Aozora Bunko) at the core:
- This model: 0.9354
- Sudachi Mode C (dictionary): 0.9308
- UniDic (dictionary): 0.9276
Homograph-only evaluation (1,000 sentences): 0.7230 sentence accuracy (0.7767 on the target words alone) vs Sudachi 0.5570 (0.6136).
Real prose only, within the sealed test: this model 0.9360, Sudachi 0.9432.
Training data
Commercially clean materials only: public-domain Aozora Bunko texts (non-translated, modern script), the CC0 ROHAN4600 corpus, and synthetic sentences generated with Qwen3 (Apache 2.0) and reverse-checked by a separate model. Every reading answer was verified against SudachiDict (Apache 2.0) and UniDic (modified BSD). Materials whose licenses did not fit — JMdict, Wikipedia, BCCWJ — were not used.
What didn't work / Limitations
- On ordinary prose, the dictionary is (slightly) better. If your text rarely turns on a homograph, Sudachi gives you 0.9432 to this model's 0.9360, with no model to run. The tagger earns its place in homograph-dense text — dialogue, fiction, anything headed for speech synthesis — not as a universal replacement.
- The homograph set is hard in absolute terms. 0.7230 sentence accuracy means roughly one sentence in four still gets a reading wrong somewhere. The dictionary's 0.5570 shows why the problem is worth a model; 0.7230 shows the model has not finished it.
- The pilot beat the production build on the target task. One epoch of training scored 0.7520 on homographs against production's 0.7230. We chose general-text balance over peak homograph performance, and reasonable people could choose the other way — the numbers for both are on the card.
- No personal names. Sentences whose difficulty is a name reading will not be helped, by design.
This is the ninth in our line of small, single-purpose Japanese models. This one's lesson is about slice honesty: an overall 0.9354 vs 0.9308 headline hides everything that matters — where it wins, where it loses, and by how much. So we published the slices.
If you build Japanese TTS or furigana tooling: how do you handle homographs today — dictionary default, hand rules, or leaving them to the voice actor?
- Model on Hugging Face: https://huggingface.co/japan-opendata/ja-reading-tagger-v1
- Code (the model series): https://github.com/japan-opendata-lab/ja-small-models
- Model page with usage notes: https://jpopendata.jp/models/ja-reading-tagger-v1/
Get the next release notes and our Kaggle experiment logs by email: https://jpopendata.jp/ (newsletter signup in the footer).
