LT_ausys — Lithuanian ears for Home Assistant and Wyoming (ONNX / int8, CPU)

This is not a new model. Since 15 November 2026 it is datolabs/upelis-0.6b-lt-v1 exported to ONNX and quantized, so that it runs on a CPU without PyTorch or NeMo.

The work that makes the model understand Lithuanian is Datolabs': they fine-tuned NVIDIA's Nemotron unified ASR 0.6B (an RNN-T transducer) on the LIEPA-3 corpus and Common Voice and published it under OpenMDW-1.1. The ONNX export (with the Lithuanian language prompt built in), the quantization recipe, the measurements and the Wyoming server are Robertas's and Claude's; the model is theirs.

Versions. Until 15 November 2026 this repository held Kristijonas Jakubsonas's kmynas-parakeet-lt-v4 (Parakeet-TDT, CC BY 4.0) in ONNX. It is still here as revision v1-kmynas: huggingface_hub.snapshot_download("RobertasTa/lt-ausys", revision="v1-kmynas"), then load that directory with onnx_asr.load_model("nemo-conformer-tdt", path). It was replaced because Upelis was more accurate on the same home commands and the same CPU, with less memory (numbers below).

ℹ️ Made with AI: the conversion, the server and this card were written by Claude (Anthropic) together with Robertas, and measured on real hardware.

Why this exists

A Lithuanian voice assistant at home needs ears that are fast on a small CPU. Whisper-family models pay a fixed 30-second-window cost for every utterance: on a Ryzen 7 8845HS a 2-second command takes 3.5 s with Paprika (Whisper large-v3-turbo, int8). A transducer only processes the audio it is given. The same command through this model takes 0.18 s on the same CPU.

The original checkpoint is a .nemo file: running it needs NeMo 3.1 (not yet on PyPI), PyTorch and 5.8 GB of RAM. This repository removes that: onnx-asr + onnxruntime + numpy, ~1.4 GB of RAM for int8.

Files

File What Size
encoder-model.onnx + encoder-model.onnx.data FastConformer encoder with the Lithuanian prompt built in, fp32 42 MB + 2.45 GB
decoder_joint-model.onnx prediction network + joint, fp32 52 MB
encoder-model.int8.onnx encoder, int8 dynamic quantization of MatMul only (see below) 662 MB
decoder_joint-model.int8.onnx ⚠️ the same fp32 decoder under the name onnx-asr expects for quantization="int8" 52 MB
vocab.txt 4 095 SentencePiece tokens + <blk> (= 4 096 lines)
config.json nemo-conformer-rnnt, 128 mel features, subsampling 8
LICENSE, NOTICE OpenMDW-1.1 and the original notice with our changes — keep both if you redistribute

Usage

pip install "onnx-asr[cpu,hub]"
import onnx_asr

model = onnx_asr.load_model("RobertasTa/lt-ausys", quantization="int8")   # CPU: int8 (0.7 GB download)
# model = onnx_asr.load_model("RobertasTa/lt-ausys")                     # fp32 (2.5 GB)
print(model.recognize("komanda.wav"))        # 16 kHz mono 16-bit WAV, or a float32 numpy array + sample_rate=

Loading by repository id reads model_type from config.json. Code that names the type itself must say "nemo-conformer-rnnt" — with "nemo-conformer-tdt" (correct for the old v1-kmynas files) this model will not load.

Output is punctuated, cased Lithuanian; numbers from 10 up come out as digits („Įjunk šviesą svetainėje 20 procentų.“), as the original model writes.

⚠️ For dictation, take the previous version. This model rarely writes full stops (82 of the 986 FLEURS sentences end with one; the NeMo checkpoint does the same). In ~45 s of continuous speech it found 2.8 % of the sentence boundaries (kmynas 84.7 %) and about half the commas (comma F1 58.0 % vs 82.6 %). For voice commands this does not matter; for text people read, use revision v1-kmynas — our dictation app Diktuoklė does.

Home Assistant / Wyoming: the companion repository RobertasTa/lt-ausys has a small Wyoming speech-to-text server (lt_ausys_server.py, systemd unit, LXC install steps) that serves this model to Home Assistant's Wyoming integration or to any Wyoming client, offline.

Conversion details

