quran-asr-tiny
A 16M-parameter speech recognizer for Quran recitation, small enough to run fully offline on a phone (19 MB int8 ONNX, sherpa-onnx). It writes the Arabic letters of what is recited (no diacritics) and handles professional reciters, ordinary people reciting into a phone, Hafs and Warsh, and anything from slow tartil to fast hadr.
Paper: Small Conformer-CTC Models for On-Device Quranic Recitation Recognition Β· DOI 10.5281/zenodo.23761691
- 6.94% WER / 2.81% CER on the Quran-Lab held-out benchmark: #6 of 33 by WER and #3 by CER on the leaderboard at submission time; read the notes before comparing.
- Better than NVIDIA's Arabic FastConformer (115M, 7.44% / 3.08%) and Whisper large-v3 (1.5B, 10.10% / 4.26%), at 1/7 and 1/90 of their size.
- Transcribes the whole 600-clip benchmark (2.1 h of audio) in 31 s on 4 CPU threads (int8).
- Trained from scratch on one laptop GPU. All training code is in
code/.
Error vs model size: open models on the Quran-Lab benchmark (lower-left is better)
Leaderboard: top 12 by overall word error rate, %
Results
Quran-Lab benchmark (official score.py, 600 clips)
WER / CER in %, lower is better. Phone = tlog_holdout (real users reciting into the Tarteel app),
EveryAyah = studio reciters, QUL = reciter al-Nufais.
| Model | Params | Overall | Phone | EveryAyah | QUL |
|---|---|---|---|---|---|
| zipformer_p-arabic-v3 (streaming, retrieval), #1 | 66M | 3.46 / 1.84 | 7.56 / 1.79 | 0.00 / 0.00 | 4.40 / 3.77 |
| fastconformer-quran (offline 4h) | 115M | 5.41 / 2.96 | 8.88 / 2.66 | 0.93 / 0.26 | 7.78 / 5.91 |
| quran-asr-tiny (this model, PyTorch fp32) | 16M | 6.94 / 2.81 | 17.95 / 5.69 | 1.83 / 0.53 | 5.23 / 3.39 |
| quran-asr-tiny (int8 ONNX, as shipped) | 16M | 7.08 / 2.86 | 18.34 / 5.81 | 1.83 / 0.53 | 5.35 / 3.44 |
| NVIDIA stt_ar_fastconformer | 115M | 7.44 / 3.08 | 16.77 / 5.61 | 1.50 / 0.49 | 7.61 / 4.20 |
| Tarteel (official app, realtime) | β | 9.56 / 5.82 | 16.17 / 7.41 | 5.97 / 3.80 | 9.05 / 6.91 |
| Whisper large-v3 | 1.5B | 10.10 / 4.26 | 26.23 / 12.39 | 5.48 / 1.79 | 4.69 / 1.83 |
Other rows are from the leaderboard's results.json. Predictions for every clip are in
results/.
Character error rate by source
Read this before comparing
- Spelling. The model writes Uthmani rasm (it is trained on the Uthmani text: Ψ§ΩΨ³Ω
ΩΨͺ, Ψ§ΩΩΨͺΨ¨,
Ψ‘Ψ§Ω
ΩΩΨ§). The benchmark's EveryAyah and QUL references are in standard spelling, so for the
numbers above each output word that exactly matches a Quran word is rewritten in standard
spelling using
spelling.json, a fixed table built from two editions of the Quran text. It never changes a word the model got wrong, only how a correct word is spelled. The same table is applied to all three sources, although the tlog references are in Uthmani spelling (it costs about 6 WER points there). Raw Uthmani output scores 12.90 / 4.25 overall and 11.51 / 4.12 on the phone recordings. - Overlap with our training data. The benchmark is held out from its authors' training data, not ours. 134 of the 200 EveryAyah clips are Sahl Yassin and Akram AlAlaqimy, two reciters in our training set. 13 of the 200 phone recordings were in our training data until step ~152k (excluded after that). Without the 134 EveryAyah clips: 8.87% WER / 3.63% CER (EveryAyah, unseen reciter only: 3.67 / 1.06).
- Greedy CTC decoding, no language model, no lexicon constraint, no target-ayah hints; the model never sees a reference.
Reciters never seen in training
Our own test set: 1,000 clips sampled from two Hafs reciters left out of training, plus 6 held-out surahs (1, 18, 36, 55, 67, 112) of the three Warsh reciters. Uthmani letters, so no spelling conversion is involved.
| Test set | CER | WER |
|---|---|---|
| Hani ar-Rifai (Hafs, unseen) | 0.63% | 1.69% |
| Muhammad Siddiq al-Minshawi, 32 kbps (Hafs, unseen) | 2.86% | 5.31% |
| Warsh: Ibrahim al-Dosary (held-out surahs) | 0.28% | 1.20% |
| Warsh: Yassin al-Jazaery (held-out surahs) | 0.28% | 1.20% |
| Warsh: Abdul Basit (held-out surahs) | 7.30% | 11.79% |
| All | 1.68% | 3.37% |
Training progress
Benchmark by checkpoint: overall WER (standard spelling) and phone-recording CER (raw Uthmani output)
Points up to 222k are averages of the last 6 checkpoints; 245k is the released checkpoint (lowest validation error). Adding more phone recordings, not more steps, is what moved the phone numbers.
Validation character error rate during training (log scale; the jump at 30k is where ordinary readers (Iqra'Eval) joined the validation set, 1,255 β 1,913 clips)
Usage
Python (sherpa-onnx)
pip install sherpa-onnx soundfile numpy scipy huggingface_hub
huggingface-cli download Abdou/quran-asr-tiny --local-dir quran-asr-tiny --exclude "code/*" "model.pt"
python quran-asr-tiny/transcribe.py recitation.wav # Uthmani letters
python quran-asr-tiny/transcribe.py recitation.wav --standard # standard spelling
Or directly:
import sherpa_onnx, soundfile as sf
rec = sherpa_onnx.OfflineRecognizer.from_zipformer_ctc(
model="model.int8.onnx", tokens="tokens.txt", num_threads=2)
wave, sr = sf.read("recitation_16k_mono.wav", dtype="float32") # 16 kHz mono
s = rec.create_stream()
s.accept_waveform(sr, wave)
rec.decode_stream(s)
print(s.result.text) # e.g. "ΩΩ ΩΩ Ψ§ΩΩΩ Ψ§ΨΨ―"
Android / iOS
The ONNX file follows sherpa-onnx's zipformer CTC interface (input x [N, T, 80] fbank and
x_lens; output log_probs, log_probs_len; metadata vocab_size = 31, subsampling_factor = 4),
so it loads with the stock sherpa-onnx mobile libraries:
OfflineModelConfig(zipformerCtc = OfflineZipformerCtcModelConfig(model = "model.int8.onnx"), tokens = "tokens.txt").
Feature extraction (80-dim log-mel fbank, 25 ms / 10 ms, 16 kHz) is done by sherpa-onnx itself.
PyTorch
model.pt holds the weights and model_config; the model class is code/quran_asr/model.py
(build(config, vocab_size=31)), the features code/quran_asr/features.py.
Exact ayah with tashkeel (retrieval)
The model writes bare Uthmani letters, and a letter or word can come out wrong. To show what was recited as the exact Quran text, with full tashkeel, match the output against the mushaf with retrieve.py (pip install rapidfuzz; it downloads the Hafs Uthmani text once):
from retrieve import Quran
quran = Quran()
m = quran.find("ΩΩ ΩΩ Ψ§ΩΩΩ Ψ§ΨΨ― Ψ§ΩΩΩ Ψ§ΩΨ΅Ω
Ψ―") # the model's output
m["ref"] # '112:1-2'
m["text"] # 'ΩΩΩΫ‘ ΩΩΩΩ Ω±ΩΩΩΩΩΩ Ψ£ΩΨΩΨ―Ω Ω±ΩΩΩΩΩΩ Ω±ΩΨ΅ΩΩΩ
ΩΨ―Ω' (the recited words)
m["ayahs"] # the full ayahs, with tashkeel
On the benchmark's QUL and phone clips it returns the right ayah for 97% of clips, in about 10 ms each. Some ayahs occur word for word in several places (e.g. 3:182 and 8:51): pass near=(sura, aya), such as the previous match or the page being read, to pick the closest one (99.5% with it).
Model
| Architecture | Conformer encoder + CTC: conv subsampling Γ4 (2 stride-2 convs, 256 ch), 6 blocks, d=320, 5 heads (RoPE), FF Γ4, conv kernel 31, BatchNorm |
| Parameters | 16.4M (int8 ONNX 19 MB, fp32 66 MB) |
| Input | 16 kHz mono, 80-dim log-mel fbank (Kaldi-compatible) |
| Output | 29 Arabic letters + word separator (31 tokens with blank); no diacritics; Ψ©βΩ, ΩβΩ, hamza seats folded |
| Spelling | Uthmani rasm (Hafs text from Tanzil); spelling.json converts to standard spelling |
| Decoding | greedy CTC |
| Riwayat | Hafs ΚΏan ΚΏAsim, Warsh ΚΏan NafiΚΏ |
Training data
| Source | Clips | Hours | What | License / terms |
|---|---|---|---|---|
| EveryAyah, Hafs | 231,455 | 1,184 | 38 professional reciters, per-ayah MP3s (murattal, mujawwad, muallim) | everyayah.com terms |
| EveryAyah, Warsh | 17,648 | 96 | 3 Warsh reciters (labels aligned from the Warsh Uthmani text) | everyayah.com terms |
| tarteel-ai/tlog | 39,893 | 98 | ordinary people reciting into a phone; 73 of 411 shards, labels checked against the audio (40% of clips dropped as mislabelled; 14% of the kept ones relabelled to a neighbouring ayah or with basmala/isti'adha added) | CC-BY-4.0 |
| IqraEval/Iqra_train | 15,422 | 21 | ordinary readers; only sentences matched to the Quran | not stated |
Labels: the Hafs Uthmani text from Tanzil (via fawazahmed0/quran-api), letters only. Validation: 0.5% of each source. Test: Hani ar-Rifai, al-Minshawi (32 kbps), and 6 Warsh surahs, never trained on.
Training
- 246,933 steps (19 epochs over a growing dataset), batches of 420 s of audio, AdamW (lr 4e-4, weight decay 1e-3), 500-step warmup, cosine decay to 2%, bf16, grad clip 5. About 24,000 hours of audio seen, ~1.5 days on one laptop GPU (RTX 5070 Ti Laptop, 12 GB).
- Ordinary people (tlog + Iqra'Eval) are sampled to 25% of each epoch's audio; Warsh weighted Γ4.
- Augmentation (from step 3,000): speed 0.9/1.0/1.1, tempo stretch Γ0.75 to Γ2.5 (WSOLA, for slow tartil to fast hadr), gain, noise (SNR 5 to 35 dB), reverb, low-pass (phone bandwidth), SpecAugment.
- What mattered: a shallow model (16-layer and wider ones collapsed to blank output), clean audio for the first steps, fixing everyayah's Warsh ayah numbering and phase-inverted stereo files, and checking tlog labels against the audio.
Limitations
- Letters only: no harakat, so it cannot judge tajweed or vowelling mistakes.
- Recitation only. Other speech is forced into Quranic-looking letters.
- Phone recordings are still the hardest case (5.7% CER vs 0.5% on studio audio); children and very noisy rooms are underrepresented.
- Riwayat other than Hafs and Warsh were not trained.
Reproduce
code/ holds the whole pipeline (download β prepare β train β export β evaluate), with its own README:
cd code && pip install -r requirements.txt
python download.py --config config/full.yaml # everyayah + Iqra'Eval + tlog (needs `hf auth login`, tlog terms accepted)
python prepare.py --config config/full.yaml # labels, numbering checks, tlog label checks, manifests
python train.py --config config/full.yaml # resumable; dashboard: python dashboard.py
python export.py --config config/full.yaml --best
python benchmark.py --config config/full.yaml --average 1 # Quran-Lab benchmark (gated)
Files
| File | |
|---|---|
model.int8.onnx |
int8 model for sherpa-onnx (what a phone app should ship) |
model.onnx |
fp32 ONNX |
model.pt |
PyTorch weights + config (step 245,000) |
tokens.txt |
sherpa-onnx tokens |
spelling.json |
Uthmani β standard spelling table (2,111 words) |
transcribe.py |
example script |
retrieve.py |
maps the output to the exact ayah, with tashkeel |
results/ |
benchmark predictions (fp32 and int8), held-out reciter scores, training log |
code/ |
training and evaluation code |
Acknowledgements
EveryAyah and the reciters; Tarteel for tlog (CC-BY-4.0); the Iqra'Eval organizers; Quran-Lab for the benchmark and leaderboard; Tanzil for the text; and the sherpa-onnx project.
Citation
@misc{fadheli2026quranasr,
author = {Fadheli, Abdeladim},
title = {Small Conformer-CTC Models for On-Device Quranic Recitation Recognition},
year = {2026},
publisher = {Zenodo},
doi = {10.5281/zenodo.23761691},
url = {https://zenodo.org/records/23761691}
}
License
MIT (code and weights). The training data keeps its own terms (see the table above).
Datasets used to train Abdou/quran-asr-tiny
IqraEval/Iqra_train
Quran-Lab/quranic-asr-benchmark
Spaces using Abdou/quran-asr-tiny 2
Evaluation results
- WER (overall) on Quran-Lab Quranic ASR Benchmark (600 held-out clips)self-reported6.940
- CER (overall) on Quran-Lab Quranic ASR Benchmark (600 held-out clips)self-reported2.810
- WER (phone recordings, tlog_holdout) on Quran-Lab Quranic ASR Benchmark (600 held-out clips)self-reported17.950
- CER (phone recordings, tlog_holdout) on Quran-Lab Quranic ASR Benchmark (600 held-out clips)self-reported5.690




