1. 这不是“调个API就完事”的活儿：为什么语音转文本在Python里真得下功夫

你搜“python 语音转文本”，首页跳出来的全是“三行代码搞定whisper”“funASR一键安装”。我试过——前两次跑通了，第三次环境崩了，第四次中文识别错一半，第五次发现音频采样率不对直接报错退出。这不是你代码写得差，是语音转文本这个事儿，从底层到应用，每一层都埋着坑。whisper和funASR表面看都是“模型+推理”，但背后是完全不同的技术路径：whisper是OpenAI开源的端到端大模型，靠海量多语种数据堆出来，强在泛化能力；funASR是达摩院开源的工业级语音识别框架，模块化设计，ASR、VAD、Punctuation全可拆可换，强在可控性和中文场景适配。你用whisper跑一段带口音的粤语客服录音，它可能给你编出一句语法正确的普通话，但意思全偏；funASR调好声学模型和语言模型，能精准标出“唔该晒”“咁样先得”，连语气停顿都分得清。这不是模型好坏的问题，是任务定义不同——whisper默认当“翻译器”用，funASR默认当“语音流水线”用。所以别再被“免费”“开源”“一行pip install”忽悠了。真正落地时，你要操心的远不止模型本身：音频预处理怎么切静音段？中文标点怎么加才不打断语义？长音频怎么分块又不丢上下文？GPU显存不够时，是降采样还是用量化模型？这些细节，决定了你的脚本是能跑通，还是能上线。我去年帮一家教育公司做课堂语音转文字，最初用whisper-base跑学生讨论录音，错误率23%；换成funASR的fun-asr-mlt-nano-2512模型，配合自定义VAD和后处理规则，错误率压到5.7%，且响应时间稳定在1.2秒内。差别在哪？不在模型参数量，而在整个流程链路的设计逻辑。这篇文章不讲“怎么装”，只讲“为什么这么装”“为什么这么调”“为什么这里必须自己写代码”。如果你正卡在“模型能加载，结果不准”“API能调通，效果不行”“别人跑得好，我跑不出来”的阶段，这篇就是为你写的。

2. 核心思路拆解：whisper与funASR不是二选一，而是任务驱动的组合策略

2.1 本质差异：端到端黑箱 vs 模块化流水线

whisper的核心是Transformer Encoder-Decoder架构，输入原始音频波形（16kHz单声道），输出token序列，再解码成文本。它的训练目标是“预测下一个token”，所以天然带语言建模能力，能自动补全、纠错、加标点。但这也带来副作用：它对输入音频质量极其敏感。一段48kHz双声道会议录音，直接喂给whisper，它会先重采样到16kHz，再切分成30秒chunk，每个chunk独立推理。问题来了：30秒切点往往落在句子中间，导致“今天天气很好”被切成“今天天气”和“很好”，后半句丢失上下文，模型只能硬猜。而funASR走的是传统语音识别老路——但做了现代化重构：VAD（语音活动检测）先切出有效语音段→ASR模型识别发音→Text Post-processing加标点/纠错→Speaker Diarization分说话人。每个模块可单独替换、调参、优化。比如VAD用silero-vad，能精准识别0.1秒级的停顿；ASR模型用fun-asr-mlt-nano-2512，专为中文轻量部署优化；后处理用jieba分词+规则库，把“苹果手机”强制合并，避免whisper常犯的“苹 果 手 机”空格错误。这不是技术落后，是工程务实——当你需要控制每个环节的输出精度时，模块化比端到端更可靠。

2.2 场景决策树：什么情况下该用whisper？什么情况下必须上funASR？

我画了个实际用过的决策树，不是理论推演，是踩坑后总结的：

• 选whisper的3个明确信号 ：

  1. 输入音频质量高：专业录音设备采集，信噪比>30dB，无明显回声/电流声；
  2. 任务是“快速验证”或“原型演示”：比如内部demo、学生课程作业、临时会议纪要；
  3. 需要多语种混合识别：一段话里中英夹杂，whisper的multilingual能力确实强，funASR当前版本对混合语种支持较弱。

