faster-whisper: 23K+ Stars로 4배 빠른 음성-텍스트 변환 — 2026년 WhisperX, whisper.cpp과 벤치마크 비교

# 가상 환경 생성
python -m venv venv-whisper
source venv-whisper/bin/activate  # Linux/Mac
# venv-whisper\Scripts\activate  # Windows

# 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} "
      f"(확률: {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 토큰 필요)
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 ct in compute_types:
        try:
            model = WhisperModel("large-v3", device=device, compute_type=ct)
            segments, info = model.transcribe(audio_path, beam_size=5)
            return segments, info, ct
        except RuntimeError as e:
            print(f"{ct} 실패: {e}, 재시도...")
            continue
    raise RuntimeError("모든 컴퓨트 타입 실패")