Fun-ASR模型快速调用：Python代码实例详解，新手友好

1. 从零开始：快速部署你的语音识别助手

如果你正在寻找一个能听懂多国语言、部署简单、效果又好的语音识别工具，那么Fun-ASR-MLT-Nano-2512绝对值得你花10分钟了解一下。这个由阿里通义实验室推出的模型，支持31种语言的识别，包括中文、英文、日语、韩语，甚至粤语方言都能搞定。

想象一下这样的场景：你有一段会议录音需要转成文字，但参会人员来自不同国家；或者你有一个多语言的播客需要生成字幕；又或者你只是想做一个能听懂你说话的智能小助手。这些需求，Fun-ASR都能帮你轻松实现。

最棒的是，你不需要是AI专家，也不需要复杂的配置。跟着本文的步骤，从环境搭建到代码调用，我会手把手带你走一遍。无论你是Python新手，还是有一定经验的开发者，都能快速上手。

2. 环境准备：5分钟搞定所有依赖

2.1 检查你的电脑环境

在开始之前，我们先确认一下你的电脑是否满足基本要求。别担心，要求并不高：

• 操作系统：Linux系统（推荐Ubuntu 20.04或更新版本）。如果你用Windows，建议安装WSL2或者用Docker。
• Python版本：3.8或更高版本，我推荐用Python 3.11，兼容性最好。
• 内存：至少8GB，处理长音频时会更流畅。
• 磁盘空间：准备5GB左右的空间，主要是存放模型文件。
• GPU（可选但推荐）：如果你有NVIDIA显卡，识别速度会快很多。没有也没关系，CPU也能跑，就是慢一点。

2.2 一步一步安装依赖

打开你的终端，跟着我一步步操作：

首先，我们安装一个重要的音频处理工具ffmpeg：

sudo apt-get update
sudo apt-get install -y ffmpeg

ffmpeg是什么？你可以把它理解成一个“万能音频转换器”，它能把各种格式的音频文件（MP3、WAV、M4A等）转换成模型能识别的标准格式。

接下来，我们创建一个独立的Python环境。为什么要创建独立环境？这是为了避免不同项目的依赖包互相冲突，就像给每个项目一个独立的“房间”。

# 创建虚拟环境
python3 -m venv funasr_env

# 激活环境（Linux/Mac）
source funasr_env/bin/activate

# 如果是Windows，用这个命令：
# funasr_env\Scripts\activate

看到命令行前面出现(funasr_env)就说明环境激活成功了。现在在这个环境里安装的任何包，都不会影响你电脑上其他的Python项目。

最后，安装Python依赖包。我们先创建一个requirements.txt文件：

funasr>=0.1.0
torch>=1.13.0
gradio>=3.50.0
pyyaml
tiktoken

然后安装：

pip install -r requirements.txt

这里安装的几个包各有各的用处：

• funasr：这是核心的语音识别库
• torch：PyTorch深度学习框架，模型运行的基础
• gradio：用来创建Web界面的，后面我们会用到
• pyyaml和tiktoken：处理配置文件和文本编码的工具

3. 第一次调用：让模型“开口说话”

3.1 下载模型文件

环境准备好了，我们还需要模型文件。你可以从HuggingFace下载，或者如果你用的是CSDN星图镜像，模型已经预装好了。

模型文件大概2GB大小，主要包括：

• model.pt：模型的核心权重文件
• model.py：模型的定义代码
• configuration.json：模型的配置信息，比如支持哪些语言
• 还有其他一些辅助文件

3.2 最简单的调用代码

现在，让我们写第一个Python程序，体验一下语音识别的神奇：

from funasr import AutoModel

# 第一步：加载模型
print("正在加载模型，第一次可能会慢一些，请耐心等待...")
model = AutoModel(
    model=".",  # 点号表示当前目录，模型文件应该在这里
    trust_remote_code=True,  # 这个必须设为True
    device="cuda:0" if torch.cuda.is_available() else "cpu"  # 自动检测GPU
)

print("模型加载完成！")

# 第二步：准备一段测试音频
# 你可以用自己的音频文件，或者用示例文件
audio_file = "example/zh.mp3"  # 假设你有一个中文测试文件

# 第三步：开始识别
result = model.generate(
    input=[audio_file],  # 把文件路径放在列表里
    language="中文",      # 告诉模型这是什么语言（可选）
    itn=True             # 开启文本规范化，比如把"123"转成"一百二十三"
)

# 第四步：查看结果
recognized_text = result[0]["text"]
print(f"识别结果：{recognized_text}")

把这段代码保存为test_asr.py，然后在终端运行：

python test_asr.py

