1. 前言

市面上有哪些主流开源语音模型，各自简单介绍一下。

2026 年，开源语音识别（ASR）领域已进入"大模型时代"，出现了多个各具特色的开源模型和框架。以下按功能定位和使用场景进行概览。

1.1 主流开源语音模型全景

模型开发方参数量语言覆盖核心优势推荐场景
WhisperOpenAI39M–1.5B99 种端侧生态最成熟、多语言多语言批量转录、端侧
Qwen3-ASR阿里通义600M/1.7B52 种（含 22 种方言）方言覆盖最广、中文 SOTA中文方言识别、服务端
Paraformer/FunASR阿里达摩院220M中文为主非自回归、速度快约 10 倍中文实时流式
SenseVoice阿里通义234M多语言情感+事件+ASR 一体化多功能中文处理
FireRedASR小红书1.1B/8.3B中文+20 方言中文精度最高（CER 0.57%）高精度中文场景
NVIDIA NeMoNVIDIA600M–2.5B4–40 种企业级平台、高并发流式英文生产部署、流式服务
sherpa-onnx深圳大学依赖模型中文优化跨平台端侧部署（12 种语言）手机/嵌入式离线

1.2 各模型详细介绍

Whisper (OpenAI)
  • 发布： 2022 年，彻底改变了开源 ASR 领域
  • 语言： 支持 99 种语言自动检测
  • 模型规格： tiny (39M)、base (74M)、small (244M)、medium (769M)、large-v3 (1.5B)、large-v3-turbo (809M)
  • 开源协议： MIT（最自由，可自由商用）
  • 端侧生态： whisper.cpp（47.5k Star，纯 C/C++ 无依赖）、faster-whisper、WhisperX
  • Distil-Whisper Large v3： 保留约 99% 原始精度，推理速度约 6 倍提升
  • 中文精度： 弱于国产方案（AISHELL-1 上 CER ~4.5–5.14%）
  • 适用场景： 多语言批量转录、端侧离线部署、开发测试基线
Qwen3-ASR (阿里通义)
  • 发布： 2026 年 1 月，基于 Qwen3-Omni 基础模型重新训练
  • 语言： 30 种语言 + 22 种中文方言（粤语、吴语、闽南语、四川话、山东话、河南话等）
  • 模型规格： 0.6B（~1.79 GiB）和 1.7B（~4.38 GiB）两个版本
  • 开源协议： Apache 2.0（可免费商用）
  • 核心优势： Qwen3-ASR-1.7B 在开源 ASR 中达到 SOTA，与商业闭源 API 具有竞争力；支持 vLLM 后端部署，0.6B 在 128 并发下吞吐量达 2000x 实时率
  • 适用场景： 中文方言识别（覆盖最广）、服务端高质量转写、会议转录、长音频处理
Paraformer / FunASR (阿里达摩院)
  • FunASR 项目： 15.2k Star，提供统一的 AutoModel 接口
  • 架构： 非自回归（Non-Autoregressive）端到端 ASR，相比自回归解码推理速度快约 10 倍
  • 中文精度： AISHELL-1 上 CER 仅 1.95%，中文精度领先
  • 配套工具链： Fsmn-VAD（语音活动检测）、ct-punc（标点恢复）、Cam++（说话人分离）、emotion2vec（情感识别）
  • 端侧部署： sherpa-onnx 可将 Paraformer 部署到 iOS/Android/鸿蒙/树莓派/RISC-V/WebAssembly
  • 适用场景： 中文实时流式转录、服务端快速部署（pip install funasr 三行代码跑通）、中文输入法、客服录音转写
SenseVoice (阿里通义)
  • 发布： 2024 年 7 月，一个模型同时完成 ASR + 情感识别 + 音频事件检测
  • 推理速度： 处理 10 秒音频仅需 70ms，比 Whisper-Large 快约 15 倍
  • 内置能力： 语种识别（LID）、情感识别（SER）、音频事件检测（AED）
  • 中文精度： AISHELL-1 上 CER 约 3.0%，多语言精度与 Whisper-Small 相当
  • 适用场景： 多功能中文语音处理、移动端离线部署、智能客服（情感感知）
