Elastic model: parakeet-tdt-0.6b-v2

Overview

ElasticModels are the models produced by TheStage AI ANNA: Automated Neural Networks Accelerator. ANNA allows you to control model size, latency and quality with a simple slider movement, routing different compression algorithms to different layers. For each model, we have produced a series of optimized models:

XL: Mathematically equivalent neural network, optimized with our DNN compiler.
L: Near lossless model, with less than 1% degradation obtained on corresponding benchmarks.
M: Faster model, with accuracy degradation less than 1.5%.
S: The fastest model, with accuracy degradation less than 2%.

Models can be accessed via TheStage AI Python SDK: ElasticModels, or deployed as Docker containers with REST API endpoints (see Deploy section).

System Requirements

Property	Value
GPU	H100
Python Version	3.10-3.12
CPU	Intel/AMD x86_64
CUDA Version	12.8+

TheStage AI Access Token Setup

Install TheStage AI CLI and setup API token:

pip install thestage
thestage config set --access-token <YOUR_ACCESS_TOKEN>

ElasticModels

Elastic Models provides the same interface as HuggingFace Transformers. Here is an example of how to use the parakeet-tdt-0.6b-v2 model.

Installation

pip install 'thestage-elastic-models[nvidia]' \
    --extra-index-url https://thestage.jfrog.io/artifactory/api/pypi/pypi-thestage-ai-production/simple
pip install datasets==3.6.0 librosa soundfile  # only needed to load audio for the example below

Usage

import torch
from elastic_models.transformers import ParakeetForTDT
from transformers import AutoProcessor

model_name = "nvidia/parakeet-tdt-0.6b-v2"
hf_token = ''
device = torch.device("cuda")

model = ParakeetForTDT.from_pretrained(
    model_name,
    token=hf_token,
    torch_dtype=torch.bfloat16,
    mode='S'
).to(device)
model.eval()

# The upstream checkpoint is published in NeMo format; the model class converts
# it to HF format on load and caches the result. Point the processor at that
# cached directory.
from elastic_models.transformers.models.parakeet import ensure_hf_checkpoint

processor = AutoProcessor.from_pretrained(
    ensure_hf_checkpoint(model_name), token=hf_token
)

# Load audio file
from datasets import load_dataset
dataset = load_dataset(
    "hf-internal-testing/librispeech_asr_dummy",
    "clean", split="validation"
)
audio_sample = dataset[0]["audio"]

# Process audio
inputs = processor(
    audio_sample["array"],
    sampling_rate=audio_sample["sampling_rate"],
    return_tensors="pt"
).to(device)
inputs["input_features"] = inputs["input_features"].to(model.dtype)

# Generate transcription
with torch.inference_mode():
    output = model.generate(**inputs)

transcription = processor.batch_decode(
    output.sequences, skip_special_tokens=True
)[0]

print(f"Transcription: {transcription}")

Quality Benchmarks

We have evaluated the models using the Hugging Face Open ASR Leaderboard methodology. For each model size (S, M, L, XL), we report Word Error Rate (WER) on standard English speech recognition benchmarks. The model is English-only.

Open ASR Leaderboard (English, WER %)

Dataset	S	M	L	XL	Original
AMI	11.45	11.4	11.32	11.15	11.15
Earnings22	11.5	11.4	11.43	11.28	11.28
GigaSpeech	9.85	9.85	9.83	9.75	9.73
LibriSpeech Clean	1.68	1.69	1.7	1.67	1.68
LibriSpeech Other	3.22	3.23	3.21	3.2	3.23
SPGISpeech	2.18	2.18	2.18	2.17	2.16
VoxPopuli	5.94	6.66	6.63	5.87	5.88
Average	6.55	6.63	6.61	6.44	6.44

Datasets

English (Open ASR Leaderboard)

Average is over the seven subsets listed below; TEDLium is not included, as it is not published in the leaderboard dataset repository.

