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

Faster-whisper é uma reimplementação de alto desempenho do modelo Whisper da OpenAI usando CTranslate2, um motor de inferência de transformers rápido. Oferece transcrição 2-4× mais rápida com precisão semelhante, ideal para produção e processamento em lote.

Este guia cobre o essencial do faster-whisper: instalação, exemplos de uso, otimização de desempenho e quando preferi-lo ao Whisper padrão da OpenAI.

O que é Faster-whisper?

Faster-whisper é uma implementação otimizada do OpenAI Whisper que usa CTranslate2 para inferência mais rápida. Mantém a mesma precisão do original, melhora bastante a velocidade e reduz o uso de memória.

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

Faster-whisper converte modelos Whisper para o formato CTranslate2, que usa código C++ otimizado para inferência. Isso permite:

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

Escolha faster-whisper quando:

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

Mantenha o OpenAI Whisper quando:

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

Instale o faster-whisper com pip:

pip install faster-whisper

Isso instala automaticamente:

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)

Para aceleração GPU são necessárias bibliotecas CUDA:

CUDA 12 (recomendado):

pip install nvidia-cublas-cu12 nvidia-cudnn-cu12==9.*

Defina o caminho das bibliotecas:

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

CUDA 11 (legado):

Se tiver CUDA 11, use uma versão mais antiga do CTranslate2:

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

Escolha conforme o hardware e o equilíbrio velocidade/precisã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

CPU (Intel/AMD):

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

GPU (NVIDIA):

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

GPU com VRAM limitada:

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

Máxima precisão:

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

Recursos avançados

1. Processamento em lote

Processe vários arquivos de áudio com eficiência:

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)

Filtre silêncio e segmentos sem fala:

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

Indique o idioma para melhorar precisão e velocidade:

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

Use modelos locais ou convertidos 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)

Transcrição de ~13 minutos de áudio:

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

Somente CPU:

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

GPU com VRAM suficiente:

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

GPU com VRAM limitada:

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

OpenAI Whisper:

import whisper

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

Faster-whisper:

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

Carregamento do modelo: WhisperModel() em vez de whisper.load_model()
Formato de retorno: tupla (segments, info) em vez de dict
Segmentos: iterador de objetos de segmento em vez de lista
Dispositivo/tipo de computação: é preciso especificar device e compute_type
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

Problema: a GPU fica sem memória com modelos grandes.

Soluções:

# 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

Problema: a transcrição é lenta na CPU.

Soluções:

# 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

Problema: RuntimeError: CUDA runtime not found

Solução:

# 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

Problema: o download do modelo expira ou falha.

Solução:

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

✅ Implantações de produção exigem velocidade
✅ Processamento em lote de vários arquivos
✅ Ambientes com recursos limitados (use INT8)
✅ Aplicações em tempo real ou quase em tempo real
✅ Aceleração GPU disponível
✅ Menor uso de memória é importante

Use OpenAI Whisper quando:

✅ Máxima compatibilidade com código existente
✅ Modelos ajustados (integração mais simples)
✅ Preferência por API mais simples
✅ Recursos experimentais primeiro no OpenAI Whisper
✅ Aprendizado/desenvolvimento (mais documentação/exemplos)

Conclusão

Faster-whisper oferece melhorias significativas de desempenho em relação ao OpenAI Whisper mantendo a mesma precisão. Com a configuração adequada, é possível obter 2-4× mais velocidade na CPU e até 8× na GPU com processamento em lote.

Pontos principais:

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

Para mais informações sobre transcrição Whisper, veja os guias Exemplo Whisper em Python, Dicas de precisão do Whisper e Formatação de transcrições Whisper.

Procura uma solução profissional de fala para texto? Visite SayToWords para explorar a nossa plataforma de transcrição com IA, com desempenho otimizado e vários formatos de saída.

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

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

O que é Faster-whisper?

Principais recursos

Como funciona

Faster-whisper vs OpenAI Whisper

Comparação de desempenho

Quando usar Faster-whisper

Instalação

Pré-requisitos

Instalação básica

Instalação GPU (NVIDIA CUDA)

Verificar a instalação

Uso básico

Transcrição simples

Obter o texto completo

Com carimbos de tempo por palavra

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

Opções de dispositivo

Tipos de computação

Exemplos por hardware

Recursos avançados

1. Processamento em lote

2. Deteção de atividade de voz (VAD)

3. Especificar idioma

4. Tamanho do feixe e outros parâmetros

5. Caminhos de modelo personalizados

Benchmarks de desempenho

Desempenho GPU (NVIDIA RTX 3070 Ti)

Desempenho CPU (Intel Core i7-12700K)

Ideias principais

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

Boas práticas

1. Escolher o tamanho certo do modelo

2. Otimizar para o seu hardware

3. Processamento em lote para vários arquivos

4. Ativar VAD com áudio ruidoso

5. Especificar idioma quando conhecido

6. Reutilizar instâncias do modelo

Migração do OpenAI Whisper

Comparação de código

Diferenças principais

Função auxiliar de migração

Resolução de problemas

Problema 1: CUDA sem memória

Problema 2: CPU lenta

Problema 3: bibliotecas CUDA não encontradas

Problema 4: falha no download do modelo

Quando usar Faster-whisper

Use Faster-whisper quando:

Use OpenAI Whisper quando:

Conclusão

Posts relacionados

O que é conversão de fala em texto e como usar: guia completo para iniciantes

Como Converter Áudio em Texto Online: Métodos Gratuitos e Precisos (Guia 2026)

Como Remover Ruído de Fundo para STT: Guia Completo de Redução de Ruído para Speech-to-Text

Experimente grátis agora