Guía de Faster-Whisper: voz a texto más rápido con CTranslate2

---

¿Qué es Faster-whisper?

Características principales

• Inferencia 2-4× más rápida que OpenAI Whisper
• Menor uso de memoria con soporte de cuantización
• Misma precisión que los modelos Whisper originales
• Soporte GPU y CPU con backends optimizados
• Procesamiento por lotes para varios archivos
• Marcas de tiempo a nivel de palabra
• Opciones de cuantización (FP32, FP16, INT8, INT8_FLOAT16)
• Detección de actividad de voz (VAD) para filtrar

Cómo funciona

• Operaciones matriciales más rápidas con bibliotecas BLAS optimizadas
• Mejor gestión de memoria con menos sobrecarga
• Cuantización para menor consumo de memoria
• Procesamiento por lotes para optimizar el rendimiento

---

Faster-whisper vs OpenAI Whisper

Comparación de rendimiento

Característica	OpenAI Whisper	Faster-whisper
Velocidad	Referencia	2-4× más rápido
Memoria	Mayor	Menor (con cuantización)
Precisión	Alta	Igual (modelos idénticos)
Soporte GPU	Sí	Sí (optimizado)
Soporte CPU	Sí	Sí (optimizado)
Cuantización	Limitada	Completa (INT8, FP16)
Procesamiento por lotes	Manual	Integrado
Instalación	Simple	Simple (incluye CTranslate2)

Cuándo usar Faster-whisper

• Necesite transcripción más rápida para cargas de producción
• Procese varios archivos por lotes
• Ejecute en sistemas con recursos limitados (use INT8)
• Construya aplicaciones en tiempo real o casi en tiempo real
• Necesite menor uso de memoria en despliegue

• Necesite máxima compatibilidad con código existente
• Use modelos afinados (faster-whisper requiere conversión)
• Prefiera una API más simple (faster-whisper es similar)
• Trabaje con funciones experimentales que llegan antes a OpenAI Whisper

---

Instalación

Requisitos previos

• Python 3.9+ (obligatorio)
• FFmpeg (opcional: faster-whisper usa PyAV, pero FFmpeg puede ser necesario para algunos formatos)
• GPU NVIDIA (opcional, para aceleración GPU)

Instalación básica

pip install faster-whisper

• el paquete faster-whisper
• ctranslate2 (motor de inferencia CTranslate2)
• pyav (decodificación de audio, sustituye la dependencia de FFmpeg)

Instalación 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

Comprobar la instalación

from faster_whisper import WhisperModel

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

---

Uso básico

Transcripción simple

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

Obtener el 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)

Con marcas de tiempo por palabra

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

---

Opciones de dispositivo y tipo de cómputo

Opciones de dispositivo

• device="cpu" — inferencia en CPU (funciona en cualquier sitio)
• device="cuda" — inferencia en GPU (requiere GPU NVIDIA y CUDA)

Tipos de cómputo

Tipo de cómputo	Velocidad	Memoria	Precisión	Caso de uso
int8	Más rápido	Mínima	Ligeramente menor	CPU, recursos limitados
int8_float16	Muy rápido	Baja	Alta	GPU con VRAM limitada
float16	Rápido	Media	Alta	GPU (recomendado)
float32	Más lento	Máxima	Máxima	Máxima precisión

Ejemplos según 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")

---

Funciones avanzadas

1. Procesamiento por lotes

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. Detección de actividad 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. Tamaño de haz y otros 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. Rutas de modelo personalizadas

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 rendimiento

Rendimiento GPU (NVIDIA RTX 3070 Ti)

Configuración	Tiempo	Uso VRAM	Aceleración
OpenAI Whisper (FP16, beam=5)	~2m 23s	~4708 MB	Referencia
Faster-whisper (FP16, beam=5)	~1m 03s	~4525 MB	2.3× más rápido
Faster-whisper (INT8, beam=5)	~59s	~2926 MB	2.4× más rápido
Faster-whisper (FP16, batch=8)	~17s	~6090 MB	8.4× más rápido
Faster-whisper (INT8, batch=8)	~16s	~4500 MB	8.9× más rápido

Rendimiento CPU (Intel Core i7-12700K)

Configuración	Tiempo	Uso RAM	Aceleración
OpenAI Whisper (FP32, beam=5)	~6m 58s	~2335 MB	Referencia
Faster-whisper (FP32, beam=5)	~2m 37s	~2257 MB	2.7× más rápido
Faster-whisper (INT8, beam=5)	~1m 42s	~1477 MB	4.1× más rápido
Faster-whisper (FP32, batch=8)	~1m 06s	~4230 MB	6.3× más rápido
Faster-whisper (INT8, batch=8)	~51s	~3608 MB	8.2× más rápido

Ideas clave

• El procesamiento por lotes da la mayor aceleración (8×+ en GPU)
• La cuantización INT8 reduce la memoria ~40 % con poca pérdida de precisión
• La aceleración GPU es esencial para modelos grandes y lotes
• CPU con INT8 es viable para modelos pequeños y un solo archivo

---

Ejemplo completo: transcripción lista para producción

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

---

Buenas prácticas

1. Elegir el tamaño de modelo adecuado

# 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. Optimizar para su 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. Procesamiento por lotes para varios archivos

# 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. Activar VAD con audio 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 cuando se conozca

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

6. Reutilizar instancias del 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)

---

Migración desde OpenAI Whisper

Comparación 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)

Diferencias clave

1. Carga del modelo: WhisperModel() en lugar de whisper.load_model()
2. Formato de retorno: tupla (segments, info) en lugar de dict
3. Segmentos: iterador de objetos segmento en lugar de lista
4. Dispositivo/tipo de cómputo: debe especificar device y compute_type
5. Acceso al texto: hay que unir segmentos para el texto completo

Función auxiliar de migración

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

---

Solución de problemas

Problema 1: CUDA sin memoria

# 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: no se encuentran bibliotecas 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__))')

Problema 4: falla la descarga del 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")

---

Cuándo usar Faster-whisper

Use Faster-whisper cuando:

Use OpenAI Whisper cuando:

---

Conclusión

• Use INT8 en CPU y sistemas limitados
• Use FP16 en GPU con VRAM suficiente
• Active el procesamiento por lotes para varios archivos
• Especifique el idioma si se conoce para mejor rendimiento
• Reutilice instancias del modelo para varias transcripciones

---