Руководство по Faster-Whisper: быстрее речь в текст с CTranslate2

---

Что такое Faster-whisper?

Ключевые возможности

• В 2–4× более быстрый инференс по сравнению с OpenAI Whisper
• Меньше памяти за счёт квантования
• Та же точность, что у исходных моделей Whisper
• Поддержка GPU и CPU с оптимизированными бэкендами
• Пакетная обработка нескольких файлов
• Временные метки на уровне слов
• Варианты квантования (FP32, FP16, INT8, INT8_FLOAT16)
• Детекция голосовой активности (VAD) для фильтрации

Как это устроено

• Более быстрые матричные операции с оптимизированными библиотеками BLAS
• Лучшее управление памятью с меньшими накладными расходами
• Квантование для снижения потребления памяти
• Пакетную обработку для роста пропускной способности

---

Faster-whisper и OpenAI Whisper

Сравнение производительности

Характеристика	OpenAI Whisper	Faster-whisper
Скорость	База	в 2–4× быстрее
Память	Выше	Ниже (с квантованием)
Точность	Высокая	Та же (те же модели)
GPU	Да	Да (оптимизировано)
CPU	Да	Да (оптимизировано)
Квантование	Ограничено	Полная поддержка (INT8, FP16)
Пакеты	Вручную	Встроено
Установка	Простая	Простая (включает CTranslate2)

Когда выбирать Faster-whisper

• Нужна более быстрая транскрипция под продакшен
• Обрабатываете много файлов пакетами
• Работаете на слабых машинах (используйте INT8)
• Делаете почти реальное время
• Нужно меньше памяти при развёртывании

• Нужна максимальная совместимость с текущим кодом
• Используете дообученные модели (для faster-whisper нужна конвертация)
• Предпочитаете более простой API (у faster-whisper он похож)
• Нужны экспериментальные функции, которые сначала появляются в OpenAI Whisper

---

Установка

Требования

• Python 3.9+ (обязательно)
• FFmpeg (по желанию: faster-whisper использует PyAV, но для части форматов может понадобиться FFmpeg)
• GPU NVIDIA (по желанию, для ускорения на GPU)

Базовая установка

pip install faster-whisper

• пакет faster-whisper
• ctranslate2 (движок CTranslate2)
• pyav (декодирование аудио, заменяет зависимость от FFmpeg)

Установка GPU (NVIDIA CUDA)

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__))')

pip install ctranslate2==3.24.0 faster-whisper

Проверка установки

from faster_whisper import WhisperModel

# Test basic import
print("Faster-whisper installed successfully!")

---

Базовое использование

Простая транскрипция

from faster_whisper import WhisperModel

# Load model (automatically downloads if not present)
model = WhisperModel("base", device="cpu", compute_type="int8")

# Transcribe audio
segments, info = model.transcribe("audio.mp3")

# Print detected language
print(f"Detected language: {info.language} (probability: {info.language_probability:.2f})")

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

Получить полный текст

from faster_whisper import WhisperModel

model = WhisperModel("base")
segments, info = model.transcribe("audio.mp3")

# Collect all text
full_text = " ".join([segment.text for segment in segments])
print(full_text)

С метками времени по словам

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")

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

for segment in segments:
    print(f"[{segment.start:.2f}s - {segment.end:.2f}s] {segment.text}")
    
    # Word-level timestamps
    for word in segment.words:
        print(f"  {word.word} [{word.start:.2f}s - {word.end:.2f}s]")

---

Устройство и тип вычислений

Устройство

• device="cpu" — инференс на CPU (везде)
• device="cuda" — на GPU (нужны NVIDIA GPU и CUDA)

Типы вычислений

Тип	Скорость	Память	Точность	Когда
int8	Самый быстрый	Минимум	Чуть ниже	CPU, мало ресурсов
int8_float16	Очень быстро	Мало	Высокая	GPU с малым VRAM
float16	Быстро	Средне	Высокая	GPU (рекомендуется)
float32	Медленнее всего	Максимум	Максимум	Максимум точности

