Consejos de precisión de Whisper: cómo mejorar la calidad de la transcripción

• Desarrolladores que optimizan la precisión de la transcripción con Whisper
• Creadores de contenido que transcriben podcasts y vídeos
• Investigadores que trabajan con datos de audio
• Cualquiera que busque consejos de precisión de Whisper

Comprender los factores de precisión de Whisper

• Calidad del audio (lo más importante)
• Tamaño del modelo
• Precisión de la detección de idioma
• Preprocesado del audio
• Parámetros de configuración
• Duración del audio y segmentación

Consejo 1: Elija el tamaño de modelo adecuado

import whisper

# Model sizes from fastest to most accurate:
# tiny, base, small, medium, large

# For maximum accuracy, use medium or large
model = whisper.load_model("medium")  # Best balance
# or
model = whisper.load_model("large")  # Maximum accuracy

import whisper

def transcribe_with_optimal_model(audio_path, prioritize_accuracy=True):
    """
    Select model based on accuracy vs speed priority.
    
    Args:
        audio_path: Path to audio file
        prioritize_accuracy: True for accuracy, False for speed
    """
    if prioritize_accuracy:
        model_size = "medium"  # or "large" for best accuracy
    else:
        model_size = "base"  # or "small" for balanced
    
    model = whisper.load_model(model_size)
    result = model.transcribe(audio_path)
    
    return result

# For critical transcriptions
result = transcribe_with_optimal_model("important_meeting.mp3", prioritize_accuracy=True)

Consejo 2: Especifique el idioma cuando lo conozca

import whisper

model = whisper.load_model("base")

# Auto-detect (less accurate)
result_auto = model.transcribe("audio.mp3")

# Specify language (more accurate)
result_en = model.transcribe("audio.mp3", language="en")
result_zh = model.transcribe("audio.mp3", language="zh")
result_es = model.transcribe("audio.mp3", language="es")

• Reduce errores de detección de idioma
• Mejora la precisión con hablantes multilingües
• Acelera el procesamiento (omite la detección)
• Mejor manejo de acentos y dialectos

import whisper
import langdetect

def transcribe_with_language_detection(audio_path, model_size="base"):
    """
    Detect language first, then transcribe with explicit language.
    """
    model = whisper.load_model(model_size)
    
    # Quick language detection
    result_quick = model.transcribe(audio_path, language=None)
    detected_lang = result_quick["language"]
    
    # Re-transcribe with detected language for better accuracy
    result = model.transcribe(audio_path, language=detected_lang)
    
    return result

result = transcribe_with_language_detection("audio.mp3")

Consejo 3: Preprocese el audio antes de transcribir

import whisper
import numpy as np
from scipy.io import wavfile
from scipy import signal

def preprocess_audio(audio_path, output_path):
    """
    Preprocess audio to improve transcription accuracy.
    """
    # Read audio file
    sample_rate, audio = wavfile.read(audio_path)
    
    # Normalize audio (scale to [-1, 1])
    if audio.dtype == np.int16:
        audio = audio.astype(np.float32) / 32768.0
    elif audio.dtype == np.int32:
        audio = audio.astype(np.float32) / 2147483648.0
    
    # Remove DC offset
    audio = audio - np.mean(audio)
    
    # Normalize volume
    max_val = np.max(np.abs(audio))
    if max_val > 0:
        audio = audio / max_val * 0.95  # Leave headroom
    
    # Resample to 16kHz (Whisper's optimal sample rate)
    if sample_rate != 16000:
        num_samples = int(len(audio) * 16000 / sample_rate)
        audio = signal.resample(audio, num_samples)
        sample_rate = 16000
    
    # Save preprocessed audio
    wavfile.write(output_path, sample_rate, (audio * 32767).astype(np.int16))
    
    return output_path

# Usage
preprocessed = preprocess_audio("raw_audio.wav", "preprocessed.wav")
model = whisper.load_model("base")
result = model.transcribe(preprocessed)

1. Normalizar niveles – volumen consistente
2. Eliminar offset DC – eliminar sesgo constante
3. Remuestrear a 16 kHz – frecuencia óptima para Whisper
4. Eliminar silencios – centrarse en el habla
5. Reducir ruido – limpiar el fondo