第一次运行会比较慢，因为模型需要加载到内存（或显存）中，可能要等30-60秒。耐心一点，之后再次调用就会快很多了。

3.3 理解代码的每个部分

让我解释一下上面代码中几个关键参数：

• model="."：这个点号代表当前目录。意思是“在当前文件夹里找模型文件”。你也可以直接指定路径，比如model="/home/user/models/funasr"。

• trust_remote_code=True：这个参数必须设为True。因为Fun-ASR用了一些自定义的代码，如果不设置这个，Python会出于安全考虑拒绝加载。

• device：这里用了个小技巧。torch.cuda.is_available()会自动检查你的电脑有没有可用的GPU。如果有，就用GPU（cuda:0）；如果没有，就用CPU。

• language="中文"：虽然模型能自动检测语言，但如果你明确知道音频是什么语言，告诉它会提高识别准确率。

• itn=True：这是“逆文本规范化”的开关。打开后，模型会把“2023年”识别成“二零二三年”，把“12:30”识别成“十二点三十分”，让结果更符合自然语言的表达习惯。

4. 实际应用：处理真实场景的音频

4.1 处理不同格式的音频文件

在实际工作中，你遇到的音频可能是各种格式的。别担心，Fun-ASR支持很多常见格式：

import os

# 定义一个函数来处理各种音频
def transcribe_audio(file_path, language=None):
    """
    将音频文件转成文字
    
    参数：
    file_path: 音频文件路径
    language: 语言类型，如"中文"、"英文"等，不指定则自动检测
    """
    if not os.path.exists(file_path):
        print(f"错误：文件 {file_path} 不存在")
        return None
    
    # 获取文件扩展名
    ext = os.path.splitext(file_path)[1].lower()
    
    # 检查是否支持该格式
    supported_formats = ['.mp3', '.wav', '.m4a', '.flac', '.ogg']
    if ext not in supported_formats:
        print(f"警告：格式 {ext} 可能不被完美支持，尝试转换...")
    
    try:
        # 调用模型识别
        result = model.generate(
            input=[file_path],
            language=language,
            itn=True,
            batch_size=1
        )
        
        text = result[0]["text"]
        return text
        
    except Exception as e:
        print(f"识别失败：{e}")
        return None

# 使用示例
files_to_process = [
    ("会议录音.mp3", "中文"),
    ("english_podcast.wav", "英文"),
    ("日语教学.m4a", "日文"),
    ("kpop_song.flac", "韩文")
]

for file_path, lang in files_to_process:
    if os.path.exists(file_path):
        print(f"\n处理文件：{file_path}")
        text = transcribe_audio(file_path, lang)
        if text:
            print(f"识别结果：{text[:100]}...")  # 只显示前100个字符

4.2 批量处理多个文件

如果你有很多音频文件需要处理，一个一个操作太麻烦了。我们可以写个批量处理的脚本：

import glob
import json
from datetime import datetime

def batch_transcribe(input_folder, output_file="results.json", language=None):
    """
    批量处理一个文件夹里的所有音频文件
    
    参数：
    input_folder: 输入文件夹路径
    output_file: 结果保存的文件名
    language: 统一语言设置，如果为None则自动检测
    """
    # 查找所有支持的音频文件
    audio_patterns = ['*.mp3', '*.wav', '*.m4a', '*.flac']
    audio_files = []
    
    for pattern in audio_patterns:
        audio_files.extend(glob.glob(os.path.join(input_folder, pattern)))
    
    if not audio_files:
        print(f"在 {input_folder} 中没有找到音频文件")
        return
    
    print(f"找到 {len(audio_files)} 个音频文件，开始处理...")
    
    results = []
    start_time = datetime.now()
    
    for i, audio_file in enumerate(audio_files, 1):
        print(f"处理第 {i}/{len(audio_files)} 个文件：{os.path.basename(audio_file)}")
        
        try:
            text = transcribe_audio(audio_file, language)
            
            if text:
                result_item = {
                    "file": os.path.basename(audio_file),
                    "path": audio_file,
                    "text": text,
                    "timestamp": datetime.now().isoformat(),
                    "language": language or "auto"
                }
                results.append(result_item)
                print(f"  成功！长度：{len(text)} 字符")
            else:
                print(f"  失败：无法识别")
                
        except Exception as e:
            print(f"  处理出错：{e}")
    
    # 保存结果到JSON文件
    with open(output_file, 'w', encoding='utf-8') as f:
        json.dump(results, f, ensure_ascii=False, indent=2)
    
    end_time = datetime.now()
    time_taken = (end_time - start_time).total_seconds()
    
    print(f"\n批量处理完成！")
    print(f"总文件数：{len(audio_files)}")
    print(f"成功识别：{len(results)}")
    print(f"总耗时：{time_taken:.2f} 秒")
    print(f"平均每个文件：{time_taken/len(audio_files):.2f} 秒")
    print(f"结果已保存到：{output_file}")
    
    return results