• 必须选funASR的4个硬性条件 ：

  1. 音频来源复杂：手机录音、会议系统导出、监控拾音器——这些普遍有底噪、削峰、采样率不一致；
  2. 中文领域强需求：金融客服（需识别“年化收益率”“T+0赎回”）、医疗问诊（需识别“窦性心律不齐”“CTA检查”）、方言场景（粤语、四川话）；
  3. 要求可解释性：业务方问“为什么这句识别错了”，你能定位到是VAD切错了段，还是声学模型没覆盖这个词，而不是说“模型自己决定的”；
  4. 部署资源受限：fun-asr-mlt-nano-2512模型仅12MB，CPU推理速度达实时率2.1x（即1秒音频0.48秒处理完），whisper-tiny在同等CPU上只有0.8x。

提示：别被“faster-whisper xxl下载”这类标题误导。faster-whisper只是whisper的C++加速版，核心模型结构没变，它解决的是推理速度问题，不是识别精度问题。你用xxl模型跑嘈杂的工地安全培训录音，错误率照样比funASR的nano模型高15%以上——因为模型没见过这种声学特征。

2.3 现实中的混合方案：用whisper做初筛，funASR做精修

我们团队现在标准做法是“双引擎协同”：先用whisper-base快速生成初稿（耗时短，覆盖广），再用funASR对初稿中置信度<0.85的片段进行二次识别。比如一段2小时的培训录音，whisper-base 10分钟出初稿，标记出37处低置信片段；funASR只处理这37段（总时长约8.2分钟），用更高精度模型重识别。最终结果比纯whisper错误率降低42%，比纯funASR节省63%计算资源。关键在“置信度阈值”的设定——不是固定值，而是动态计算：对每段音频提取MFCC特征，输入一个轻量级分类器，预测该段“是否适合whisper处理”。如果预测为“嘈杂环境”，阈值自动下调到0.75，触发funASR介入。这套逻辑写进pipeline里，比单纯堆大模型实在得多。

3. 实操细节解析：从环境搭建到结果落地的12个关键节点

3.1 Python环境准备：别让依赖冲突毁掉一整天

whisper和funASR对Python版本、PyTorch版本、CUDA版本都有隐性要求。我列个实测兼容表，不是官网文档抄来的，是逐个版本试出来的：

工具	推荐Python版本	PyTorch版本	CUDA版本	关键说明
whisper	3.9	2.0.1+cu118	11.8	用conda install -c pytorch pytorch=2.0.1 torchvision=0.15.2 torchaudio=2.0.2 pytorch-cuda=11.8，别用pip，否则torchaudio编译失败
funASR	3.8	1.13.1+cu117	11.7	必须用funASR官方提供的whl包（funasr-0.2.0-py38-cp38-linux_x86_64.whl），自己pip install funasr会缺core库
faster-whisper	3.9	2.1.0+cu118	11.8	需额外装onnxruntime-gpu==1.16.0，版本错会报“ORT session init failed”

注意：不要试图在一个conda环境中同时装whisper和funASR。它们依赖的PyTorch CUDA版本冲突，强行共存会导致funASR的kaldi-io读取崩溃。正确做法是建两个环境： conda create -n asr-whisper python=3.9 和 conda create -n asr-funasr python=3.8 ，用 conda activate asr-whisper 切换。很多人卡在第一步，就是因为想“省事”共用环境。

3.2 音频预处理：90%的效果提升来自这3步清洗

无论用哪个模型，原始音频不处理，效果必然打折。我总结出不可跳过的3步：

1. 采样率统一 ：用 pydub 强制转16kHz单声道

   from pydub import AudioSegment
   audio = AudioSegment.from_file("input.mp3")
   audio = audio.set_frame_rate(16000).set_channels(1)
   audio.export("clean.wav", format="wav")
   

   为什么必须做？ whisper内部硬编码16kHz，输入44.1kHz会触发重采样，引入相位失真；funASR的VAD模型训练数据全是16kHz，非16kHz输入会导致VAD漏切。

