upelis-0.6b-lt-v1

Upelis is a Lithuanian speech recognition model that works in real time. It writes text while you speak, with about half a second of delay, and the same weights can also transcribe a whole recording at once.

Upelis yra lietuvių kalbos atpažinimo modelis, veikiantis realiu laiku: tekstas atsiranda kalbant, maždaug pusės sekundės delsa. Tie patys svoriai gali atpažinti ir visą įrašą iš karto.

• Model type: FastConformer encoder and RNN-T decoder with a language-ID prompt, 0.6B parameters. The architecture is unchanged from the base model.
• Base model: nvidia/nemotron-labs-unified-asr-0.6b
• Language: Lithuanian, including English words and names inside Lithuanian speech
• Modes: streaming at 0.16 to 1.12 s latency, or offline
• License: OpenMDW-1.1
• Version: v1, released 2026-11
• Made by: Datolabs

Intended use

• Live Lithuanian captions, dictation and voice interfaces (streaming).
• Transcribing recorded Lithuanian speech (offline).

Out of scope: song lyrics; far-field or music-heavy audio; strictly verbatim transcription (the model writes standard written forms, see Output format); medical, legal or financial content where errors matter, unless a person reviews the text.

Input and output

Input	Mono audio, 16 kHz; language prompt target_lang="lt"
Output	Lithuanian text with punctuation and capitalisation, numbers written as described in Output format; empty for audio without speech

The model is available as a NeMo checkpoint only. There is no Transformers, ONNX or GGUF version yet.

Results

Word error rate (WER, %, lower is better). Before scoring, text is lower-cased, punctuation is removed and whitespace collapsed; digits are kept as written. Latency is the algorithmic delay: how much future audio the model waits for before it writes a word. All results use greedy decoding. FLEURS was not used in training, and no Common Voice test or dev speaker or sentence was used in training.

Latency options

Test set	offline	1.12 s	0.56 s	0.32 s	0.24 s	0.16 s
FLEURS lt_lt test	8.03	8.79	9.52	10.19	10.86	12.33
Common Voice 22.0 lt test	4.85	5.90	6.80	–	–	10.77

"–" means not measured. Common Voice sentences come largely from Lithuanian Wikipedia.

Comparison with offline Lithuanian models (FLEURS lt_lt test)

All rows below were measured by us on the same 986 utterances with the same normaliser; the other models were run with their authors' recommended decoding, so our numbers for them can differ slightly from their own cards.

FLEURS references write numbers as digits. Upelis does too, while models that spell numbers out are penalised for it. The last two columns remove that difference: "numbers masked" replaces every number, every spelled-out numeral and the unit words that go with them (percent, year) with one token in both reference and output, and "no digits" keeps only the 805 of 986 utterances whose reference has no digits. eval/numbers_masked.py computes all three columns from a NeMo predictions file.

Model	Mode	WER	Numbers masked	No digits
upelis-0.6b-lt-v1 (this model)	streaming 0.56 s	9.56	7.31	6.74
upelis-0.6b-lt-v1 (this model)	offline	8.07	6.00	5.58
azuolas-whisper-lt	offline	8.96	5.37	4.62
azuolas-qwen-lt	offline	9.76	6.19	5.17
kmynas-parakeet-lt-v4	offline	10.55	6.96	6.06
nemotron-labs-unified-asr-0.6b (base model)	streaming 0.56 s	24.88	24.10	23.75

The comparison tables join digit groups such as "250 000" before scoring, so Upelis results here differ from the latency table by up to 0.05 points. For Ąžuolas (both versions) and kmynas, our WER is within 0.03 points of what their authors report on FLEURS.

Comparison with the other Lithuanian streaming model

VULSK/nemotron-asr-streaming-0.6b-medical-lt is a cache-aware streaming model that is also trained on Lithuanian medical dictation. We ran it with its recommended cache-aware streaming script and scored it the same way:

Model	Latency	WER	Numbers masked	No digits
upelis-0.6b-lt-v1 (this model)	1.12 s	8.83	6.78	6.26
nemotron-asr-streaming-0.6b-medical-lt	1.12 s ([56,13])	18.80	15.24	14.60
upelis-0.6b-lt-v1 (this model)	0.16 s	12.38	10.03	9.46
nemotron-asr-streaming-0.6b-medical-lt	0.16 s ([56,1])	20.40	16.89	16.29

How we read these results:

• In streaming mode Upelis is about as accurate as kmynas is offline, and about twice as accurate as the VULSK streaming model on FLEURS. VULSK may do better on medical dictation, which Upelis was not trained on.
• Offline, Ąžuolas is still more accurate once the number format is taken out of the comparison. Ąžuolas v2 is more accurate on the utterances without digits and slightly less accurate with numbers masked. Upelis is a smaller model that also has to work in streaming mode.
• FLEURS has 986 recordings but only 349 distinct sentences, so differences below about 0.5 points are within noise.

How to use

Requires NVIDIA NeMo Speech 3.1.0, the version the base model card lists. It is not on PyPI yet: the latest release there, 3.0.0, predates unified ASR models, so install NeMo from GitHub. This is the commit we tested, on Linux with an NVIDIA GPU:

