OpenAI Whisper：97.2k Stars 通用语音识别完全指南

# Ubuntu / Debian
sudo apt update && sudo apt install ffmpeg

# Arch Linux
sudo pacman -S ffmpeg

# macOS (Homebrew)
brew install ffmpeg

# Windows (Chocolatey)
choco install ffmpeg

# Windows (Scoop)
scoop install ffmpeg

# 创建虚拟环境
python -m venv whisper-env
source whisper-env/bin/activate  # Linux/macOS
# 或
whisper-env\Scripts\activate  # Windows

# 安装 PyTorch（建议 CPU 版本）
pip install torch torchaudio

# 安装 Whisper
pip install -U openai-whisper

# 或从源码安装最新版本
pip install git+https://github.com/openai/whisper.git

# 使用默认模型（turbo）转写音频
whisper audio.flac audio.mp3 audio.wav

# 指定语言
whisper japanese.wav --language Japanese

# 指定模型
whisper audio.wav --model small

# 翻译为英语（需使用多语言模型）
whisper japanese.wav --model medium --language Japanese --task translate

# 输出所有信息（包含语言识别结果）
whisper audio.wav --model medium --task translate --verbose True

# 纯音频（无说话人分离）
whisper audio.wav

# 指定输出格式
whisper audio.wav --model medium --format json  # JSON
whisper audio.wav --model medium --format srt   # SRT字幕
whisper audio.wav --model medium --format vtt   # VTT字幕
whisper audio.wav --model medium --format txt   # 纯文本

# 温度采样（创造性）
whisper audio.wav --model medium --temperature 0.0  # 确定性强
whisper audio.wav --model medium --temperature 1.0  # 创造性强

# 条件分割（用于长音频）
whisper audio.wav --model medium --condition_on_previous_text True

# 忽略无语音片段
whisper audio.wav --model medium --word_timestamps True

# 查看帮助
whisper --help

import whisper
import torch

# 检测 GPU
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# 加载模型
model = whisper.load_model("base")
model = model.to(device)

# 转写音频
result = model.transcribe("audio.mp3")
print(result["text"])

import whisper

model = whisper.load_model("medium")

# 获取详细结果
result = model.transcribe(
    "audio.mp3",
    verbose=True,           # 打印进度
    task="transcribe",      # 或 "translate"
    language="zh",        # 指定语言
    temperature=0.0,      # 采样温度
    condition_on_previous_text=True,  # 条件生成
    initial_prompt="...",  # 初始提示
    word_timestamps=True,   # 词级时间戳
)

# 完整返回结构
print(result.keys())
# dict_keys(['text', 'segments', 'language'])

# 文本内容
print(result["text"])

# 段落级别信息
for segment in result["segments"]:
    print(f"[{segment['start']:.2f}s - {segment['end']:.2f}s] {segment['text']}")
    print(f"  语言: {segment.get('language', 'N/A')}")
    print(f"  置信度: {segment.get('avg_logprob', 'N/A'):.2f}")

# 词级时间戳
for segment in result["segments"]:
    for word in segment.get("words", []):
        print(f"{word['word']}: {word['start']:.2f}s - {word['end']:.2f}s")

import whisper

model = whisper.load_model("base")

# 加载音频
audio = whisper.load_audio("audio.mp3")
audio = whisper.pad_or_trim(audio)

# 生成梅尔频谱
mel = whisper.log_mel_spectrogram(audio, n_mels=model.dims.n_mels).to(model.device)

# 检测语言
_, probs = model.detect_language(mel)
detected_lang = max(probs, key=probs.get)
print(f"检测到语言: {detected_lang}")
print(f"语言概率: {probs[detected_lang]:.2%}")

import whisper

model = whisper.load_model("turbo")

# 加载并处理音频
audio = whisper.load_audio("audio.mp3")
audio = whisper.pad_or_trim(audio)

# 生成梅尔频谱
mel = whisper.log_mel_spectrogram(audio, n_mels=model.dims.n_mels).to(model.device)

# 解码
options = whisper.DecodingOptions(
    task="transcribe",
    language="zh",
    temperature=0.0,
)
result = whisper.decode(model, mel, options)

print(f"文本: {result.text}")
print(f"语言: {result.language}")
print(f"是否完成: {result.no_speech_prob:.2f}")

import torch
import whisper

# 检查 CUDA
print(f"CUDA available: {torch.cuda.is_available()}")
print(f"GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'None'}")

# 使用 GPU
model = whisper.load_model("medium")
model = model.to("cuda")

# 转写
result = model.transcribe("audio.mp3")

import whisper
from concurrent.futures import ThreadPoolExecutor

model = whisper.load_model("small")
audio_files = ["audio1.mp3", "audio2.mp3", "audio3.mp3"]

def transcribe(file):
    result = model.transcribe(file)
    return file, result["text"]

# 多线程处理
with ThreadPoolExecutor(max_workers=4) as executor:
    results = list(executor.map(transcribe, audio_files))

for file, text in results:
    print(f"{file}: {text}")

import whisper

model = whisper.load_model("medium")

# 处理长音频（自动分chunk）
result = model.transcribe(
    "long_audio.mp3",
    chunk_length=30,        # chunk 长度（秒）
    stride_length=5,      # 相邻 chunk 重叠（秒）
    condition_on_previous_text=True,  # 使用前一个 chunk 的文本
)

print(result["text"])

import whisper
import torch

# CPU 内存优化：使用小模型
model = whisper.load_model("tiny")

# GPU 内存优化：半精度
model = whisper.load_model("medium").to("cuda").half()

# 批处理大小
result = model.transcribe(
    "audio.mp3",
    batch_size=8,  # 降低内存占用
)

# 使用 Hugging Face Transformers 微调
pip install transformers datasets

python train.py \
    --model_name_or_path openai/whisper-small \
    --dataset_name mozilla-foundation/common_voice_11_zh-CN \
    --language zh \
    --output_dir ./whisper-finetuned \
    --num_train_epochs 3 \
    --per_device_train_batch_size 8 \
    --learning_rate 1e-5

from faster_whisper import WhisperModel

# 加载加速版模型（CUDA）
model = WhisperModel(
    "medium",
    device="cuda",
    compute_type="float16"
)

segments, info = model.transcribe("audio.mp3", beam_size=5)

for segment in segments:
    print(f"{segment.start:.2f}s - {segment.end:.2f}s: {segment.text}")

import whisperx

# 加载模型和音频
model = whisperx.load_model("medium", device="cuda")
audio = whisperx.load_audio("audio.mp3")

# 转写
result = model.transcribe(audio, batch_size=8)

# 时间戳对齐
result = whisperx.align(
    result["segments"],
    model,
    audio,
    device="cuda"
)

# 获取带时间戳的词
for segment in result["segments"]:
    for word in segment["words"]:
        print(f"{word['word']}: {word['start']:.2f}s - {word['end']:.2f}s")