Qwen3-ASR-0.6B

The Qwen3-ASR family includes Qwen3-ASR-1.7B and Qwen3-ASR-0.6B, which support language identification and ASR for 52 languages and dialects. Both leverage large-scale speech training data and the strong audio understanding capability of their foundation model, Qwen3-Omni. Experiments show that the 1.7B version achieves state-of-the-art performance among open-source ASR models and is competitive with the strongest proprietary commercial APIs. Here are the main features: * **All-in-one**: Qwen3-ASR-1.7B and Qwen3-ASR-0.6B support language identification and speech recognition for 30 languages and 22 Chinese dialects, so as to English accents from multiple countries and regions. * **Excellent and Fast**: The Qwen3-ASR family ASR models maintains high-quality and robust recognition under complex acoustic environments and challenging text patterns. Qwen3-ASR-1.7B achieves strong performance on both open-sourced and internal benchmarks. While the 0.6B version achieves accuracy-efficient trade-off, it reaches 2000 times throughput at a concurrency of 128. They both achieve streaming / offline unified inference with single model and support transcribe long audio. * **Novel and strong forced alignment Solution**: We introduce Qwen3-ForcedAligner-0.6B, which supports timestamp prediction for arbitrary units within up to 5 minutes of speech in 11 languages. Evaluations show its timestamp accuracy surpasses E2E based forced-alignment models. * **Comprehensive inference toolkit**: In addition to open-sourcing the architectures and weights of the Qwen3-ASR series, we also release a powerful, full-featured inference framework that supports vLLM-based batch inference, asynchronous serving, streaming inference, timestamp prediction, and more. Below is an introduction and download information for the Qwen3-ASR models. Please select and download the model that fits your needs. During model loading in the `qwen-asr` package or vLLM, model weights will be downloaded automatically based on the model name. However, if your runtime environment does not allow downloading weights during execution, you can use the following commands to manually download the model weights to a local directory: pip install -U modelscope modelscope download --model Qwen/Qwen3-ASR-1.7B --local_dir ./Qwen3-ASR-1.7B modelscope download --model Qwen/Qwen3-ASR-0.6B --local_dir ./Qwen3-ASR-0.6B modelscope download --model Qwen/Qwen3-ForcedAligner-0.6B --local_dir ./Qwen3-ForcedAligner-0.6B pip install -U "huggingface_hub[cli]" huggingface-cli download Qwen/Qwen3-ASR-1.7B --local-dir ./Qwen3-ASR-1.7B huggingface-cli download Qwen/Qwen3-ASR-0.6B --local-dir ./Qwen3-ASR-0.6B huggingface-cli download Qwen/Qwen3-ForcedAligner-0.6B --local-dir ./Qwen3-ForcedAligner-0.6B The easiest way to use Qwen3-ASR is to install the `qwen-asr` Python package from PyPI. This will pull in the required runtime dependencies and allow you to load any released Qwen3-ASR model. If you’d like to simplify environment setup further, you can also use our official [Docker image](#docker). The `qwen-asr` package provides two backends: the transformers backend and the vLLM backend. For usage instructions for different backends, please refer to [Python Package Usage](#python-package-usage). We recommend using a **fresh, isolated environment** to avoid dependency conflicts with existing packages. You can create a clean Python 3.12 environment like this: conda create -n qwen3-asr python=3.12 -y conda activate qwen3-asr Run the following command to get the minimal installation with transformers-backend support: pip install -U qwen-asr To enable the vLLM backend for faster inference and streaming support, run: pip install -U qwen-asr[vllm] If you want to develop or modify the code locally, install from source in editable mode: git clone https://github.com/QwenLM/Qwen3-ASR.git cd Qwen3-ASR pip install -e . Additionally, we recommend using FlashAttention 2 to reduce GPU memory usage and accelerate inference speed, especially for long inputs and large batch sizes. pip install -U flash-attn --no-build-isolation If your machine has less than 96GB of RAM and lots of CPU cores, run: MAX_JOBS=4 pip install -U flash-attn --no-build-isolation Also, you should have hardware that is compatible with FlashAttention 2. Read more about it in the official documentation of the [FlashAttention repository](https://github.com/Dao-AILab/flash-attention). FlashAttention 2 can only be used when a model is loaded in `torch.float16` or `torch.bfloat16`. The `qwen-asr` package provides two backends: **transformers backend** and **vLLM backend**. You can pass audio inputs as a local path, a URL, base64 data, or a `(np.ndarray, sr)` tuple, and run batch inference. To quickly try Qwen3-ASR, you can use `Qwen3ASRModel.from_pretrained(...)` for the transformers backend with the following code: import torch from qwen_asr import Qwen3ASRModel model = Qwen3ASRModel.from_pretrained( "Qwen/Qwen3-ASR-1.7B", dtype=torch.bfloat16, device_map="cuda:0", max_inference_batch_size=32, # Batch size limit for inference. -1 means unlimited. Smaller values can help avoid OOM. max_new_tokens=256, # Maximum number of tokens to generate. Set a larger value for long audio input. ) results = model.transcribe( audio="https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav", language=None, # set "English" to force the language ) print(results[0].language) print(results[0].text) If you want to return timestamps, pass `forced_aligner` and its init kwargs. Here is an example of batch inference with timestamps output: import torch from qwen_asr import Qwen3ASRModel model = Qwen3ASRModel.from_pretrained( "Qwen/Qwen3-ASR-1.7B", dtype=torch.bfloat16, device_map="cuda:0", max_inference_batch_size=32, # Batch size limit for inference. -1 means unlimited. Smaller values can help avoid OOM. max_new_tokens=256, # Maximum number of tokens to generate. Set a larger value for long audio input. forced_aligner="Qwen/Qwen3-ForcedAligner-0.6B", forced_aligner_kwargs=dict( dtype=torch.bfloat16, device_map="cuda:0", ), ) results = model.transcribe( audio=[ "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_zh.wav", "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav", ], language=["Chinese", "English"], # can also be set to None for automatic language detection return_time_stamps=True, ) for r in results: print(r.language, r.text, r.time_stamps[0]) For more detailed usage examples, please refer to the [example code](https://github.com/QwenLM/Qwen3-ASR/blob/main/examples/example_qwen3_asr_transformers.py) for the transformers backend. If you want the fastest inference speed with Qwen3-ASR, we strongly recommend using the vLLM backend by initializing the model with `Qwen3ASRModel.LLM(...)`. Example code is provided below. Note that you must install it via `pip install -U qwen-asr[vllm]`. If you want the model to output timestamps, it’s best to install FlashAttention via `pip install -U flash-attn --no-build-isolation` to speed up inference for the forced aligner model. Remember to wrap your code under `if __name__ == '__main__':` to avoid the `spawn` error described in [vLLM Troubleshooting](https://docs.vllm.ai/en/latest/usage/troubleshooting/#python-multiprocessing). import torch from qwen_asr import Qwen3ASRModel if __name__ == '__main__': model = Qwen3ASRModel.LLM( model="Qwen/Qwen3-ASR-1.7B", gpu_memory_utilization=0.7, max_inference_batch_size=128, # Batch size limit for inference. -1 means unlimited. Smaller values can help avoid OOM. max_new_tokens=4096, # Maximum number of tokens to generate. Set a larger value for long audio input. forced_aligner="Qwen/Qwen3-ForcedAligner-0.6B", forced_aligner_kwargs=dict( dtype=torch.bfloat16, device_map="cuda:0", ), ) results = model.transcribe( audio=[ "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_zh.wav", "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav", ], language=["Chinese", "English"], # can also be set to None for automatic language detection return_time_stamps=True, ) for r in results: print(r.language, r.text, r.time_stamps[0]) For more detailed usage examples, please refer to the [example code](https://github.com/QwenLM/Qwen3-ASR/blob/main/examples/example_qwen3_asr_vllm.py) for the vLLM backend. In addition, you can start a vLLM server via the `qwen-asr-serve` command, which is a wrapper around `vllm serve`. You can pass any arguments supported by `vllm serve`, for example: qwen-asr-serve Qwen/Qwen3-ASR-1.7B --gpu-memory-utilization 0.8 --host 0.0.0.0 --port 8000 And send requests to the server via: import requests url = "http://localhost:8000/v1/chat/completions" headers = {"Content-Type": "application/json"} data = { "messages": [ { "role": "user", "content": [ { "type": "audio_url", "audio_url": { "url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav" }, } ], } ] } response = requests.post(url, headers=headers, json=data, timeout=300) response.raise_for_status() content = response.json()['choices'][0]['message']['content'] print(content) from qwen_asr import parse_asr_output language, text = parse_asr_output(content) print(language) print(text) Qwen3-ASR fully supports streaming inference. Currently, streaming inference is only available with the vLLM backend. Note that streaming inference does not support batch inference or returning timestamps. Please refer to the [example code](https://github.com/QwenLM/Qwen3-ASR/blob/main/examples/example_qwen3_asr_vllm_streaming.py) for details. You can also launch a streaming web demo through the [guide](#streaming-demo) to experience Qwen3-ASR’s streaming transcription capabilities. `Qwen3-ForcedAligner-0.6B` can align text–speech pairs and return word or character level timestamps. Here is an example of using the forced aligner directly: import torch from qwen_asr import Qwen3ForcedAligner model = Qwen3ForcedAligner.from_pretrained( "Qwen/Qwen3-ForcedAligner-0.6B", dtype=torch.bfloat16, device_map="cuda:0", ) results = model.align( audio="https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_zh.wav", text="甚至出现交易几乎停滞的情况。", language="Chinese", ) print(results[0]) print(results[0][0].text, results[0][0].start_time, results[0][0].end_time) In addition, the forced aligner supports local paths / URLs / base64 data / `(np.ndarray, sr)` inputs and batch inference. Please refer to the [example code](https://github.com/QwenLM/Qwen3-ASR/blob/main/examples/example_qwen3_forced_aligner.py) for details. To further explore Qwen3-ASR, we encourage you to try our DashScope API for a faster and more efficient experience. For detailed API information and documentation, please refer to the following: To launch the Qwen3-ASR web UI gradio demo, install the `qwen-asr` package and run `qwen-asr-demo`. Use the command below for help: qwen-asr-demo --help To launch the demo, you can use the following commands: qwen-asr-demo \ --asr-checkpoint Qwen/Qwen3-ASR-1.7B \ --backend transformers \ --cuda-visible-devices 0 \ --ip 0.0.0.0 --port 8000 qwen-asr-demo \ --asr-checkpoint Qwen/Qwen3-ASR-1.7B \ --aligner-checkpoint Qwen/Qwen3-ForcedAligner-0.6B \ --backend transformers \ --cuda-visible-devices 0 \ --backend-kwargs '{"device_map":"cuda:0","dtype":"bfloat16","max_inference_batch_size":8,"max_new_tokens":256}' \ --aligner-kwargs '{"device_map":"cuda:0","dtype":"bfloat16"}' \ --ip 0.0.0.0 --port 8000 qwen-asr-demo \ --asr-checkpoint Qwen/Qwen3-ASR-1.7B \ --aligner-checkpoint Qwen/Qwen3-ForcedAligner-0.6B \ --backend vllm \ --cuda-visible-devices 0 \ --backend-kwargs '{"gpu_memory_utilization":0.7,"max_inference_batch_size":8,"max_new_tokens":2048}' \ --aligner-kwargs '{"device_map":"cuda:0","dtype":"bfloat16"}' \ --ip 0.0.0.0 --port 8000 Then open `http://<your-ip>:8000`, or access it via port forwarding in tools like VS Code. This demo supports two backends: transformers and vLLM. All backend-specific initialization parameters should be passed via `--backend-kwargs` as a JSON dict. If not provided, the demo will use sensible defaults. --backend-kwargs '{"device_map":"cuda:0","dtype":"bfloat16"}' --backend-kwargs '{"gpu_memory_utilization":0.65}' Because vLLM does not follow `cuda:0` style device selection, this demo selects GPUs by setting `CUDA_VISIBLE_DEVICES` via `--cuda-visible-devices`. --cuda-visible-devices 0 --cuda-visible-devices 1 Timestamps are only available when `--aligner-checkpoint` is provided. If you launch the demo without a forced aligner, the timestamps UI will be hidden automatically. qwen-asr-demo --asr-checkpoint Qwen/Qwen3-ASR-1.7B qwen-asr-demo \ --asr-checkpoint Qwen/Qwen3-ASR-1.7B \ --aligner-checkpoint Qwen/Qwen3-ForcedAligner-0.6B To avoid browser microphone permission issues after deploying the server, it is recommended/required to run the gradio service over HTTPS (especially when accessed remotely or behind modern browsers/gateways). Use `--ssl-certfile` and `--ssl-keyfile` to enable HTTPS. First, generate a private key and a self-signed certificate (valid for 365 days): openssl req -x509 -newkey rsa:2048 \ -keyout key.pem -out cert.pem \ -days 365 -nodes \ -subj "/CN=localhost" Then run the demo with HTTPS: qwen-asr-demo \ --asr-checkpoint Qwen/Qwen3-ASR-1.7B \ --backend transformers \ --cuda-visible-devices 0 \ --ip 0.0.0.0 --port 8000 \ --ssl-certfile cert.pem \ --ssl-keyfile key.pem \ --no-ssl-verify Then open `https://<your-ip>:8000` to use it. If your browser shows a warning, that’s expected for self-signed certificates. For production, use a real certificate. To experience Qwen3-ASR’s streaming transcription capability in a web UI, we provide a minimal Flask-based streaming demo. The demo captures microphone audio in the browser, resamples it to 16,000 Hz, and continuously pushes PCM chunks to the model. Run the demo with the following command: qwen-asr-demo-streaming \ --asr-model-path Qwen/Qwen3-ASR-1.7B \ --host 0.0.0.0 \ --port 8000 \ --gpu-memory-utilization 0.9 Then open `http://<your-ip>:8000`, or access it via port forwarding in tools like VS Code. vLLM officially provides day-0 model support for Qwen3-ASR for efficient inference. You can run Qwen3-ASR with vLLM nightly wheel or docker image. To install the nightly version of vLLM, we recommend using `uv` as the environment manager uv venv source .venv/bin/activate uv pip install -U vllm --pre \ --extra-index-url https://wheels.vllm.ai/nightly/cu129 \ --extra-index-url https://download.pytorch.org/whl/cu129 \ --index-strategy unsafe-best-match uv pip install "vllm[audio]" # For additional audio dependencies You can easily deploy Qwen3-ASR with vLLM by running the following command vllm serve Qwen/Qwen3-ASR-1.7B After the model server is successfully deployed, you can interact with it in multiple ways. import base64 import httpx from openai import OpenAI client = OpenAI( base_url="http://localhost:8000/v1", api_key="EMPTY" ) response = client.chat.completions.create( model="Qwen/Qwen3-ASR-1.7B", messages=[ { "role": "user", "content": [ { "type": "audio_url", "audio_url": { {"url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav"} } } ] } ], ) print(response.choices[0].message.content) This model is also supported on vLLM with OpenAI transcription API. import httpx from openai import OpenAI client = OpenAI( base_url="http://localhost:8000/v1", api_key="EMPTY" ) audio_url = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav" audio_file = httpx.get(audio_url).content transcription = client.audio.transcriptions.create( model="Qwen/Qwen3-ASR-1.7B", file=audio_file, ) print(transcription.text) curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "messages": [ {"role": "user", "content": [ {"type": "audio_url", "audio_url": {"url": "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_en.wav"}} ]} ] }' See the following example on using vLLM to run offline inference with Qwen3-ASR from vllm import LLM, SamplingParams from vllm.assets.audio import AudioAsset import base64 import requests llm = LLM( model="Qwen/Qwen3-ASR-1.7B" ) audio_asset = AudioAsset("winning_call") conversation = [ { "role": "user", "content": [ { "type": "audio_url", "audio_url": {"url": audio_asset.url} } ] } ] sampling_params = SamplingParams(temperature=0.01, max_tokens=256) outputs = llm.chat(conversation, sampling_params=sampling_params) print(outputs[0].outputs[0].text) To make it easier to use our `qwen-asr` Python package, we provide a pre-built Docker image: [qwenllm/qwen3-asr](https://hub.docker.com/r/qwenllm/qwen3-asr). You only need to install the GPU driver and download the model files to run the code. Please follow the [NVIDIA Container Toolkit installation guide](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html) to ensure Docker can access your GPU. If you are in Mainland China and have trouble reaching Docker Hub, you may use a registry mirror to accelerate image pulls. First, pull the image and start a container: LOCAL_WORKDIR=/path/to/your/workspace HOST_PORT=8000 CONTAINER_PORT=80 docker run --gpus all --name qwen3-asr \ -v /var/run/docker.sock:/var/run/docker.sock -p $HOST_PORT:$CONTAINER_PORT \ --mount type=bind,source=$LOCAL_WORKDIR,target=/data/shared/Qwen3-ASR \ --shm-size=4gb \ -it qwenllm/qwen3-asr:latest After running the command, you will enter the container’s bash shell. Your local workspace (**replace** `/path/to/your/workspace` **with the actual path**) will be mounted inside the container at `/data/shared/Qwen3-ASR`. Port `8000` on the host is mapped to port `80` in the container, so you can access services running in the container via `http://<host-ip>:8000`. Note that services inside the container must bind to `0.0.0.0` (not `127.0.0.1`) for port forwarding to work. If you exit the container, you can start it again and re-enter it with: docker start qwen3-asr docker exec -it qwen3-asr bash To remove the container completely, run: docker rm -f qwen3-asr During evaluation, we ran inference for all models with `dtype=torch.bfloat16` and set `max_new_tokens=1024` using vLLM. Greedy search was used for all decoding, and none of the tests specified a language parameter. The detailed evaluation results are shown below. If you find our paper and code useful in your research, please consider giving a star :star: and citation :pencil: :) @article{Qwen3-ASR, title={Qwen3-ASR Technical Report}, author={Xian Shi, Xiong Wang, Zhifang Guo, Yongqi Wang, Pei Zhang, Xinyu Zhang, Zishan Guo, Hongkun Hao, Yu Xi, Baosong Yang, Jin Xu, Jingren Zhou, Junyang Lin}, journal={arXiv preprint arXiv:2601.21337}, year={2026} }