Whisper de OpenAI con Python

 

Tutorial: Cómo Usar Whisper de OpenAI con Python para Transcripción de Audio

Hola lectores! En este tutorial les mostraré cómo utilizar Whisper, el potente modelo de reconocimiento de voz de OpenAI, con Python para transcribir archivos de audio a texto.

¿Qué es Whisper?

Whisper es un sistema de reconocimiento automático de voz (ASR) de código abierto desarrollado por OpenAI que puede transcribir audio en múltiples idiomas con gran precisión. Es capaz de manejar diferentes acentos, ruido de fondo y jerga técnica.

Requisitos previos

  • Python 3.7 o superior

  • pip (gestor de paquetes de Python)

  • Un poco de conocimiento básico de Python

Paso 1: Instalación

Primero, necesitamos instalar Whisper. Abre tu terminal o línea de comandos y ejecuta:

bash
Copy
Download
pip install -U openai-whisper

Whisper también requiere tener instalado ffmpeg en tu sistema:

Paso 2: Cargar un modelo

Whisper ofrece varios modelos con diferentes equilibrios entre velocidad y precisión:

  • tiny - Más rápido, menos preciso

  • base

  • small

  • medium

  • large - Más lento, más preciso

python
Copy
Download
import whisper

# Cargar el modelo (puedes cambiar 'base' por otro modelo según tus necesidades)
model = whisper.load_model("base")

Paso 3: Transcribir un archivo de audio

Ahora vamos a transcribir un archivo de audio. Guarda tu archivo de audio (MP3, WAV, etc.) en el mismo directorio que tu script o proporciona la ruta completa.

python
Copy
Download
# Transcribir audio
result = model.transcribe("audio.mp3")
print(result["text"])

Paso 4: Opciones avanzadas

Whisper ofrece varias opciones para personalizar la transcripción:

python
Copy
Download
result = model.transcribe(
    "audio.mp3",
    language="es",  # Especificar idioma (opcional)
    fp16=False,     # Usar precisión simple si no tienes GPU
    verbose=True    # Mostrar progreso
)

# También puedes obtener segmentos con marcas de tiempo
for segment in result["segments"]:
    print(f"{segment['start']} - {segment['end']}: {segment['text']}")

Paso 5: Procesamiento por lotes

Si tienes varios archivos para transcribir:

python
Copy
Download
import os

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

for audio_file in audio_files:
    if os.path.exists(audio_file):
        result = model.transcribe(audio_file)
        print(f"Transcripción para {audio_file}:")
        print(result["text"])
        print("\n---\n")
    else:
        print(f"Archivo {audio_file} no encontrado")

Consejos para mejores resultados

  1. Calidad de audio: Mientras más claro el audio, mejor será la transcripción.

  2. Modelo adecuado: Para español, los modelos medium o large suelen dar mejores resultados.

  3. Especificar idioma: Aunque Whisper detecta automáticamente el idioma, especificarlo puede mejorar la precisión.

  4. Hardware: Para archivos largos o modelos grandes, considera usar una GPU.

Ejemplo completo

python
Copy
Download
import whisper

def transcribir_audio(ruta_audio, modelo="base", idioma="es"):
    # Cargar modelo
    model = whisper.load_model(modelo)
    
    # Transcribir audio
    result = model.transcribe(ruta_audio, language=idioma)
    
    # Mostrar resultados
    print("Transcripción completa:")
    print(result["text"])
    
    print("\nSegmentos con marcas de tiempo:")
    for segment in result["segments"]:
        print(f"{segment['start']:.2f}s - {segment['end']:.2f}s: {segment['text']}")
    
    return result

# Uso de la función
transcripcion = transcribir_audio("entrevista.mp3", modelo="medium")

Conclusión

Whisper es una herramienta poderosa para convertir audio a texto con Python. Con solo unas pocas líneas de código puedes integrar capacidades avanzadas de reconocimiento de voz en tus proyectos.

¿Tienes preguntas o quieres compartir cómo estás usando Whisper? ¡Déjalo en los comentarios!

Nota: Recuerda que los modelos más grandes requieren más recursos y tiempo de procesamiento. Elige el modelo que mejor se adapte a tus necesidades


Estructura de Proyecto y Puesta en Marcha de Whisper con Python

Vamos a ver cómo hacer funcionar Whisper en un proyecto real y la estructura recomendada para organizar tu código.

Estructura Recomendada del Proyecto

