transcripcion-whisper/README.md

# 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**:
   ```bash
   docker-compose build
   ```

2. **Iniciar el sistema**:
   ```bash
   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**:
   ```bash
   docker-compose logs -f
   ```

5. **Detener el sistema**:
   ```bash
   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.