Примеры по железу

# Best for CPU: INT8
model = WhisperModel("base", device="cpu", compute_type="int8")

# Best for GPU: FP16
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

# Use INT8_FLOAT16 for large models
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Use FP32 (slower but most accurate)
model = WhisperModel("large-v2", device="cuda", compute_type="float32")

---

Расширенные возможности

1. Пакетная обработка

from faster_whisper import WhisperModel
from pathlib import Path

model = WhisperModel("base", device="cuda", compute_type="float16")

audio_files = ["audio1.mp3", "audio2.mp3", "audio3.mp3"]

for audio_file in audio_files:
    print(f"Transcribing: {audio_file}")
    segments, info = model.transcribe(audio_file)
    
    text = " ".join([seg.text for seg in segments])
    print(f"Result: {text[:100]}...")
    print()

2. VAD

from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    vad_filter=True,  # Enable VAD filtering
    vad_parameters=dict(
        min_silence_duration_ms=500,  # Minimum silence duration
        threshold=0.5  # VAD threshold
    )
)

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

3. Язык

from faster_whisper import WhisperModel

model = WhisperModel("base")

# Specify language (faster and more accurate)
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # English
)

# Or let it auto-detect
segments, info = model.transcribe("audio.mp3")  # Auto-detect
print(f"Detected: {info.language}")

4. Размер луча и другие параметры

from faster_whisper import WhisperModel

model = WhisperModel("base")

segments, info = model.transcribe(
    "audio.mp3",
    beam_size=5,  # Higher = more accurate but slower (default: 5)
    best_of=5,    # Number of candidates to consider
    temperature=0.0,  # Lower = more deterministic
    condition_on_previous_text=True,  # Use context from previous segments
    initial_prompt="This is a technical meeting about AI and machine learning."
)

5. Свои пути к моделям

from faster_whisper import WhisperModel

# Use local model directory
model = WhisperModel(
    "base",
    device="cpu",
    compute_type="int8",
    download_root="./models"  # Custom download directory
)

# Or specify full path to converted model
model = WhisperModel(
    "/path/to/converted/model",
    device="cuda",
    compute_type="float16"
)

---

Бенчмарки

GPU (NVIDIA RTX 3070 Ti)

Конфигурация	Время	VRAM	Ускорение
OpenAI Whisper (FP16, beam=5)	~2m 23s	~4708 MB	База
Faster-whisper (FP16, beam=5)	~1m 03s	~4525 MB	в 2.3× быстрее
Faster-whisper (INT8, beam=5)	~59s	~2926 MB	в 2.4× быстрее
Faster-whisper (FP16, batch=8)	~17s	~6090 MB	в 8.4× быстрее
Faster-whisper (INT8, batch=8)	~16s	~4500 MB	в 8.9× быстрее

CPU (Intel Core i7-12700K)

Конфигурация	Время	RAM	Ускорение
OpenAI Whisper (FP32, beam=5)	~6m 58s	~2335 MB	База
Faster-whisper (FP32, beam=5)	~2m 37s	~2257 MB	в 2.7× быстрее
Faster-whisper (INT8, beam=5)	~1m 42s	~1477 MB	в 4.1× быстрее
Faster-whisper (FP32, batch=8)	~1m 06s	~4230 MB	в 6.3× быстрее
Faster-whisper (INT8, batch=8)	~51s	~3608 MB	в 8.2× быстрее

Выводы

• Пакеты дают самый большой выигрыш (8×+ на GPU)
• INT8 режет память ~40% с малой потерей точности
• GPU критична для больших моделей и пакетов
• CPU + INT8 уместны для маленьких моделей и одного файла

---

Полный пример: транскрипция для продакшена

from faster_whisper import WhisperModel
from pathlib import Path
import json
from datetime import datetime

