Downloads · 30 days
0
xezpeleta/parakeet-tdt-0.6b-v3-basque-sherpa-onnx
parakeet-tdt-0.6b-v3-basque-sherpa-onnx is a automatic speech recognition model from xezpeleta. Use it when you need speech turned into text. It is set up for sherpa-onnx. The card lists the license as cc-by-4.0.
ONNX export of itzune/parakeet-tdt-0.6b-v3-basque packaged for sherpa-onnx — a cross-platform, real-time speech recognition engine for edge devices, mobile, embedded systems, and WebAssembly.
Downloads · 30 days
0
Access
Public
Updated Oct 8, 2026
Repo size
3.2 GB
Likes
0
Public
Click a slice to open those files.
.weights2.4 GB · 76%
From the Hugging Face model README
ONNX export of itzune/parakeet-tdt-0.6b-v3-basque packaged for sherpa-onnx — a cross-platform, real-time speech recognition engine for edge devices, mobile, embedded systems, and WebAssembly.
The weights are INT8 dynamically quantised from the BF16 fine-tuned checkpoint, reducing the total package size from ~2.4 GB to ~641 MB while preserving transcription quality.
| Property | Value |
|---|---|
| Architecture | FastConformer RNNT-TDT (Parakeet TDT 0.6B v3) |
| Language | Basque (eu) |
| Sample rate | 16 kHz mono |
| Parameters | ~600 M |
| Vocabulary size | 1024 tokens (SentencePiece BPE) |
| Quantisation | INT8 dynamic (QUInt8 encoder / QInt8 decoder+joiner) |
| sherpa-onnx model type | nemo_transducer |
| Subsampling factor | 8 |
| Feature dimension | 128 log-mel filterbanks |
| Base model | nvidia/parakeet-tdt-0.6b-v3 |
| Fine-tuned model | itzune/parakeet-tdt-0.6b-v3-basque |
| Fine-tuning framework | NVIDIA NeMo |
| Hardware | NVIDIA L40 (48 GB) |
| File | Size | Description |
|---|---|---|
encoder.int8.onnx | 623 MB | INT8 encoder (FastConformer) |
decoder.int8.onnx | 12 MB | INT8 prediction network |
joiner.int8.onnx | 6 MB | INT8 joint network |
tokens.txt | 92 KB | Vocabulary (one token per line, index = line number) |
WER measured on held-out test splits from asierhv/composite_corpus_eu_v2.1:
| Split | Baseline (base model on Basque) | Fine-tuned |
|---|---|---|
test_cv (Common Voice) | 108.47% | 6.92% |
test_parl (Parliament) | 107.61% | 4.36% |
test_oslr (OpenSLR) | 108.52% | 14.52% |
The base model is English-oriented. WER > 100% on Basque is expected for it; the fine-tuned numbers represent the actual usable quality.
pip install sherpa-onnx
Or download a pre-built binary / use the C++ API — see the sherpa-onnx documentation.
import sherpa_onnx
# Point to the folder containing the 3 ONNX files + tokens.txt
model_dir = "/path/to/parakeet-tdt-0.6b-v3-basque-sherpa-onnx"
recognizer = sherpa_onnx.OfflineRecognizer.from_transducer(
encoder=f"{model_dir}/encoder.int8.onnx",
decoder=f"{model_dir}/decoder.int8.onnx",
joiner=f"{model_dir}/joiner.int8.onnx",
tokens=f"{model_dir}/tokens.txt",
num_threads=4,
decoding_method="greedy_search",
model_type="nemo_transducer",
)
# Transcribe a WAV file (16 kHz mono)
stream = recognizer.create_stream()
audio, sample_rate = sherpa_onnx.read_wave("/path/to/audio.wav")
stream.accept_waveform(sample_rate, audio)
recognizer.decode_stream(stream)
print(stream.result.text)
sherpa-onnx \
--encoder-model=encoder.int8.onnx \
--decoder-model=decoder.int8.onnx \
--joiner-model=joiner.int8.onnx \
--tokens=tokens.txt \
--decoding-method=greedy_search \
--model-type=nemo_transducer \
/path/to/audio.wav
[!IMPORTANT] This is an offline (non-streaming) model:
OnlineRecognizeris not supported. The encoder exported from the NeMo checkpoint does not carry the streaming metadata required bysherpa-onnxonline recognizers (e.g.window_size), because the Parakeet TDT architecture is not cache-aware-streaming. Real-time transcription is achieved instead by combining a VAD (voice activity detector) with the offline recognizer: speech segments are detected live, and each completed segment is transcribed as a whole. With this INT8 model on a modern CPU the recognizer runs ~10–15× faster than real time, so the experience is effectively real-time.
You will also need the silero_vad.onnx voice-activity detector
(download, ~600 KB):
import queue
import time
import numpy as np
import sherpa_onnx
import sounddevice as sd # requires PortAudio: apt install libportaudio2
model_dir = "/path/to/parakeet-tdt-0.6b-v3-basque-sherpa-onnx"
vad_model = "/path/to/silero_vad.onnx"
sample_rate = 16000
recognizer = sherpa_onnx.OfflineRecognizer.from_transducer(
encoder=f"{model_dir}/encoder.int8.onnx",
decoder=f"{model_dir}/decoder.int8.onnx",
joiner=f"{model_dir}/joiner.int8.onnx",
tokens=f"{model_dir}/tokens.txt",
num_threads=4,
decoding_method="greedy_search",
model_type="nemo_transducer",
)
silero = sherpa_onnx.SileroVadModelConfig()
silero.model = vad_model
vad_config = sherpa_onnx.VadModelConfig()
vad_config.silero_vad = silero
vad = sherpa_onnx.VoiceActivityDetector(vad_config, buffer_size_in_seconds=120)
def transcribe(samples: np.ndarray) -> str:
stream = recognizer.create_stream()
stream.accept_waveform(sample_rate, samples)
recognizer.decode_stream(stream)
return stream.result.text
audio_queue: queue.Queue = queue.Queue()
def callback(indata, frames, t, status):
audio_queue.put(indata[:, 0].copy())
print("Listening... Press Ctrl+C to stop.")
with sd.InputStream(samplerate=sample_rate, channels=1, dtype="float32",
blocksize=512, callback=callback):
t_partial = 0.0
try:
while True:
try:
chunk = audio_queue.get(timeout=0.1)
except queue.Empty:
continue
vad.accept_waveform(chunk)
# While speech is ongoing: show partial results (throttled)
if vad.is_speech_detected():
seg = vad.current_segment # property, not a method
if len(seg.samples) > sample_rate // 2 and time.time() - t_partial > 0.5:
print(f"\r {transcribe(seg.samples)[:70]:<70}", end="", flush=True)
t_partial = time.time()
# Segment finished (short silence detected): print final result
elif not vad.empty():
seg = vad.front # property; pop() only removes it and returns None
vad.pop()
print(f"\r✅ {transcribe(seg.samples)[:70]:<70}", flush=True)
except KeyboardInterrupt:
print("\nBye.")
Notes:
vad.current_segment and vad.front are properties in the Python API;
vad.pop() removes a finished segment and returns None.arecord -q -f S16_LE -r 16000 -c 1 -t raw, and feed the chunks
to vad.accept_waveform() from a subprocess pipe.sherpa-onnx supports many deployment targets beyond Python:
| Platform | Notes |
|---|---|
| Android | Java/Kotlin API, pre-built AAR |
| iOS | Swift/ObjC API |
| Raspberry Pi / ARM | Static C++ binaries available |
| WebAssembly | In-browser speech recognition |
| Windows / macOS / Linux | Native binaries and shared libraries |
See sherpa-onnx releases for pre-built packages.
This model was exported from the .nemo checkpoint using a custom script based on the official sherpa-onnx export guide for Parakeet TDT:
onnxruntime.quantization.quantize_dynamicThe export and fine-tuning code is available at: xezpeleta/parakeet-tdt-0.6b-v3-basque.
| Repo | Format | Use case |
|---|---|---|
| itzune/parakeet-tdt-0.6b-v3-basque | NeMo .nemo | Full NeMo / PyTorch inference & fine-tuning |
| xezpeleta/parakeet-tdt-0.6b-v3-basque-onnx-asr | ONNX-ASR | Simple Python inference via onnx-asr |
| This repo | sherpa-onnx INT8 | On-device / real-time / cross-platform |
If you use this model, please credit:
Underlying source collections in the training corpus:
CC BY 4.0. Inherit license obligations from the base model and dataset.