Consejo 4: Use la temperatura para mejores resultados

import whisper

model = whisper.load_model("base")

# Default temperature (0.0)
result_default = model.transcribe("audio.mp3")

# Lower temperature for more deterministic results
result_low_temp = model.transcribe(
    "audio.mp3",
    temperature=0.0,  # Most deterministic
    best_of=5,  # Try multiple decodings, pick best
    beam_size=5  # Beam search size
)

• temperature=0.0: Más determinista, mejor para precisión
• temperature=0.2: Ligera aleatoriedad, buen equilibrio
• temperature=0.6: Por defecto, equilibrado
• Valores más altos: más creativo pero menos preciso

def transcribe_with_optimal_settings(audio_path, model_size="base"):
    """
    Use optimal settings for maximum accuracy.
    """
    model = whisper.load_model(model_size)
    
    result = model.transcribe(
        audio_path,
        temperature=0.0,  # Most deterministic
        best_of=5,  # Try 5 decodings, pick best
        beam_size=5,  # Beam search
        patience=1.0,  # Patience for beam search
        condition_on_previous_text=True,  # Use context
        initial_prompt="This is a conversation about technology."  # Context hint
    )
    
    return result

Consejo 5: Proporcione un prompt inicial de contexto

import whisper

model = whisper.load_model("base")

# Without context
result_basic = model.transcribe("meeting.mp3")

# With context (much better accuracy)
result_context = model.transcribe(
    "meeting.mp3",
    initial_prompt="This is a business meeting discussing project timelines and deliverables."
)

# For technical content
result_tech = model.transcribe(
    "lecture.mp3",
    initial_prompt="This is a computer science lecture about machine learning and neural networks."
)

• Contenido técnico: incluya términos del dominio
• Nombres y lugares: mencione sustantivos propios importantes
• Acentos: describa el acento o dialecto
• Contexto: describa el entorno o el tema

def transcribe_with_context(audio_path, context_description):
    """
    Transcribe with context for better accuracy.
    """
    model = whisper.load_model("medium")
    
    result = model.transcribe(
        audio_path,
        initial_prompt=context_description,
        language="en"
    )
    
    return result

# Example usage
result = transcribe_with_context(
    "interview.mp3",
    "This is an interview with Dr. Sarah Johnson about medical research. "
    "The conversation includes technical medical terminology."
)

Consejo 6: Maneje bien los archivos de audio largos

import whisper
from pydub import AudioSegment
import os

def transcribe_long_audio(audio_path, model_size="base", chunk_length_minutes=30):
    """
    Transcribe long audio by splitting into optimal chunks.
    """
    model = whisper.load_model(model_size)
    
    # Load audio
    audio = AudioSegment.from_file(audio_path)
    chunk_length_ms = chunk_length_minutes * 60 * 1000
    
    # Split into chunks
    chunks = []
    for i in range(0, len(audio), chunk_length_ms):
        chunks.append(audio[i:i + chunk_length_ms])
    
    # Transcribe each chunk
    full_text = []
    all_segments = []
    
    for i, chunk in enumerate(chunks):
        chunk_path = f"temp_chunk_{i}.wav"
        chunk.export(chunk_path, format="wav")
        
        print(f"Transcribing chunk {i+1}/{len(chunks)}")
        result = model.transcribe(chunk_path)
        
        # Adjust timestamps for chunk offset
        offset = i * chunk_length_ms / 1000.0
        for segment in result["segments"]:
            segment["start"] += offset
            segment["end"] += offset
            all_segments.append(segment)
        
        full_text.append(result["text"])
        
        # Clean up
        os.remove(chunk_path)
    
    # Combine results
    combined_result = {
        "text": " ".join(full_text),
        "segments": all_segments,
        "language": result["language"]
    }
    
    return combined_result

# Usage
result = transcribe_long_audio("long_podcast.mp3", model_size="medium", chunk_length_minutes=30)

• Dividir en fragmentos de 20–30 minutos
• Usar el mismo tamaño de modelo en todos los fragmentos
• Mantener contexto entre fragmentos
• Fusionar segmentos con marcas de tiempo correctas

