Qwen3-ASR-0.6B快速部署教程：vscode python环境配置指南

最近阿里开源的Qwen3-ASR系列语音识别模型挺火的，特别是那个0.6B版本，据说在性能和效率上平衡得不错。很多开发者想试试，但一看到环境配置就头疼，尤其是刚接触语音识别的新手。

今天我就来手把手教你在VSCode里配置Python环境，把Qwen3-ASR-0.6B跑起来。整个过程其实没想象中那么复杂，跟着步骤走，半小时内就能搞定。

1. 准备工作：你需要什么

在开始之前，先确认一下你的电脑环境。Qwen3-ASR-0.6B虽然是个轻量级模型，但对硬件还是有些基本要求的。

硬件要求：

• GPU：推荐NVIDIA显卡，显存至少4GB（6GB以上更稳妥）
• 内存：8GB以上
• 存储空间：模型文件大约2-3GB，加上Python环境，建议预留10GB空间

软件要求：

• 操作系统：Windows 10/11，macOS，或者Linux都行
• Python版本：3.8到3.11都可以，我用的是3.10
• VSCode：最新版本就行

如果你没有独立显卡，用CPU也能跑，就是速度会慢一些。不过Qwen3-ASR-0.6B本身比较轻量，CPU推理也不是不能接受。

2. VSCode环境配置

2.1 安装Python和VSCode

如果你还没装Python，先去官网下载安装。记得安装时勾选“Add Python to PATH”，这样后面在命令行里就能直接用了。

VSCode的安装更简单，官网下载安装包，一路下一步就行。装好后打开VSCode，你会看到这样一个界面：

2.2 安装必要的VSCode扩展

VSCode的强大之处在于扩展，对于Python开发，这几个扩展是必须的：

1. Python扩展：微软官方的Python支持
2. Pylance：Python语言服务器，提供智能提示
3. Jupyter：如果你要跑Notebook的话

安装方法很简单，在VSCode左侧找到扩展图标（四个方块那个），搜索“Python”，第一个就是。点击安装，其他扩展也类似。

2.3 创建项目文件夹

在电脑上找个地方新建个文件夹，比如我放在D:\Projects\qwen3-asr-demo。然后在VSCode里打开这个文件夹：

# 打开VSCode终端（快捷键Ctrl+`）
# 创建项目文件夹
mkdir qwen3-asr-demo
cd qwen3-asr-demo

或者在VSCode里直接点“文件”->“打开文件夹”，选择你刚创建的文件夹。

3. Python虚拟环境配置

虚拟环境是个好东西，它能让你每个项目的Python包都独立，不会互相干扰。特别是做AI项目，不同模型需要的包版本可能冲突，用虚拟环境就省心多了。

3.1 创建虚拟环境