# 使用示例：处理一个文件夹里的所有音频
# batch_transcribe("我的音频文件夹", language="中文")

4.3 处理长音频和实时流

有时候你需要处理很长的音频，比如一两个小时的会议录音。直接处理可能会内存不足，这时候可以分段处理：

def transcribe_long_audio(file_path, chunk_duration=30, language=None):
    """
    分段处理长音频文件
    
    参数：
    file_path: 音频文件路径
    chunk_duration: 每段时长（秒），默认30秒
    language: 语言类型
    """
    import librosa
    import soundfile as sf
    import tempfile
    import shutil
    
    # 创建临时文件夹存放分段文件
    temp_dir = tempfile.mkdtemp()
    
    try:
        # 加载音频文件
        print(f"加载音频文件：{file_path}")
        audio, sr = librosa.load(file_path, sr=16000, mono=True)
        duration = len(audio) / sr
        
        print(f"音频信息：采样率 {sr}Hz，时长 {duration:.1f} 秒")
        
        # 计算需要分成多少段
        num_chunks = int(duration / chunk_duration) + 1
        print(f"将分成 {num_chunks} 段，每段 {chunk_duration} 秒")
        
        all_texts = []
        
        for i in range(num_chunks):
            start_sample = i * chunk_duration * sr
            end_sample = min((i + 1) * chunk_duration * sr, len(audio))
            
            if start_sample >= len(audio):
                break
                
            chunk = audio[start_sample:end_sample]
            
            # 保存分段到临时文件
            chunk_file = os.path.join(temp_dir, f"chunk_{i:03d}.wav")
            sf.write(chunk_file, chunk, sr)
            
            print(f"处理第 {i+1}/{num_chunks} 段...")
            
            # 识别这段音频
            result = model.generate(
                input=[chunk_file],
                language=language,
                itn=True
            )
            
            if result and result[0]["text"]:
                all_texts.append(result[0]["text"])
            
            # 清理临时文件
            os.remove(chunk_file)
        
        # 合并所有结果
        full_text = " ".join(all_texts)
        
        print(f"\n处理完成！总文本长度：{len(full_text)} 字符")
        return full_text
        
    except Exception as e:
        print(f"处理长音频时出错：{e}")
        return None
        
    finally:
        # 清理临时文件夹
        shutil.rmtree(temp_dir, ignore_errors=True)

# 使用示例
# long_text = transcribe_long_audio("长会议录音.mp3", chunk_duration=60, language="中文")

5. 进阶技巧：提升识别准确率和速度

5.1 调整参数获得更好效果

模型提供了一些参数可以调整，让识别效果更好：

# 更精细的参数配置
result = model.generate(
    input=["audio.mp3"],
    cache={},  # 用于流式识别，保持对话上下文
    batch_size=2,  # 批量大小，GPU内存够大可以调大
    language="中文",
    itn=True,
    hotword="",  # 热词：告诉模型某些词出现的概率高
    use_itn=True,  # 是否使用逆文本规范化
    disfluency=False,  # 是否去除口语中的填充词（嗯、啊等）
    timestamp=False  # 是否输出时间戳
)

# 获取更详细的结果信息
detailed_result = result[0]
print(f"识别文本：{detailed_result['text']}")
print(f"识别置信度：{detailed_result.get('score', 'N/A')}")
if 'timestamp' in detailed_result:
    print(f"时间戳：{detailed_result['timestamp']}")

5.2 处理特殊场景

场景一：有背景噪音的音频

# 对于嘈杂环境录制的音频，可以尝试预处理
def preprocess_noisy_audio(input_path, output_path):
    """
    简单的音频预处理，减少噪音影响
    """
    import numpy as np
    import soundfile as sf
    
    # 读取音频
    audio, sr = librosa.load(input_path, sr=16000)
    
    # 简单的降噪处理（这里只是示例，实际可以用更专业的库）
    # 1. 标准化音量
    audio = audio / np.max(np.abs(audio)) * 0.9
    
    # 2. 简单的滤波（去除极低和极高频率）
    from scipy import signal
    b, a = signal.butter(4, [100, 7000], btype='band', fs=sr)
    audio = signal.filtfilt(b, a, audio)
    
    # 保存处理后的音频
    sf.write(output_path, audio, sr)
    return output_path

# 使用预处理
clean_audio = preprocess_noisy_audio("嘈杂录音.mp3", "清理后.wav")
result = model.generate(input=[clean_audio], language="中文")