Consejo 7: Optimice para audio ruidoso

import whisper
import noisereduce as nr
import soundfile as sf
import numpy as np

def transcribe_noisy_audio(audio_path, model_size="medium"):
    """
    Reduce noise before transcription for better accuracy.
    """
    # Load audio
    audio, sample_rate = sf.read(audio_path)
    
    # Reduce noise
    reduced_noise = nr.reduce_noise(
        y=audio,
        sr=sample_rate,
        stationary=False,  # For non-stationary noise
        prop_decrease=0.8  # Reduce noise by 80%
    )
    
    # Save cleaned audio
    cleaned_path = "cleaned_audio.wav"
    sf.write(cleaned_path, reduced_noise, sample_rate)
    
    # Transcribe with larger model (better for noisy audio)
    model = whisper.load_model(model_size)
    result = model.transcribe(cleaned_path)
    
    # Clean up
    os.remove(cleaned_path)
    
    return result

# Usage
result = transcribe_noisy_audio("noisy_recording.mp3", model_size="medium")

• Use modelos medium o large
• Preprocese con reducción de ruido
• Aumente el parámetro best_of
• Proporcione contexto sobre las condiciones de ruido

Consejo 8: Use marcas de tiempo por palabra para más control

import whisper

model = whisper.load_model("base")

# Get word timestamps
result = model.transcribe(
    "audio.mp3",
    word_timestamps=True  # Enable word-level timestamps
)

# Access word timestamps
for segment in result["segments"]:
    print(f"Segment: {segment['text']}")
    print(f"Start: {segment['start']:.2f}s, End: {segment['end']:.2f}s")
    
    if "words" in segment:
        for word in segment["words"]:
            print(f"  Word: {word['word']} ({word['start']:.2f}s - {word['end']:.2f}s)")

• Subtítulos: sincronización precisa por palabra
• Corrección de errores: identificar palabras problemáticas
• Búsqueda: encontrar palabras concretas en el texto
• Análisis del habla: patrones de habla

Consejo 9: Combine varias decodificaciones

import whisper

model = whisper.load_model("base")

# Single decoding (default)
result_single = model.transcribe("audio.mp3")

# Multiple decodings, pick best (more accurate)
result_best = model.transcribe(
    "audio.mp3",
    best_of=5,  # Try 5 decodings
    temperature=(0.0, 0.2, 0.4, 0.6, 0.8)  # Different temperatures
)

• Precisión: mayor con varias decodificaciones
• Velocidad: más lenta (5× con best_of=5)
• Úselo cuando: la precisión sea crítica y la velocidad menos importante

Consejo 10: Postprocese las transcripciones

import re
import whisper

def post_process_transcript(text):
    """
    Fix common transcription errors.
    """
    # Fix common contractions
    text = re.sub(r"\b(\w+) '(\w+)\b", r"\1'\2", text)  # Fix spacing in contractions
    
    # Fix common homophones (add your own)
    replacements = {
        "there": "their",  # Context-dependent
        "its": "it's",  # Context-dependent
        # Add more based on your domain
    }
    
    # Capitalize sentences
    sentences = re.split(r'([.!?]\s+)', text)
    capitalized = []
    for i, sentence in enumerate(sentences):
        if sentence.strip():
            capitalized.append(sentence[0].upper() + sentence[1:] if len(sentence) > 1 else sentence.upper())
        else:
            capitalized.append(sentence)
    
    return "".join(capitalized)

# Usage
model = whisper.load_model("base")
result = model.transcribe("audio.mp3")
processed_text = post_process_transcript(result["text"])

Ejemplo completo: optimización de precisión lista para producción

import whisper
import os
from pathlib import Path

