2-1Estructura de Proyecto y Puesta en Marcha de Whisper con Python

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

3. 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

3. 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

¿Necesitas alguna adaptación específica para tu caso de uso? ¡Déjame saber en los comentarios