Sistema Distribuido de Transcripción con Whisper

Este proyecto implementa un sistema distribuido para la transcripción de archivos de audio utilizando el modelo Whisper de OpenAI. El sistema divide los archivos de audio en segmentos más pequeños (de 5 minutos), procesa estos segmentos en paralelo utilizando múltiples contenedores, y luego unifica las transcripciones para generar un archivo de subtítulos.

Arquitectura del Sistema

El sistema está compuesto por cuatro tipos de componentes principales:

1. Receptor (Receiver): Monitorea el directorio de entrada para nuevos archivos de audio y los envía a RabbitMQ para su procesamiento.
2. Particionador (Splitter): Divide los archivos de audio en segmentos de 5 minutos.
3. Procesadores (Processors): Transcriben los segmentos de audio utilizando Whisper (7 contenedores en paralelo).
4. Unificador (Unifier): Recopila todas las transcripciones, las ordena y genera un archivo final de subtítulos (.srt).

Requisitos previos

• Docker
• Docker Compose

Estructura del proyecto

whisper-distributed/
├── docker-compose.yml    # Definición de los servicios
├── input/                # Directorio para colocar los archivos de audio a transcribir
├── output/               # Directorio donde se guardarán los subtítulos generados
├── shared/               # Directorio compartido para almacenamiento temporal
├── processor/            # Código del procesador Whisper
│   ├── app.py
│   └── Dockerfile
├── receiver/             # Código del receptor
│   ├── app.py
│   └── Dockerfile
├── splitter/             # Código del particionador
│   ├── app.py
│   └── Dockerfile
└── unifier/              # Código del unificador
    ├── app.py
    └── Dockerfile

Uso del sistema

1. Preparación:

   docker-compose build
   

2. Iniciar el sistema:

   docker-compose up -d
   

3. Uso:

   • Coloca los archivos de audio que deseas transcribir en el directorio input/.
   • El sistema detectará automáticamente los archivos y comenzará a procesarlos.
   • Los subtítulos resultantes se guardarán en el directorio output/ con el formato nombre_original_transcription.srt.

4. Monitoreo de logs:

   docker-compose logs -f
   

5. Detener el sistema:

   docker-compose down
   

Flujo de trabajo

1. El receptor detecta un nuevo archivo de audio en el directorio input/ y lo envía a la cola audio_split_queue.
2. El particionador recibe el archivo, lo divide en segmentos de 5 minutos y envía cada segmento a la cola audio_process_queue.
3. Los procesadores (7 contenedores) reciben los segmentos, los transcriben utilizando Whisper y envían las transcripciones a la cola text_unify_queue.
4. El unificador recopila todas las transcripciones de un mismo archivo, las ordena según su posición original y genera un archivo de subtítulos en formato SRT.

Configuración

El sistema viene configurado con valores predeterminados, pero se pueden ajustar varios parámetros:

• Tamaño de los segmentos: Por defecto, 5 minutos. Se puede modificar en splitter/app.py (variable SEGMENT_DURATION_MS).
• Modelo de Whisper: Por defecto, "base". Se puede cambiar a "tiny", "small", "medium" o "large" en processor/app.py (variable WHISPER_MODEL).
• Número de procesadores: Se pueden agregar o quitar procesadores modificando el archivo docker-compose.yml.

Notas

• El modelo "base" de Whisper ofrece un buen equilibrio entre precisión y velocidad. Los modelos más grandes (como "medium" o "large") son más precisos pero requieren más recursos.
• Para archivos muy largos, el sistema puede tardar bastante tiempo en procesarlos, especialmente con modelos grandes.
• Asegúrate de tener suficiente espacio en disco para los archivos temporales.