faster-whisper: 4 倍速语音转文本，23K+ Stars — 2026 年对比 WhisperX、whisper.cpp 基准测试

# 创建虚拟环境
python -m venv venv-whisper
source venv-whisper/bin/activate

# 安装 faster-whisper
pip install faster-whisper

# 通过 pip 安装 cuBLAS 和 cuDNN（仅限 Linux）
pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

# 设置库路径
export LD_LIBRARY_PATH=$(python3 -c 'import os; import nvidia.cublas.lib; import nvidia.cudnn.lib; print(os.path.dirname(nvidia.cublas.lib.__file__) + ":" + os.path.dirname(nvidia.cudnn.lib.__file__))')

# 安装 faster-whisper
pip install faster-whisper

# 拉取官方 NVIDIA CUDA 镜像
docker run -it --rm --gpus all \
  -v $(pwd)/audio:/audio \
  nvidia/cuda:12.3.2-cudnn9-runtime-ubuntu22.04 \
  bash

# 容器内
apt-get update && apt-get install -y python3-pip
pip install faster-whisper

# verify_setup.py
from faster_whisper import WhisperModel
import torch

print(f"PyTorch CUDA 可用: {torch.cuda.is_available()}")
print(f"CUDA 设备数: {torch.cuda.device_count()}")

model = WhisperModel("tiny", device="cuda", compute_type="float16")
print(f"模型加载设备: {model.model.device}")
print("安装验证成功")

from faster_whisper import WhisperModel

# 加载模型（首次运行时自动从 Hugging Face 下载）
model = WhisperModel("large-v3", device="cuda", compute_type="int8")

# 转录音频
segments, info = model.transcribe("audio.mp3", beam_size=5)

print(f"检测语言: {info.language} (概率: {info.language_probability:.2f})")

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

pip install whisperx

import whisperx
import torch

device = "cuda" if torch.cuda.is_available() else "cpu"
audio_file = "meeting.mp3"

# 1. 使用 faster-whisper 后端转录
model = whisperx.load_model("large-v3", device, compute_type="int8")
audio = whisperx.load_audio(audio_file)
result = model.transcribe(audio, batch_size=8)

# 2. 对齐获取词级时间戳
model_a, metadata = whisperx.load_align_model(
    language_code=result["language"], device=device
)
result = whisperx.align(result["segments"], model_a, metadata, audio, device)

# 3. 说话人分离（需要 Hugging Face token）
diarize_model = whisperx.DiarizationPipeline(
    use_auth_token="your_hf_token", device=device
)
diarize_segments = diarize_model(audio)
result = whisperx.assign_word_speakers(diarize_segments, result)

for segment in result["segments"]:
    speaker = segment.get("speaker", "UNKNOWN")
    print(f"[{segment['start']:.2f}s -> {segment['end']:.2f}s] "
          f"{speaker}: {segment['text']}")

docker run -d --gpus all \
  -p 9000:9000 \
  -e ASR_MODEL=large-v3 \
  -e ASR_ENGINE=faster_whisper \
  -e COMPUTE_TYPE=int8 \
  onerahming/openai-whisper-asr

import requests

with open("audio.mp3", "rb") as f:
    response = requests.post(
        "http://localhost:9000/asr",
        files={"audio_file": f},
        data={"language": "en", "output": "json"}
    )
print(response.json())

docker run -d --gpus all \
  -p 8000:8000 \
  -e WHISPER__MODEL=large-v3 \
  -e WHISPER__COMPUTE_TYPE=int8 \
  fedirz/speaches:latest-gpu

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="dummy")

with open("audio.mp3", "rb") as f:
    transcript = client.audio.transcriptions.create(model="large-v3", file=f)
print(transcript.text)

from faster_whisper import WhisperModel
import requests

model = WhisperModel("large-v3", device="cuda", compute_type="int8")
segments, info = model.transcribe("japanese_audio.mp3", beam_size=5)
japanese_text = " ".join([s.text for s in segments])

response = requests.post("http://localhost:5000/translate", json={
    "q": japanese_text, "source": "ja", "target": "en"
})
print(response.json()["translatedText"])

from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="int8")

segments, info = model.transcribe(
    "audio.mp3",
    vad_filter=True,
    vad_parameters=dict(
        min_silence_duration_ms=500,
        speech_pad_ms=200,
        threshold=0.5
    ),
    beam_size=5
)

from faster_whisper import WhisperModel
import glob, time

model = WhisperModel("large-v3", device="cuda", compute_type="int8")
audio_files = glob.glob("podcasts/*.mp3")

start = time.time()
for file_path in audio_files:
    segments, _ = model.transcribe(file_path, batch_size=8, beam_size=5)
    text = " ".join([s.text for s in segments])
    print(f"{file_path}: {len(text)} 字符")
print(f"总耗时: {time.time() - start:.1f}秒，处理 {len(audio_files)} 个文件")

segments, _ = model.transcribe("audio.mp3", word_timestamps=True)
for segment in segments:
    for word in segment.words:
        print(f"[{word.start:.2f}s -> {word.end:.2f}s] {word.word}")

pip install transformers[torch]>=4.23

ct2-transformers-converter \
  --model openai/whisper-large-v3 \
  --output_dir whisper-large-v3-ct2 \
  --copy_files tokenizer.json preprocessor_config.json \
  --quantization float16

from faster_whisper import WhisperModel
from prometheus_client import Counter, Histogram, start_http_server

REQUEST_COUNT = Counter("transcription_requests_total", "总请求数")
REQUEST_DURATION = Histogram("transcription_duration_seconds", "请求耗时")

model = WhisperModel("large-v3", device="cuda", compute_type="int8")

@REQUEST_DURATION.time()
def transcribe(audio_path):
    REQUEST_COUNT.inc()
    return model.transcribe(audio_path, beam_size=5)

start_http_server(8000)

from faster_whisper import WhisperModel

def safe_transcribe(audio_path, device="cuda"):
    compute_types = ["int8", "int8_float16", "float16", "float32"]
    for compute_type in compute_types:
        try:
            model = WhisperModel("large-v3", device=device, compute_type=compute_type)
            segments, info = model.transcribe(audio_path, beam_size=5)
            return segments, info, compute_type
        except RuntimeError as e:
            print(f"{compute_type} 失败: {e}，重试中...")
            continue
    raise RuntimeError("所有计算类型均失败")