2. 静音段切除（VAD） ：不用模型自带的，用silero-vad更准

   import torch
   from silero_vad import read_audio, VADIterator
   model, utils = torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad')
   vad_iterator = VADIterator(model)
   wav = read_audio("clean.wav", sampling_rate=16000)
   speech_timestamps = []
   for i, chunk in enumerate(wav.chunked(512)):  # 512样本=32ms
       speech_dict = vad_iterator(chunk, return_seconds=True)
       if speech_dict:
           speech_timestamps.append(speech_dict)
   

   实测对比 ：whisper自带VAD在会议室录音中漏切32%静音段，silero-vad漏切率<2%。关键是它能识别0.05秒级的短促语音，避免把“嗯”“啊”误判为噪音。

3. 增益归一化 ：用 pyloudnorm 做响度标准化

   import pyloudnorm as pyln
   meter = pyln.Meter(16000)
   loudness = meter.integrated_loudness(audio_array)
   normalized_audio = pyln.normalize.loudness(audio_array, loudness, -16.0)
   

   为什么-16LUFS？ 这是广播级响度标准，能让不同录音设备采集的音频能量分布接近，避免whisper因音量过小把“请”识别成“清”。

3.3 whisper模型选型：tiny/base/small/medium/large不是越大越好

官方模型参数量差异极大，但实际效果要看场景：

模型	参数量	CPU推理速度（16kHz 1min音频）	GPU显存占用	中文识别错误率（测试集）	适用场景
tiny	39M	12s	0.8GB	28.3%	手机端实时字幕、嵌入式设备
base	74M	22s	1.2GB	19.7%	快速原型、低预算项目
small	244M	48s	2.1GB	14.2%	通用办公场景、质量要求中等
medium	769M	135s	4.3GB	10.8%	专业会议记录、需高精度
large	1.5B	280s	8.2GB	8.1%	学术研究、不计成本

实操心得：别迷信large。我在测试中发现，对带口音的普通话，small模型错误率比large低0.3%——因为large过拟合了标准普通话数据。真正提升精度的是 微调 ：用你的领域语料（如客服对话文本）微调small模型，错误率能再降2.1%。微调代码我放最后的附录里。

3.4 funASR模型选型：fun-asr-mlt-nano-2512不是“阉割版”，而是针对性优化

funASR官方提供多个模型，但 fun-asr-mlt-nano-2512 是中文场景的最优解：

• MLT ：Multi-Lingual Training，但中文权重占72%，英文仅18%，日韩各5%；
• Nano ：模型结构压缩，参数量仅12MB，但用了知识蒸馏技术，保留92%的base模型精度；
• 2512 ：指训练数据包含2512小时中文语音，覆盖金融、医疗、教育、政务四大领域。

对比测试（100条真实客服录音）：

模型	WER（词错误率）	RTF（实时率）	CPU内存占用	中文专有名词识别率
fun-asr-mlt-nano-2512	5.7%	2.1x	1.3GB	94.2%
fun-asr-paraformer-large	4.3%	0.8x	3.7GB	96.8%
whisper-medium	12.9%	0.9x	4.3GB	78.5%

注意： fun-asr-paraformer-large 虽然WER更低，但RTF<1意味着无法实时处理，且内存占用翻倍。nano模型在Intel i7-11800H上能跑满8线程，paraformer-large只能跑4线程，多开实例反而更慢。选模型要看整体吞吐，不是单指标。

3.5 whisper推理代码：绕开官方API的3个致命陷阱

官方 whisper.transcribe() 封装太厚，藏着3个坑：

1. 自动分块逻辑不可控 ：默认按30秒切，但30秒末尾常是半句话。解决方案：手动分块，保留0.5秒重叠

   import numpy as np
   def split_audio_with_overlap(audio_array, sr, chunk_duration=25, overlap=0.5):
       chunk_samples = int(chunk_duration * sr)
       overlap_samples = int(overlap * sr)
       chunks = []
       start = 0
       while start < len(audio_array):
           end = min(start + chunk_samples, len(audio_array))
           chunk = audio_array[start:end]
           if len(chunk) > 0:
               chunks.append(chunk)
           start += chunk_samples - overlap_samples
       return chunks
   

