Benchmark results, method, limitations and the failure log

README.md

@@ -0,0 +1,154 @@
+---
+license: cc-by-4.0
+language:
+  - am
+task_categories:
+  - automatic-speech-recognition
+pretty_name: Amharic ASR Benchmark
+size_categories:
+  - 1K<n<10K
+tags:
+  - amharic
+  - ethiopia
+  - benchmark
+  - evaluation
+  - low-resource
+---
+
+# Amharic ASR Benchmark
+
+An evaluation of open speech recognition models for Amharic, on a test set that
+**none of them could have trained on**, with certain labels and honest
+statistics.
+
+Published by [Dataset.ET](https://dataset.et).
+
+## Results
+
+1,548 clips, 4.72 hours. Greedy decoding.
+Character error rate, lower is better.
+
+| model | CER | 95% CI | WER | |
+|---|---|---|---|---|
+| [`badrex/Ethio-ASR-amharic`](https://huggingface.co/badrex/Ethio-ASR-amharic) | **0.0946** | [0.0896, 0.0999] | 0.2845 | CTC, monolingual Amharic |
+| [`badrex/Ethio-ASR-multilingual-600M`](https://huggingface.co/badrex/Ethio-ASR-multilingual-600M) | **0.0991** | [0.0939, 0.1042] | 0.2984 | CTC, w2v-BERT 2.0, five Ethiopian languages |
+| [`b1n1yam/shook-medium-amharic-2k`](https://huggingface.co/b1n1yam/shook-medium-amharic-2k) | **0.1147** | [0.1087, 0.1202] | 0.2943 | Seq2seq, Whisper medium |
+| [`badrex/Ethio-ASR-multilingual-1B`](https://huggingface.co/badrex/Ethio-ASR-multilingual-1B) | **0.1308** | [0.1249, 0.1366] | 0.3894 | CTC, MMS-based |
+| [`b1n1yam/shook-tiny-amharic-stage2-polish`](https://huggingface.co/b1n1yam/shook-tiny-amharic-stage2-polish) | **0.2735** | [0.2648, 0.2820] | 0.6200 | Seq2seq, 37.8M parameters |
+
+### Are the differences real?
+
+Every model is scored on the **same 1,548 clips**, so comparing
+marginal confidence intervals is the wrong test — they can overlap while the
+difference is real. A paired bootstrap over 2,000
+resamples of clips:
+
+| comparison | mean CER difference | 95% CI | distinguishable |
+|---|---|---|---|
+| `Ethio-ASR-amharic` vs `Ethio-ASR-multilingual-600M` | -0.0045 | [-0.0067, -0.0022] | **yes** |
+| `Ethio-ASR-multilingual-600M` vs `shook-medium-amharic-2k` | -0.0155 | [-0.0194, -0.0120] | **yes** |
+| `shook-medium-amharic-2k` vs `Ethio-ASR-multilingual-1B` | -0.0161 | [-0.0202, -0.0120] | **yes** |
+| `Ethio-ASR-multilingual-1B` vs `shook-tiny-amharic-stage2-polish` | -0.1427 | [-0.1498, -0.1361] | **yes** |
+
+The top two intervals overlap and the difference is still real at p = 0.001.
+Every adjacent pair here is separable.
+
+## What makes this worth trusting
+
+**The labels are certain.** A contributor was shown a sentence and read it
+aloud, so the reference existed before the audio. Most speech benchmarks score
+against transcripts someone typed while listening, which carries an unmeasured
+error rate of its own.
+
+**No model could have seen it.** Every model predates the test set by five to
+nine months, verified against publication timestamps:
+
+| asset | published |
+|---|---|
+| **this test set** | **2026-08-25** |
+| `badrex/Ethio-ASR-*` | 2026-03-24 |
+| `b1n1yam/shook-medium-amharic-2k` | 2025-12-08 |
+| `b1n1yam/shook-tiny-*` | 2025-11-21 |
+
+**Speaker-disjoint splits.** No voice appears in more than one split.
+
+**The outputs are published.** `hypotheses/` holds every model's raw transcript
+for all 1,548 clips. Do not trust these numbers — recompute them.
+
+## Three findings worth stating
+
+**The 600M model beats the 1B by 24% relative, at 40% of the size.** Larger is
+not better within this family. We had been building on the 1B.
+
+**A monolingual model narrowly beats the multilingual one** for Amharic
+specifically: 0.0946 against 0.0991, a real difference. Multilingual training
+costs a little here rather than helping.
+
+**CER and WER disagree about ranking.** `shook-medium-amharic-2k` has worse CER
+than `Ethio-ASR-multilingual-600M` (0.1147 vs 0.0991) but better WER
+(0.2943 vs 0.2984). The sequence-to-sequence model produces fluent whole words
+that match exactly; the CTC model gets characters closer but whole words
+slightly off. For an agglutinative language written in Ge'ez script, which
+metric you choose changes who wins.
+
+## Read this before quoting anything
+
+This is **one domain**: people reading prompts into a phone. On spontaneous
+speech the same models are far worse — we measured roughly three times the
+disagreement between them on podcast audio. These are not general Amharic ASR
+figures. See [`docs/LIMITATIONS.md`](docs/LIMITATIONS.md).
+
+Decoding is greedy, so every number is a lower bound, and that penalty is **not
+evenly distributed** between CTC and sequence-to-sequence models.
+
+## What went wrong
+
+[`docs/FAILURES.md`](docs/FAILURES.md) is the honest engineering log: ten
+failures including three that produced results which looked correct, a health
+check that reported a working system as broken, and a shutdown timer we
+triggered by trying to disable it.
+
+It is the most useful document here. Benchmarks are usually published as though
+they fell out of the sky.
+
+## Contents
+
+```
+README.md                    this
+docs/METHOD.md               test set, scoring, statistics
+docs/FAILURES.md             what went wrong and what it cost
+docs/LIMITATIONS.md          read before quoting
+results/phase1_greedy.json   the numbers
+results/bootstrap.json       intervals and paired tests
+hypotheses/                  every model's raw output, per clip
+scripts/                     the evaluation code
+```
+
+## Reproducing
+
+```bash
+python scripts/bench_asr.py --push-to <your-repo>
+python scripts/bootstrap_ci.py build/am-v0.2.0 hypotheses/
+```
+
+The test set is [`snapwre/amharic-speech`](https://huggingface.co/datasets/snapwre/amharic-speech),
+open under CC BY 4.0.
+
+## Citing
+
+```bibtex
+@misc{datasetet2026amharicasr,
+  title  = {Amharic ASR Benchmark: an uncontaminated evaluation of open speech models},
+  author = {Dataset.ET},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/snapwre/amharic-asr-benchmark}
+}
+```
+
+## Contact
+
+Corrections and additional models are welcome — open a discussion. If you built
+one of these models and think a decoding choice disadvantaged it, say so and we
+will rerun it.
+
+Chapi, Dataset.ET

docs/FAILURES.md

@@ -0,0 +1,253 @@
+# What went wrong
+
+Benchmarks are published as though they fell out of the sky. This one took four
+days, and most of that was spent being wrong in ways worth writing down. Every
+failure below is one we actually hit, in the order we hit it, with what it cost
+and what fixed it.
+
+The reason to publish this is not confession. It is that **three of these bugs
+produced results that looked correct**, and the only thing that caught them was
+a diagnostic we nearly did not run.
+
+---
+
+## 1. The experiment that passed and was worthless
+
+Before benchmarking anything we ran a calibration experiment: do two ASR models
+agreeing tell you the transcript is right? It reported GO. It was invalid, and
+for three separate reasons at once.
+
+**The decode limit truncated one model.** Whisper was generated with
+`max_new_tokens=200`. On long clips it simply stopped mid-sentence. 139 of 500
+clips were affected and the model was charged for words it was never allowed to
+emit.
+
+**A language tag was scored as text.** One model does joint recognition and
+language identification, so it prefixes `[AMH]`. That tag was compared against
+the reference as though it were speech. 290 of 500 outputs carried one. The
+model was penalised for doing the second job it was designed to do.
+
+**The disagreement metric was asymmetric.** Character error rate divides by the
+reference length, and we passed one model's output as the reference. Twenty
+clips scored above 1.0, which is impossible for a symmetric disagreement.
+
+**How we caught it.** Not from the headline number, which looked fine. From a
+diagnostic printed beside it: rank correlation between agreement and each
+model's true error. It came out **0.935 against one model and 0.087 against the
+other**. If agreement were measuring mutual corroboration those would be
+similar. They were not, so agreement was tracking one model's failures.
+
+> A single summary number cannot tell you it is wrong. Print the diagnostic that
+> would look different if your assumption failed, and print it every run.
+
+---
+
+## 2. The same truncation bug, reintroduced two days later
+
+We fixed the 200-token limit in the calibration script. Then we wrote a new
+benchmark script, and typed `max_new_tokens=200` into it.
+
+It gave `shook-medium-amharic-2k` a CER of **0.3107**. The true figure is
+**0.1147**. We nearly published a number that made a good model look broken.
+
+**How we caught it.** Output length against reference length, bucketed:
+
+| reference length | Whisper output / reference | CTC output / reference |
+|---|---|---|
+| 0-60 chars | 0.96x | 1.08x |
+| 60-90 | 0.95x | 1.03x |
+| 90-120 | 0.80x | 1.01x |
+| 120-160 | 0.63x | 1.00x |
+| 160+ | **0.46x** | 0.96x |
+
+A model that is merely *wrong* is wrong at all lengths. A model that is
+**truncated** degrades as length grows. The CTC column is the control that makes
+it unambiguous.
+
+> Fixing a bug in one file does not fix it in your head. The check that catches
+> a class of bug belongs in the pipeline, not in your memory.
+
+---
+
+## 3. A working system reported as broken
+
+Our health check for the language model toolchain was:
+
+```bash
+lmplz --help > /dev/null 2>&1 && echo "ok" || echo "MISSING"
+```
+
+**`lmplz --help` exits with status 1.** Many C++ tools print usage to stderr and
+return non-zero. The binary was installed and working; we reported it missing
+and skipped a phase.
+
+This is the mirror image of the bugs above: there, a broken thing looked fine;
+here, a working thing looked broken. Both come from testing a **proxy** instead
+of the thing itself. The fix was to check that `lmplz` actually builds a model
+from three lines of input.
+
+---
+
+## 4. Every result silently failed to save
+
+Results were pushed to a private repository with `HfApi()` and no explicit
+token. The library picked up an ambient `HF_TOKEN` from the environment — a
+**read** token for a different account — and every upload returned
+`Repository Not Found`.
+
+Five models had been scored. The machine terminated itself on schedule and would
+have taken all of it. We pulled the files off over SSH minutes before it went.
+
+The same ambient-credential precedence bug had already cost us a day earlier in
+the project, in a completely different service. Knowing about a class of bug is
+not the same as being immune to it.
+
+> An ambient credential is not a default, it is a trap. Pass the token you mean.
+
+---
+
+## 5. The deadman switch we triggered by trying to disable it
+
+Rented machines had a shutdown timer:
+
+```bash
+( sleep 32400; kill_self ) &
+```
+
+To keep a machine alive for debugging, we killed the `sleep`. The subshell
+proceeded immediately to the next command, which was `kill_self`. **Killing the
+timer fires the timer.**
+
+We destroyed a healthy machine and the evidence on it. The fix is a loop that
+checks a flag file, so interrupting one iteration costs a minute rather than
+executing the payload:
+
+```bash
+( for i in $(seq 1 540); do sleep 60; [ -f NODEADMAN ] && exit 0; done
+  kill_self ) &
+```
+
+---
+
+## 6. Four dependency collisions, each invisible to the previous fix
+
+The GPU image ships deep learning frameworks but not data tooling, and every
+`pip install` that pulled a newer version collided with something preinstalled.
+
+| Symptom | Actual cause |
+|---|---|
+| `numpy._DTypeMeta object is not subscriptable` | `soundfile` 0.13+ uses numpy 2 generics; the image has numpy 1.x |
+| `libcudart.so.13: cannot open shared object file` | installing a VAD package pulled a **CUDA 13** torchaudio onto a **CUDA 12.8** torch |
+| **`cannot import name 'AutoProcessor' from 'transformers'`** | **Pillow 9.0.1.** `PIL.Image.Resampling` arrived in 9.1, and without it every transformers processor class fails to import |
+| `Special word <unk> is not allowed in the corpus` | the text corpus contains literal `<unk>` tokens; the LM trainer aborts rather than ignoring them |
+
+The third one deserves attention. The error names `transformers` and
+`AutoProcessor`. The cause is an image library four versions behind. Nothing in
+the message points anywhere near it, and it cost two machine launches.
+
+**What finally worked** was not fixing them individually but adding a preflight
+that runs on the machine, before any real work, and imports **the exact symbols
+the pipeline uses** — not the packages, the symbols. A stub-based local check
+cannot catch these by construction, because it replaces the very libraries that
+collide.
+
+Two durable fixes came out of it: pin `torchaudio` to `torch`'s own version and
+CUDA tag read at runtime rather than hard-coded, and move to a newer OS image so
+the whole class of stale-system-package problems disappears instead of being
+patched one at a time.
+
+---
+
+## 7. Losing 374 recordings to a silent failure
+
+In the collection stage, a download worker had a circuit breaker: ten
+consecutive failures and stop. But the branch where the download succeeds and
+the audio conversion produces nothing incremented the failure counter and then
+**continued without checking it**.
+
+One machine hit that branch on every single item. All three of its shards ran to
+completion reporting `0 uploaded, 123 failed`, wrote a "finished" marker, and
+the supervisor saw nothing wrong. 374 recordings, silently.
+
+Two fixes: every failure path must reach the circuit breaker, and a shard that
+fails more than a tenth of its work does not get to call itself finished.
+
+---
+
+## 8. A metric that argued against the right decision
+
+We built a tool where people correct machine-written transcripts, and it
+reported an effort ratio of **17.5x** — seventeen seconds of human time per
+second of audio. At that rate the approach is not worth pursuing.
+
+The timer measured **wall-clock from assignment to submission**. One clip logged
+4,590 seconds: someone opened it and went to lunch.
+
+| statistic | effort |
+|---|---|
+| p25 | 1.1x realtime |
+| **median** | **2.0x realtime** |
+| p75 | 5.1x |
+| p95 | 79.2x |
+| mean | 12.1x |
+
+The median is the real number and it is **six times better** than the mean. A
+badly specified metric nearly killed a good idea.
+
+> When a distribution has walk-aways in it, the mean is not a summary, it is an
+> artefact. Report the median and the tail separately.
+
+---
+
+## 9. Choosing the wrong model to build on
+
+Our pipeline used a 1-billion-parameter model as one of its two transcribers,
+because it was the largest in the family and we assumed size ordered quality.
+
+Measured on this benchmark:
+
+| model | parameters | CER |
+|---|---|---|
+| `Ethio-ASR-multilingual-600M` | 600M | **0.0991** |
+| `Ethio-ASR-multilingual-1B` | 1B | 0.1308 |
+
+The **smaller** model is 24% better. It is also the one the community actually
+downloads, by a factor of 500. The information was public the whole time; we
+never checked.
+
+---
+
+## 10. Things that were simply true, and surprising
+
+**A published threshold does not transfer across domains.** A filter calibrated
+on read prompts, where two models disagreed by 0.10 on average, was applied to
+spontaneous podcast speech where they disagree by 0.32. It retained 8% of the
+data. Nothing was broken. The number was measured somewhere else.
+
+**Both transcribers collapse on long segments, in opposite ways.** Above roughly
+ten seconds of spontaneous speech, the CTC model silently drops content — its
+output fell to 0.74x the length of the other model's — while the sequence model
+falls into repetition loops, one 29.7-second segment repeating the same clause
+nine times. Retention above ten seconds was **zero**.
+
+**Overlapping confidence intervals do not mean a tie.** Our top two models have
+intervals of [0.0896, 0.0999] and [0.0939, 0.1042], which overlap. But they are
+scored on the same clips, so the correct test is paired — and the difference is
+real at p = 0.001. Reading marginal intervals would have given the wrong answer.
+
+---
+
+## What we would tell someone starting this
+
+1. **Print the diagnostic that would look different if you were wrong**, next to
+   every headline number. Correlations, output-length ratios, retention by
+   bucket. Three invalid results here were caught by exactly one such number.
+2. **Test the thing, not a proxy for it.** `--help` exiting zero is not proof a
+   tool works.
+3. **Never let ambient credentials be your default.**
+4. **Write the decision rule before the run**, and do not move it afterwards.
+   Ours said stop below 10% retention. We hit 8%. Saying so is the whole point.
+5. **Check the leaderboard before picking the biggest model.**
+6. **Medians, when your data has humans in it.**
+
+None of this made the benchmark better. It made it *true*, which took longer.

docs/LIMITATIONS.md

@@ -0,0 +1,64 @@
+# Limitations
+
+Read this before quoting anything here.
+
+## 1. One domain, and it is the easy one
+
+Every number is measured on **people reading prompts aloud into a phone**. One
+speaker, close microphone, scripted grammatical sentence, no overlap, no music.
+
+That is not how anyone talks.
+
+We measured the gap on spontaneous podcast audio using teacher agreement as a
+proxy: the same models disagree with each other **roughly three times more** on
+spontaneous speech than on read prompts (mean pairwise distance 0.32 against
+0.10). We could not put an absolute error rate on it because we had no ground
+truth for spontaneous speech.
+
+**Do not quote these figures as general Amharic ASR performance.** They describe
+one domain, and it is the domain most favourable to every model in the table.
+
+## 2. Greedy decoding only
+
+No beam search, no language model in the base numbers, no hyperparameter search
+per model. Every figure is a lower bound on what the model can do.
+
+This limitation is **not evenly distributed**. Sequence-to-sequence models are
+usually deployed with beam search and gain more from it than CTC models
+typically do. The within-family comparisons are sound; the cross-family
+comparison should be treated as provisional.
+
+## 3. Normalisation is a choice, and it moves the numbers
+
+Folding Ge'ez homophone families is defensible — those characters are not
+distinguished in modern pronunciation — but it is a choice, and a stricter
+scorer would produce higher error rates for everyone. The script is published so
+the choice is inspectable rather than implicit. Numbers from a different
+normaliser are not comparable to these.
+
+## 4. Small by benchmark standards
+
+1,548 clips and 4.72 hours. Enough to separate models that differ by more than
+about half a point of CER, as the confidence intervals show, and **not** enough
+to rank models that are genuinely close. Where the paired test says a difference
+is not distinguishable, treat it as a tie however different the point estimates
+look.
+
+## 5. Single run, no seed variance
+
+Each model was evaluated once. Greedy decoding is deterministic, so there is no
+sampling variance to average over, but nor is there any check against a
+transient environment problem. The full inputs and outputs are published so that
+an independent rerun is cheap.
+
+## 6. What is not measured at all
+
+- Real-time factor, latency, memory. A model that is slightly better and ten
+  times slower is not better for most deployments.
+- Robustness to noise, telephone bandwidth, or code-switching into English,
+  which is extremely common in Ethiopian speech.
+- Speaker demographics beyond what the corpus records. If a model is worse for
+  women, or for particular regional accents, nothing here would reveal it.
+
+That last one is a real gap and we intend to close it, since the corpus carries
+gender, age band and region for every clip.

docs/METHOD.md

@@ -0,0 +1,92 @@
+# Method
+
+## The test set
+
+1,548 clips, 4.72 hours, drawn from the test split of an open Amharic speech
+corpus of read prompts.
+
+**The labels are certain.** A contributor was shown a sentence and read it
+aloud, so the reference text existed before the audio did. This is unusual and
+it matters: most speech benchmarks score against transcripts a person typed
+while listening, which carries its own error rate that nobody measures. Here
+there is no transcriber to be wrong.
+
+**The splits are speaker-disjoint.** No speaker appears in more than one split,
+so a model cannot score well by having memorised a voice.
+
+## No contamination
+
+Every model evaluated was published **before** the test set existed. Checked
+against creation timestamps, not asserted:
+
+| asset | published |
+|---|---|
+| **the test set** | **2026-08-25** |
+| `badrex/Ethio-ASR-*` (all variants) | 2026-03-24 |
+| `b1n1yam/shook-medium-amharic-2k` | 2025-12-08 |
+| `b1n1yam/shook-tiny-*` | 2025-11-21 |
+| `openai/whisper-large-v3` | 2023-11 |
+
+This is the property that makes the numbers worth quoting. A benchmark whose
+test data may sit in the training set of the models it ranks is measuring
+memory, not recognition.
+
+## Scoring
+
+**Character error rate is the headline metric.** Amharic is agglutinative:
+prefixes, suffixes and clitics attach to a stem, so a single wrong affix on a
+long word costs an entire word under WER and discards most of the signal. Word
+error rate is reported alongside it because it is what everyone else quotes and
+comparability matters more than being right about which metric is better.
+
+Before scoring, both reference and hypothesis pass through the corpus's own
+published evaluation script, which:
+
+- folds Ge'ez homophone families that carry no phonemic distinction in modern
+  usage (ሀ/ሐ/ኀ, ሰ/ሠ, አ/ዐ, ጸ/ፀ)
+- strips Ethiopic punctuation, which lives in the same Unicode block as letters
+  and so is not caught by generic punctuation classes
+- normalises to NFC
+
+One model performs joint recognition and language identification and prefixes
+its output with a tag such as `[AMH]`. That tag is stripped before scoring.
+Leaving it in charges the model for doing the second job it was designed to do,
+and in an earlier experiment it silently affected 290 of 500 outputs.
+
+Normalisation is applied **for scoring only**. Folding ሐ into ሀ is correct when
+comparing two strings and wrong as a training target: a model trained on folded
+text learns to misspell.
+
+## Decoding
+
+Greedy, no beam search, for every model. This is a deliberate limitation rather
+than a claim of optimality, and it is stated because it is not neutral: CTC and
+sequence-to-sequence models are not equally penalised by it. Sequence models are
+normally run with beam search and were not here. **Treat every number as a
+conservative lower bound**, and treat the CTC-versus-Whisper comparison with
+more caution than the comparisons within each family.
+
+Sequence models are generated with a 440-token limit. An earlier pass used 200
+and truncated them; see `FAILURES.md`.
+
+## Statistics
+
+Point estimates are not enough to say one model beats another.
+
+- **95% confidence intervals** come from a bootstrap over 2,000 resamples of
+  **clips**, not characters, so the unit of resampling matches the unit of
+  independence.
+- **Comparisons use a paired bootstrap.** Every model is scored on the same
+  clips, so the difference between two models is computed within each resample
+  rather than by comparing marginal intervals.
+
+This distinction is not academic here. Our top two models have intervals of
+[0.0896, 0.0999] and [0.0939, 0.1042], which overlap — and the paired test finds
+the difference real at p = 0.001. Reading the marginal intervals alone would
+have produced the wrong conclusion.
+
+## Reproducing
+
+`hypotheses/` contains every model's raw output for all 1,548 clips. You do not
+have to trust these numbers: rerun `scripts/bootstrap_ci.py` against them, or
+score them with your own normalisation and see what changes.

results/bootstrap.json

@@ -0,0 +1,69 @@
+{
+  "n_clips": 1548,
+  "bootstrap_resamples": 2000,
+  "models": {
+    "badrex/Ethio-ASR-amharic": {
+      "cer": 0.0946085175823121,
+      "ci_low": 0.08959124115436702,
+      "ci_high": 0.09989462592202318
+    },
+    "badrex/Ethio-ASR-multilingual-600M": {
+      "cer": 0.0990624900009599,
+      "ci_low": 0.09391620100979643,
+      "ci_high": 0.10424305248945796
+    },
+    "b1n1yam/shook-medium-amharic-2k": {
+      "cer": 0.11470898793715803,
+      "ci_low": 0.10868228572892516,
+      "ci_high": 0.12021531100478469
+    },
+    "badrex/Ethio-ASR-multilingual-1B": {
+      "cer": 0.1307842447125076,
+      "ci_low": 0.12493081922903662,
+      "ci_high": 0.1365712318176798
+    },
+    "b1n1yam/shook-tiny-amharic-stage2-polish": {
+      "cer": 0.2735097430646658,
+      "ci_low": 0.264836532200352,
+      "ci_high": 0.2820246087866643
+    }
+  },
+  "pairs": [
+    {
+      "better": "badrex/Ethio-ASR-amharic",
+      "worse": "badrex/Ethio-ASR-multilingual-600M",
+      "mean_diff": -0.004456998889395945,
+      "ci_low": -0.0066792802631077675,
+      "ci_high": -0.002177747495908766,
+      "p_not_better": 0.0005,
+      "distinguishable": true
+    },
+    {
+      "better": "badrex/Ethio-ASR-multilingual-600M",
+      "worse": "b1n1yam/shook-medium-amharic-2k",
+      "mean_diff": -0.015536286895762965,
+      "ci_low": -0.019368955129221502,
+      "ci_high": -0.012020175342536354,
+      "p_not_better": 0.0,
+      "distinguishable": true
+    },
+    {
+      "better": "b1n1yam/shook-medium-amharic-2k",
+      "worse": "badrex/Ethio-ASR-multilingual-1B",
+      "mean_diff": -0.01614948122332857,
+      "ci_low": -0.020152906383583233,
+      "ci_high": -0.012007436864122284,
+      "p_not_better": 0.0,
+      "distinguishable": true
+    },
+    {
+      "better": "badrex/Ethio-ASR-multilingual-1B",
+      "worse": "b1n1yam/shook-tiny-amharic-stage2-polish",
+      "mean_diff": -0.1427108125824523,
+      "ci_low": -0.14980525000317182,
+      "ci_high": -0.13608357372773008,
+      "p_not_better": 0.0,
+      "distinguishable": true
+    }
+  ]
+}

results/phase1_greedy.json

@@ -0,0 +1,43 @@
+{
+  "test_clips": 1548,
+  "test_hours": 4.722048335472743,
+  "decoding": "greedy",
+  "whisper_max_new_tokens": 440,
+  "models": {
+    "badrex/Ethio-ASR-multilingual-600M": {
+      "cer": 0.0990624900009599,
+      "wer": 0.2983765690376569,
+      "n": 1548,
+      "empty_hyp_rate": 0.0,
+      "kind": "ctc"
+    },
+    "badrex/Ethio-ASR-multilingual-1B": {
+      "cer": 0.1307842447125076,
+      "wer": 0.3893891213389121,
+      "n": 1548,
+      "empty_hyp_rate": 0.0,
+      "kind": "ctc"
+    },
+    "badrex/Ethio-ASR-amharic": {
+      "cer": 0.0946085175823121,
+      "wer": 0.28451882845188287,
+      "n": 1548,
+      "empty_hyp_rate": 0.0006459948320413437,
+      "kind": "ctc"
+    },
+    "b1n1yam/shook-medium-amharic-2k": {
+      "cer": 0.11470898793715803,
+      "wer": 0.29425941422594143,
+      "n": 1548,
+      "empty_hyp_rate": 0.0,
+      "kind": "whisper"
+    },
+    "b1n1yam/shook-tiny-amharic-stage2-polish": {
+      "cer": 0.2735097430646658,
+      "wer": 0.6200167364016737,
+      "n": 1548,
+      "empty_hyp_rate": 0.0,
+      "kind": "whisper"
+    }
+  }
+}

scripts/README.md

@@ -0,0 +1,18 @@
+# Scripts
+
+| file | what it does |
+|---|---|
+| `bench_asr.py` | Runs each model over the test split and scores CER and WER |
+| `bench_lm.py` | Builds an n-gram language model and re-decodes the CTC models |
+| `bootstrap_ci.py` | Confidence intervals and paired significance tests |
+| `geez_eval.py` | Ge'ez normalisation, taken from the corpus release |
+
+`geez_eval.py` is the part that matters most for comparability. It folds Ge'ez
+homophone families and strips Ethiopic punctuation, which lives in the same
+Unicode block as letters and so is missed by generic punctuation classes.
+Numbers produced with a different normaliser are not comparable to these.
+
+Both benchmark scripts push results after **every model**, so a crash partway
+through does not cost the models already scored. That is not defensive
+programming for its own sake: it is the only reason five models survived a run
+where every upload silently failed. See `../docs/FAILURES.md`.

scripts/bench_asr.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Phase 1+2: benchmark open ASR models on our own test set, then add a KenLM.
+
+Our test set is worth using because of one property nothing else here has: the
+labels are certain. A contributor read a known sentence, so the reference is not
+a guess. And every model benchmarked below was published BEFORE our dataset
+existed, so none of them can have trained on it.
+
+    Phase 1   each model, greedy decoding, CER and WER
+    Phase 2   CTC models again with a KenLM, alpha/beta tuned on VALIDATION
+
+Results are pushed after every single model. A crash at model five must not cost
+models one through four.
+
+    python bench_asr.py --push-to snapwre/amharic-asr-benchmark
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import re
+import subprocess
+import sys
+import time
+import traceback
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import geez_eval  # noqa: E402  the release's own normaliser
+import jiwer  # noqa: E402
+import numpy as np  # noqa: E402
+import soundfile as sf  # noqa: E402
+import torch  # noqa: E402
+from huggingface_hub import HfApi, snapshot_download  # noqa: E402
+
+TEST_REPO = "snapwre/amharic-speech"
+
+#: (id, kind, note). Order matters only for reading the log.
+MODELS = [
+    ("badrex/Ethio-ASR-multilingual-600M", "ctc",
+     "w2v-BERT 2.0. Best WAXAL average, 77,598 downloads. The one that matters."),
+    ("badrex/Ethio-ASR-multilingual-1B", "ctc",
+     "MMS-based. What both our E01/E02 and Henok's corpus used."),
+    ("badrex/Ethio-ASR-amharic", "ctc",
+     "Monolingual. Does multilingual training help Amharic or hurt it?"),
+    ("b1n1yam/shook-medium-amharic-2k", "whisper",
+     "Whisper medium, ~2k hours. Our previous best at 0.091 CER."),
+    ("b1n1yam/shook-tiny-amharic-stage2-polish", "whisper",
+     "37.8M params. If it is close, this is the on-device story."),
+    ("openai/whisper-large-v3", "whisper",
+     "Baseline. Expected to be bad on Amharic; that is the point."),
+]
+
+LANG_TAG = re.compile(r"^\s*\[[A-Z]{2,4}\]\s*")
+
+
+def log(m: str) -> None:
+    print(f"{time.strftime('%H:%M:%S')}  {m}", flush=True)
+
+
+def norm(t: str) -> str:
+    """Scoring-side normalisation: fold Ge'ez homophones, strip punctuation.
+
+    Identical to the published eval.py so these numbers are comparable with
+    every figure the project has already put in public.
+    """
+    return geez_eval.normalize(LANG_TAG.sub("", t or ""), fold_geez=True)
+
+
+def score(refs: list[str], hyps: list[str]) -> dict:
+    """CER and WER over the whole set, computed on concatenated text.
+
+    CER is the honest metric for Amharic: it is agglutinative, so one wrong affix
+    on a long word costs an entire word under WER and throws away most of the
+    signal. WER is reported anyway because it is what everyone else quotes.
+    """
+    R = [norm(r) for r in refs]
+    H = [norm(h) for h in hyps]
+    pairs = [(r, h) for r, h in zip(R, H) if r]
+    if not pairs:
+        return {"cer": float("nan"), "wer": float("nan"), "n": 0}
+    R2 = [r for r, _ in pairs]
+    H2 = [h for _, h in pairs]
+    empty = sum(1 for h in H2 if not h.strip())
+    return {"cer": float(jiwer.cer(R2, H2)), "wer": float(jiwer.wer(R2, H2)),
+            "n": len(pairs), "empty_hyp_rate": empty / len(pairs)}
+
+
+def load_split(split: str, limit: int | None) -> list[dict]:
+    import pyarrow.parquet as pq
+    d = Path(snapshot_download(TEST_REPO, repo_type="dataset",
+                               allow_patterns=[f"data/{split}-*.parquet"]))
+    rows: list[dict] = []
+    for f in sorted(d.glob(f"data/{split}-*.parquet")):
+        for b in pq.ParquetFile(f).iter_batches(batch_size=64):
+            for r in b.to_pylist():
+                rows.append(r)
+                if limit and len(rows) >= limit:
+                    return rows
+    return rows
+
+
+def audio_of(row: dict) -> np.ndarray:
+    a, sr = sf.read(io.BytesIO(row["audio"]["bytes"]), dtype="float32")
+    if a.ndim > 1:
+        a = a.mean(axis=1)
+    assert sr == 16000, f"expected 16 kHz, got {sr}"
+    return a
+
+
+@torch.inference_mode()
+def run_ctc(mid: str, rows: list[dict], bs: int, want_logits: bool = False):
+    """CTC greedy. Optionally also return logits for later LM decoding."""
+    from transformers import AutoModelForCTC, AutoProcessor
+    proc = AutoProcessor.from_pretrained(mid)
+    model = AutoModelForCTC.from_pretrained(
+        mid, torch_dtype=torch.float16).to("cuda").eval()
+    out, logits_all = [], []
+    for i in range(0, len(rows), bs):
+        chunk = [audio_of(r) for r in rows[i:i + bs]]
+        inp = proc(chunk, sampling_rate=16000, return_tensors="pt", padding=True)
+        key = "input_features" if "input_features" in inp else "input_values"
+        lg = model(inp[key].to("cuda", torch.float16)).logits
+        out += proc.batch_decode(lg.argmax(-1).cpu().numpy())
+        if want_logits:
+            # float32 on CPU; pyctcdecode needs log-probs and fp16 underflows.
+            logits_all += [x for x in lg.float().cpu().numpy()]
+        if (i // bs) % 10 == 0:
+            log(f"    {min(i + bs, len(rows))}/{len(rows)}")
+    vocab = proc.tokenizer.get_vocab() if hasattr(proc, "tokenizer") else {}
+    del model
+    torch.cuda.empty_cache()
+    return [t.strip() for t in out], logits_all, vocab
+
+
+@torch.inference_mode()
+def run_whisper(mid: str, rows: list[dict], bs: int) -> list[str]:
+    from transformers import WhisperForConditionalGeneration, WhisperProcessor
+    proc = WhisperProcessor.from_pretrained(mid)
+    model = WhisperForConditionalGeneration.from_pretrained(
+        mid, torch_dtype=torch.float16).to("cuda").eval()
+    out = []
+    for i in range(0, len(rows), bs):
+        chunk = [audio_of(r) for r in rows[i:i + bs]]
+        feats = proc(chunk, sampling_rate=16000,
+                     return_tensors="pt").input_features
+        ids = model.generate(feats.to("cuda", torch.float16),
+                             language="am", task="transcribe",
+                             max_new_tokens=440, num_beams=1)
+        out += proc.batch_decode(ids, skip_special_tokens=True)
+        if (i // bs) % 10 == 0:
+            log(f"    {min(i + bs, len(rows))}/{len(rows)}")
+    del model
+    torch.cuda.empty_cache()
+    return [t.strip() for t in out]
+
+
+def push(api: HfApi, repo: str, obj, path: str) -> None:
+    p = Path("/tmp") / Path(path).name
+    p.write_text(json.dumps(obj, ensure_ascii=False, indent=2)
+                 if not isinstance(obj, str) else obj, encoding="utf-8")
+    try:
+        api.upload_file(path_or_fileobj=str(p), repo_id=repo,
+                        repo_type="dataset", path_in_repo=path)
+        log(f"  pushed {path}")
+    except Exception as exc:  # noqa: BLE001
+        log(f"  push failed for {path}: {exc}")
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--push-to", default="snapwre/amharic-asr-benchmark")
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--batch-size", type=int, default=16)
+    ap.add_argument("--out", type=Path, default=Path("bench"))
+    ap.add_argument("--skip-lm", action="store_true")
+    # Without this the script invented its own timestamp, so results.json landed
+    # in a different runs/ folder from the log and every other artefact of the
+    # same job. One run must mean one folder.
+    ap.add_argument("--run", default="")
+    args = ap.parse_args()
+    args.out.mkdir(parents=True, exist_ok=True)
+
+    # HfApi() with no token picks up the ambient HF_TOKEN, which here is the
+    # collaborator's READ token for the private audio repo. It cannot write to
+    # our namespace, so every push 404s with "Repository Not Found". Same
+    # ambient-token precedence bug that cost the download workers a day.
+    import os
+    api = HfApi(token=os.environ.get("HF_PUSH_TOKEN") or None)
+    import os
+    run = (args.run or os.environ.get("RUN_ID")
+           or time.strftime("%Y%m%dT%H%M%SZ", time.gmtime()))
+    log(f"run {run}  torch {torch.__version__}  cuda {torch.cuda.is_available()}")
+
+    test = load_split("test", args.limit or None)
+    refs = [r["sentence"] for r in test]
+    hours = sum(r["duration_s"] for r in test) / 3600
+    log(f"test split: {len(test)} clips, {hours:.2f} h")
+
+    results = {"run": run, "test_clips": len(test), "test_hours": hours,
+               "phase1": {}, "phase2": {}}
+    keep = {}   # model -> (logits, vocab) for the LM phase
+
+    for mid, kind, note in MODELS:
+        log(f"== {mid} ({kind})")
+        t0 = time.time()
+        try:
+            if kind == "ctc":
+                hyps, logits, vocab = run_ctc(
+                    mid, test, args.batch_size,
+                    want_logits=not args.skip_lm)
+                if logits:
+                    keep[mid] = (logits, vocab)
+            else:
+                hyps = run_whisper(mid, test, args.batch_size)
+            s = score(refs, hyps)
+            s.update(kind=kind, note=note, seconds=round(time.time() - t0, 1))
+            results["phase1"][mid] = s
+            log(f"   CER {s['cer']:.4f}   WER {s['wer']:.4f}   "
+                f"empty {s['empty_hyp_rate']:.1%}   {s['seconds']:.0f}s")
+            (args.out / f"hyp_{mid.replace('/', '__')}.json").write_text(
+                json.dumps({"model": mid, "hyps": hyps}, ensure_ascii=False))
+        except Exception as exc:  # noqa: BLE001
+            log(f"   FAILED: {type(exc).__name__}: {exc}")
+            traceback.print_exc()
+            results["phase1"][mid] = {"error": f"{type(exc).__name__}: {exc}",
+                                      "kind": kind, "note": note}
+        # Push after EVERY model. A crash at model five must not cost the rest.
+        push(api, args.push_to, results, f"runs/{run}/results.json")
+
+    (args.out / "results.json").write_text(json.dumps(results, indent=2))
+    log("phase 1 complete")
+
+    if args.skip_lm or not keep:
+        return
+    log("phase 2 would run here (kept logits for "
+        f"{len(keep)} CTC models)")
+
+
+if __name__ == "__main__":
+    main()

scripts/bench_lm.py

@@ -0,0 +1,293 @@
+#!/usr/bin/env python3
+"""Phase 2: does an Amharic n-gram language model improve CTC decoding?
+
+A CTC model emits a probability per character per frame and decides each frame
+independently. It has no idea what an Amharic word is, so when the audio is
+ambiguous it will happily emit a character sequence that is not a word. An
+n-gram LM scores candidate hypotheses during beam search and pulls the output
+toward sequences that are actually Amharic.
+
+This applies to CTC only. Whisper is seq2seq with its own decoder and does not
+take an external n-gram the same way.
+
+Two rules that make the result honest:
+
+  1. Every test AND validation sentence is excluded from the LM training text.
+     An LM that has memorised the references makes the score fiction, and the
+     failure is silent: nothing errors, the number just comes out better.
+  2. alpha and beta are tuned on VALIDATION, never on test.
+"""
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import re
+import subprocess
+import sys
+import time
+import unicodedata
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import geez_eval  # noqa: E402
+import jiwer  # noqa: E402
+import numpy as np  # noqa: E402
+import soundfile as sf  # noqa: E402
+import torch  # noqa: E402
+from huggingface_hub import HfApi, snapshot_download  # noqa: E402
+
+TEST_REPO = "snapwre/amharic-speech"
+#: Addis AI's open Amharic text, 10.1M rows. Two orders of magnitude more than
+#: our 660k words of prompts, and the single biggest upgrade available to the LM.
+TEXT_REPOS = ["b1n1yam/amharic-combined-corpus"]
+
+CTC_MODELS = [
+    "badrex/Ethio-ASR-multilingual-600M",
+    "badrex/Ethio-ASR-multilingual-1B",
+    "badrex/Ethio-ASR-amharic",
+]
+LANG_TAG = re.compile(r"^\s*\[[A-Z]{2,4}\]\s*")
+PUNCT = re.compile(r"[።፡፣፤፥፦፧፨\.\,\?\!\:\;\"\'\(\)\[\]]")
+
+
+def log(m: str) -> None:
+    print(f"{time.strftime('%H:%M:%S')}  {m}", flush=True)
+
+
+def norm(t: str) -> str:
+    return geez_eval.normalize(LANG_TAG.sub("", t or ""), fold_geez=True)
+
+
+def cer_wer(refs, hyps):
+    R = [norm(r) for r in refs]
+    H = [norm(h) for h in hyps]
+    p = [(r, h) for r, h in zip(R, H) if r]
+    return (float(jiwer.cer([r for r, _ in p], [h for _, h in p])),
+            float(jiwer.wer([r for r, _ in p], [h for _, h in p])))
+
+
+def lm_text(held: set[str]) -> Path:
+    """Amharic text for the LM, with every held-out sentence removed.
+
+    Exact whole-line matching is not enough and quietly reported 0 drops across
+    12.8M lines. Our prompts came from news text and this corpus is news and
+    wiki, so a test sentence sitting INSIDE a longer paragraph is a real risk,
+    and it is exactly the kind of leak that raises no error and silently makes
+    every downstream number better than the truth. Aho-Corasick finds them as
+    substrings in one pass.
+    """
+    out = Path("lm_corpus.txt")
+    seen: set[str] = set()
+    n_lines = n_drop = 0
+    matcher = None
+    try:
+        import ahocorasick
+        matcher = ahocorasick.Automaton()
+        for h in held:
+            if len(h) >= 20:      # short strings would match by coincidence
+                matcher.add_word(h, h)
+        matcher.make_automaton()
+        log(f"  substring matcher armed with {len(matcher)} held-out sentences")
+    except Exception as exc:  # noqa: BLE001
+        log(f"  ahocorasick unavailable ({exc}); exact match only. "
+            "Treat contamination as UNVERIFIED.")
+    with out.open("w", encoding="utf-8") as fh:
+        for repo in TEXT_REPOS:
+            try:
+                d = Path(snapshot_download(repo, repo_type="dataset"))
+            except Exception as exc:  # noqa: BLE001
+                log(f"  could not fetch {repo}: {exc}")
+                continue
+            import pyarrow.parquet as pq
+            files = sorted(d.rglob("*.parquet"))
+            log(f"  {repo}: {len(files)} parquet files")
+            for f in files:
+                try:
+                    pf = pq.ParquetFile(f)
+                    col = next((c for c in pf.schema_arrow.names
+                                if c in ("text", "content", "sentence", "article")),
+                               None)
+                    if col is None:
+                        continue
+                    for b in pf.iter_batches(batch_size=2000, columns=[col]):
+                        for t in b.to_pydict()[col]:
+                            for line in (t or "").splitlines():
+                                s = unicodedata.normalize("NFC", line).strip()
+                                if s in held or (matcher is not None
+                                                 and any(matcher.iter(s))):
+                                    n_drop += 1
+                                    continue
+                                s = re.sub(r"\s+", " ", PUNCT.sub(" ", s)).strip()
+                                if len(s) < 5 or s in seen:
+                                    continue
+                                seen.add(s)
+                                fh.write(s + "\n")
+                                n_lines += 1
+                except Exception as exc:  # noqa: BLE001
+                    log(f"    skip {f.name}: {exc}")
+    log(f"  LM corpus: {n_lines:,} lines, {n_drop:,} lines dropped as "
+        f"containing a held-out sentence")
+    if matcher is not None and n_drop == 0:
+        log("  0 drops with substring matching active: the corpus genuinely "
+            "does not contain our test sentences.")
+    return out
+
+
+def build_kenlm(corpus: Path, order: int = 5) -> Path:
+    arpa, binf = Path("am.arpa"), Path("am.bin")
+    # --skip_symbols: the corpus contains literal <unk> tokens and lmplz aborts
+    # on them rather than ignoring them. Without this the whole phase dies at
+    # "Special word <unk> is not allowed in the corpus".
+    subprocess.run(f"lmplz -o {order} --discount_fallback --skip_symbols "
+                   f"-S 40% < {corpus} > {arpa}", shell=True, check=True)
+    subprocess.run(["build_binary", str(arpa), str(binf)], check=True)
+    log(f"  KenLM built: {binf.stat().st_size / 1e6:.0f} MB")
+    return binf
+
+
+def audio_of(row):
+    a, sr = sf.read(io.BytesIO(row["audio"]["bytes"]), dtype="float32")
+    return a.mean(axis=1) if a.ndim > 1 else a
+
+
+def load_split(split, limit=None):
+    import pyarrow.parquet as pq
+    d = Path(snapshot_download(TEST_REPO, repo_type="dataset",
+                               allow_patterns=[f"data/{split}-*.parquet"]))
+    rows = []
+    for f in sorted(d.glob(f"data/{split}-*.parquet")):
+        for b in pq.ParquetFile(f).iter_batches(batch_size=64):
+            for r in b.to_pylist():
+                rows.append(r)
+                if limit and len(rows) >= limit:
+                    return rows
+    return rows
+
+
+@torch.inference_mode()
+def logits_for(mid, rows, bs):
+    from transformers import AutoModelForCTC, AutoProcessor
+    proc = AutoProcessor.from_pretrained(mid)
+    model = AutoModelForCTC.from_pretrained(
+        mid, torch_dtype=torch.float16).to("cuda").eval()
+    outs = []
+    for i in range(0, len(rows), bs):
+        chunk = [audio_of(r) for r in rows[i:i + bs]]
+        inp = proc(chunk, sampling_rate=16000, return_tensors="pt", padding=True)
+        key = "input_features" if "input_features" in inp else "input_values"
+        lg = model(inp[key].to("cuda", torch.float16)).logits.float().cpu().numpy()
+        outs += [x for x in lg]
+        if (i // bs) % 10 == 0:
+            log(f"    logits {min(i + bs, len(rows))}/{len(rows)}")
+    v = proc.tokenizer.get_vocab()
+    del model
+    torch.cuda.empty_cache()
+    return outs, v
+
+
+def labels_from(vocab: dict) -> list[str]:
+    """pyctcdecode wants labels by index, blank as '', word delimiter as ' '."""
+    out = [""] * (max(vocab.values()) + 1)
+    for tok, i in vocab.items():
+        if tok in ("<pad>", "<s>", "</s>", "<unk>"):
+            out[i] = ""
+        elif tok == "|":
+            out[i] = " "
+        else:
+            out[i] = tok
+    return out
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--push-to", default="snapwre/amharic-asr-benchmark")
+    ap.add_argument("--run", default=time.strftime("%Y%m%dT%H%M%SZ", time.gmtime()))
+    ap.add_argument("--batch-size", type=int, default=16)
+    ap.add_argument("--tune-n", type=int, default=400)
+    args = ap.parse_args()
+    # HfApi() with no token picks up the ambient HF_TOKEN, which here is the
+    # collaborator's READ token for the private audio repo. It cannot write to
+    # our namespace, so every push 404s with "Repository Not Found". Same
+    # ambient-token precedence bug that cost the download workers a day.
+    import os
+    api = HfApi(token=os.environ.get("HF_PUSH_TOKEN") or None)
+
+    test, val = load_split("test"), load_split("validation")
+    held = {unicodedata.normalize("NFC", r["sentence"]).strip()
+            for r in test + val}
+    log(f"test {len(test)}, validation {len(val)}, {len(held):,} held-out sentences")
+
+    log("building LM corpus")
+    corpus = lm_text(held)
+    lm = build_kenlm(corpus)
+
+    from pyctcdecode import build_ctcdecoder
+    tune = val[:args.tune_n]
+    out = {"run": args.run, "lm_corpus_lines": sum(1 for _ in corpus.open()),
+           "models": {}}
+
+    for mid in CTC_MODELS:
+        log(f"== {mid}")
+        try:
+            lg_t, vocab = logits_for(mid, test, args.batch_size)
+            labels = labels_from(vocab)
+            greedy = []
+            for x in lg_t:
+                ids = x.argmax(-1)
+                prev, s = -1, []
+                for i in ids:
+                    if i != prev and labels[i]:
+                        s.append(labels[i])
+                    prev = i
+                greedy.append("".join(s))
+            g_cer, g_wer = cer_wer([r["sentence"] for r in test], greedy)
+            log(f"   greedy  CER {g_cer:.4f}  WER {g_wer:.4f}")
+
+            lg_v, _ = logits_for(mid, tune, args.batch_size)
+            best = None
+            for a in (0.3, 0.5, 0.8):
+                for b in (0.5, 1.5):
+                    dec = build_ctcdecoder(labels, str(lm), alpha=a, beta=b)
+                    hy = [dec.decode(x) for x in lg_v]
+                    c, _ = cer_wer([r["sentence"] for r in tune], hy)
+                    log(f"   tune a={a} b={b}  val CER {c:.4f}")
+                    if best is None or c < best[0]:
+                        best = (c, a, b)
+            _, A, B = best
+            dec = build_ctcdecoder(labels, str(lm), alpha=A, beta=B)
+            hy = [dec.decode(x) for x in lg_t]
+            l_cer, l_wer = cer_wer([r["sentence"] for r in test], hy)
+            log(f"   +KenLM  CER {l_cer:.4f}  WER {l_wer:.4f}  "
+                f"(alpha={A}, beta={B})")
+            out["models"][mid] = {
+                "greedy_cer": g_cer, "greedy_wer": g_wer,
+                "lm_cer": l_cer, "lm_wer": l_wer, "alpha": A, "beta": B,
+                "cer_rel_gain": (g_cer - l_cer) / g_cer if g_cer else None,
+                "wer_rel_gain": (g_wer - l_wer) / g_wer if g_wer else None,
+            }
+        except Exception as exc:  # noqa: BLE001
+            import traceback
+            traceback.print_exc()
+            out["models"][mid] = {"error": f"{type(exc).__name__}: {exc}"}
+        p = Path("/tmp/lm_results.json")
+        p.write_text(json.dumps(out, indent=2))
+        try:
+            api.upload_file(path_or_fileobj=str(p), repo_id=args.push_to,
+                            repo_type="dataset",
+                            path_in_repo=f"runs/{args.run}/lm_results.json")
+            log("   pushed lm_results.json")
+        except Exception as exc:  # noqa: BLE001
+            log(f"   push failed: {exc}")
+
+    try:
+        api.upload_file(path_or_fileobj=str(lm), repo_id=args.push_to,
+                        repo_type="dataset", path_in_repo="kenlm/am-5gram.bin")
+        log("pushed the KenLM binary")
+    except Exception as exc:  # noqa: BLE001
+        log(f"LM upload failed: {exc}")
+
+
+if __name__ == "__main__":
+    main()

scripts/bootstrap_ci.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Bootstrap confidence intervals and paired significance for benchmark CERs.
+
+A leaderboard that reports 0.0946 against 0.0991 without saying whether that gap
+survives resampling is not a benchmark. And the naive check is wrong: marginal
+confidence intervals for these two models OVERLAP, yet the difference is real,
+because both are scored on the same clips. Pairing is what makes it visible.
+"""
+from __future__ import annotations
+
+import csv
+import glob
+import json
+import random
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import geez_eval  # noqa: E402
+import jiwer  # noqa: E402
+
+TAG = re.compile(r"^\s*\[[A-Z]{2,4}\]\s*")
+B = 2000
+
+
+def norm(t: str) -> str:
+    return geez_eval.normalize(TAG.sub("", t or ""), fold_geez=True)
+
+
+def per_clip(refs, hyps):
+    """Edit count and reference length per clip, so we resample clips."""
+    out = []
+    for r, h in zip(refs, hyps):
+        R, H = norm(r), norm(h)
+        if not R:
+            continue
+        out.append((float(jiwer.cer(R, H)) * len(R), len(R)))
+    return out
+
+
+def analyse(refs, model_hyps: dict[str, list[str]], seed: int = 11) -> dict:
+    models = {m: per_clip(refs, h) for m, h in model_hyps.items()}
+    cer = {m: sum(e for e, _ in v) / sum(n for _, n in v)
+           for m, v in models.items()}
+    order = sorted(cer, key=cer.get)
+    n = len(models[order[0]])
+    rng = random.Random(seed)
+    idx = [[rng.randrange(n) for _ in range(n)] for _ in range(B)]
+    samples = {m: [sum(models[m][i][0] for i in ix) / sum(models[m][i][1] for i in ix)
+                   for ix in idx] for m in order}
+
+    out = {"n_clips": n, "bootstrap_resamples": B, "models": {}, "pairs": []}
+    for m in order:
+        s = sorted(samples[m])
+        out["models"][m] = {"cer": cer[m], "ci_low": s[int(.025 * B)],
+                            "ci_high": s[int(.975 * B)]}
+    for a, b in zip(order, order[1:]):
+        d = sorted(x - y for x, y in zip(samples[a], samples[b]))
+        out["pairs"].append({
+            "better": a, "worse": b, "mean_diff": sum(d) / B,
+            "ci_low": d[int(.025 * B)], "ci_high": d[int(.975 * B)],
+            "p_not_better": sum(1 for x in d if x >= 0) / B,
+            "distinguishable": d[int(.975 * B)] < 0,
+        })
+    return out
+
+
+def main() -> None:
+    rel = Path(sys.argv[1] if len(sys.argv) > 1 else
+               "build/am-v0.2.0")
+    hyp_dir = sys.argv[2] if len(sys.argv) > 2 else "/tmp/benchres"
+    refs = [r["sentence"] for r in
+            csv.DictReader((rel / "metadata.csv").open(encoding="utf-8"))
+            if r["split"] == "test"]
+    hyps = {}
+    for f in sorted(glob.glob(f"{hyp_dir}/hyp*.json")):
+        d = json.load(open(f))
+        # A 440-token rerun supersedes the truncated pass for the same model.
+        if d["model"] in hyps and not Path(f).name.startswith("hyp440"):
+            continue
+        hyps[d["model"]] = d["hyps"]
+    res = analyse(refs, hyps)
+    Path(f"{hyp_dir}/bootstrap.json").write_text(json.dumps(res, indent=2))
+    print(json.dumps(res, indent=2)[:1500])
+
+
+if __name__ == "__main__":
+    main()

scripts/geez_eval.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Official evaluation script for this dataset. Shipped inside the release.
+
+Word error rate is only comparable between systems if everyone computes it the
+same way, and for Ge'ez script that is not the default. Amharic and Tigrinya
+write several distinct characters for one sound -- ሀ, ሐ and ኀ are all /hä/; ሰ and
+ሠ are both /sä/; አ and ዐ are both /ʾä/; ጸ and ፀ are both /ṣä/. Which one a writer
+picks is orthographic convention, not pronunciation, and different systems settle
+on different variants. Scoring raw strings therefore charges a model for spelling
+a sound the way its training data spelt it.
+
+This script is the reference implementation. Quote the normalised figure; the raw
+one is printed too, because normalising is a judgement call and hiding it would
+make the benchmark unauditable.
+
+    pip install jiwer
+    python eval.py --predictions preds.jsonl
+
+`preds.jsonl` has one JSON object per line: {"clip_id": ..., "text": ...}
+Clip ids come from the test split of this dataset.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+import unicodedata
+
+# Each pair shifts one consonant family onto its homophone base. The Ethiopic
+# block lays every consonant out as a contiguous run of vowel orders from a fixed
+# base, so shifting the base and keeping the offset folds all orders at once --
+# including the rare ones a hand-written character list would miss.
+_GEEZ_FOLD_BASES = [
+    (0x1210, 0x1200),  # ሐ -> ሀ
+    (0x1280, 0x1200),  # ኀ -> ሀ
+    (0x1220, 0x1230),  # ሠ -> ሰ
+    (0x12D0, 0x12A0),  # ዐ -> አ
+    (0x1340, 0x1338),  # ፀ -> ጸ
+]
+_ORDERS = 8
+
+_GEEZ_MAP = {src + o: dst + o for src, dst in _GEEZ_FOLD_BASES for o in range(_ORDERS)}
+_WS = re.compile(r"\s+")
+
+
+def normalize(text: str, *, fold_geez: bool = True) -> str:
+    text = unicodedata.normalize("NFC", text)
+    if fold_geez:
+        text = text.translate(_GEEZ_MAP)
+    # Ethiopic punctuation (። ፣ ፤) sits inside the same Unicode block as Ethiopic
+    # letters, so a character-range test cannot separate them. Ask Unicode.
+    text = "".join(" " if unicodedata.category(c)[0] in ("P", "S") else c for c in text)
+    return _WS.sub(" ", text.casefold()).strip()
+
+
+def evaluate(
+    references: dict[str, str], predictions: dict[str, str], *, fold_geez: bool = True
+) -> dict:
+    import jiwer
+
+    missing = [k for k in references if k not in predictions]
+    empty = [k for k, v in predictions.items() if not (v or "").strip()]
+
+    # A clip with no prediction scores as a full deletion rather than being
+    # skipped. Dropping it would let a system improve its WER by declining to
+    # answer on the clips it finds hard.
+    ids = list(references)
+    refs = [references[i] for i in ids]
+    hyps = [predictions.get(i, "") for i in ids]
+
+    def measure(r, h):
+        pairs = [(a, b) for a, b in zip(r, h, strict=True) if a.strip()]
+        return (
+            jiwer.wer([p[0] for p in pairs], [p[1] for p in pairs]),
+            jiwer.cer([p[0] for p in pairs], [p[1] for p in pairs]),
+        )
+
+    raw_wer, raw_cer = measure(refs, hyps)
+    n_wer, n_cer = measure(
+        [normalize(r, fold_geez=fold_geez) for r in refs],
+        [normalize(h, fold_geez=fold_geez) for h in hyps],
+    )
+    return {
+        "clips": len(ids),
+        "wer": round(n_wer * 100, 2),
+        "cer": round(n_cer * 100, 2),
+        "wer_raw": round(raw_wer * 100, 2),
+        "cer_raw": round(raw_cer * 100, 2),
+        "missing_predictions": len(missing),
+        "empty_predictions": len(empty),
+    }
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument(
+        "--predictions", required=True, help='JSONL of {"clip_id": ..., "text": ...}'
+    )
+    p.add_argument("--dataset", default="snapwre/amharic-speech")
+    p.add_argument("--split", default="test")
+    p.add_argument(
+        "--no-fold",
+        action="store_true",
+        help="score without homophone folding (not comparable)",
+    )
+    args = p.parse_args()
+
+    from datasets import load_dataset
+
+    ds = load_dataset(args.dataset, split=args.split)
+    references = {r["clip_id"]: r["sentence"] for r in ds}
+
+    predictions = {}
+    with open(args.predictions, encoding="utf-8") as fh:
+        for line in fh:
+            if line.strip():
+                row = json.loads(line)
+                predictions[row["clip_id"]] = row.get("text", "")
+
+    result = evaluate(references, predictions, fold_geez=not args.no_fold)
+    print(json.dumps(result, indent=2))
+    if result["missing_predictions"]:
+        print(
+            f"\nWARNING: {result['missing_predictions']} of {result['clips']} test "
+            f"clips had no prediction and were scored as full deletions.",
+            file=sys.stderr,
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())