在VSCode里打开终端（快捷键Ctrl+`），然后输入：

# 创建虚拟环境，名字叫venv
python -m venv venv

这个命令会在当前文件夹下创建一个叫venv的文件夹，里面就是独立的Python环境。

3.2 激活虚拟环境

创建好后需要激活它，不同系统激活方式不一样：

Windows：

venv\Scripts\activate

macOS/Linux：

source venv/bin/activate

激活后，你会看到终端提示符前面多了个(venv)，说明现在已经在虚拟环境里了。

如果不想每次打开终端都手动激活，可以在VSCode里设置默认使用这个虚拟环境。按Ctrl+Shift+P打开命令面板，输入“Python: Select Interpreter”，选择你刚创建的虚拟环境里的Python解释器（路径是项目文件夹/venv/Scripts/python.exe）。

4. 安装Qwen3-ASR依赖包

现在到了关键步骤，安装Qwen3-ASR需要的Python包。Qwen3-ASR官方提供了两种后端：Transformers和vLLM。vLLM速度更快，但安装稍微复杂点。我们先从简单的Transformers开始。

4.1 基础依赖安装

在激活的虚拟环境终端里，依次执行：

# 升级pip到最新版本
python -m pip install --upgrade pip

# 安装PyTorch（根据你的CUDA版本选择）
# 如果你有CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 如果没有GPU或者CUDA版本不同，用这个
pip install torch torchvision torchaudio

# 安装Qwen3-ASR核心包
pip install qwen-asr

qwen-asr这个包是官方封装好的，里面包含了运行Qwen3-ASR所需的大部分依赖。安装过程可能会花几分钟，取决于你的网络速度。

4.2 可选：安装vLLM后端

如果你想要更快的推理速度，可以安装vLLM后端。不过vLLM对CUDA版本要求比较严格，而且安装过程可能会遇到各种问题。新手可以先跳过这一步，用Transformers后端跑通再说。

如果你决定要装，可以试试：

# 安装vLLM（可能需要根据你的CUDA版本调整）
pip install vllm

# 安装带音频支持的vLLM
pip install "vllm[audio]"

如果安装过程中报错，大概率是CUDA版本不匹配。这时候可以去vLLM的GitHub页面看看官方文档，或者直接用Transformers后端，其实也够用了。

4.3 验证安装

安装完成后，写个简单的Python脚本来验证一下：

# test_install.py
import torch
print(f"PyTorch版本: {torch.__version__}")
print(f"CUDA是否可用: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU设备: {torch.cuda.get_device_name(0)}")
    print(f"CUDA版本: {torch.version.cuda}")

在终端里运行：

python test_install.py

如果看到CUDA可用，并且显示了你的GPU信息，说明环境配置基本没问题了。

5. 下载和加载模型

Qwen3-ASR-0.6B模型可以从Hugging Face或者ModelScope下载。国内用户用ModelScope可能更快一些。

5.1 第一次运行自动下载

最简单的方法是直接写代码运行，第一次运行时会自动下载模型：

# download_model.py
import torch
from qwen_asr import Qwen3ASRModel
import time

print("开始加载Qwen3-ASR-0.6B模型...")
start_time = time.time()

# 这里指定使用0.6B版本
model = Qwen3ASRModel.from_pretrained(
    "Qwen/Qwen3-ASR-0.6B",
    torch_dtype=torch.float16,  # 使用半精度减少显存占用
    device_map="auto",  # 自动选择设备（GPU或CPU）
)

end_time = time.time()
print(f"模型加载完成，耗时: {end_time - start_time:.2f}秒")
print(f"模型设备: {model.device}")

第一次运行这个脚本时，会下载大约2-3GB的模型文件。下载速度取决于你的网络，可能需要等一会儿。

5.2 手动下载（可选）

如果自动下载太慢或者经常中断，可以手动下载。先安装ModelScope：

pip install modelscope

然后写个下载脚本：

# manual_download.py
from modelscope import snapshot_download

model_dir = snapshot_download('Qwen/Qwen3-ASR-0.6B', cache_dir='./models')
print(f"模型下载到: {model_dir}")

下载完成后，加载模型时可以指定本地路径：

model = Qwen3ASRModel.from_pretrained(
    "./models/Qwen/Qwen3-ASR-0.6B",
    torch_dtype=torch.float16,
    device_map="auto",
)

6. 第一个语音识别示例

环境配好了，模型也下载了，现在来写个最简单的语音识别例子。

6.1 准备测试音频

首先你需要一个音频文件。可以用手机录一段话，保存为WAV格式，或者用下面这个在线音频测试：

# 下载一个测试音频
import requests

audio_url = "https://qianwen-res.oss-cn-beijing.aliyuncs.com/Qwen3-ASR-Repo/asr_zh.wav"
response = requests.get(audio_url)
with open("test_audio.wav", "wb") as f:
    f.write(response.content)
print("测试音频下载完成")

这个音频是官方提供的测试文件，内容是中文语音。

6.2 基础语音识别

现在写个完整的识别脚本：

# basic_asr.py
import torch
from qwen_asr import Qwen3ASRModel
import time

def main():
    # 1. 加载模型
    print("加载模型中...")
    model = Qwen3ASRModel.from_pretrained(
        "Qwen/Qwen3-ASR-0.6B",
        torch_dtype=torch.float16,
        device_map="auto",
    )
    print("模型加载完成")
    
    # 2. 准备音频文件路径
    audio_file = "test_audio.wav"  # 替换成你的音频文件
    
    # 3. 执行语音识别
    print("开始语音识别...")
    start_time = time.time()
    
    results = model.transcribe(
        audio=audio_file,
        language=None,  # None表示自动检测语言
    )
    
    end_time = time.time()
    
    # 4. 输出结果
    print(f"\n识别完成，耗时: {end_time - start_time:.2f}秒")
    print(f"检测到的语言: {results[0].language}")
    print(f"识别文本: {results[0].text}")
    
    # 5. 保存结果到文件
    with open("transcription.txt", "w", encoding="utf-8") as f:
        f.write(f"语言: {results[0].language}\n")
        f.write(f"文本: {results[0].text}\n")
    
    print("结果已保存到 transcription.txt")

if __name__ == "__main__":
    main()

运行这个脚本：

python basic_asr.py

如果一切正常，你会看到类似这样的输出：

加载模型中...
模型加载完成
开始语音识别...
识别完成，耗时: 1.23秒
检测到的语言: Chinese
识别文本: 这是一个测试音频，用于演示Qwen3-ASR的语音识别能力。

6.3 处理多个音频文件

实际应用中，我们经常需要批量处理音频文件。Qwen3-ASR支持一次处理多个文件：

# batch_asr.py
import torch
from qwen_asr import Qwen3ASRModel
import os

def process_audio_folder(folder_path):
    """处理文件夹中的所有音频文件"""
    
    # 加载模型
    model = Qwen3ASRModel.from_pretrained(
        "Qwen/Qwen3-ASR-0.6B",
        torch_dtype=torch.float16,
        device_map="auto",
    )
    
    # 收集所有音频文件
    audio_files = []
    for file in os.listdir(folder_path):
        if file.endswith(('.wav', '.mp3', '.flac', '.m4a')):
            audio_files.append(os.path.join(folder_path, file))
    
    if not audio_files:
        print("文件夹中没有找到音频文件")
        return
    
    print(f"找到 {len(audio_files)} 个音频文件")
    
    # 批量识别
    results = model.transcribe(
        audio=audio_files,
        language=None,  # 自动检测语言
    )
    
    # 输出结果
    for i, result in enumerate(results):
        print(f"\n文件: {os.path.basename(audio_files[i])}")
        print(f"语言: {result.language}")
        print(f"文本: {result.text[:100]}...")  # 只显示前100个字符
        
        # 保存每个文件的结果
        output_file = f"{audio_files[i]}_transcription.txt"
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(f"文件: {audio_files[i]}\n")
            f.write(f"语言: {result.language}\n")
            f.write(f"文本: {result.text}\n")
    
    print(f"\n所有结果已保存到对应的txt文件")

if __name__ == "__main__":
    # 替换成你的音频文件夹路径
    audio_folder = "./audio_files"
    process_audio_folder(audio_folder)

7. 进阶功能：带时间戳的识别

Qwen3-ASR还有个很实用的功能——时间戳预测，能告诉你每个词在音频中的开始和结束时间。这个功能需要额外加载一个对齐模型。

7.1 安装对齐模型

# timestamp_asr.py
import torch
from qwen_asr import Qwen3ASRModel

def transcribe_with_timestamps(audio_file):
    """带时间戳的语音识别"""
    
    # 加载主模型和对齐模型
    model = Qwen3ASRModel.from_pretrained(
        "Qwen/Qwen3-ASR-0.6B",
        torch_dtype=torch.float16,
        device_map="auto",
        
        # 添加强制对齐器
        forced_aligner="Qwen/Qwen3-ForcedAligner-0.6B",
        forced_aligner_kwargs=dict(
            torch_dtype=torch.float16,
            device_map="auto",
        ),
    )
    
    # 执行识别，返回时间戳
    results = model.transcribe(
        audio=audio_file,
        language="Chinese",  # 指定语言可以提高准确性
        return_time_stamps=True,  # 关键参数：返回时间戳
    )
    
    return results[0]

def main():
    audio_file = "test_audio.wav"
    result = transcribe_with_timestamps(audio_file)
    
    print(f"识别文本: {result.text}")
    print(f"语言: {result.language}")
    print("\n时间戳信息:")
    
    # 时间戳是一个列表，每个元素是(开始时间, 结束时间, 词)
    for start, end, word in result.time_stamps:
        print(f"  [{start:.2f}s - {end:.2f}s]: {word}")
    
    # 也可以按句子组织时间戳
    print("\n按句子组织的时间戳:")
    sentences = []
    current_sentence = []
    
    for start, end, word in result.time_stamps:
        current_sentence.append((start, end, word))
        # 简单的句子分割：遇到句号、问号、感叹号
        if word in ['。', '？', '！', '.', '?', '!']:
            sentences.append(current_sentence)
            current_sentence = []
    
    if current_sentence:  # 添加最后一个句子
        sentences.append(current_sentence)
    
    for i, sentence in enumerate(sentences, 1):
        sentence_text = ''.join(word for _, _, word in sentence)
        start_time = sentence[0][0]
        end_time = sentence[-1][1]
        print(f"句子{i} [{start_time:.2f}s - {end_time:.2f}s]: {sentence_text}")

if __name__ == "__main__":
    main()

时间戳功能对于做字幕生成、语音分析特别有用。比如你可以用这个功能来：

1. 生成字幕文件：把时间戳转换成SRT或VTT格式
2. 语音分析：分析说话人的语速、停顿
3. 音频标注：精确标注音频中的特定内容

7.2 生成SRT字幕文件

基于时间戳，我们可以很容易地生成字幕文件：

# generate_subtitle.py
def generate_srt(result, output_file="subtitle.srt"):
    """生成SRT格式的字幕文件"""
    
    sentences = []
    current_sentence = []
    
    # 按句子分组
    for start, end, word in result.time_stamps:
        current_sentence.append((start, end, word))
        if word in ['。', '？', '！', '.', '?', '!']:
            sentences.append(current_sentence)
            current_sentence = []
    
    if current_sentence:
        sentences.append(current_sentence)
    
    # 生成SRT内容
    srt_content = ""
    for i, sentence in enumerate(sentences, 1):
        start_time = sentence[0][0]
        end_time = sentence[-1][1]
        text = ''.join(word for _, _, word in sentence)
        
        # 格式化时间（SRT格式：00:00:00,000）
        start_str = format_time(start_time)
        end_str = format_time(end_time)
        
        srt_content += f"{i}\n"
        srt_content += f"{start_str} --> {end_str}\n"
        srt_content += f"{text}\n\n"
    
    # 保存文件
    with open(output_file, "w", encoding="utf-8") as f:
        f.write(srt_content)
    
    print(f"字幕文件已保存到: {output_file}")

def format_time(seconds):
    """将秒数格式化为SRT时间格式"""
    hours = int(seconds // 3600)
    minutes = int((seconds % 3600) // 60)
    secs = int(seconds % 60)
    millis = int((seconds - int(seconds)) * 1000)
    
    return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"

8. 常见问题解决

在实际部署过程中，你可能会遇到一些问题。这里整理了几个常见的：

8.1 显存不足问题

Qwen3-ASR-0.6B虽然不大，但在某些显卡上可能还是会显存不足。可以试试这些方法：

# 方法1：使用更低的精度
model = Qwen3ASRModel.from_pretrained(
    "Qwen/Qwen3-ASR-0.6B",
    torch_dtype=torch.float16,  # 半精度
    device_map="auto",
)

# 方法2：使用CPU（速度会慢）
model = Qwen3ASRModel.from_pretrained(
    "Qwen/Qwen3-ASR-0.6B",
    torch_dtype=torch.float32,
    device_map="cpu",  # 强制使用CPU
)

# 方法3：分批处理长音频
def process_long_audio(audio_file, chunk_duration=30):
    """将长音频分割成小块处理"""
    import librosa
    import soundfile as sf
    
    # 加载音频
    y, sr = librosa.load(audio_file, sr=16000)
    
    # 计算总时长和块数
    total_duration = len(y) / sr
    chunks = []
    
    for i in range(0, len(y), int(chunk_duration * sr)):
        chunk = y[i:i + int(chunk_duration * sr)]
        if len(chunk) > 0:
            # 保存临时文件
            temp_file = f"temp_chunk_{i//sr}.wav"
            sf.write(temp_file, chunk, sr)
            chunks.append(temp_file)
    
    return chunks

8.2 音频格式不支持

Qwen3-ASR支持常见的音频格式，但如果你遇到格式问题，可以先用ffmpeg转换：

# 安装ffmpeg-python
# pip install ffmpeg-python

import ffmpeg

def convert_audio(input_file, output_file="converted.wav"):
    """转换音频格式为WAV"""
    try:
        ffmpeg.input(input_file).output(
            output_file,
            ar=16000,  # 采样率16000Hz
            ac=1,      # 单声道
            acodec='pcm_s16le'  # 16位PCM
        ).run(quiet=True)
        print(f"转换完成: {output_file}")
        return output_file
    except Exception as e:
        print(f"转换失败: {e}")
        return None

8.3 模型下载慢或失败

国内用户下载Hugging Face模型可能比较慢，可以尝试：

1. 使用ModelScope：国内镜像，速度更快
2. 手动下载：用下载工具下载后放到本地
3. 设置代理：如果有的话

# 使用ModelScope下载
from modelscope import snapshot_download

# 先下载到本地
model_dir = snapshot_download('Qwen/Qwen3-ASR-0.6B')

# 然后从本地加载
model = Qwen3ASRModel.from_pretrained(
    model_dir,  # 使用本地路径
    torch_dtype=torch.float16,
    device_map="auto",
)

8.4 识别准确率不高

如果发现识别结果不准确，可以试试：

1. 指定语言：明确告诉模型音频是什么语言
2. 预处理音频：去除噪声，标准化音量
3. 调整参数：有些参数可以微调

# 指定语言可以提高准确性
results = model.transcribe(
    audio=audio_file,
    language="Chinese",  # 明确指定中文
    # language="English",  # 或者英文
    # language="Japanese",  # 日文等
)

# 对于有噪声的音频，可以尝试预处理
def preprocess_audio(audio_file):
    """简单的音频预处理"""
    import librosa
    import numpy as np
    
    y, sr = librosa.load(audio_file, sr=16000)
    
    # 简单的降噪（可以根据需要调整）
    y_processed = librosa.effects.preemphasis(y)
    
    # 保存处理后的音频
    import soundfile as sf
    sf.write("processed.wav", y_processed, sr)
    
    return "processed.wav"

9. 实际应用示例

最后，我们来看几个实际的应用场景，把学到的知识用起来。

9.1 实时录音识别

虽然Qwen3-ASR本身不是为实时识别设计的，但我们可以结合录音功能实现近实时的识别：

# realtime_asr.py
import pyaudio
import wave
import threading
import queue
import torch
from qwen_asr import Qwen3ASRModel
import numpy as np

class RealtimeASR:
    def __init__(self, model_name="Qwen/Qwen3-ASR-0.6B"):
        """初始化实时ASR"""
        print("加载模型中...")
        self.model = Qwen3ASRModel.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            device_map="auto",
        )
        print("模型加载完成")
        
        # 音频参数
        self.chunk = 1024
        self.format = pyaudio.paInt16
        self.channels = 1
        self.rate = 16000
        
        # 录音控制
        self.is_recording = False
        self.audio_queue = queue.Queue()
        
    def record_audio(self, duration=5):
        """录制音频"""
        p = pyaudio.PyAudio()
        
        stream = p.open(
            format=self.format,
            channels=self.channels,
            rate=self.rate,
            input=True,
            frames_per_buffer=self.chunk
        )
        
        print(f"开始录制{duration}秒...")
        frames = []
        
        for _ in range(0, int(self.rate / self.chunk * duration)):
            data = stream.read(self.chunk)
            frames.append(data)
        
        stream.stop_stream()
        stream.close()
        p.terminate()
        
        print("录制完成")
        
        # 保存为WAV文件
        wf = wave.open("recorded.wav", 'wb')
        wf.setnchannels(self.channels)
        wf.setsampwidth(p.get_sample_size(self.format))
        wf.setframerate(self.rate)
        wf.writeframes(b''.join(frames))
        wf.close()
        
        return "recorded.wav"
    
    def transcribe_file(self, audio_file):
        """转录音频文件"""
        results = self.model.transcribe(
            audio=audio_file,
            language=None,
        )
        return results[0].text
    
    def run(self):
        """运行实时识别演示"""
        try:
            while True:
                command = input("\n输入命令: [r]录制 [q]退出: ").strip().lower()
                
                if command == 'r':
                    # 录制5秒音频
                    audio_file = self.record_audio(duration=5)
                    
                    # 识别
                    print("识别中...")
                    text = self.transcribe_file(audio_file)
                    print(f"识别结果: {text}")
                    
                elif command == 'q':
                    print("退出程序")
                    break
                    
        except KeyboardInterrupt:
            print("\n程序被中断")
        except Exception as e:
            print(f"发生错误: {e}")

if __name__ == "__main__":
    # 需要先安装pyaudio: pip install pyaudio
    asr = RealtimeASR()
    asr.run()

9.2 批量处理文件夹中的音频

如果你有很多音频文件需要处理，可以写个批量处理的脚本：

# batch_processor.py
import os
import json
from datetime import datetime
import torch
from qwen_asr import Qwen3ASRModel

class BatchAudioProcessor:
    def __init__(self, model_path="Qwen/Qwen3-ASR-0.6B"):
        self.model = Qwen3ASRModel.from_pretrained(
            model_path,
            torch_dtype=torch.float16,
            device_map="auto",
        )
        
    def process_folder(self, input_folder, output_file="results.json"):
        """处理整个文件夹的音频文件"""
        
        # 支持的音频格式
        audio_extensions = {'.wav', '.mp3', '.flac', '.m4a', '.ogg'}
        
        # 收集所有音频文件
        audio_files = []
        for root, dirs, files in os.walk(input_folder):
            for file in files:
                if any(file.lower().endswith(ext) for ext in audio_extensions):
                    audio_files.append(os.path.join(root, file))
        
        if not audio_files:
            print(f"在 {input_folder} 中没有找到音频文件")
            return
        
        print(f"找到 {len(audio_files)} 个音频文件")
        
        results = []
        for i, audio_file in enumerate(audio_files, 1):
            print(f"处理文件 {i}/{len(audio_files)}: {os.path.basename(audio_file)}")
            
            try:
                # 识别
                transcription = self.model.transcribe(
                    audio=audio_file,
                    language=None,
                )[0]
                
                # 保存结果
                result = {
                    "file": audio_file,
                    "filename": os.path.basename(audio_file),
                    "language": transcription.language,
                    "text": transcription.text,
                    "timestamp": datetime.now().isoformat(),
                }
                results.append(result)
                
                print(f"  语言: {transcription.language}")
                print(f"  文本: {transcription.text[:50]}...")
                
            except Exception as e:
                print(f"  处理失败: {e}")
                results.append({
                    "file": audio_file,
                    "error": str(e),
                    "timestamp": datetime.now().isoformat(),
                })
        
        # 保存所有结果到JSON文件
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(results, f, ensure_ascii=False, indent=2)
        
        print(f"\n处理完成！结果已保存到 {output_file}")
        
        # 统计信息
        successful = sum(1 for r in results if 'text' in r)
        failed = len(results) - successful
        
        print(f"成功: {successful} 个文件")
        print(f"失败: {failed} 个文件")
        
        return results

if __name__ == "__main__":
    processor = BatchAudioProcessor()
    
    # 替换成你的音频文件夹路径
    input_folder = "./my_audio_files"
    
    if os.path.exists(input_folder):
        processor.process_folder(input_folder)
    else:
        print(f"文件夹不存在: {input_folder}")
        print("正在创建示例文件夹结构...")
        os.makedirs(input_folder, exist_ok=True)
        print(f"请将音频文件放入 {input_folder} 文件夹中，然后重新运行")

9.3 创建简单的Web界面

如果你想让非技术人员也能用，可以做个简单的Web界面：

# web_interface.py
from flask import Flask, request, render_template, jsonify
import os
from werkzeug.utils import secure_filename
import torch
from qwen_asr import Qwen3ASRModel

app = Flask(__name__)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 16 * 1024 * 1024  # 16MB限制

# 确保上传文件夹存在
os.makedirs(app.config['UPLOAD_FOLDER'], exist_ok=True)

# 加载模型（全局只加载一次）
print("正在加载模型...")
model = Qwen3ASRModel.from_pretrained(
    "Qwen/Qwen3-ASR-0.6B",
    torch_dtype=torch.float16,
    device_map="auto",
)
print("模型加载完成")

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return jsonify({'error': '没有选择文件'}), 400
    
    file = request.files['file']
    if file.filename == '':
        return jsonify({'error': '没有选择文件'}), 400
    
    if file:
        # 保存文件
        filename = secure_filename(file.filename)
        filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
        file.save(filepath)
        
        try:
            # 识别语音
            language = request.form.get('language', None)
            if language == 'auto':
                language = None
            
            results = model.transcribe(
                audio=filepath,
                language=language,
            )
            
            # 返回结果
            result = {
                'filename': filename,
                'language': results[0].language,
                'text': results[0].text,
                'success': True
            }
            
            return jsonify(result)
            
        except Exception as e:
            return jsonify({'error': str(e), 'success': False}), 500
        
        finally:
            # 清理上传的文件
            if os.path.exists(filepath):
                os.remove(filepath)

if __name__ == '__main__':
    # 创建HTML模板
    html_content = """
    <!DOCTYPE html>
    <html>
    <head>
        <title>Qwen3-ASR 语音识别</title>
        <style>
            body { font-family: Arial, sans-serif; max-width: 800px; margin: 0 auto; padding: 20px; }
            .container { background: #f5f5f5; padding: 20px; border-radius: 10px; }
            h1 { color: #333; }
            .upload-form { margin: 20px 0; }
            .result { background: white; padding: 15px; border-radius: 5px; margin-top: 20px; }
            .loading { display: none; color: #666; }
        </style>
    </head>
    <body>
        <div class="container">
            <h1>Qwen3-ASR 语音识别</h1>
            
            <form class="upload-form" id="uploadForm">
                <div>
                    <label>选择音频文件:</label>
                    <input type="file" name="file" accept=".wav,.mp3,.flac,.m4a" required>
                </div>
                
                <div style="margin: 10px 0;">
                    <label>语言:</label>
                    <select name="language">
                        <option value="auto">自动检测</option>
                        <option value="Chinese">中文</option>
                        <option value="English">英文</option>
                        <option value="Japanese">日文</option>
                    </select>
                </div>
                
                <button type="submit">上传并识别</button>
            </form>
            
            <div class="loading" id="loading">
                识别中，请稍候...
            </div>
            
            <div class="result" id="result" style="display: none;">
                <h3>识别结果</h3>
                <p><strong>文件:</strong> <span id="filename"></span></p>
                <p><strong>语言:</strong> <span id="detected_language"></span></p>
                <p><strong>文本:</strong></p>
                <div id="text" style="background: #f8f9fa; padding: 10px; border-radius: 5px;"></div>
            </div>
        </div>
        
        <script>
            document.getElementById('uploadForm').addEventListener('submit', async function(e) {
                e.preventDefault();
                
                const formData = new FormData(this);
                const loading = document.getElementById('loading');
                const result = document.getElementById('result');
                
                // 显示加载中
                loading.style.display = 'block';
                result.style.display = 'none';
                
                try {
                    const response = await fetch('/upload', {
                        method: 'POST',
                        body: formData
                    });
                    
                    const data = await response.json();
                    
                    if (data.success) {
                        // 显示结果
                        document.getElementById('filename').textContent = data.filename;
                        document.getElementById('detected_language').textContent = data.language;
                        document.getElementById('text').textContent = data.text;
                        result.style.display = 'block';
                    } else {
                        alert('识别失败: ' + data.error);
                    }
                } catch (error) {
                    alert('上传失败: ' + error.message);
                } finally {
                    loading.style.display = 'none';
                }
            });
        </script>
    </body>
    </html>
    """
    
    # 创建模板文件夹
    os.makedirs('templates', exist_ok=True)
    with open('templates/index.html', 'w', encoding='utf-8') as f:
        f.write(html_content)
    
    # 启动Flask应用
    app.run(debug=True, host='0.0.0.0', port=5000)

运行这个Web应用后，在浏览器打开 http://localhost:5000 就能看到一个简单的上传界面，可以上传音频文件并看到识别结果。

10. 总结

走完这一整套流程，你应该已经能在VSCode里顺利运行Qwen3-ASR-0.6B了。从环境配置到实际应用，我们一步步搭建了一个完整的语音识别开发环境。

实际用下来，Qwen3-ASR-0.6B给我的感觉是挺适合新手入门的。模型不大，对硬件要求相对友好，而且官方封装的qwen-asr包让调用变得特别简单。虽然0.6B版本在准确率上可能不如更大的1.7B版本，但对于大多数日常应用来说已经够用了，特别是考虑到它的速度和资源消耗。

如果你刚开始接触语音识别，我建议先从简单的例子开始，跑通基础功能，然后再慢慢尝试更复杂的应用。遇到问题不用慌，大部分都是环境配置或者依赖包版本的问题，按照错误信息搜索一下基本都能找到解决方案。

这套环境配置方法不仅适用于Qwen3-ASR，其他类似的AI模型部署也大同小异。掌握了这个流程，以后遇到新的模型也能快速上手。接下来你可以试试用这个模型做点实际的项目，比如给视频自动加字幕，或者做个语音笔记应用，应该会挺有意思的。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。