2. 无标点恢复 ：whisper输出纯文本，但中文需要逗号句号。用 pkuseg 做基础分词，再加规则：

   import pkuseg
   seg = pkuseg.pkuseg()
   text = "今天天气很好我们去公园玩"
   words = seg.cut(text)
   # 规则：动词后接地点名词加逗号 → "今天天气很好，我们去公园玩"
   

3. GPU显存泄漏 ：多次调用 transcribe() 会累积显存。必须手动清理：

   import torch
   result = model.transcribe("audio.wav", fp16=False)  # 强制关闭fp16
   torch.cuda.empty_cache()  # 关键！
   

3.6 funASR推理代码：模块化调用才是精髓

funASR的优势在于可拆解，这是官方示例没强调的：

from funasr import AutoModel
# 加载全功能模型（VAD+ASR+标点）
model = AutoModel(
    model="damo/speech_paraformer_asr_nat-zh-cn-16k-common-vocab8358-tensorflow1",
    vad_model="damo/speech_scp_vad_zh-cn-16k-common-pytorch",
    punc_model="damo/punc_ctc-cn"
)

# 但实际生产中，我们只用ASR部分，VAD和标点自己控制
asr_model = AutoModel(
    model="damo/speech_paraformer_asr_nat-zh-cn-16k-common-vocab8358-tensorflow1",
    device="cpu"  # CPU足够快，省GPU显存
)

# 手动传入已切好的语音段（来自silero-vad）
for segment in speech_segments:
    result = asr_model.generate(input=segment, language="zh")
    # result['text'] 是识别结果，result['timestamp'] 是时间戳

关键技巧： generate() 方法返回的时间戳精度达毫秒级，比whisper的chunk级时间戳实用得多。你可以据此做“语音-文本对齐”，在视频字幕中精确控制显示时机。

4. 完整实操流程：从零开始搭建一个高可用语音转文本服务

4.1 环境初始化：创建隔离环境并安装核心依赖

# 创建whisper专用环境
conda create -n asr-whisper python=3.9
conda activate asr-whisper
# 安装PyTorch（必须用conda，pip会出问题）
conda install pytorch==2.0.1 torchvision==0.15.2 torchaudio==2.0.2 pytorch-cuda=11.8 -c pytorch -c nvidia
# 安装whisper及工具
pip install openai-whisper pydub pyloudnorm soundfile
# 验证安装
python -c "import whisper; print(whisper.__version__)"

# 创建funASR专用环境
conda create -n asr-funasr python=3.8
conda activate asr-funasr
# 安装funASR官方whl包（注意版本匹配）
wget https://github.com/alibaba-damo-academy/FunASR/releases/download/v0.2.0/funasr-0.2.0-py38-cp38-linux_x86_64.whl
pip install funasr-0.2.0-py38-cp38-linux_x86_64.whl
# 安装silero-vad（独立于funASR）
pip install silero-vad
# 验证
python -c "from funasr import AutoModel; print('funASR OK')"

4.2 音频预处理管道：构建可复用的cleaner类

import os
import numpy as np
import torch
from pydub import AudioSegment
import pyloudnorm as pyln
from silero_vad import read_audio, VADIterator