FireRedASR (小红书)
  • 发布： 2026 年 2 月发布 v2，中文公开基准精度第一
  • 版本： LLM 版本（8.3B）和 AED 版本（1.1B）
  • 中文精度： AISHELL-1 上 AED 版本 CER 仅 0.57%，LLM 版本普通话平均 CER 2.89%
  • 适用场景： 对中文精度要求极高的生产环境、会议逐字稿、客服质检、歌词识别

2. Qwen3-ASR 主要功能与作用

2.1 核心功能

语音识别（ASR）

  • 支持 52 类语言与方言：30 种语言 + 22 种中文方言（普通话、粤语、吴语、闽南语、四川话、山东话、河南话、东北话、安徽话、天津话、福建话、甘肃话、贵州话、河北话、湖北话、湖南话、江西话、宁夏话、陕西话、山西话、云南话、浙江话等）
  • 支持语种自动识别（Language Identification）
  • 支持强制指定输出语言
  • 原生支持标点恢复，无需单独的标点模型
  • 原生支持时间戳输出

其他音频能力

  • 语音情感识别（SER）： 可识别语音中的情感倾向（高兴、悲伤、愤怒等）
  • 音频事件检测（AED）： 识别环境音、音乐等音频事件
  • 说话人分离： 支持多人对话场景理解
  • 流式识别： 支持低延迟流式音频交互，即时文本输出

2.2 模型版本与定位

模型参数量权重大小RTF适用场景
Qwen3-ASR-0.6B600M~1.79 GiB0.00923（单并发）端侧部署、边缘设备、高并发低延迟
Qwen3-ASR-1.7B1700M~4.38 GiB0.01482（单并发）云端服务器、最高精度
Qwen3-ForcedAligner-0.6B600M-3 分钟音频 1.7 秒强制语音对齐（音素级时间戳）

2.3 特色能力

热词增强（Hotword Boosting）

  • 支持通过 prompt 传入热词（专业术语优化）
  • 热词在模型推理时注入，相比传统 CTC 热词注入更灵活（支持自定义 LLM prompt 塞入业务上下文）

FormalASR 微调版

  • FormalASR 是基于 Qwen3-ASR-1.7B 微调的紧凑型端到端模型
  • 直接将口语转写为书面文本：去除填充词、重组句式、规范标点
  • 无需额外 LLM 后处理步骤，适合设备端部署
  • 相比原始 Qwen3-ASR-1.7B，平均输出 token 减少 22.8%
  • 长句（40–49 token）延迟减少约 388ms

强制对齐

  • 附带 Qwen3-ForcedAligner-0.6B 专门强制对齐模型
  • 支持 11 种语言、最长 5 分钟的语音时间戳预测
  • 精度超越 E2E 对齐模型

3. Qwen3-ASR 部署使用方式

3.1 安装方式

方式一：pip 安装

pip install qwen-omni-asr

方式二：从源码安装

git clone https://github.com/QwenLM/Qwen3-ASR.git
cd Qwen3-ASR
pip install -e .

方式三：Docker 部署

docker pull ghcr.io/qwenlm/qwen3-asr:latest
docker run -p 8000:8000 ghcr.io/qwenlm/qwen3-asr:latest

3.2 支持的硬件

硬件类型推荐模型最低要求
NVIDIA GPUQwen3-ASR-1.7B16GB 显存
CPUQwen3-ASR-0.6B8GB 内存
ARM64 边缘设备Qwen3-ASR-0.6B INT84GB 内存
Rockchip NPUQwen3-ASR-0.6B INT8RK3588

3.3 API 接口方式

REST API 接口

# 启动服务
python -m qwen_asr.server --model Qwen3-ASR-1.7B --port 8000

# 调用 API
curl -X POST http://localhost:8000/asr \
  -F "audio=@recording.wav" \
  -F "language=zh" \
  -F "hotwords=['人工智能', '语音识别']"

gRPC 接口

import grpc
import qwen_asr_pb2
import qwen_asr_pb2_grpc