def transcribe_with_maximum_accuracy(
    audio_path,
    model_size="medium",
    language=None,
    context_prompt=None,
    output_format="txt"
):
    """
    Transcribe audio with maximum accuracy using best practices.
    
    Args:
        audio_path: Path to audio file
        model_size: Whisper model size (medium or large recommended)
        language: Language code (None for auto-detect)
        context_prompt: Initial prompt for context
        output_format: Output format (txt, json, srt)
    """
    # Load model (medium or large for best accuracy)
    print(f"Loading Whisper model: {model_size}")
    model = whisper.load_model(model_size)
    
    # Prepare transcription parameters
    transcribe_kwargs = {
        "temperature": 0.0,  # Most deterministic
        "best_of": 5,  # Try multiple decodings
        "beam_size": 5,  # Beam search
        "patience": 1.0,
        "condition_on_previous_text": True,
        "word_timestamps": True,  # Get word-level timestamps
    }
    
    # Add language if specified
    if language:
        transcribe_kwargs["language"] = language
    
    # Add context prompt if provided
    if context_prompt:
        transcribe_kwargs["initial_prompt"] = context_prompt
    
    # Transcribe
    print(f"Transcribing: {audio_path}")
    result = model.transcribe(audio_path, **transcribe_kwargs)
    
    # Post-process
    result["text"] = post_process_transcript(result["text"])
    
    # Save result
    base_name = Path(audio_path).stem
    output_path = f"{base_name}_transcript.{output_format}"
    
    if output_format == "txt":
        with open(output_path, "w", encoding="utf-8") as f:
            f.write(result["text"])
    elif output_format == "json":
        import json
        with open(output_path, "w", encoding="utf-8") as f:
            json.dump(result, f, indent=2, ensure_ascii=False)
    
    print(f"✓ Transcription saved: {output_path}")
    print(f"  Language: {result['language']}")
    print(f"  Duration: {result['segments'][-1]['end']:.2f}s")
    
    return result

# Example usage
result = transcribe_with_maximum_accuracy(
    audio_path="important_meeting.mp3",
    model_size="medium",
    language="en",
    context_prompt="This is a business meeting discussing quarterly results and project updates.",
    output_format="txt"
)

Comparación de precisión: antes y después de optimizar

Resumen de buenas prácticas

Para máxima precisión:

1. ✅ Use el modelo medium o large
2. ✅ Especifique el idioma explícitamente
3. ✅ Proporcione contexto con initial_prompt
4. ✅ Use temperature=0.0 para resultados deterministas
5. ✅ Active word_timestamps para salida detallada
6. ✅ Preprocese audio ruidoso
7. ✅ Divida archivos largos en fragmentos
8. ✅ Use best_of=5 para contenido crítico

Para equilibrio velocidad/precisión:

1. ✅ Use el modelo small o base
2. ✅ Deje que Whisper detecte el idioma automáticamente
3. ✅ Use la temperatura por defecto
4. ✅ Omita el parámetro best_of
5. ✅ Procese archivos con preprocesado mínimo

Errores frecuentes a evitar

❌ Usar el modelo tiny para contenido importante

❌ No especificar el idioma

❌ Ignorar el contexto

❌ Usar ajustes por defecto con audio ruidoso

❌ Procesar archivos muy largos sin dividir

Solución de problemas de precisión

Problema: Baja precisión con términos técnicos

result = model.transcribe(
    "technical_audio.mp3",
    initial_prompt="This audio contains technical terminology related to machine learning, neural networks, and deep learning."
)

Problema: Mala precisión con acentos

# Use larger model
model = whisper.load_model("medium")

# Provide accent context
result = model.transcribe(
    "accented_audio.mp3",
    initial_prompt="This speaker has a British accent.",
    language="en"
)

Problema: Errores con nombres propios

# Include names in initial prompt
result = model.transcribe(
    "interview.mp3",
    initial_prompt="This interview features Dr. Sarah Johnson and Professor Michael Chen discussing research."
)

Conclusión

• Selección del modelo: Elija medium o large para contenido crítico
• Configuración: Use temperatura y decodificación óptimas
• Contexto: Proporcione información del dominio
• Preprocesado: Limpie el audio antes de transcribir
• Postprocesado: Corrija errores habituales automáticamente

1. El tamaño del modelo tiene el mayor impacto en la precisión
2. Especificar el idioma mejora mucho los resultados
3. Los prompts de contexto ayudan con contenido especializado
4. Varias decodificaciones (best_of) aumentan la precisión pero ralentizan el proceso
5. La calidad del audio sigue siendo el factor más importante