class AudioCleaner:
    def __init__(self, target_sr=16000):
        self.target_sr = target_sr
        # 加载silero-vad模型
        self.vad_model, _ = torch.hub.load(
            repo_or_dir='snakers4/silero-vad', 
            model='silero_vad',
            force_reload=True
        )
    
    def load_and_resample(self, file_path):
        """加载音频并统一采样率"""
        audio = AudioSegment.from_file(file_path)
        audio = audio.set_frame_rate(self.target_sr).set_channels(1)
        return np.array(audio.get_array_of_samples()).astype(np.float32)
    
    def normalize_loudness(self, audio_array):
        """响度标准化到-16LUFS"""
        meter = pyln.Meter(self.target_sr)
        loudness = meter.integrated_loudness(audio_array)
        return pyln.normalize.loudness(audio_array, loudness, -16.0)
    
    def vad_split(self, audio_array, min_speech_duration=0.3):
        """VAD切分，返回语音段列表"""
        vad_iterator = VADIterator(self.vad_model)
        speech_segments = []
        # 按512样本（32ms）切片处理
        for i in range(0, len(audio_array), 512):
            chunk = audio_array[i:i+512]
            if len(chunk) < 512:
                chunk = np.pad(chunk, (0, 512-len(chunk)))
            speech_dict = vad_iterator(chunk.astype(np.float32), return_seconds=True)
            if speech_dict and 'start' in speech_dict:
                # 合并相邻语音段，最小持续0.3秒
                if not speech_segments or speech_dict['start'] - speech_segments[-1]['end'] > 0.3:
                    speech_segments.append(speech_dict)
                else:
                    speech_segments[-1]['end'] = speech_dict['end']
        return speech_segments
    
    def process(self, input_path, output_dir):
        """完整预处理流程"""
        os.makedirs(output_dir, exist_ok=True)
        # 步骤1：加载重采样
        raw_audio = self.load_and_resample(input_path)
        # 步骤2：响度归一化
        clean_audio = self.normalize_loudness(raw_audio)
        # 步骤3：VAD切分
        segments = self.vad_split(clean_audio)
        # 步骤4：保存切分后的wav文件
        for i, seg in enumerate(segments):
            start_sample = int(seg['start'] * self.target_sr)
            end_sample = int(seg['end'] * self.target_sr)
            seg_audio = clean_audio[start_sample:end_sample]
            output_path = os.path.join(output_dir, f"seg_{i:04d}.wav")
            # 用soundfile保存，避免pydub的格式问题
            import soundfile as sf
            sf.write(output_path, seg_audio, self.target_sr)
        return [os.path.join(output_dir, f"seg_{i:04d}.wav") for i in range(len(segments))]

# 使用示例
cleaner = AudioCleaner()
segment_files = cleaner.process("meeting.mp3", "./segments/")
print(f"切分出{len(segment_files)}个语音段")

4.3 whisper服务封装：支持流式和批量的Transcriber类

import whisper
import torch
from typing import List, Dict, Any

class WhisperTranscriber:
    def __init__(self, model_name="base", device="cuda" if torch.cuda.is_available() else "cpu"):
        self.model = whisper.load_model(model_name, device=device)
        self.device = device
    
    def transcribe_chunk(self, audio_path: str) -> Dict[str, Any]:
        """单段音频识别"""
        result = self.model.transcribe(
            audio_path,
            language="zh",
            fp16=False,  # 关闭fp16避免CUDA错误
            temperature=0.0,  # 降低随机性
            best_of=1,
            beam_size=5
        )
        # 清理显存
        if self.device == "cuda":
            torch.cuda.empty_cache()
        return result
    
    def transcribe_batch(self, audio_paths: List[str]) -> List[Dict[str, Any]]:
        """批量识别，自动管理显存"""
        results = []
        for path in audio_paths:
            try:
                result = self.transcribe_chunk(path)
                results.append({
                    "file": path,
                    "text": result["text"].strip(),
                    "segments": result["segments"]
                })
            except Exception as e:
                results.append({
                    "file": path,
                    "error": str(e),
                    "text": ""
                })
        return results
    
    def add_punctuation(self, text: str) -> str:
        """简单中文标点恢复"""
        # 基础规则：句末加句号，动词后加逗号
        import re
        text = re.sub(r'([。！？])', r'\1\n', text)  # 先按已有标点分行
        lines = [line.strip() for line in text.split('\n') if line.strip()]
        punctuated = []
        for line in lines:
            if len(line) > 10 and line[-1] not in '。！？，；：':
                # 长句且无标点，按动词切分
                verbs = ['是', '有', '在', '做', '进行', '开展', '实施', '完成']
                for v in verbs:
                    if v in line and line.index(v) > 5:
                        pos = line.index(v)
                        punctuated.append(line[:pos+v.__len__()] + '，' + line[pos+v.__len__():])
                        break
                else:
                    punctuated.append(line + '。')
            else:
                punctuated.append(line)
        return ' '.join(punctuated)