LibriSpeech Clean: Read English speech from audiobooks, recorded in clean conditions. Tests baseline transcription accuracy on clear, well-articulated speech.
LibriSpeech Other: Read English speech from audiobooks with more challenging acoustic conditions, including noisier recordings and less common speakers.
SPGISpeech: Financial earnings calls and presentations, featuring domain-specific terminology, spontaneous speech, and diverse speaker accents.
VoxPopuli: European Parliament event recordings in multiple languages, featuring political discourse, formal speech, and multilingual speakers.
GigaSpeech: Large-scale multi-domain English speech corpus from audiobooks, podcasts, and YouTube, representing diverse acoustic conditions and speaking styles.
Earnings22: Corporate earnings calls with financial terminology, multiple speakers, and telephone-quality audio.
AMI: Meeting recordings with overlapping speech, distant microphones, and natural conversational dynamics.

Metrics

WER (Word Error Rate): Measures the proportion of word-level errors (substitutions, insertions, deletions) in the transcription compared to the reference text. Lower values indicate better accuracy.

Latency Benchmarks

We measured RTFx (Real-Time Factor) for each model size on various GPUs. RTFx indicates how many times faster than real-time the model transcribes audio. Higher RTFx is better.

RTFx, batch size 1

GPU/Model Size	S	M	L	XL	Original
H100	615	608	597	557	89

RTFx, batched

GPU/Model Size	S	M	L	XL	Original
H100 (batch 16)	2600	2540	2497	2400	765
H100 (batch 32)	3858	3750	3649	3452	1184
H100 (batch 64)	4522	4385	4231	3971	1744

Benchmarking Methodology

RTFx (Real-Time Factor) is audio_duration / transcription_time: higher values mean faster-than-real-time transcription. Measured on a single H100 over LibriSpeech test-clean, 192 clips in dataset order, one timed pass, with features precomputed before the timer. Decoding uses the label-looping loop captured as a single CUDA graph; the Original row is the unaccelerated model and does not use it.

Algorithm summary:

Load the parakeet-tdt-0.6b-v2 model with the specified size (S, M, L, XL, original).

Load a 10-minute audio file and resample to 16kHz mono.

Run a warm-up pass to initialize GPU caches.

Synchronize the GPU, record the start time.

Run the transcription pipeline with the specified batch size and chunk length.

Synchronize the GPU, record the end time.

Calculate RTFx as audio_duration / time_taken.

Serving with Docker Image

For serving with Nvidia GPUs, we provide ready-to-go Docker containers with OpenAI-compatible API endpoints. Using our containers you can set up an inference endpoint on any desired cloud/serverless providers as well as on-premise servers. You can also use this container to run inference through TheStage AI platform.

Prebuilt image from ECR

Pull docker image and start inference container. The container serves one model on one GPU; on a multi-GPU host --gpus all is fine, the model is placed on a single device:

docker pull public.ecr.aws/i3f7g5s7/thestage/elastic-models:0.2.4.post0-stt-streaming-v2-20261008-19026a9

docker run --rm -it \
  --name triton-stt \
  --gpus all \
  -p 127.0.0.1:80:80 \
  -v "$HOME/.cache:/opt/project/.cache/" \
  -e MODEL_TYPE=stt_streaming_v2 \
  -e MODEL_REPO=nvidia/parakeet-tdt-0.6b-v2 \
  -e MODEL_SIZE=<MODEL_SIZE> \
  -e PARAKEET_MODE=<PARAKEET_MODE> \
  -e AUTH_TOKEN=<AUTH_TOKEN> \
  -e MODEL_BATCH=<MODEL_BATCH> \
  -e PIPELINE_MAX_BATCH_SIZE=<PIPELINE_MAX_BATCH_SIZE> \
  -e CHUNK_LENGTH=<CHUNK_LENGTH> \
  -e PREPROCESSOR_WORKERS=<PREPROCESSOR_WORKERS> \
  -e MODEL_INSTANCES=<MODEL_INSTANCES> \
  -e PREPROCESSOR_QUEUE_DELAY=<PREPROCESSOR_QUEUE_DELAY> \
  -e MODEL_QUEUE_DELAY=<MODEL_QUEUE_DELAY> \
  -e ENSEMBLE_QUEUE_DELAY=<ENSEMBLE_QUEUE_DELAY> \
  -e HUGGINGFACE_ACCESS_TOKEN=<HUGGINGFACE_ACCESS_TOKEN> \
  -e THESTAGE_AUTH_TOKEN=<THESTAGE_ACCESS_TOKEN> \
  public.ecr.aws/i3f7g5s7/thestage/elastic-models:0.2.4.post0-stt-streaming-v2-20261008-19026a9

