mohammed/fastconformer-quran-ar
FastConformer Quran Arabic ASR
A fine-tuned NVIDIA FastConformer Hybrid Large model for Quranic Arabic speech recognition, achieving 0.14% Word Error Rate on the tarteel-ai/everyayah validation set.
This model supports both offline transcription (full bilateral context, highest accuracy) and real-time streaming (causal local attention, cache-aware frame-by-frame inference).
Model Details
Training
Fine-tuned using a 3-phase progressive unfreezing strategy on a single NVIDIA RTX 4070 Ti (12 GB):
Progressive unfreezing prevents catastrophic forgetting of the base model's Arabic speech representations while allowing the full model to adapt to Quranic phonetics, tajweed rules, and recitation style.
Training data: tarteel-ai/everyayah — a diverse multi-reciter dataset of complete Quranic recitations at multiple audio qualities, covering all 114 surahs across dozens of reciters.
Usage
Installation
pip install nemo_toolkit[asr]Offline transcription (recommended for files)
The .nemo file is saved with full bilateral attention context — transcribe() works out of the box with no configuration required.
import nemo.collections.asr as nemo_asr
model = nemo_asr.models.EncDecHybridRNNTCTCBPEModel.from_pretrained(
"mohammed/fastconformer-quran-ar"
)
model.eval()
# Transcribe a .wav file (16kHz mono)
result = model.transcribe(["recitation.wav"])
print(result[0].text)
# e.g. "بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ"Real-time streaming
The model supports cache-aware streaming inference via NeMo's cache_aware_stream_step(). The key loading sequence (order matters):
import torch
import nemo.collections.asr as nemo_asr
from omegaconf import OmegaConf, open_dict
model = nemo_asr.models.EncDecHybridRNNTCTCBPEModel.from_pretrained(
"mohammed/fastconformer-quran-ar"
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = model.to(device)
# Step 1 — reset conv padding to symmetric (safety check before mode switch)
for layer in model.encoder.layers:
if hasattr(layer, "conv") and hasattr(layer.conv, "conv"):
conv = layer.conv.conv
ks = conv.kernel_size[0] if isinstance(conv.kernel_size, tuple) else conv.kernel_size
conv.padding = ((ks - 1) // 2, (ks - 1) // 2)
# Step 2 — switch to causal local attention for streaming
model.change_attention_model(
self_attention_model="rel_pos_local_attn",
att_context_size=[128, 0], # 128 frames lookback (~10s), fully causal
)
with open_dict(model.cfg):
model.cfg.encoder.conv_context_size = "causal"
# Step 3 — causal conv padding
for layer in model.encoder.layers:
if hasattr(layer, "conv") and hasattr(layer.conv, "conv"):
conv = layer.conv.conv
ks = conv.kernel_size[0] if isinstance(conv.kernel_size, tuple) else conv.kernel_size
conv.padding = (ks - 1, 0)
# Step 4 — greedy decoder
decoding_cfg = OmegaConf.structured(model.cfg.decoding)
OmegaConf.set_struct(decoding_cfg, False)
decoding_cfg.strategy = "greedy"
decoding_cfg.greedy.max_symbols = 10
decoding_cfg.greedy.use_cuda_graph_decoder = False # incompatible with streaming
model.change_decoding_strategy(decoding_cfg)
model.eval()
# Streaming loop — feed 80ms PCM int16 frames
cache_last_channel, cache_last_time = None, None
chunk_samples = 16000 * 1600 // 1000 # 1600ms chunk
audio_chunk = torch.zeros(1, chunk_samples, device=device) # replace with real audio
audio_len = torch.tensor([chunk_samples], device=device)
with torch.no_grad():
processed, processed_len = model.preprocessor(
input_signal=audio_chunk, length=audio_len
)
encoded, encoded_len, cache_last_channel, cache_last_time, _ = (
model.encoder.cache_aware_stream_step(
processed_signal=processed,
processed_signal_length=processed_len,
cache_last_channel=cache_last_channel,
cache_last_time=cache_last_time,
keep_all_outputs=False,
)
)For a complete streaming implementation with microphone input, silence detection, word callbacks, and a FastAPI WebSocket server, see the companion script in the repository files.
Qualitative Examples
The following are exact reference vs. predicted outputs from the validation set — the model transcribed these word-for-word correctly, including full diacritisation (tashkeel):
These span multiple surahs (Al-Furqan, An-Nur, Ash-Shu'ara, As-Saffat) and include some of the most phonetically demanding ayahs in the Quran — long compound sentences, rare vocabulary (نُشُورًا، سُبَاتًا), emphatic consonants, and precise tashkeel on every word.
Intended Use & Limitations
Intended use:
- Quranic recitation transcription and verification
- Tajweed learning applications
- Ayah identification from audio
- Recitation correction apps (compare hypothesis against reference ayah)
Limitations:
- Optimised specifically for Quranic Arabic — performance on Modern Standard Arabic or dialectal Arabic will be significantly lower than the base model
- Best results on clean, single-speaker recitation audio at 16kHz
- The streaming mode introduces ~1.6s of latency per chunk due to the encoder's minimum chunk size requirement
Citation
If you use this model, please cite the base model and dataset:
@misc{fastconformer-quran-ar,
author = {Mohammed},
title = {FastConformer Quran Arabic ASR},
year = {2026},
publisher = {Hugging Face},
url = {https://huggingface.co/mohammed/fastconformer-quran-ar}
}@misc{everyayah,
author = {Tarteel AI},
title = {EveryAyah: A Quranic Recitation Dataset},
publisher = {Hugging Face},
url = {https://huggingface.co/datasets/tarteel-ai/everyayah}
}