Offline English speech-to-text. NeMo SALM (Speech-Augmented Language
Model): a FastConformer audio encoder (32 layers, d_model=1024) feeds
audio embeddings into a Qwen3-1.7B causal LM (28 layers,
hidden_size=2048) via audio-token injection at a sentinel position in
the prompt. English only. Takes a 16 kHz mono WAV and produces a
transcript via greedy decoding.
WER measured on the full LibriSpeech test-clean split (2620 English
utterances) with the Whisper-style English text normalizer and jiwer
3.x, on the metal backend of an Apple M4. The same-machine NeMo SALM
reference run (CPU torch, dither=0.0, greedy model.generate) lands
at 1.61% with 95% bootstrap CI [1.47%, 1.75%]: 0.01 above
NVIDIA's published 1.60% but well within statistical noise. All six
GGUF presets land at exactly 1.63% (+0.02 over our reference run,
same CI band). Investigation of the worst per-utterance differences
shows scattered token-level noise consistent with BF16 weight
precision (homophones, word-boundary flips, function-word
substitutions). Reproduce with scripts/wer/run.py +
scripts/wer/score.py.
If your audio isn't already 16 kHz mono WAV, convert it first:
ffmpeg -i input.mp3 -ar 16000 -ac 1 output.wav
See the transcribe.cpp model page for performance
numbers, numerical validation, and reproduction steps.
License
Inherited from the base model: CC-BY-4.0. See the
upstream model card for full terms.
Original Model Card
The section below is reproduced from
nvidia/canary-qwen-2.5b at commit
b1469e1bba1cfe140205529c79c434ca47180960 for offline reference. The upstream card is the
authoritative source.
NVIDIA NeMo Canary-Qwen-2.5B is an English speech recognition model that achieves state-of-the art performance on multiple English speech benchmarks. With 2.5 billion parameters and running at 418 RTFx, Canary-Qwen-2.5B supports automatic speech-to-text recognition (ASR) in English with punctuation and capitalization (PnC). The model works in two modes: as a transcription tool (ASR mode) and as an LLM (LLM mode). In ASR mode, the model is only capable of transcribing the speech into text, but does not retain any LLM-specific skills such as reasoning. In LLM mode, the model retains all of the original LLM capabilities, which can be used to post-process the transcript, e.g. summarize it or answer questions about it. In LLM mode, the model does not "understand" the raw audio anymore - only its transcript. This model is ready for commercial use.
License/Terms of Use:
Canary-Qwen-2.5B is released under the CC-BY-4.0 license. By using this model, you are agreeing to the terms and conditions of the license.
Discover more from NVIDIA:
For documentation, deployment guides, enterprise-ready APIs, and the latest open models—including Nemotron and other cutting-edge speech, translation, and generative AI—visit the NVIDIA Developer Portal at developer.nvidia.com.
Join the community to access tools, support, and resources to accelerate your development with NVIDIA’s NeMo, Riva, NIM, and foundation models.
The model is intended for users requiring speech-to-text transcription capabilities for English speech, and/or transcript post-processing capabilities enabled by prompting the underlying LLMs. Typical use-cases: transcription, summarization, answering user questions about the transcript.
For documentation, deployment guides, enterprise-ready APIs, and the latest open models—including Nemotron and other cutting-edge speech, translation, and generative AI—visit the NVIDIA Developer Portal at developer.nvidia.com.
Join the community to access tools, support, and resources to accelerate your development with NVIDIA’s NeMo, Riva, NIM, and foundation models.
Canary-Qwen is a Speech-Augmented Language Model (SALM) [9] model with FastConformer [2] Encoder and Transformer Decoder [3]. It is built using two base models: nvidia/canary-1b-flash [1,5] and Qwen/Qwen3-1.7B [4], a linear projection, and low-rank adaptation (LoRA) applied to the LLM. The audio encoder computes audio representation that is mapped to the LLM embedding space via a linear projection, and concatenated with the embeddings of text tokens. The model is prompted with "Transcribe the following:
Limitations
Input length. The maximum audio duration in training was 40s, and the maximum token sequence length was 1024 tokens (including prompt, audio, and response). The model may technically be able to process longer sequences, but its accuracy may be degraded.
Exclusively ASR oriented capabilities. The model is not expected to preserve any of the underlying LLM's capabilities into speech modality.
English-only language support. The model was trained using English data only. It may be able to spuriously transcribe other languages as the underlying encoder was pretrained using German, French, and Spanish speech in addition to English, but it's unlikely to be reliable as a multilingual model.
NVIDIA NeMo
To train, fine-tune or transcribe with Canary-Qwen-2.5B, you will need to install NVIDIA NeMo.
bash
1# Currently requires installing the latest trunk version of NeMo, and PyTorch 2.6+ for FSDP2 support.2python -m pip install"nemo_toolkit[asr,tts] @ git+https://github.com/NVIDIA/NeMo.git"
How to Use this Model
The model is available for use in the NVIDIA NeMo toolkit [6], and can be used as a pre-trained checkpoint for inference or for fine-tuning on another dataset.
Input Type(s): Audio, text prompt Input Format(s): Audio: .wav or .flac files. Text prompt string for ASR mode: Transcribe the following: <|audioplaceholder|> Input Parameters(s): Audio: Two-Dimensional (batch, audio-samples); Text: One-Dimensional (string) Other Properties Related to Input: 16000 Hz Mono-channel Audio, Pre-Processing Not Needed
Input to Canary-Qwen-2.5B is a batch of prompts that include audio.
Example usage in ASR mode (speech-to-text):
python
1answer_ids = model.generate(2 prompts=[3[{"role":"user","content":f"Transcribe the following: {model.audio_locator_tag}","audio":["speech.wav"]}]4],5 max_new_tokens=128,6)7print(model.tokenizer.ids_to_text(answer_ids[0].cpu()))
To transcribe a dataset of recordings, specify the input as jsonl manifest file, where each line in the file is a dictionary containing the following fields:
yaml
1# Example of a line in input_manifest.json2{3"audio_filepath":"/path/to/audio.wav",# path to the audio file4"duration":30.0,# duration of the audio5}
and then use:
bash
1cd NeMo
2python examples/speechlm2/salm_generate.py \3pretrained_name=nvidia/canary-qwen-2.5b \4inputs=input_manifest.json \5output_manifest=generations.jsonl \6batch_size=128\7user_prompt="Transcribe the following:"# audio locator is added automatically at the end if not present
Output:
Output Type(s): Text Output Format: Text transcript as a sequence of token IDs or a string Output Parameters: One-Dimensional text string Other Properties Related to Output: May Need Inverse Text Normalization
Our AI models are designed and/or optimized to run on NVIDIA GPU-accelerated systems. By leveraging NVIDIA’s hardware (e.g. GPU cores) and software frameworks (e.g., CUDA libraries), the model achieves faster training and inference times compared to CPU-only solutions.
Canary-Qwen-2.5B was trained using the NVIDIA NeMo toolkit [6] for a total of 90k steps on 32 NVIDIA A100 80GB GPUs. LLM parameters were kept frozen. Speech encoder, projection, and LoRA parameters were trainable. The encoder's output frame rate is 80ms, or 12.5 tokens per second. The model was trained on approximately 1.3B tokens in total (this number inlcudes the speech encoder output frames, text response tokens, prompt tokens, and chat template tokens).
** The total size (in number of data points): approx. 40 million (speech, text) pairs
** Total number of datasets: 26, with 18 for training and 8 for test
** Dataset partition: Training 99.6%, testing 0.04%, validation 0%
** Time period for training data collection: 1990-2025
** Time period for testing data collection: 2005-2022
** Time period for validation data collection N/A (unused)
The Canary-Qwen-2.5B model is trained on a total of 234K hrs of publicly available speech data.
The datasets below include conversations, videos from the web and audiobook recordings.
Data Collection Method:
Human
Labeling Method:
Hybrid: Human, Automated
Properties
English (234.5k hours)
The majority of the training data comes from the English portion of the Granary dataset [7]:
YouTube-Commons (YTC) (109.5k hours)
YODAS2 (77k hours)
LibriLight (13.6k hours)
In addition, the following datasets were used:
Librispeech 960 hours
Fisher Corpus
Switchboard-1 Dataset
WSJ-0 and WSJ-1
National Speech Corpus (Part 1, Part 6)
VCTK
VoxPopuli (EN)
Europarl-ASR (EN)
Multilingual Librispeech (MLS EN)
Mozilla Common Voice (v11.0)
Mozilla Common Voice (v7.0)
Mozilla Common Voice (v4.0)
AMI
FLEURS
AMI was oversampled during model training to constitute about 15% of the total data observed.
This skewed the model towards predicting verbatim transcripts that include conversational speech disfluencies such as repetitions.
The training transcripts contained punctuation and capitalization.
Number of characters per minute on MUSAN 48 hrs eval set (max_new_tokens=50 following nvidia/canary-1b-flash evaluation)
Version
Model
# of character per minute
2.5.0
Canary-Qwen-2.5B
138.1
Noise Robustness
WER on Librispeech Test Clean at different SNR (signal to noise ratio) levels of additive white noise
Version
Model
SNR 10
SNR 5
SNR 0
SNR -5
2.5.0
Canary-Qwen-2.5B
2.41%
4.08%
9.83%
30.60%
Model Fairness Evaluation
As outlined in the paper "Towards Measuring Fairness in AI: the Casual Conversations Dataset" [8], we assessed the Canary-Qwen-2.5B model for fairness. The model was evaluated on the CasualConversations-v1 dataset with inference done on non-overlapping 40s chunks, and the results are reported as follows:
Gender Bias:
Gender
Male
Female
N/A
Other
Num utterances
18471
23378
880
18
% WER
16.71
13.85
17.71
29.46
Age Bias:
Age Group
(18-30)
(31-45)
(46-85)
(1-100)
Num utterances
15058
13984
12810
41852
% WER
15.73
15.3
14.14
15.11
(Error rates for fairness evaluation are determined by normalizing both the reference and predicted text, similar to the methods used in the evaluations found at https://github.com/huggingface/open_asr_leaderboard.)
Inference:
Engine: NVIDIA NeMo Test Hardware :
A6000
A100
RTX 5090
Ethical Considerations:
NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this model meets requirements for the relevant industry and use case and addresses unforeseen product misuse.
For more detailed information on ethical considerations for this model, please see the Model Card++ Explainability, Bias, Safety & Security, and Privacy Subcards. Please report security vulnerabilities or NVIDIA AI Concerns here.