class TranscriptionService:
    """Production-ready transcription service using faster-whisper."""
    
    def __init__(self, model_size="base", device="cpu", compute_type="int8"):
        """Initialize the transcription service."""
        print(f"Loading model: {model_size} on {device} ({compute_type})")
        self.model = WhisperModel(
            model_size,
            device=device,
            compute_type=compute_type
        )
        print("Model loaded successfully!")
    
    def transcribe_file(self, audio_path, output_format="txt", **kwargs):
        """
        Transcribe an audio file.
        
        Args:
            audio_path: Path to audio file
            output_format: Output format (txt, json, srt, vtt)
            **kwargs: Additional transcription parameters
        """
        audio_path = Path(audio_path)
        if not audio_path.exists():
            raise FileNotFoundError(f"Audio file not found: {audio_path}")
        
        print(f"Transcribing: {audio_path.name}")
        
        # Transcribe
        segments, info = self.model.transcribe(
            str(audio_path),
            word_timestamps=True,
            **kwargs
        )
        
        # Collect results
        result = {
            "file": str(audio_path),
            "language": info.language,
            "language_probability": info.language_probability,
            "duration": info.duration,
            "segments": []
        }
        
        full_text_parts = []
        for segment in segments:
            segment_data = {
                "start": segment.start,
                "end": segment.end,
                "text": segment.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end,
                        "probability": word.probability
                    }
                    for word in segment.words
                ]
            }
            result["segments"].append(segment_data)
            full_text_parts.append(segment.text)
        
        result["text"] = " ".join(full_text_parts)
        
        # Save based on format
        output_path = audio_path.parent / f"{audio_path.stem}_transcript"
        
        if output_format == "txt":
            self._save_txt(result, output_path.with_suffix(".txt"))
        elif output_format == "json":
            self._save_json(result, output_path.with_suffix(".json"))
        elif output_format == "srt":
            self._save_srt(result, output_path.with_suffix(".srt"))
        elif output_format == "vtt":
            self._save_vtt(result, output_path.with_suffix(".vtt"))
        
        print(f"✓ Transcription saved: {output_path}.{output_format}")
        return result
    
    def _save_txt(self, result, path):
        """Save as plain text."""
        with open(path, "w", encoding="utf-8") as f:
            f.write(result["text"])
    
    def _save_json(self, result, path):
        """Save as JSON."""
        with open(path, "w", encoding="utf-8") as f:
            json.dump(result, f, indent=2, ensure_ascii=False)
    
    def _save_srt(self, result, path):
        """Save as SRT subtitles."""
        with open(path, "w", encoding="utf-8") as f:
            for i, seg in enumerate(result["segments"], start=1):
                start = self._format_srt_time(seg["start"])
                end = self._format_srt_time(seg["end"])
                f.write(f"{i}\n{start} --> {end}\n{seg['text']}\n\n")
    
    def _save_vtt(self, result, path):
        """Save as WebVTT."""
        with open(path, "w", encoding="utf-8") as f:
            f.write("WEBVTT\n\n")
            for seg in result["segments"]:
                start = self._format_vtt_time(seg["start"])
                end = self._format_vtt_time(seg["end"])
                f.write(f"{start} --> {end}\n{seg['text']}\n\n")
    
    def _format_srt_time(self, seconds):
        """Format time for SRT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d},{millis:03d}"
    
    def _format_vtt_time(self, seconds):
        """Format time for VTT."""
        hours = int(seconds // 3600)
        minutes = int((seconds % 3600) // 60)
        secs = int(seconds % 60)
        millis = int((seconds % 1) * 1000)
        return f"{hours:02d}:{minutes:02d}:{secs:02d}.{millis:03d}"

# Usage
if __name__ == "__main__":
    # Initialize service
    service = TranscriptionService(
        model_size="base",
        device="cpu",  # Change to "cuda" for GPU
        compute_type="int8"  # Use "float16" for GPU
    )
    
    # Transcribe file
    result = service.transcribe_file(
        "meeting.mp3",
        output_format="json",
        beam_size=5,
        language="en"
    )
    
    print(f"\nLanguage: {result['language']}")
    print(f"Duration: {result['duration']:.2f}s")
    print(f"Text: {result['text'][:200]}...")

---

Рекомендации

1. Размер модели

# For speed (CPU)
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# For balance
model = WhisperModel("base", device="cpu", compute_type="int8")

# For accuracy (GPU recommended)
model = WhisperModel("large-v2", device="cuda", compute_type="float16")

2. Под железо

model = WhisperModel("base", device="cpu", compute_type="int8")

model = WhisperModel("large-v2", device="cuda", compute_type="float16")

model = WhisperModel("medium", device="cuda", compute_type="int8_float16")

3. Пакеты для нескольких файлов

# Process multiple files efficiently
audio_files = ["file1.mp3", "file2.mp3", "file3.mp3"]
model = WhisperModel("base", device="cuda", compute_type="float16")

for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)
    # Process results...

4. VAD при шуме

segments, info = model.transcribe(
    "noisy_audio.mp3",
    vad_filter=True,
    vad_parameters=dict(
        min_silence_duration_ms=1000,
        threshold=0.5
    )
)

5. Язык, если известен

# Faster and more accurate when language is known
segments, info = model.transcribe(
    "audio.mp3",
    language="en"  # Specify instead of auto-detect
)

6. Переиспользование модели

# Load model once, reuse for multiple files
model = WhisperModel("base")

# Process multiple files with same model
for audio_file in audio_files:
    segments, info = model.transcribe(audio_file)

---

Переход с OpenAI Whisper

Сравнение кода

import whisper

model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
print(result["text"])

from faster_whisper import WhisperModel

model = WhisperModel("base", device="cpu", compute_type="int8")
segments, info = model.transcribe("audio.mp3")
text = " ".join([seg.text for seg in segments])
print(text)

Отличия

1. Загрузка: WhisperModel() вместо whisper.load_model()
2. Формат ответа: кортеж (segments, info) вместо dict
3. Сегменты: итератор объектов, не список
4. Device/compute_type: нужно задавать явно
5. Текст: склеить сегменты

Вспомогательная функция

def convert_to_whisper_format(segments, info):
    """Convert faster-whisper output to OpenAI Whisper format."""
    return {
        "text": " ".join([seg.text for seg in segments]),
        "language": info.language,
        "segments": [
            {
                "id": i,
                "start": seg.start,
                "end": seg.end,
                "text": seg.text,
                "words": [
                    {
                        "word": word.word,
                        "start": word.start,
                        "end": word.end
                    }
                    for word in seg.words
                ] if hasattr(seg, 'words') else []
            }
            for i, seg in enumerate(segments)
        ]
    }

# Usage
segments, info = model.transcribe("audio.mp3", word_timestamps=True)
result = convert_to_whisper_format(segments, info)
# Now compatible with OpenAI Whisper format

---

Устранение неполадок

Проблема 1: не хватает памяти CUDA

# Use smaller model
model = WhisperModel("base", device="cuda", compute_type="float16")

# Or use INT8 quantization
model = WhisperModel("large-v2", device="cuda", compute_type="int8_float16")

# Or use CPU
model = WhisperModel("large-v2", device="cpu", compute_type="int8")

Проблема 2: медленный CPU

# Use INT8 quantization
model = WhisperModel("base", device="cpu", compute_type="int8")

# Use smaller model
model = WhisperModel("tiny", device="cpu", compute_type="int8")

# Reduce beam size
segments, info = model.transcribe("audio.mp3", beam_size=1)

Проблема 3: не найдены библиотеки CUDA

# Install CUDA libraries
pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

# Set library path
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__))')

Проблема 4: сбой загрузки модели

# Specify download directory
model = WhisperModel(
    "base",
    download_root="./models",  # Custom directory
    local_files_only=False
)

# Or download manually from Hugging Face
# Then use local path
model = WhisperModel("/path/to/local/model")

---

Когда использовать Faster-whisper

Faster-whisper, если:

OpenAI Whisper, если:

---

Заключение

• INT8 для CPU и слабых систем
• FP16 для GPU с достаточным VRAM
• Включайте пакеты для нескольких файлов
• Указывайте язык, если известен
• Переиспользуйте загруженную модель

---