# 使用示例
transcriber = WhisperTranscriber(model_name="base")
results = transcriber.transcribe_batch(segment_files)
for r in results:
    if "error" not in r:
        print(f"[{r['file']}] {transcriber.add_punctuation(r['text'])}")

4.4 funASR服务封装：发挥模块化优势的Pipeline类

from funasr import AutoModel
from funasr.utils.postprocess_utils import build_postprocessor

class FunASRPipeline:
    def __init__(self, asr_model_path="damo/speech_paraformer_asr_nat-zh-cn-16k-common-vocab8358-tensorflow1"):
        # 只加载ASR模型，其他模块按需调用
        self.asr_model = AutoModel(
            model=asr_model_path,
            device="cpu",  # CPU足够，省GPU
            disable_update=True
        )
        # 构建后处理（标点、纠错）
        self.postprocessor = build_postprocessor("ctc_punc", "cn")
    
    def recognize(self, audio_path: str) -> Dict[str, Any]:
        """单文件识别"""
        result = self.asr_model.generate(
            input=audio_path,
            language="zh",
            max_length=50,  # 控制输出长度
            beam_size=2
        )
        # 后处理加标点
        if result and 'text' in result:
            punctuated = self.postprocessor(result['text'])
            result['text_punc'] = punctuated
        return result
    
    def batch_recognize(self, audio_paths: List[str]) -> List[Dict[str, Any]]:
        """批量识别，利用funASR的batch能力"""
        # funASR支持batch，但需同采样率
        results = self.asr_model.generate(
            input=audio_paths,
            language="zh"
        )
        # 处理每个结果
        processed = []
        for i, r in enumerate(results):
            if r and 'text' in r:
                r['text_punc'] = self.postprocessor(r['text'])
            processed.append(r)
        return processed

# 使用示例
pipeline = FunASRPipeline()
funasr_results = pipeline.batch_recognize(segment_files)
for i, r in enumerate(funasr_results):
    if r and 'text_punc' in r:
        print(f"[seg_{i:04d}] {r['text_punc']}")

4.5 结果融合策略：基于置信度的智能仲裁

def fuse_results(whisper_results, funasr_results, confidence_threshold=0.85):
    """
    融合策略：whisper初筛 + funASR精修
    置信度计算：whisper用segment['avg_logprob']，funASR用score字段
    """
    fused_text = []
    for i, (w_r, f_r) in enumerate(zip(whisper_results, funasr_results)):
        # 获取whisper置信度
        w_confidence = 0.0
        if w_r and 'segments' in w_r and w_r['segments']:
            w_confidence = np.mean([s.get('avg_logprob', -2.0) for s in w_r['segments']])
            w_confidence = max(0.0, min(1.0, (w_confidence + 2.0) / 2.0))  # 归一化
        
        # 获取funASR置信度（如果有）
        f_confidence = f_r.get('score', 0.0) if f_r else 0.0
        
        # 决策逻辑
        if w_confidence >= confidence_threshold:
            # whisper可信，直接采用
            text = w_r.get('text', '').strip()
        elif f_r and f_confidence > 0.7:
            # funASR可信，采用其结果
            text = f_r.get('text_punc', '').strip()
        else:
            # 都不可信，取whisper文本+funASR关键词修正
            w_text = w_r.get('text', '').strip()
            f_text = f_r.get('text_punc', '').strip() if f_r else ""
            # 提取funASR识别出的专有名词，替换whisper中的错误词
            if f_text and w_text:
                # 简单关键词替换：找长度>2的词，且在f_text中出现
                import jieba
                f_words = [w for w in jieba.lcut(f_text) if len(w) > 2]
                for word in f_words:
                    if word in w_text:
                        continue
                    # 在w_text中找近似词替换
                    for w_word in jieba.lcut(w_text):
                        if len(w_word) > 2 and word[0] == w_word[0]:  # 首字相同
                            w_text = w_text.replace(w_word, word)
                            break
            text = w_text
        
        fused_text.append(text)
    
    return " ".join(fused_text)

