Fadhma-300M

A 300M-parameter CTC acoustic model for Kabyle (Taqbaylit, kab, Latin script), trained on 144.31 hours of read speech and decoded against a 5-gram language model built from three million normalised Kabyle sentences.

It transcribes Kabyle at 8.01% character error rate and 25.65% word error rate on 15,003 held-out utterances from 888 speakers it has never heard. It is, as far as we can establish, the first Kabyle speech recognition system published with an error rate measured on a speaker-disjoint split — and the first CTC result for the language at any size.

Its output is written in canonical Kabyle orthography, because the transcripts it learned from were repaired before it saw them.

Results

Common Voice 22.0 Kabyle test split: 15,003 utterances, 16.00 hours, 888 speakers present in no other split. Hypothesis and reference are reduced by the same normalisation policy before either is scored.

decoding	character error rate	word error rate
beam search, 5-gram shallow fusion	8.01%	25.65%
greedy CTC, no language model	8.53%	30.12%

Three things worth reading carefully.

The language model buys words, not phonemes. It takes 4.5 points off the word error rate and 0.5 off the character error rate, which is the shape you should expect: an n-gram cannot fix a misheard sound, it can only prefer a spelling that is a word. Both rows are reported because a single number here would hide which half of the system produced it.

There is no comparison table, deliberately. Every number in this card was produced by one harness on this split. No competing system has been run through it, so none appears. Two figures circulate for Kabyle and neither is comparable: Meta's Omnilingual ASR reports CER 6.2, but that figure lives in per_language_results_table_7B_llm_asr.csv — a 7B model with an LLM decoder, 23× the parameters and the architecture this model deliberately does not use. No per-language CTC result was published for any language. The honest comparison is facebook/omniASR-CTC-300M: public, Apache-2.0, exactly this size, and unscored on Kabyle by anyone. Running it costs no training and has not been done. Until it is, treat this model's error rate as a first measurement rather than a ranking.

Character error rate and word error rate diverge here for a structural reason. Kabyle attaches object pronouns and directional particles with hyphens — -d, -n, -awen, -iw. A hyphen the model writes as a space is one character wrong and two words wrong. At 92% character accuracy that accounts for a large share of the 25.65%, and it is a property of the orthography rather than of the acoustics.

Intended use

Transcribing Kabyle speech: voice notes, oral archives, interviews, broadcast, and speech input to downstream NLP. The output is canonical Kabyle Latin, so it can be fed to Amrouche-1.3B or Masinissa-31M without a repair step.

Not suitable for: any language other than Kabyle; audio with heavy background music or noise without voice-activity filtering first; or medical, legal or safety-critical transcription without human review. No safety evaluation of any kind has been performed.

Why CTC and not an encoder-decoder

This model exists to convert Kabyle's one abundant resource into its scarcest one: the project has 571 validated hours of speech and roughly 70 million unique tokens of text, and transcription is what turns the first into the second.

That purpose forbids a decoder. An encoder-decoder carries an internal language model, which is why Whisper hallucinates fluent text nobody said — and a hallucination here would be fabricated Kabyle entering a corpus under a provenance record claiming a human spoke it. CTC emits characters aligned to frames. It can mishear. It cannot invent a sentence.

Whisper is also refuted on measurement, not preference: 6 of the 10 Kabyle-specific letters have no token in its vocabulary and decode through UTF-8 byte fallback, its fertility on Kabyle is 3.3600 tokens per word against this project's tokenizer at 1.8837, and at a 3.463 s mean clip length against a fixed 30 s window, 11.5% of its compute is signal.

Architecture

Fine-tuned from Meta's Omnilingual ASR SSL encoder (ylacombe/omniASR_W2V_300M_SSL), which lists kab_Latn among the 1,668 languages in its pretraining.

Total parameters	315,482,152
Trainable	311,287,848
Frozen	4,194,304 — the 7-layer convolutional feature extractor
Layers / hidden / heads	24 / 1,024 / 16 (head size 64)
Feed-forward	4,096, GELU
Front end	7 convolutions, kernel 10,3,3,3,3,2,2, stride 5,2,2,2,2,2,2 — one frame per 20 ms
CTC classes	40: [PAD], [UNK], |, 36 Kabyle letters and -
Loss	CTC, ctc_zero_infinity=True

The convolutional front end is frozen, so the acoustic representation learned across Meta's multilingual pretraining survives contact with 144 hours of one language.