channel = grpc.insecure_channel('localhost:50051')
stub = qwen_asr_pb2_grpc.ASRStub(channel)

with open('recording.wav', 'rb') as f:
    audio_data = f.read()

request = qwen_asr_pb2.ASRRequest(
    audio=audio_data,
    language='zh',
    stream=True,
    hotwords=['人工智能']
)

for response in stub.Recognize(request):
    print(response.text)

Python 本地调用

from qwen_asr import QwenASR

# 加载模型
model = QwenASR.from_pretrained("Qwen/Qwen3-ASR-1.7B")

# 离线识别
result = model.transcribe("recording.wav")
print(result.text)        # 转录文本
print(result.words)       # 逐词时间戳
print(result.language)    # 识别语言

# 流式识别
for chunk in model.transcribe_stream(audio_generator()):
    print(chunk.text)     # 实时输出

3.4 推理加速方案

INT8 量化效果

模型FP32 大小INT8 大小精度损失
Qwen3-ASR-0.6B~600MB~200MBCER +0.3%
Qwen3-ASR-1.7B~3.4GB~900MBCER +0.5%

量化感知训练（QAT）： Qwen3-ASR 在训练阶段已启用 QAT，模型权重适应 INT8 数值分布，所以 INT8 量化后 CER 仅上升 0.28–0.3%，远优于后训练量化（PTT）的效果。

推理加速框架

  • vLLM： 推荐方案，支持高并发部署。0.6B 在 128 并发下吞吐量达 2000x 实时率
  • TensorRT-LLM： NVIDIA 推荐方案，对 Transformer 架构优化最佳，可实现 2–4x 加速
  • ONNX Runtime： 跨平台最优选择，支持 CPU/GPU/NPU
  • OpenVINO： Intel CPU/GPU 端侧加速

3.5 最小硬件配置

场景CPU内存显存推荐模型
开发测试（CPU）4 核8 GB无Qwen3-ASR-0.6B
生产部署（GPU）8 核16 GB16 GBQwen3-ASR-1.7B
端侧部署（ARM64）ARM 64-bit4 GB无Qwen3-ASR-0.6B INT8
边缘设备（NPU）RK35884 GBNPU 6 TOPSQwen3-ASR-0.6B INT8

4. 客户端测试工具

以下提供一个完整的 Python 客户端测试工具，支持 Qwen3-ASR 的各种识别模式：

4.1 基础离线识别工具

"""
Qwen3-ASR 客户端测试工具
支持离线识别、流式识别、批量处理等功能
"""

import argparse
import asyncio
from pathlib import Path
from qwen_asr import QwenASR
import json
from datetime import datetime