场景二：混合语言的音频

# 对于中英混合的音频，可以尝试分段识别
def transcribe_mixed_language(audio_path, segment_duration=10):
    """
    处理混合语言音频，分段尝试不同语言
    """
    # 先尝试用中文识别整个音频
    chinese_result = model.generate(input=[audio_path], language="中文")
    chinese_text = chinese_result[0]["text"]
    
    # 再尝试用英文识别
    english_result = model.generate(input=[audio_path], language="英文")
    english_text = english_result[0]["text"]
    
    # 简单判断：哪个结果的置信度更高就用哪个
    # 实际中可以更复杂的逻辑，比如分段检测语言
    print(f"中文识别结果：{chinese_text}")
    print(f"英文识别结果：{english_text}")
    
    # 这里可以添加自己的逻辑来选择或合并结果
    return chinese_text  # 暂时返回中文结果

5.3 性能优化建议

如果你的识别速度不够快，可以试试这些方法：

1. 使用GPU加速：这是最有效的提速方法。确保你的PyTorch安装了CUDA版本：

   # 检查PyTorch是否支持CUDA
   python -c "import torch; print(torch.cuda.is_available())"
   

2. 调整批处理大小：如果你一次处理多个文件，可以调整batch_size：

   # 根据你的GPU内存调整
   # 4GB显存建议 batch_size=1
   # 8GB显存可以尝试 batch_size=2
   result = model.generate(input=file_list, batch_size=2)
   

3. 音频预处理：提前把音频转换成16kHz、单声道的WAV格式，可以减少模型内部的转换时间。

4. 模型预热：服务启动后，先用一个短音频“热身”一下：

   # 服务启动后先运行一次
   warmup_audio = "short_test.wav"  # 准备一个很短的测试文件
   model.generate(input=[warmup_audio])
   print("模型预热完成，可以开始正式识别了")
   

6. 常见问题与解决方案

6.1 安装和运行问题

问题1：ImportError: No module named 'funasr'

解决方案：确保你已经正确安装了funasr包
pip install funasr

问题2：CUDA out of memory

解决方案：减少batch_size，或者使用CPU模式
model = AutoModel(model=".", device="cpu")

问题3：音频文件无法读取

解决方案：检查音频格式，尝试用ffmpeg转换
ffmpeg -i input.m4a -ar 16000 -ac 1 output.wav

6.2 识别准确率问题

问题：中文识别有错误

可能原因和解决方案：
1. 音频质量差：确保录音清晰，减少背景噪音
2. 采样率不对：转换为16kHz
3. 方言或口音：明确指定语言，如language="中文"
4. 专业术语：使用hotword参数添加专业词汇

问题：英文识别效果不好

尝试：
1. 明确指定language="英文"
2. 关闭itn：itn=False（英文不需要数字转文字）
3. 检查音频是否是单声道

6.3 性能问题

问题：识别速度太慢

优化建议：
1. 使用GPU：device="cuda:0"
2. 缩短音频长度：分段处理长音频
3. 提前转换格式：统一为16kHz WAV格式
4. 使用更快的存储：SSD比HDD快

7. 总结：开始你的语音识别之旅

通过本文的介绍，你应该已经掌握了Fun-ASR-MLT-Nano-2512的基本使用方法。让我们回顾一下关键点：

核心步骤很简单：

1. 准备好Python环境，安装必要的依赖包
2. 下载模型文件到本地
3. 用几行代码加载模型
4. 调用generate方法识别音频
5. 获取并处理识别结果

这个模型的优势很明显：

• 支持31种语言，覆盖大多数使用场景
• 识别准确率高，尤其在中文环境下表现优秀
• 部署简单，不需要复杂的配置
• 既有Python API，也有Web界面，使用灵活

给新手的建议：

1. 先从简单的示例开始，跑通整个流程
2. 用自己的声音录一段测试，看看识别效果
3. 尝试处理不同格式、不同语言的音频
4. 遇到问题时，先检查音频质量和格式
5. 多语言场景下，明确指定语言参数能提高准确率

语音识别技术正在改变我们与设备交互的方式。无论是做会议记录、生成视频字幕、开发语音助手，还是分析客户电话录音，Fun-ASR都能为你提供一个强大而简单的起点。

现在，你可以开始动手尝试了。从一个简单的脚本开始，慢慢扩展到更复杂的应用。记住，最好的学习方式就是实践。遇到问题不要怕，查看错误信息，搜索解决方案，或者参考官方文档。编程的世界里，每个问题都有答案，关键在于不断尝试。

---

获取更多AI镜像

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