text
Copy
Download
/proyecto-whisper
│
├── /audios                  # Carpeta para archivos de audio de entrada
│   ├── entrada1.mp3
│   └── entrada2.wav
│
├── /transcripciones         # Carpeta para resultados de transcripción
│   ├── salida1.txt
│   └── salida1.json
│
├── config.py                # Configuraciones del proyecto
├── main.py                  # Script principal
├── requirements.txt         # Dependencias
└── README.md                # Documentación

Paso 1: Configuración Inicial

  1. Crea la estructura de carpetas

  2. Crea el archivo requirements.txt:

text
Copy
Download
openai-whisper
python-dotenv
tqdm

  1. Instala las dependencias:

bash
Copy
Download
pip install -r requirements.txt

Paso 2: Configuración (config.py)

python
Copy
Download
import os
from dotenv import load_dotenv

# Cargar variables de entorno
load_dotenv()

# Configuración
class Config:
    # Directorios
    AUDIO_INPUT_DIR = "audios"
    TRANSCRIPT_OUTPUT_DIR = "transcripciones"
    
    # Modelo Whisper (tiny, base, small, medium, large)
    MODEL_NAME = os.getenv("WHISPER_MODEL", "base")
    
    # Idioma (None para auto-detectar)
    LANGUAGE = os.getenv("LANGUAGE", "es")
    
    # Formato de salida
    OUTPUT_FORMATS = ["txt", "json", "srt"]

Paso 3: Código Principal (main.py)

python
Copy
Download
import os
import whisper
import json
from tqdm import tqdm
from config import Config

def transcribe_audio(input_path, output_base, config):
    """Transcribe un archivo de audio usando Whisper"""
    
    # Cargar modelo
    model = whisper.load_model(config.MODEL_NAME)
    
    # Transcribir
    result = model.transcribe(
        input_path,
        language=config.LANGUAGE,
        verbose=False
    )
    
    # Guardar resultados en diferentes formatos
    if "txt" in config.OUTPUT_FORMATS:
        with open(f"{output_base}.txt", "w", encoding="utf-8") as f:
            f.write(result["text"])
    
    if "json" in config.OUTPUT_FORMATS:
        with open(f"{output_base}.json", "w", encoding="utf-8") as f:
            json.dump(result, f, ensure_ascii=False, indent=2)
    
    if "srt" in config.OUTPUT_FORMATS:
        with open(f"{output_base}.srt", "w", encoding="utf-8") as f:
            for i, segment in enumerate(result["segments"], start=1):
                f.write(f"{i}\n")
                f.write(f"{segment['start']:.3f} --> {segment['end']:.3f}\n")
                f.write(f"{segment['text']}\n\n")
    
    return result

def process_all_audios(config):
    """Procesa todos los archivos de audio en el directorio de entrada"""
    
    # Crear directorio de salida si no existe
    os.makedirs(config.TRANSCRIPT_OUTPUT_DIR, exist_ok=True)
    
    # Obtener lista de archivos de audio
    audio_files = [
        f for f in os.listdir(config.AUDIO_INPUT_DIR)
        if f.lower().endswith(('.mp3', '.wav', '.m4a', '.ogg'))
    ]
    
    if not audio_files:
        print(f"No se encontraron archivos de audio en {config.AUDIO_INPUT_DIR}")
        return
    
    print(f"Procesando {len(audio_files)} archivo(s) de audio...")
    
    for audio_file in tqdm(audio_files, desc="Transcribiendo audios"):
        input_path = os.path.join(config.AUDIO_INPUT_DIR, audio_file)
        output_base = os.path.join(
            config.TRANSCRIPT_OUTPUT_DIR,
            os.path.splitext(audio_file)[0]
        )
        
        try:
            transcribe_audio(input_path, output_base, config)
        except Exception as e:
            print(f"\nError procesando {audio_file}: {str(e)}")

if __name__ == "__main__":
    config = Config()
    process_all_audios(config)
    print("Proceso completado!")

Paso 4: Poner en Marcha el Proyecto

  1. Coloca tus archivos de audio en la carpeta /audios

  2. Ejecuta el script principal:

bash
Copy
Download
python main.py

  1. Encuentra los resultados en /transcripciones:

    • Archivos .txt con el texto transcrito

    • Archivos .json con todos los metadatos

    • Archivos .srt con subtítulos con marcas de tiempo

Optimizaciones Adicionales

1. Usar GPU (si está disponible)

Instala la versión de PyTorch para GPU:

bash
Copy
Download
pip uninstall torch
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

2. Procesamiento por lotes con multiprocesamiento

Modifica main.py para usar múltiples núcleos:

python
Copy
Download
from multiprocessing import Pool, cpu_count

def process_single_audio(args):
    audio_file, config = args
    input_path = os.path.join(config.AUDIO_INPUT_DIR, audio_file)
    output_base = os.path.join(
        config.TRANSCRIPT_OUTPUT_DIR,
        os.path.splitext(audio_file)[0]
    )
    try:
        transcribe_audio(input_path, output_base, config)
        return (audio_file, True)
    except Exception as e:
        return (audio_file, False, str(e))

def process_all_audios(config):
    # ... (código anterior para crear directorios)
    
    audio_files = [f for f in os.listdir(config.AUDIO_INPUT_DIR) 
                  if f.lower().endswith(('.mp3', '.wav', '.m4a', '.ogg'))]
    
    if not audio_files:
        print(f"No se encontraron archivos de audio en {config.AUDIO_INPUT_DIR}")
        return
    
    print(f"Procesando {len(audio_files)} archivo(s) de audio con {cpu_count()} procesos...")
    
    with Pool(processes=cpu_count()) as pool:
        results = list(tqdm(
            pool.imap(process_single_audio, [(f, config) for f in audio_files]),
            total=len(audio_files),
            desc="Transcribiendo audios"
        ))
    
    # Mostrar resumen de resultados
    success = sum(1 for r in results if r[1])
    errors = len(audio_files) - success
    
    print(f"\nProceso completado: {success} éxitos, {errors} errores")
    if errors > 0:
        print("\nErrores encontrados:")
        for r in results:
            if not r[1]:
                print(f"- {r[0]}: {r[2]}")

Posibles Problemas y Soluciones

  1. Error de memoria: Usa un modelo más pequeño (tiny o base) o divide el audio en segmentos

  2. Audio muy largo: Procesa por fragmentos de 30-60 segundos

  3. Baja calidad de transcripción:

    • Prueba con el modelo large

    • Especifica el idioma exacto

    • Mejora la calidad del audio de entrada

Conclusión

Esta estructura te permite:

  • Organizar fácilmente tus archivos de entrada/salida

  • Configurar el modelo según tus necesidades

  • Procesar múltiples archivos automáticamente

  • Obtener resultados en diferentes formatos

  • Escalar usando múltiples núcleos del CPU

Comentarios

Publicar un comentario

Entradas más populares de este blog

1-configurar Vosk para que utilice todos los recursos de mi pc

  Para configurar   Vosk   y que utilice   todos los recursos de tu PC   con la   máxima prioridad , sigue estos pasos (cubriendo ajustes de software, sistema operativo y configuración de Vosk): 1. Configuración de Vosk (Python) A. Usar el modelo más optimizado Descarga el modelo  Vosk más grande y preciso  (pero aún rápido) para tu idioma (ej.  vosk-model-es-0.42  para español): bash Copy Download wget https://alphacephei.com/vosk/models/vosk-model-es-0.42.zip unzip vosk-model-es-0.42.zip B. Ajustar parámetros de reconocimiento En tu script de Python, activa opciones de rendimiento: python Copy Download from vosk import Model , KaldiRecognizer import pyaudio # Carga el modelo con threads adicionales (usa todos los núcleos del CPU) model = Model ( "ruta/al/modelo" , log_level = 0 ) # log_level=0 silencia logs innecesarios # Configura el reconocedor para audio en tiempo real recognizer = KaldiRecognizer ( model , 16000 ) ...
Leer más

3-Whisper vs Vosk

  La elección entre   Whisper   (de OpenAI) y   Vosk   para   dictado por voz en tiempo real   depende de varios factores, como precisión, velocidad, idiomas soportados y requerimientos de hardware. Aquí tienes una comparación detallada: 1. Precisión y Calidad del Dictado Característica Whisper Vosk Modelo base Basado en transformers (OpenAI) Basado en Kaldi (ASR tradicional) Precisión en español Muy alta (especialmente en modelos "medium" o "large") Buena, pero puede requerir ajustes para voces con ruido o acentos Idiomas soportados 100+ (incluyendo español con gran calidad) 20+ (español incluido, con modelos específicos) Contexto y fluidez Mejor manejo de frases largas y contexto Más enfocado en palabras sueltas o frases cortas 👉  Ganador :  Whisper  (mejor para transcripciones fluidas y naturales). 2. Velocidad y Tiempo Real Característica Whisper Vosk Latencia Mayor (depende del modelo; "tiny" o "base" son más rápidos) Muy baja (opt...
Leer más