class QwenASRTester:
    """Qwen3-ASR 测试工具类"""

    def __init__(self, model_path: str, device: str = "auto"):
        """
        初始化测试器

        Args:
            model_path: 模型路径或模型 ID（如 "Qwen/Qwen3-ASR-1.7B"）
            device: 运行设备（"auto" / "cuda" / "cpu"）
        """
        self.model = QwenASR.from_pretrained(
            model_path,
            device=device,
            torch_dtype="auto"
        )
        self.results = []

    def transcribe_file(self, audio_path: str, language: str = None,
                        hotwords: list = None) -> dict:
        """
        对单个音频文件进行离线识别

        Args:
            audio_path: 音频文件路径
            language: 指定语言代码（如 "zh"、"en"、"yue"）
            hotwords: 热词列表

        Returns:
            包含文本、时间戳、语言等信息的字典
        """
        kwargs = {}
        if language:
            kwargs["language"] = language
        if hotwords:
            kwargs["hotwords"] = hotwords

        result = self.model.transcribe(audio_path, **kwargs)

        output = {
            "file": audio_path,
            "text": result.text,
            "language": result.language,
            "duration": result.duration,
            "timestamp": datetime.now().isoformat()
        }

        # 如果有逐词时间戳
        if hasattr(result, 'words') and result.words:
            output["words"] = [
                {"word": w["text"], "start": w["start"], "end": w["end"]}
                for w in result.words
            ]

        self.results.append(output)
        return output

    def transcribe_directory(self, dir_path: str, **kwargs) -> list:
        """
        批量识别目录下的所有音频文件

        Args:
            dir_path: 音频文件目录路径
            **kwargs: 传递给 transcribe_file 的额外参数

        Returns:
            所有文件的识别结果列表
        """
        supported_extensions = {'.wav', '.mp3', '.flac', '.m4a', '.ogg'}
        audio_files = Path(dir_path).rglob('*')
        audio_files = [
            f for f in audio_files
            if f.suffix.lower() in supported_extensions and f.is_file()
        ]

        results = []
        for audio_file in sorted(audio_files):
            print(f"正在处理: {audio_file}")
            try:
                result = self.transcribe_file(str(audio_file), **kwargs)
                results.append(result)
                print(f"  结果: {result['text'][:50]}...")
            except Exception as e:
                print(f"  错误: {e}")
        return results

    def test_latency(self, audio_path: str, num_runs: int = 5) -> dict:
        """
        测试识别延迟

        Args:
            audio_path: 音频文件路径
            num_runs: 测试轮数

        Returns:
            平均延迟、P50、P95、P99 等统计信息
        """
        import time
        latencies = []

        for i in range(num_runs):
            start = time.perf_counter()
            self.model.transcribe(audio_path)
            elapsed = time.perf_counter() - start
            latencies.append(elapsed)

        latencies.sort()
        n = len(latencies)
        return {
            "audio_file": audio_path,
            "num_runs": num_runs,
            "avg_latency_ms": round(sum(latencies) / n * 1000, 2),
            "min_latency_ms": round(min(latencies) * 1000, 2),
            "max_latency_ms": round(max(latencies) * 1000, 2),
            "p50_ms": round(latencies[int(n * 0.5)] * 1000, 2),
            "p95_ms": round(latencies[int(n * 0.95)] * 1000, 2),
            "p99_ms": round(latencies[int(n * 0.99)] * 1000, 2),
        }


def main():
    parser = argparse.ArgumentParser(description="Qwen3-ASR 客户端测试工具")
    parser.add_argument("--model", type=str, default="Qwen/Qwen3-ASR-1.7B",
                        help="模型路径或模型 ID")
    parser.add_argument("--file", type=str, help="单个音频文件路径")
    parser.add_argument("--dir", type=str, help="批量处理的音频目录")
    parser.add_argument("--language", type=str, help="指定语言代码")
    parser.add_argument("--hotwords", type=str, nargs="*",
                        help="热词列表（空格分隔）")
    parser.add_argument("--device", type=str, default="auto",
                        choices=["auto", "cuda", "cpu"])
    parser.add_argument("--latency-test", type=str,
                        help="延迟测试模式，指定音频文件")
    parser.add_argument("--latency-runs", type=int, default=5,
                        help="延迟测试轮数")
    parser.add_argument("--output", type=str, help="结果输出文件路径（JSON）")

    args = parser.parse_args()

    tester = QwenASRTester(model_path=args.model, device=args.device)

    # 延迟测试模式
    if args.latency_test:
        stats = tester.test_latency(args.latency_test, args.latency_runs)
        print(json.dumps(stats, indent=2, ensure_ascii=False))
        return

    # 单文件模式
    if args.file:
        result = tester.transcribe_file(
            args.file,
            language=args.language,
            hotwords=args.hotwords
        )
        print(json.dumps(result, indent=2, ensure_ascii=False))

    # 批量模式
    elif args.dir:
        results = tester.transcribe_directory(
            args.dir,
            language=args.language,
            hotwords=args.hotwords
        )
        print(f"共处理 {len(results)} 个文件")

    # 输出保存
    if args.output:
        with open(args.output, 'w', encoding='utf-8') as f:
            json.dump(tester.results, f, indent=2, ensure_ascii=False)
        print(f"结果已保存到: {args.output}")


if __name__ == "__main__":
    main()

4.2 使用示例

# 单文件识别（中文）
python asr_tester.py --model Qwen/Qwen3-ASR-1.7B --file demo.wav --language zh