The 40 classes are derived from the transcripts' own characters — after normalisation, not before, and the ordering is the whole point. Common Voice's Kabyle transcripts are raw contributor text and carry the same homoglyph substitution as every other Kabyle source: Greek ε accounts for 10.6% of that letter's occurrences. Take the inventory first and the homoglyph becomes a 41st class, so the model learns to reproduce the corruption at corpus scale. Gate on the alphabet without normalising and the character is deleted instead, which splits the word in two and makes every word error rate computed over it wrong. Normalising first avoids both: 40 classes from a 128-character raw inventory, with 1.73% of rows repaired.

Nobody else fine-tuning Kabyle ASR has a reference orthography to check against. That is what the first four phases of this project bought.

Training data

Common Voice 22.0 Kabyle, CC-0, normalised at normaliser 1.3.0+rules1.0.0.

split	clips	hours	speakers
train	152,478	144.31	162
dev	15,002	15.21	135
test	15,003	16.00	888

Speaker overlap between splits is zero, verified on the built splits rather than trusted from the upstream partition. Every clip passed a CTC feasibility check first — a target longer than the available acoustic frames makes the loss infinite.

The weights are Apache-2.0 and every clip and transcript is CC-0, so unlike this project's text models there is no licence composition to disclose: all 182,483 clips are public domain.

Training recipe

Objective	CTC
Optimiser	AdamW, lr 1e-4, β (0.9, 0.98), weight decay 0.01
Batch	dynamic micro-batches of 160 audio-seconds, gradient accumulation 4
Schedule	250 warmup steps, cosine decay to 1e-5
Steps	6,568 — 8 epochs
Precision	bfloat16 autocast
Masking	mask_time_prob 0.05, layerdrop 0.0
Hardware	one NVIDIA A10G, 24 GiB
Seed	20260813

Validation improved monotonically across every evaluation:

step	2,500	4,500	5,250	5,750	6,000	6,568
dev loss	0.4275	0.3599	0.3572	0.3506	0.3425	0.3340
greedy CER	10.83%	9.49%	9.24%	8.97%	8.67%	8.53%
greedy WER	36.67%	33.76%	32.69%	31.62%	30.78%	30.12%

160 audio-seconds is a measured ceiling, not a round number. At 320 the run died asking the allocator for 1.95 GiB in a single tensor: wav2vec2's first convolution turns one 16 kHz channel into 512 channels at 3.2 kHz, and layer_norm sits on autocast's fp32 list, so a budget stated in seconds of audio reaches the allocator expanded 102×. The first step survived it and the second did not, because AdamW does not allocate its moment buffers until the first optimizer step — a training loop that survives one step has not proved it fits.

Language model

5gram.klm, 186.65 MB, built from AƔBALU-Text v1, the largest clean Kabyle text corpus assembled — 3,246,174 lines from its 3,041,989 records, because 204,185 of them carry an internal newline and lmplz reads a sentence per line:

lmplz --order 5 --prune 0 1 2 3 --skip_symbols --discount_fallback
build_binary trie 5gram.arpa 5gram.klm

--skip_symbols is required rather than defensive: the corpus contains lines carrying <s> and </s>, and lmplz aborts on them. trie rather than probing because the model is memory-mapped once per container and array compression is what makes 186 MB affordable beside the acoustic model.

Those arguments live in agbalu.speech.lm as values the test suite asserts on, so what produced the published binary is checkable rather than a shell line in a document.

Shallow fusion runs at α 0.5, β 1.5 — pyctcdecode's documented defaults, unswept. A sweep needs the dev split decoded once per setting, which is GPU time this has not had, so the 4.5-point word error reduction above is a floor on what the fusion is worth rather than a tuned result.

Usage

Greedy, with nothing but transformers:

import librosa
import torch
from transformers import AutoProcessor, Wav2Vec2ForCTC

REPO = "agbalu/Fadhma-300M"
processor = AutoProcessor.from_pretrained(REPO)
model = Wav2Vec2ForCTC.from_pretrained(REPO).eval()

waveform, _ = librosa.load("sample.wav", sr=16_000, mono=True)
inputs = processor(waveform, sampling_rate=16_000, return_tensors="pt")
with torch.inference_mode():
    logits = model(inputs.input_values).logits

print(processor.batch_decode(logits.argmax(-1))[0])

That is CER 8.53 / WER 30.12. The 5-gram takes it to 8.01 / 25.65, and needs pyctcdecode and kenlm:

import json

import librosa
import torch
from huggingface_hub import hf_hub_download
from pyctcdecode import build_ctcdecoder
from transformers import AutoProcessor, Wav2Vec2ForCTC

REPO = "agbalu/Fadhma-300M"
processor = AutoProcessor.from_pretrained(REPO)
model = Wav2Vec2ForCTC.from_pretrained(REPO).eval()