Parameter	Description
`<MODEL_SIZE>`	Names the served model: `parakeet-tdt-0-6b-v2-<size>-cl<chunk>-bs<batch>`. One of S, M, L, XL, eager.
`<PARAKEET_MODE>`	Accelerated encoder to load: S, M, L or XL. Without it the original model is served.
`<AUTH_TOKEN>`	Bearer token the endpoint requires. Protected inference requests return 503 while it is unset.
`<MODEL_BATCH>`	Maximum batch size for the model.
`<PIPELINE_MAX_BATCH_SIZE>`	Maximum batch size for the ASR pipeline processing.
`<CHUNK_LENGTH>`	Audio chunk length in seconds (e.g., 10, 15, 20, 30).
`<PREPROCESSOR_WORKERS>`	Number of preprocessor worker processes (e.g., 8).
`<MODEL_INSTANCES>`	Number of Triton model instances (e.g., 1).
`<PREPROCESSOR_QUEUE_DELAY>`	Preprocessor dynamic-batching queue delay in microseconds (e.g., 10000).
`<MODEL_QUEUE_DELAY>`	Model dynamic-batching queue delay in microseconds (e.g., 10000).
`<ENSEMBLE_QUEUE_DELAY>`	Ensemble dynamic-batching queue delay in microseconds (e.g., 10000).
`<HUGGINGFACE_ACCESS_TOKEN>`	Hugging Face access token.
`<THESTAGE_ACCESS_TOKEN>`	TheStage token generated on the platform (Profile -> Access tokens).

Invocation

CLI

elastic-models-client client stt \
    --host 127.0.0.1 --port 80 --metadata-port 80 \
    --authorization <AUTH_TOKEN> \
    --sample sample.wav --lang-id en

cURL

curl -X POST http://127.0.0.1:80/v1/audio/transcriptions \
    -H "Authorization: Bearer <AUTH_TOKEN>" \
    -F "file=@sample.wav" \
    -F "model=parakeet-tdt-0-6b-v2-<MODEL_SIZE_LOWER>-cl<CHUNK_LENGTH>-bs<MODEL_BATCH>" \
    -F "language=en"

Endpoint Parameters

Method

POST /v1/audio/transcriptions

Header Parameters

Authorization: string

Bearer token for authentication; it must match the container's AUTH_TOKEN.

Input Body

All fields are sent as multipart/form-data.

file : binary

The audio file to transcribe.

model : string

Specifies the model to use for transcription. Format: parakeet-tdt-0-6b-v2-<size>-cl<chunk_length>-bs<batch_size>, where <size> is MODEL_SIZE lowercased (s, m, l, xl, or eager), <chunk_length> is CHUNK_LENGTH, and <batch_size> is MODEL_BATCH. The dot in the model name becomes a hyphen. Example: parakeet-tdt-0-6b-v2-s-cl15-bs1.

language : string

Language of the audio (e.g., "en", "es", "fr").

Model tree for TheStageAI/Elastic-parakeet-tdt-0.6b-v2

Base model

nvidia/parakeet-tdt-0.6b-v2

Quantized

(35)

this model

TheStageAI
/

Elastic-parakeet-tdt-0.6b-v2