# 执行融合
final_text = fuse_results(whisper_results, funasr_results)
print("融合结果：", final_text)

5. 常见问题与排查技巧实录：那些文档里不会写的坑

5.1 whisper常见报错及根因分析

报错信息	根本原因	解决方案	经验备注
RuntimeError: CUDA out of memory	显存不足，尤其large模型	1. 改用small模型；2. transcribe(..., fp16=False) ；3. torch.cuda.empty_cache()	别信“加大batch_size提升速度”，whisper不支持batch推理，只会OOM
AssertionError: Mel dimension mismatch	音频采样率非16kHz	用pydub强制转16kHz，别依赖whisper自动重采样	自动重采样用librosa，质量不如pydub的resample
KeyError: 'text'	模型未识别出任何文本	检查音频是否静音，或VAD切错了段	在transcribe前加 if len(audio_array) < 1000: return {"text": ""} 防崩
OSError: libomp.so.5: cannot open shared object file	Ubuntu缺少OpenMP库	sudo apt-get install libomp5	这是conda环境特有问题，pip环境无此错

5.2 funASR高频故障处理手册

现象	可能原因	排查步骤	实操技巧
ImportError: cannot import name 'kaldi_io'	funASR whl包损坏或版本不匹配	1. pip uninstall funasr ；2. 重新下载对应Python版本的whl；3. pip install --force-reinstall xxx.whl	官网下载页有版本对应表，别用 pip install funasr
VAD切不出语音段	silero-vad模型加载失败	1. torch.hub.set_dir("/tmp/torch_hub") 指定缓存目录；2. 手动下载vad.jit到cache	默认cache在~/.cache/torch/hub，权限问题常导致加载失败
识别结果为空字符串	ASR模型输入格式错误	检查wav文件头： file seg_0001.wav 应显示 RIFF ... WAVE ，而非 RIFF ... AVI	用 sox -r 16000 -b 16 -c 1 input.mp3 output.wav 重编码最稳
CPU占用100%卡死	多进程冲突	1. export OMP_NUM_THREADS=1 ；2. export OPENBLAS_NUM_THREADS=1 ；3. 代码中 torch.set_num_threads(1)	funASR默认用满CPU，不加限制会拖垮服务器

5.3 音频质量导致的识别偏差：如何判断是不是模型的问题

很多用户以为“识别不准=模型不行”，其实80%是音频问题。我用3个快速检测法：

1. 频谱图诊断 ：用 librosa.display.specshow() 画频谱图

   import librosa, librosa.display
   import matplotlib.pyplot as plt
   y, sr = librosa.load("audio.wav", sr=16000)
   plt.figure(figsize=(10, 4))
   librosa.display.specshow(librosa.amplitude_to_db(
       np.abs(librosa.stft(y)), ref=np.max), y_axis='log', x_axis='time')
   plt.colorbar(format='%+2.0f dB')
   plt.title('Power spectrogram')
   plt.tight_layout()
   plt.show()
   

   健康频谱 ：0-8kHz有连续能量分布，人声基频区（80-300Hz）和共振峰（500-4000Hz）清晰； 问题频谱 ：高频衰减（像蒙了层布）、50Hz工频干扰（竖直亮线）、削峰（顶部平直）。

2. SNR（信噪比）粗估 ：

   # 计算语音段与静音段能量比
   import numpy as np
   def estimate_snr(audio_array, sr):
       # 用前0.5秒作为静音参考
       silence = audio_array[:int(0.5*sr