nvidia / canary-qwen-2.5b

| |

Model Overview

Description:

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 458 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.

References:

[1] Less is More: Accurate Speech Recognition & Translation without Web-Scale Data

[2] Fast Conformer with Linearly Scalable Attention for Efficient Speech Recognition

[3] Attention Is All You Need

[4] Qwen/Qwen3-1.7B Model Card

[5] Training and Inference Efficiency of Encoder-Decoder Speech Models

[6] NVIDIA NeMo Toolkit

[7] Granary: Speech Recognition and Translation Dataset in 25 European Languages

[8] Towards Measuring Fairness in AI: the Casual Conversations Dataset

[9] SALM: Speech-augmented Language Model with In-context Learning for Speech Recognition and Translation

Deployment Geography:

Global

Use Case:

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.

Release Date:

Huggingface 07/17/2025 via https://huggingface.co/nvidia/canary-qwen-2.5b

Model Architecture:

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 .

# Currently requires installing the latest trunk version of NeMo, and PyTorch 2.6+ for FSDP2 support.
python -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.

Loading the Model

from nemo.collections.speechlm2.models import SALM

model = SALM.from_pretrained('nvidia/canary-qwen-2.5b')

Input:

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):

answer_ids = model.generate(
    prompts=[
        [{"role": "user", "content": f"Transcribe the following: {model.audio_locator_tag}", "audio": ["speech.wav"]}]
    ],
    max_new_tokens=128,
)
print(model.tokenizer.ids_to_text(answer_ids[0].cpu()))

Example usage in LLM mode (text-only):

prompt = "..."
transcript = "..."
with model.llm.disable_adapter():
    answer_ids = model.generate(
        prompts=[[{"role": "user", "content": f"{prompt}\n\n{transcript}"}]],
        max_new_tokens=2048,
    )

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:

# Example of a line in input_manifest.json
{
    "audio_filepath": "/path/to/audio.wav",  # path to the audio file
    "duration": 30.0,  # duration of the audio
}

and then use:

cd NeMo
python examples/speechlm2/salm_generate.py \
  pretrained_name=nvidia/canary-qwen-2.5b \
  inputs=input_manifest.json \
  output_manifest=generations.jsonl \
  batch_size=128 \
  user_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.

Software Integration:

Runtime Engine(s):

• NeMo - 2.5.0 or higher
  

Supported Hardware Microarchitecture Compatibility:

• [NVIDIA Ampere]
  
• [NVIDIA Blackwell]
  
• [NVIDIA Jetson]
  
• [NVIDIA Hopper]
  
• [NVIDIA Lovelace]
  
• [NVIDIA Pascal]
  
• [NVIDIA Turing]
  
• [NVIDIA Volta]
  

[Preferred/Supported] Operating System(s):

• [Linux]
  
• [Linux 4 Tegra]
  
• [Windows]
  

Model Version(s):

Canary-Qwen-2.5B

Training

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 model can be trained using this example script and base config .

The tokenizer was inherited from Qwen/Qwen3-1.7B .

Training and Evaluation Datasets:

Training Dataset:

** 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.

Evaluation Dataset:

Data Collection Method:

• Human
  

Labeling Method:

• Human
  

Automatic Speech Recognition:

• HuggingFace OpenASR Leaderboard evaluation sets

Hallucination Robustness:

• MUSAN 48 hrs eval set

Noise Robustness:

• Librispeech

Model Fairness:

• Casual Conversations Dataset

Performance

The ASR predictions were generated using greedy decoding.

ASR Performance (w/o PnC)

The ASR performance is measured with word error rate (WER), and we process the groundtruth and predicted text with whisper-normalizer version 0.1.12.

WER on HuggingFace OpenASR leaderboard :

More details on evaluation can be found at HuggingFace ASR Leaderboard

Hallucination Robustness

Number of characters per minute on MUSAN 48 hrs eval set ( max_new_tokens=50 following nvidia/canary-1b-flash evaluation)

Noise Robustness

WER on Librispeech Test Clean at different SNR (signal to noise ratio) levels of additive white noise

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:

Age Bias:

(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 .