Guia Faster-Whisper: fala para texto mais rápido com CTranslate2

---

O que é Faster-whisper?

Principais recursos

• Inferência 2-4× mais rápida que o OpenAI Whisper
• Menor uso de memória com suporte a quantização
• Mesma precisão dos modelos Whisper originais
• Suporte a GPU e CPU com backends otimizados
• Processamento em lote para vários arquivos
• Carimbos de tempo por palavra
• Opções de quantização (FP32, FP16, INT8, INT8_FLOAT16)
• Deteção de atividade de voz (VAD) para filtrar

Como funciona

• Operações matriciais mais rápidas com bibliotecas BLAS otimizadas
• Melhor gestão de memória com menos sobrecarga
• Quantização para menor consumo de memória
• Processamento em lote para otimizar o throughput

---

Faster-whisper vs OpenAI Whisper

Comparação de desempenho

Recurso	OpenAI Whisper	Faster-whisper
Velocidade	Referência	2-4× mais rápido
Memória	Maior	Menor (com quantização)
Precisão	Alta	Igual (modelos idênticos)
Suporte GPU	Sim	Sim (otimizado)
Suporte CPU	Sim	Sim (otimizado)
Quantização	Limitada	Completa (INT8, FP16)
Processamento em lote	Manual	Integrado
Instalação	Simples	Simples (inclui CTranslate2)

Quando usar Faster-whisper

• Precisar de transcrição mais rápida para cargas de produção
• Processar vários arquivos em lote
• Executar em sistemas com recursos limitados (use INT8)
• Criar aplicações em tempo real ou quase em tempo real
• Precisar de menor uso de memória em implantação

• Precisar de máxima compatibilidade com código existente
• Usar modelos ajustados (faster-whisper exige conversão)
• Preferir uma API mais simples (faster-whisper é parecido)
• Trabalhar com recursos experimentais que chegam primeiro ao OpenAI Whisper

---

Instalação

Pré-requisitos

• Python 3.9+ (obrigatório)
• FFmpeg (opcional: faster-whisper usa PyAV, mas o FFmpeg pode ser necessário para alguns formatos)
• GPU NVIDIA (opcional, para aceleração GPU)

Instalação básica

pip install faster-whisper

• o pacote faster-whisper
• ctranslate2 (motor de inferência CTranslate2)
• pyav (decodificação de áudio, substitui a dependência do FFmpeg)

Instalação 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

Verificar a instalação

from faster_whisper import WhisperModel

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

---

Uso básico

Transcrição simples

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}")

Obter o texto completo

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)

Com carimbos de tempo por palavra

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]")

---

Opções de dispositivo e tipo de computação

Opções de dispositivo

• device="cpu" — inferência na CPU (funciona em qualquer lugar)
• device="cuda" — inferência na GPU (requer GPU NVIDIA e CUDA)

Tipos de computação

Tipo de computação	Velocidade	Memória	Precisão	Caso de uso
int8	Mais rápido	Mínima	Ligeiramente menor	CPU, recursos limitados
int8_float16	Muito rápido	Baixa	Alta	GPU com VRAM limitada
float16	Rápido	Média	Alta	GPU (recomendado)
float32	Mais lento	Máxima	Máxima	Máxima precisão

Exemplos por hardware

# 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")

---

Recursos avançados

1. Processamento em lote

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. Deteção de atividade de voz (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. Especificar idioma

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. Tamanho do feixe e outros parâmetros

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. Caminhos de modelo personalizados

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"
)

---

Benchmarks de desempenho

Desempenho GPU (NVIDIA RTX 3070 Ti)

Configuração	Tempo	Uso de VRAM	Aceleração
OpenAI Whisper (FP16, beam=5)	~2m 23s	~4708 MB	Referência
Faster-whisper (FP16, beam=5)	~1m 03s	~4525 MB	2.3× mais rápido
Faster-whisper (INT8, beam=5)	~59s	~2926 MB	2.4× mais rápido
Faster-whisper (FP16, batch=8)	~17s	~6090 MB	8.4× mais rápido
Faster-whisper (INT8, batch=8)	~16s	~4500 MB	8.9× mais rápido

Desempenho CPU (Intel Core i7-12700K)

Configuração	Tempo	Uso de RAM	Aceleração
OpenAI Whisper (FP32, beam=5)	~6m 58s	~2335 MB	Referência
Faster-whisper (FP32, beam=5)	~2m 37s	~2257 MB	2.7× mais rápido
Faster-whisper (INT8, beam=5)	~1m 42s	~1477 MB	4.1× mais rápido
Faster-whisper (FP32, batch=8)	~1m 06s	~4230 MB	6.3× mais rápido
Faster-whisper (INT8, batch=8)	~51s	~3608 MB	8.2× mais rápido

Ideias principais

• Processamento em lote traz o maior ganho (8×+ na GPU)
• Quantização INT8 reduz a memória ~40% com perda mínima de precisão
• Aceleração GPU é essencial para modelos grandes e lotes
• CPU com INT8 é viável para modelos menores e arquivo único

---

Exemplo completo: transcrição pronta para produção

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]}...")

---

Boas práticas

1. Escolher o tamanho certo do modelo

# 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. Otimizar para o seu hardware

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. Processamento em lote para vários arquivos

# 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. Ativar VAD com áudio ruidoso

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

5. Especificar idioma quando conhecido

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

6. Reutilizar instâncias do modelo

# 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)

---

Migração do OpenAI Whisper

Comparação de código

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)

Diferenças principais

1. Carregamento do modelo: WhisperModel() em vez de whisper.load_model()
2. Formato de retorno: tupla (segments, info) em vez de dict
3. Segmentos: iterador de objetos de segmento em vez de lista
4. Dispositivo/tipo de computação: é preciso especificar device e compute_type
5. Acesso ao texto: é preciso juntar segmentos para o texto completo

Função auxiliar de migração

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

---

Resolução de problemas

Problema 1: CUDA sem memória

# 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")

Problema 2: CPU lenta

# 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)

Problema 3: bibliotecas CUDA não encontradas

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

Problema 4: falha no download do modelo

# 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")

---

Quando usar Faster-whisper

Use Faster-whisper quando:

Use OpenAI Whisper quando:

---

Conclusão

• Use INT8 na CPU e em sistemas limitados
• Use FP16 na GPU com VRAM suficiente
• Ative processamento em lote para vários arquivos
• Especifique o idioma quando conhecido para melhor desempenho
• Reutilize instâncias do modelo para várias transcrições

---