with open(hf_hub_download(REPO, "vocab.json"), encoding="utf-8") as handle:
    vocabulary = json.load(handle)

# `pyctcdecode` reads label 0 as the CTC blank and a literal space as the word delimiter,
# where this vocabulary writes `[PAD]` and `|`.
labels = [token for token, _ in sorted(vocabulary.items(), key=lambda item: item[1])]
labels = ["" if token == "[PAD]" else " " if token in ("|", "[UNK]") else token
          for token in labels]

decoder = build_ctcdecoder(labels, kenlm_model_path=hf_hub_download(REPO, "5gram.klm"))

waveform, _ = librosa.load("sample.wav", sr=16_000, mono=True)
inputs = processor(waveform, sampling_rate=16_000, return_tensors="pt")
with torch.inference_mode():
    logits = model(inputs.input_values).logits[0].float().numpy()

print(decoder.decode(logits, beam_width=100, alpha=0.5, beta=1.5))

Three things above are not stylistic and will produce wrong output if changed.

The label substitution. Handed this vocabulary unchanged, pyctcdecode emits [PAD] and | verbatim in every transcript, and every error rate computed from one is wrong.

.float() before .numpy(). The model runs in bfloat16, which numpy cannot represent: without it, numpy() raises TypeError: Got unsupported ScalarType BFloat16.

AutoProcessor, not a bare Wav2Vec2FeatureExtractor(). The published extractor sets do_normalize: true; a default one feeds the model a distribution it never saw and returns a plausible, worse transcript with nothing raising.

Limitations

162 training speakers against 888 in the test split. This is the binding constraint. It is a property of the corpus, not of the recipe: Common Voice Kabyle is 571 validated hours contributed by a small number of people, and no amount of additional training reaches speakers who are not in it. Wherever this model fails, speaker generalisation is the first place to look, and the roughly 395 validated hours outside these three splits are what would move it.

Hyphenated clitics are where character accuracy and word accuracy part company, as above.

Read speech only. Common Voice is read aloud from written prompts. Spontaneous conversation, overlapping speakers, telephone bandwidth and regional variation are entirely unbenchmarked, and the register mismatch cuts both ways: the language model was built from written Kabyle, which is not what a prompt reader sounds like either.

Not evaluated beyond this split. One corpus, one domain, 15,003 test utterances. Treat everything else as unmeasured.

No safety evaluation of any kind has been performed.

The output carries no punctuation and no capitals. The CTC vocabulary is 40 characters and none of them is a mark, so that is a property of the architecture rather than a shortfall of the training. agbalu/Belaid-31M puts both back — one utterance at a time, which is the shape this model emits.

Files

file	description
model.safetensors	315,482,152 acoustic parameters
config.json	the architecture, Wav2Vec2ForCTC with a 40-class head
preprocessor_config.json	the feature extractor, with do_normalize: true
vocab.json, tokenizer_config.json, added_tokens.json	the 40 CTC classes as a Wav2Vec2CTCTokenizer, so AutoProcessor resolves
5gram.klm	the KenLM binary, 186.65 MB

The training checkpoint, with AdamW's moments and the resume state, is not published. Ask if you need it.

Reproduction

make modal-asr-repack                  # decode the audio once, CPU only
make modal-asr TASK=lm                 # build the 5-gram
make modal-asr-train EPOCHS=8          # train
make modal-asr TASK=evaluate           # score the test split, both decodings

The evaluation writes its results to the run's volume rather than to the repository, so the figures in this card come from that run's own output. Re-running the last command regenerates them.

The name

Fadhma Aït Mansour Amrouche (1882–1967) began, in 1930, writing down the songs and tales she had inherited from her ancestors — hearing Kabyle and putting it on paper, which is precisely what this model does.

Her daughter Taos names the translation model Amrouche-1.3B, and the pair split the oral-tradition work the way the two models do: the mother wrote the tradition down, the daughter carried it into French while singing only in Kabyle.

The naming is homage; it implies no endorsement by anyone.

Citation

@software{agbalu_fadhma_2026,
  title  = {Fadhma-300M: CTC speech recognition for Kabyle},
  author = {AƔBALU},
  year   = {2026},
  url    = {https://huggingface.co/agbalu/Fadhma-300M},
  note   = {Fine-tuned from ylacombe/omniASR_W2V_300M_SSL on Common Voice 22.0 Kabyle;
            normaliser 1.3.0+rules1.0.0}
}

Licence

Apache-2.0 for the weights and code. The audio and transcripts are CC-0 from Mozilla Common Voice. The language model derives from AƔBALU-Text v1, a third of which has no resolvable licence — see Masinissa-31M for that corpus's composition before redistributing derivatives of the .klm binary.