Source upelis-0.6b-lt-v1.nemo (2 507 796 480 B, SHA-256 cfd2d9f1a10c2c764a932a2802c6b981ae7567b8a624f637a5cbb55e7258c0ef)
Language prompt Upelis is a multilingual prompt model: NeMo adds the language one-hot (Lithuanian = index 31) through prompt_kernel after the encoder, inside model.forward. A plain model.export() exports the encoder without it. We export an encoder subclass whose forward_for_export applies the fixed Lithuanian prompt, checked against NeMo's own forward before export (max difference 0.00)
Export NeMo 3.1 model.export() on CPU, opset 17, check_trace=False — tool: export_nemo_prompt_to_onnx.py
Encoder packing the >2 GB encoder is repacked with onnx.save(..., all_tensors_to_one_file=True) into one .onnx.data
Quantization onnxruntime.quantization.quantize_dynamic(weight_type=QInt8, per_channel=True, op_types_to_quantize=["MatMul"]), onnxruntime 1.31.0
Decoder left in fp32
Mode offline (full context). The streaming modes of the original were not exported
Converted 15 November 2026

Why MatMul only. On the previous model every variant that also quantized the convolutions lost 5–19 of 119 commands on our exam and became 2–4× slower on this CPU; MatMul-only kept the exam and was the fastest. Here too it keeps the exam score of the fp32 model (103/119).

What was measured, and what was not

Normalisation: lower-case, punctuation removed, Lithuanian letters kept; WER = all errors / all reference words. Greedy decoding, no VAD, Lithuanian forced.

model FLEURS lt test, 986 read sentences: WER · CER 127 home voice commands (one speaker, speakerphone): WER command exam, 119 commands: correct · wrong · not understood 500 non-speech clips: % with any text
LT_ausys int8 (this) 8.32 % · 4.26 % 14.4 % 103 · 4 · 12 32.8 %
LT_ausys fp32 (this) 8.27 % · 4.26 % 14.0 % 103 · 4 · 12 29.8 %
LT_ausys until 2026-11-15 (kmynas v4) int8 10.58 % · 6.15 % 17.4 % 101 · 3 · 15 40 %
Paprika (Whisper large-v3-turbo, CT2 int8) 11.97 % · 6.49 % 23.4 % 93 · 5 · 21 43 %

Speed and memory. Wyoming server in a Proxmox LXC on an AMD Ryzen 7 8845HS, 4 threads, the 127 commands: 0.183 s median (p90 0.21 s), peak RAM 1.38 GB (the kmynas version in the same container: 0.197 s). On a Ryzen 9 9950X desktop: 0.044 s per command, 0.142 s median per FLEURS sentence, peak RAM 1.4 GB (FLEURS) / 1.7 GB (non-speech).

  • fp32 ONNX reproduces the NeMo checkpoint: 127/127 command transcripts identical, character for character (NeMo 3.1, CPU). NeMo on a GPU gives 8.05 % on FLEURS (the original card: 8.03 %); the 0.2-point gap to our fp32 ONNX on a CPU is arithmetic, the command transcripts do not differ.
  • Digits help on FLEURS. 18 % of FLEURS references write numbers as digits; this model writes larger numbers as digits, the old one wrote them as words. On the 770 sentences without numbers the gap is smaller: 5.3 % against 5.9 % (NeMo, GPU).
  • The command set is 127 recordings of one speaker. It says how the model behaves on short home commands, not how it generalises across speakers; FLEURS is the neutral read-speech figure.

Not measured: GPU execution providers, batching, the streaming modes, utterances longer than 20 s (use a VAD for long audio), other quantization schemes (static, fp16), and other speakers.

Acknowledgements

  • Datolabs — Upelis v1, the model itself.
  • NVIDIA — Nemotron unified ASR 0.6B. Vytautas Magnus University, Vilnius University and the Institute of the Lithuanian Language — the LIEPA-3 corpus. Mozilla — Common Voice.
  • Kristijonas Jakubsonas — kmynas v4, which was LT_ausys until 15 November 2026.
  • Ilya Stupakov — onnx-asr, which made the CPU path a few lines long.
  • Open Home Foundation — the Wyoming protocol.

License

OpenMDW-1.1, the same as the original (LICENSE). If you redistribute these files, keep LICENSE and NOTICE with them; NOTICE lists what was changed here. The previous files (revision v1-kmynas) remain CC BY 4.0.

Downloads last month
249
Inference Providers NEW
This model isn't deployed by any Inference Provider. 🙋 Ask for provider support

Model tree for RobertasTa/lt-ausys

Quantized
(1)
this model

Space using RobertasTa/lt-ausys 1

Collection including RobertasTa/lt-ausys

Evaluation results