# 单文件识别（粤语）
python asr_tester.py --model Qwen/Qwen3-ASR-1.7B --file cantonese.wav --language yue

# 带热词识别
python asr_tester.py --file meeting.wav --language zh --hotwords "人工智能" "大语言模型"

# 批量处理
python asr_tester.py --dir ./audio_files/ --language zh --output results.json

# 延迟测试（5 轮）
python asr_tester.py --latency-test test.wav --latency-runs 5 --device cuda

4.3 流式识别测试工具

"""
流式识别测试工具 - 演示实时语音识别
"""

import asyncio
import pyaudio
from qwen_asr import QwenASR


class StreamASRTester:
    """流式识别测试"""

    def __init__(self, model_path: str = "Qwen/Qwen3-ASR-0.6B"):
        self.model = QwenASR.from_pretrained(model_path)
        self.chunks = []

    async def stream_recognize(self, audio_generator, language: str = "zh"):
        """
        流式识别

        Args:
            audio_generator: 音频数据生成器，yield 音频 chunk
            language: 语言代码
        """
        for audio_chunk in audio_generator:
            result = await self.model.transcribe_stream(
                audio_chunk,
                language=language
            )
            self.chunks.append(result)
            yield result

    def summarize(self) -> dict:
        """汇总流式识别结果"""
        total_text = "".join(c.text for c in self.chunks)
        return {
            "chunk_count": len(self.chunks),
            "total_text": total_text,
            "avg_chunk_duration": (
                sum(c.duration for c in self.chunks) / len(self.chunks)
                if self.chunks else 0
            )
        }


async def mic_audio_generator():
    """从麦克风采集音频"""
    CHUNK = 1024
    FORMAT = pyaudio.paInt16
    CHANNELS = 1
    RATE = 16000

    p = pyaudio.PyAudio()
    stream = p.open(
        format=FORMAT,
        channels=CHANNELS,
        rate=RATE,
        input=True,
        frames_per_buffer=CHUNK
    )

    print("🎤 正在从麦克风采集音频...（按 Ctrl+C 停止）")
    try:
        while True:
            data = stream.read(CHUNK)
            yield data
    except KeyboardInterrupt:
        print("\n停止采集")
    finally:
        stream.stop_stream()
        stream.close()
        p.terminate()


async def main():
    tester = StreamASRTester()
    async for result in tester.stream_recognize(
        mic_audio_generator(),
        language="zh"
    ):
        print(f"实时输出: {result.text}")


if __name__ == "__main__":
    asyncio.run(main())

5. Qwen3-ASR 在语音输入法软件方面的应用

5.1 语音输入法的技术架构演进

传统语音输入流程
音频采集 → 预处理(降噪/VAD) → 特征提取(MFCC/Filterbank) → 声学模型 → 语言模型 → 解码 → 后处理

传统方案的总延迟为：VAD 检测 100–300ms + ASR 推理 500–2000ms + 语言模型 200–800ms + 后处理 100–500ms，总计约 1.5–5 秒。

大模型时代的语音输入法变化

趋势一：ASR + LLM 双引擎架构成为主流

音频采集 → 云端/本地 ASR → 转录文本 → LLM 润色(去口癖/纠错/格式化) → 插入光标位置

趋势二：输入法 OS 级集成

  • 豆包输入法： Seed-ASR 2.0，0.8 秒低延迟，150MB 离线模型
  • 千问输入法（阿里）： 2026 年 5 月上线 PC 端
  • Google Gboard： 内置 Gemini Live，Android 默认输入法覆盖 10 亿+ 用户
  • CosyVoice 输入法（阿里）： 2026 年 6 月发布，支持方言识别

趋势三：从"逐字转写"到"理解意图"

AI 不再只是转录语音，还理解用户意图：

  • 语音段分类为 content（内容输入）、edit（编辑）、send（发送）、undo（撤销）
  • 支持自然语言修正指令"不对"“改成”“删掉刚才那句”

5.2 Qwen3-ASR 在语音输入法中的集成方案

