diarray/parakeet-snalinlug-sc-lid

Parakeet SNA-LIN-LUG SC-LID

parakeet-snalinlug-sc-lid is a 114.6M-parameter multilingual automatic speech recognition model for Lingala, Luganda, and Shona. It uses a 17-layer FastConformer encoder with hybrid RNN-T and CTC decoders and a small language-identification head. Soft language probabilities are projected into the acoustic feature space, allowing the model to condition transcription on its own language prediction without a caller-provided language label.

The training code, tokenizer, experiment configs, and inference helper are available in diarray-hub/parakeet-sc-lid.

Intended use

The model is a research artifact for multilingual ASR experiments in:

• Lingala (lin / ln)
• Luganda (lug / lg)
• Shona (sna / sn)

It accepts audio through NeMo's ASR preprocessing path (trained at 16 kHz) and returns unpunctuated transcription text. It can optionally expose the LID head's predicted ISO 639-3 code. It is not validated for high-stakes, legal, medical, or safety-critical transcription.

Architecture

• 114,625,029 parameters
• 17 FastConformer layers, hidden size 512
• depthwise-striding subsampling factor 8
• 1,024-token SentencePiece tokenizer
• hybrid RNN-T and auxiliary CTC decoders
• three-class linear LID head and language-to-encoder projection
• training loss: RNN-T + 0.3 × CTC + 0.2 × weighted LID
• LID class weights: [0.774524, 1.543837, 0.942376] for [lin, lug, sna]

The model was initialized and trained from the provided configuration rather than fine-tuned from a named pretrained checkpoint.

Usage

Clone the code repository, place the downloaded .nemo file in it, and use the included CLI:

python infer.py audio.wav \
  --nemo-file parakeet-snalinlug-sc-lid.nemo \
  --return-lid

To use the CTC branch, add --decoder ctc. Output is one JSON object per input file:

{"audio": "/absolute/path/audio.wav", "text": "...", "language": "lin"}

Programmatic restoration uses restore_model() and conditioned_encoder() from lid_conditioned_encoder.py. The wrapper is required because NeMo's generic transcribe() path calls the encoder directly and would otherwise bypass the language-conditioning path used in training.

NeMo compatibility

This archive was produced with NeMo 2.5.0. Direct loading under NeMo 3.0.0 fails because NeMo blocks the serialized project-local model target under its safe-instantiation policy. The repository's compatibility loader explicitly imports the trusted custom class, removes the archive's target string, and restores with that class.

Some other NeMo 2.5 archives can also fail on newer strict decoding schemas when a serialized boosting_tree lacks key_phrase_items_list (NVIDIA-NeMo/Speech#15658). The loader patches that field only when such a tree exists. Inspection and inference testing confirmed that this checkpoint does not itself contain the problematic boosting-tree node.

Training data

The experimental mixture was constructed from:

• WAXAL ASR subsets for all three languages and the Luganda TTS subset
• Lingala 100hrs
• FLEURS for Shona and Luganda
• SALT for Luganda

WAXAL and AfriVoice-derived subsets contain significant overlap. Only one copy was retained during experiment preparation. Consult utils/download_speech_datasets.py in the code repository for source/config names and preprocessing behavior.

Transcripts containing digits were discarded; punctuation was stripped; audio was converted to mono 16 kHz WAV; and WAXAL samples shorter than three seconds were filtered.

Evaluation

Evaluation	Result	Notes
Author's public experimental test set	~25.6% WER	Mixed public sources; including the Zindi public (phase 1) set
Same split, language identification	100% accuracy	Three target languages only
Tiny native-speaker Lingala check	~40% of utterances contained an error	Five private self-recorded samples; not formal WER

All values are self-reported. The public split includes WAXAL, FLEURS, and other sources assembled for this experiment. The tiny human check counted whether an utterance had any insertion, omission, or substitution; it must not be compared directly with corpus-level WER.

Experiment 3 added LID class weighting and outperformed the first two experiments. It also changed learning rate, warmup, and evaluation batch size, so the available runs do not provide a controlled class-weighting ablation.

Limitations

• Reference alignment in parts of WAXAL is noisy, which can distort both training and WER.
• The model creator does not speak the target languages; qualitative coverage is minimal.
• The human evaluation is far too small to establish real-world quality or dialect coverage.
• Perfect LID accuracy on one constructed split does not imply robustness to other languages, code-switching, noise, or domain shift.
• There is no no-LID baseline and no controlled comparison with alternative multilingual ASR methods.
• Outputs may contain insertions, omissions, substitutions, spelling errors, and socially meaningful mistranscriptions.

License and attribution

The checkpoint and tokenizer are released under CC BY-SA 4.0 as a conservative choice for artifacts learned from CC BY-SA training sources. Attribute this model as diarray/parakeet-snalinlug-sc-lid and preserve the same license for adapted distributions.

Training datasets retain their own licenses and required attributions. WAXAL's current card lists provider-specific CC BY-SA 4.0 terms for the three languages used here; FLEURS and Lingala 100hrs are CC BY 4.0; SALT is CC BY-SA 4.0. Users are responsible for reviewing the current upstream terms. Repository code is separately MIT licensed, except for the NVIDIA-derived training entry point that retains its Apache-2.0 notice.