pip install "nemo_toolkit[asr] @ git+https://github.com/NVIDIA-NeMo/Speech.git@8eb458b8ee304143426be5070d3f55fb3b5fb736"

Offline transcription

import nemo.collections.asr as nemo_asr

model = nemo_asr.models.ASRModel.from_pretrained("datolabs/upelis-0.6b-lt-v1")
result = model.transcribe(["recording.wav"], target_lang="lt")
print(result[0].text)

Streaming

speech_to_text_streaming_infer_rnnt.py runs the model in streaming mode. For the 0.56 s setting used in the results above:

python speech_to_text_streaming_infer_rnnt.py \
  pretrained_name=datolabs/upelis-0.6b-lt-v1 \
  dataset_manifest=manifest.json \
  output_filename=output.json \
  left_context_secs=5.6 chunk_secs=0.16 right_context_secs=0.40 \
  att_context_size_as_chunk=true target_lang=lt batch_size=16

manifest.json has one JSON line per file:

{"audio_filepath": "recording.wav", "duration": 12.3, "text": ""}

Latency	chunk_secs	right_context_secs
1.12 s	0.56	0.56
0.56 s	0.16	0.40
0.32 s	0.08	0.24
0.24 s	0.08	0.16
0.16 s	0.08	0.08

Always pass target_lang=lt. The model can also detect the language itself, but it was trained mostly with the Lithuanian prompt.

Streaming is buffered, as in the base model: the left context (5.6 s by default) is recomputed for every chunk, so it costs more compute than a cache-aware streaming model at the same latency. A shorter left context is faster but less accurate. On a single NVIDIA GPU one 0.16 s chunk took us roughly 20 to 70 ms with greedy decoding.

Offline, on an NVIDIA GB10 (DGX Spark), the 2.97 hours of the FLEURS test set took 58 s one file at a time (about 185 times faster than real time) and 35 s in batches of 16 (about 300 times), with greedy decoding and 4.7 GiB of GPU memory.

The model already writes punctuation, capitalisation and digits. Do not add NeMo's separate punctuation or inverse text normalisation stage on top of it.

Names and rare words

NeMo's phrase boosting (decoding.greedy.boosting_tree or per-stream biasing, see the NeMo documentation on context biasing) helps with names the model has not heard, such as a colleague's name. In our tests a boosted name is recognised reliably at the start of a sentence; in the middle of a sentence it needs a strong boost, which starts to change other words.

Output format

The training transcripts follow these rules, so the model writes text the same way:

• Punctuation and capitalisation.
• Numbers of 10 and above, numbers with units (percent, euro, minutes, degrees and so on) and years as digits. A single number from 1 to 9 stays a word ("du kartus").
• Some international brand and product names in their original spelling with the Lithuanian ending after an apostrophe, for example "Facebook'e" or "iPhone'ą".

Limitations

• Most training audio was recorded close to the microphone, so accuracy drops noticeably when the speaker is 2 to 3 m away or music is playing.
• Names that are rare in Lithuanian speech are often split into common words. Phrase boosting helps (see above).
• Years are not always written as digits. Some come out as words, especially colloquial forms.
• The tokenizer has no Lithuanian or straight quotation marks and no long dash. Where the training text had them, the model outputs ⁇; remove it with text.replace("⁇", "").strip().
• The model is not meant for song lyrics.
• Most training speech is standard Lithuanian. Dialects, children's speech and heavily accented speech were not evaluated separately.
• Transcribing people's speech can involve personal data; get consent where the law requires it.

Training data

• LIEPA-3 Lithuanian speech corpus (about 10,000 hours of read and spontaneous speech) by Vytautas Magnus University, Vilnius University and the Institute of the Lithuanian Language, CC BY 4.0; used through its Hugging Face packaging. Punctuation and capitalisation were added to the transcripts automatically, and numbers and brand names were normalised to the format above.
• Common Voice 22.0 Lithuanian train split (about 12 hours, CC0).
• Common Voice 22.0 English (about 10 hours, CC0), so the model keeps recognising English words.

The model was fine-tuned from the base model for both offline use and streaming at several latencies.

License and attribution

upelis-0.6b-lt-v1 is released under the OpenMDW License 1.1, the same license as the base model. If you redistribute the model, keep the license and the NOTICE file with it.

It is a derivative of:

• nvidia/nemotron-labs-unified-asr-0.6b by NVIDIA, OpenMDW-1.1
• LIEPA-3 Lithuanian speech corpus by Vytautas Magnus University, Vilnius University and the Institute of the Lithuanian Language, CC BY 4.0 (transcripts modified as described above)
• Common Voice 22.0, CC0

Citation

@misc{upelis_0.6b_lt_v1,
  title  = {upelis-0.6b-lt-v1: Lithuanian streaming and offline speech recognition},
  author = {{Datolabs}},
  year   = {2026},
  url    = {https://huggingface.co/datolabs/upelis-0.6b-lt-v1}
}

Please also cite the base model: Reducing the Offline-Streaming Gap for Unified ASR Transducer with Consistency Regularization.

Contact

Questions and feedback: open a discussion on this page.