方案 A：云端 API 模式
用户说话 → 音频上传 → 云端 Qwen3-ASR → 转录文本 → LLM 润色 → 插入光标

适用于个人用户使用，部署成本低，无需 GPU。

方案 B：自部署服务器（团队/企业）
┌──────────────┐     WebSocket      ┌────────────────────────┐
│  Tauri 桌面   │ ◄────────────────► │  FastAPI + Qwen3-ASR   │
│  客户端       │                   │  vLLM 推理 + GPU        │
└──────────────┘                   │  NVIDIA GPU ≥16GB 显存  │
                                   └────────────────────────┘
  • 后端使用 FastAPI + WebSocket 提供流式识别
  • 测试数据（AWS g5.xlarge，NVIDIA A10G）：30s 音频 ASR 延迟 ~0.8s，RTF 0.025
方案 C：纯端侧离线部署

通过 sherpa-onnx 加载 Qwen3-ASR 的 INT8 量化模型：

音频采集 → sherpa-onnx (Qwen3-ASR-0.6B int8) → 文本输出
  • 模型大小约 200MB（INT8 量化）
  • 数据完全不出设备，适合隐私敏感场景

5.3 中文语音识别的优化策略

热词增强：Qwen3-ASR 支持通过 prompt 传入热词，修改热词需重启程序（LLM 架构特性）。

FormalASR 微调：基于 Qwen3-ASR-1.7B 微调的紧凑型模型，直接将口语转写为书面文本，适合设备端部署。

标点恢复：Qwen3-ASR 原生支持标点预测，无需单独的标点模型。

5.4 性能优化方案

优化手段节省延迟
端侧 VAD（Silero）替代云端 VAD节省 100–300ms
流式 ASR 而非批量模式节省首 Token 延迟 500–2000ms
关闭 Beam Search（num_beams=1）延迟降低 60%，CER 影响 <0.2%
KV Cache 复用减少重复计算

5.5 开源参考项目

项目技术栈特点
SayItTauri + vLLM + Qwen3-ASR最完整的参考实现
ChatyInput跨平台 + LLM意图识别 + 智能编辑
HashtypeAndroid IME + Flutter多种 STT 后端
fcitx5-vinputLinux Fcitx5 插件本地+云端 ASR 切换
voice-input-methodCLI + GUI支持 5 种 ASR 后端

6. 结束语

开源语音识别模型在 2026 年已进入了百花齐放的时代。从 Whisper 的多语言通用能力，到 Qwen3-ASR 的中文方言全覆盖，再到 FireRedASR 的极致中文精度，每个模型都在特定方向上做出了差异化优势。

对于语音输入法这样的应用场景，Qwen3-ASR 凭借 52 种语言/方言的覆盖、支持流式识别、INT8 量化后仅需 200MB、以及 vLLM 推理加速等特性，已经成为开源语音输入法的理想选择之一。结合 FormalASR 微调版和热词注入能力，甚至可以定制出面向特定领域或特定用户的语音输入方案。

随着端侧算力不断提升和模型压缩技术持续发展，未来的语音输入法将更加智能化、个性化和低延迟化。

参考资料

# 语音识别 # 人工智能
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

程序员学 AI（八）：AI Agent 到底是什么？从回答问题到完成任务

avatar AI Agent技术社区
cover

22道AI Agent 工程师必会的面试题，别啥都不会就出去找工作

avatar AI Agent技术社区

写给 TypeScript 工程师的 OpenClaw.NET 上手指南：用你熟悉的 TS 思维，跑起一个生产级 AI Agent

读代码层：TS 和 C# 本来就是「远房亲戚」——asyncawait??、接口、泛型、严格空检查，你的心智模型几乎无缝平移。真正要适应的只有两件事：类型是具名而非结构化的（多一句显式声明），以及 NativeAOT 下的「禁反射」约束。写扩展层：你甚至可以不怎么碰 C#——Node.js 插件桥意味着你的 TypeScript 插件就是一等公民，而且能在生产 aot 车道跑。内核给你 .NET

avatar AI Agent技术社区