Instala Whisper con Docker en tu RTX 5090: Transcripción Local Gratis

Instala Whisper con Docker en tu RTX 5090: Transcripción Local Gratis

¿Tienes una NVIDIA RTX 5090, 5080 o 5070 y quieres aprovecharla al máximo? Hoy te enseño a montar un stack de transcripción de audio/video a texto completamente local y gratuito usando Whisper de OpenAI.

Olvídate de pagar $0.36 por hora a servicios cloud. Con este setup transcribirás 20 veces más rápido que el tiempo real, sin límites y sin enviar tus datos a ningún sitio.

Lo que lograrás:

• Transcribir videos de YouTube a texto en minutos
• Convertir podcasts en artículos de blog
• Generar subtítulos automáticos para tus videos
• Todo 100% gratis, sin límites, en tu GPU

¿Qué es Whisper y por qué montarlo local?

Whisper es el modelo de reconocimiento de voz de OpenAI. Es open source, soporta 99+ idiomas y tiene una precisión del 95-98% en español.

Comparación: Local vs Cloud

ROI: Si transcribes 10 horas de audio al mes, con OpenAI pagarías $43.20/año. Con tu RTX 5090: €0/año.

Este setup de Whisper local es ideal si tienes un servidor IA casero con GPU NVIDIA, ya que aprovechas el hardware que ya tienes para múltiples tareas (LLMs, generación de imágenes, transcripción).

Requisitos: ¿Qué necesitas?

Hardware

• GPU NVIDIA RTX 5000 series (5090, 5080, 5070) o cualquier GPU con 10GB+ VRAM
• 32GB RAM recomendado (mínimo 16GB)
• 50GB espacio libre en disco (para modelos cacheados)

Si estás montando tu setup desde cero, te recomiendo nuestra guía completa para montar tu homelab desde cero, donde cubrimos desde la selección de hardware hasta la configuración básica.

Software

• Linux (Ubuntu 22.04+, Debian 12+) – También funciona en Windows con WSL2
• Docker instalado
• Drivers NVIDIA actualizados (550+)
• CUDA 12.0+

Verificar tu GPU

# Verificar que tu GPU está detectada
nvidia-smi

# Deberías ver algo así:
# +-----------------------------------------------------------------------------------------+
# | NVIDIA-SMI 550.54.15    Driver Version: 550.54.15    CUDA Version: 13.0                |
# +-----------------------------------------------------------------------------------------+
# |   0  NVIDIA GeForce RTX 5090     Off | 00000000:01:00.0  On |                  N/A     |
# | 32GB / 32768MB |

Si ves tu RTX 5090 (o 5080/5070), ¡estás listo!

Paso 1: Instalar Docker (si no lo tienes)

# Actualizar sistema
sudo apt update && sudo apt upgrade -y

# Instalar Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Añadir usuario al grupo docker
sudo usermod -aG docker $USER

# Aplicar cambios (o reinicia sesión)
newgrp docker

# Verificar instalación
docker --version
# Docker version 24.0.7, build afdd53b

Nota: Si después de añadirte al grupo docker sigues teniendo el error «permission denied», consulta nuestra guía completa para solucionar Docker permission denied en 3 minutos.

Paso 2: Instalar NVIDIA Container Toolkit

Este es el componente crítico que permite a Docker usar tu GPU NVIDIA.

# Añadir repositorio NVIDIA
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | \
  sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] \
  https://nvidia.github.io/libnvidia-container/stable/deb/$(dpkg --print-architecture) /" | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

# Instalar
sudo apt update
sudo apt install -y nvidia-container-toolkit

# Configurar Docker para usar GPU
sudo nvidia-ctk runtime configure --runtime=docker

# Reiniciar Docker
sudo systemctl restart docker

Verificar que Docker puede usar la GPU

# Test rápido
docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu22.04 nvidia-smi

# Si ves el output de nvidia-smi, ¡funciona! ✅

Paso 3: Crear el Stack de Whisper

Estructura del Proyecto

# Crear directorio
mkdir -p ~/whisper-stack
cd ~/whisper-stack

# Crear subdirectorios
mkdir -p whisper-models whisper-uploads whisper-output

Crear docker-compose.yml

Crea un archivo llamado docker-compose.yml con este contenido:

services:
  whisper-api:
    image: onerahmet/openai-whisper-asr-webservice:latest-gpu
    container_name: whisper-api
    ports:
      - "9000:9000"
    environment:
      - ASR_MODEL=large-v3
      - ASR_ENGINE=faster_whisper
      - ASR_MODEL_PATH=/models
    volumes:
      - ./whisper-models:/models
      - ./whisper-uploads:/uploads
      - ./whisper-output:/output
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped

¿Qué hace cada cosa?

• ASR_MODEL=large-v3: Modelo más preciso de OpenAI (95-98% precisión)
• ASR_ENGINE=faster_whisper: Motor optimizado con CTranslate2 (2-4x más rápido)
• count: all: Usa todas las GPUs disponibles
• ports: 9000: API REST accesible en http://localhost:9000

Paso 4: Iniciar el Stack

# Iniciar en modo background
docker compose up -d

# Ver logs (primera vez descarga ~10GB de modelo)
docker logs -f whisper-api

# Espera a ver este mensaje:
# INFO:     Application startup complete.
# INFO:     Uvicorn running on http://0.0.0.0:9000

Primera vez: Descarga el modelo large-v3 (~10GB). Puede tardar 5-15 minutos dependiendo de tu conexión.

Siguientes veces: Inicia en segundos (modelo ya cacheado).

Verificar que Funciona

# Test API
curl http://localhost:9000/docs

# Si ves la documentación Swagger, ¡funciona! ✅

# Verificar GPU dentro del container
docker exec whisper-api nvidia-smi

# Deberías ver tu RTX 5090 listada

Paso 5: Primera Transcripción

Método 1: Con un Audio Local

# Coloca un audio en whisper-uploads/
cp /ruta/a/tu/audio.mp3 whisper-uploads/

# Transcribir
curl -X POST http://localhost:9000/asr \
  -F "audio_file=@whisper-uploads/audio.mp3" \
  -F "task=transcribe" \
  -F "language=es" \
  -F "output=txt" \
  > transcripcion.txt

# Ver resultado
cat transcripcion.txt

Método 2: Desde YouTube (más útil)

Primero instala yt-dlp:

# Instalar yt-dlp
pip3 install yt-dlp

# O con apt (Ubuntu/Debian)
sudo apt install yt-dlp

Crea un script llamado youtube_to_text.sh:

#!/bin/bash
# youtube_to_text.sh - Descarga y transcribe video de YouTube

VIDEO_URL="$1"
LANGUAGE="${2:-es}"

echo "📺 Descargando audio de: $VIDEO_URL"

# Descargar audio
yt-dlp -x --audio-format mp3 \
  --audio-quality 0 \
  -o "whisper-uploads/%(title)s.%(ext)s" \
  "$VIDEO_URL"

# Encontrar archivo descargado
AUDIO_FILE=$(ls -t whisper-uploads/*.mp3 | head -1)
echo "✅ Audio descargado: $AUDIO_FILE"

# Transcribir
echo "📝 Transcribiendo..."
curl -s -X POST http://localhost:9000/asr \
  -F "audio_file=@$AUDIO_FILE" \
  -F "language=$LANGUAGE" \
  -F "output=txt" \
  > "${AUDIO_FILE%.mp3}.txt"

echo "✅ Transcripción guardada: ${AUDIO_FILE%.mp3}.txt"

# Mostrar primeras líneas
head -20 "${AUDIO_FILE%.mp3}.txt"

Hazlo ejecutable y úsalo:

# Hacer ejecutable
chmod +x youtube_to_text.sh

# Usar
./youtube_to_text.sh "https://www.youtube.com/watch?v=VIDEO_ID" es

# Ejemplo real (video de 19 min):
./youtube_to_text.sh "https://www.youtube.com/watch?v=aircAruvnKk" en

# Resultado:
# 📺 Descargando audio de: https://www.youtube.com/watch?v=aircAruvnKk
# ✅ Audio descargado: whisper-uploads/But what is a neural network.mp3
# 📝 Transcribiendo...
# ✅ Transcripción guardada en ~58 segundos
# ~3,700 palabras transcritas con 98% precisión

Casos de Uso Prácticos

1. Crear Artículos de Blog desde YouTube

# Transcribir video técnico
./youtube_to_text.sh "https://www.youtube.com/watch?v=abc123" es

# Editar transcripción:
# - Añadir introducción personalizada
# - Insertar ejemplos de código
# - Crear secciones con ## subtítulos
# - Optimizar para SEO
# - Publicar en WordPress

# Tiempo total: 45-75 min (vs 4-6h escribiendo desde cero)

2. Generar Subtítulos Automáticos

# Extraer audio de tu video
ffmpeg -i tutorial.mp4 -vn -acodec mp3 audio.mp3

# Generar subtítulos SRT
curl -X POST http://localhost:9000/asr \
  -F "audio_file=@audio.mp3" \
  -F "language=es" \
  -F "output=srt" \
  > subtitulos.srt

# Incrustar en video
ffmpeg -i tutorial.mp4 -i subtitulos.srt \
  -c copy -c:s mov_text \
  tutorial_con_subs.mp4

3. Transcribir Podcasts

# Descargar podcast
wget https://podcast.com/episode.mp3 -O whisper-uploads/podcast.mp3

# Transcribir
curl -X POST http://localhost:9000/asr \
  -F "audio_file=@whisper-uploads/podcast.mp3" \
  -F "language=es" \
  -F "output=json" \
  | python3 -m json.tool > podcast.json

# Ahora tienes transcripción con timestamps para crear artículo

Integración con n8n: Automatización Total

La API de Whisper en localhost:9000 es perfecta para n8n. Puedes crear workflows que automatizan completamente el proceso de generar contenido desde videos.

Si eres nuevo en n8n, te recomiendo empezar por nuestra guía de los 15 nodos clave de n8n para entender los bloques fundamentales. Y si quieres ver ejemplos prácticos, tenemos 20 workflows listos para usar que puedes adaptar a tus necesidades.

Workflow 1: YouTube → Transcripción → WordPress (Automático)

Descripción: Cada vez que se publica un video en un canal de YouTube que sigues, automáticamente descarga el audio, lo transcribe con Whisper y crea un draft en WordPress.

Nodos necesarios:

1. RSS Feed Trigger – Monitorea canal YouTube
2. Execute Command (yt-dlp) – Descarga audio
3. HTTP Request (Whisper) – Transcribe
4. Execute Command (limpieza) – Elimina repeticiones
5. HTTP Request (WordPress) – Crea draft
6. Telegram – Notifica

Configuración Paso a Paso

Node 1: RSS Feed Trigger

{
  "url": "https://www.youtube.com/feeds/videos.xml?channel_id=CHANNEL_ID",
  "pollTime": 3600
}

Node 2: Execute Command (Descargar Audio)

// Command
const videoUrl = $json["link"];
const outputDir = "/home/z/whisper-stack/whisper-uploads";

return {
  json: {
    command: `yt-dlp -x --audio-format mp3 --audio-quality 0 -o "${outputDir}/%(title)s.%(ext)s" "${videoUrl}" && ls -t ${outputDir}/*.mp3 | head -1`
  }
};

Node 3: HTTP Request (Whisper API)

Este es el nodo clave. Configúralo así:

{
  "method": "POST",
  "url": "http://localhost:9000/asr",
  "authentication": "none",
  "sendBody": true,
  "contentType": "multipart-form-data",
  "bodyParameters": {
    "parameters": [
      {
        "name": "audio_file",
        "value": "={{$node[\"Execute Command\"].json[\"stdout\"].trim()}}",
        "parameterType": "formBinaryData"
      },
      {
        "name": "task",
        "value": "transcribe"
      },
      {
        "name": "language",
        "value": "es"
      },
      {
        "name": "output",
        "value": "txt"
      }
    ]
  },
  "options": {
    "timeout": 600000,
    "response": {
      "response": {
        "fullResponse": false,
        "neverError": false,
        "responseFormat": "text"
      }
    }
  }
}

Importante: La API de Whisper devuelve texto plano cuando usas output=txt. El texto estará en $json["body"].

Node 4: Execute Command (Limpiar Repeticiones)

// Guardar transcripción en archivo temporal
const transcription = $json["body"];
const tempFile = `/tmp/transcripcion_${Date.now()}.txt`;
const cleanFile = `/tmp/transcripcion_${Date.now()}_clean.txt`;

// Comando para limpiar
return {
  json: {
    command: `echo '${transcription}' > ${tempFile} && python3 /home/z/whisper-stack/limpiar_repeticiones.py ${tempFile} ${cleanFile} && cat ${cleanFile}`,
    tempFile: tempFile,
    cleanFile: cleanFile
  }
};

Node 5: HTTP Request (WordPress REST API)

{
  "method": "POST",
  "url": "https://www.eldiarioia.es/wp-json/wp/v2/posts",
  "authentication": "basicAuth",
  "basicAuth": {
    "user": "{{$credentials.wordpressUser}}",
    "password": "{{$credentials.wordpressAppPassword}}"
  },
  "sendBody": true,
  "bodyParameters": {
    "parameters": [
      {
        "name": "title",
        "value": "={{$node[\"RSS Feed Trigger\"].json[\"title\"]}}"
      },
      {
        "name": "content",
        "value": "={{$node[\"Execute Command1\"].json[\"stdout\"]}}"
      },
      {
        "name": "status",
        "value": "draft"
      },
      {
        "name": "excerpt",
        "value": "Transcripción automática desde YouTube con Whisper local."
      }
    ]
  }
}

Node 6: Telegram Notification

{
  "chatId": "YOUR_CHAT_ID",
  "text": "✅ Nuevo artículo generado: {{$node[\"RSS Feed Trigger\"].json[\"title\"]}}\n\n🔗 {{$node[\"HTTP Request1\"].json[\"link\"]}}\n\n📝 Listo para editar y publicar."
}

Workflow 2: Webhook Manual para Transcripciones On-Demand

Crea un webhook que puedes llamar manualmente para transcribir cualquier video:

Node 1: Webhook Trigger

{
  "path": "whisper-transcribe",
  "httpMethod": "POST",
  "responseMode": "lastNode"
}

Request body esperado:

{
  "video_url": "https://www.youtube.com/watch?v=abc123",
  "language": "es",
  "title": "Título del artículo (opcional)"
}

Llamar al webhook:

curl -X POST http://localhost:5678/webhook/whisper-transcribe \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://www.youtube.com/watch?v=aircAruvnKk",
    "language": "en",
    "title": "Neural Networks Explained"
  }'

El workflow descarga, transcribe y devuelve el texto en la respuesta HTTP.

Workflow 3: Batch Processing de Playlists

Transcribe una playlist completa de YouTube en una sola ejecución:

1. HTTP Request – Obtiene videos de playlist con YouTube API
2. Split In Batches – Procesa videos de 3 en 3
3. Execute Command – Descarga audio (para cada video)
4. HTTP Request (Whisper) – Transcribe (para cada video)
5. Merge – Combina resultados
6. Telegram – Notifica cuando termina todo

Ventaja: Procesas 10-20 videos overnight sin intervención manual.

Tips para Integración n8n + Whisper

1. Gestión de Timeouts

Videos largos (>1h) tardan ~3-4 min en transcribirse. Ajusta timeouts en n8n:

{
  "options": {
    "timeout": 600000  // 10 minutos (en milisegundos)
  }
}

2. Manejo de Errores

Añade un nodo Error Trigger que capture fallos y notifique:

// En el Error Trigger
const errorMessage = $json["error"]["message"];
const videoUrl = $json["video_url"];

return {
  json: {
    message: `❌ Error transcribiendo: ${videoUrl}\n\nError: ${errorMessage}`
  }
};

3. Caché de Transcripciones

Guarda transcripciones en base de datos para no reprocesar:

// Antes de transcribir, buscar en DB
const videoId = extractVideoId($json["video_url"]);

// SELECT transcription FROM cache WHERE video_id = ?

if (cached) {
  return cached;
} else {
  // Transcribir y guardar en cache
}

4. Monitoreo de GPU

Añade un nodo que verifique disponibilidad de GPU antes de transcribir:

# Execute Command Node
nvidia-smi --query-gpu=memory.free --format=csv,noheader,nounits | head -1

# Si VRAM libre < 10000 MB, esperar o notificar

Ejemplo Real: Mi Workflow de Producción

Así es como yo uso n8n + Whisper en El Diario IA:

1. RSS Trigger monitorea 5 canales técnicos YouTube (Fireship, NetworkChuck, etc.)
2. Video nuevo detectado → Whisper transcribe (2-3 min)
3. Python script limpia repeticiones y divide en secciones
4. OpenRouter API (Claude Sonnet) mejora estructura y añade intro/conclusión
5. SwarmUI genera imagen featured desde keywords
6. WordPress crea draft con todo listo
7. Telegram me notifica: "Artículo listo, revisar en 15 min"

Tiempo total automatizado: 10-15 min. Yo solo edito y publico.

Resultado: 2-3 artículos técnicos por semana sin esfuerzo.

Configurar Credenciales en n8n

Para WordPress y Telegram, añade credenciales en n8n:

WordPress API Credential:

{
  "name": "WordPress ElDiarioIA",
  "type": "httpBasicAuth",
  "data": {
    "user": "tu_usuario",
    "password": "tu_application_password"
  }
}

Telegram Bot Credential:

{
  "name": "Telegram Bot",
  "type": "telegramApi",
  "data": {
    "accessToken": "YOUR_BOT_TOKEN_FROM_BOTFATHER"
  }
}

Workflow JSON Completo (Importar en n8n)

El workflow completo incluye todos los nodos configurados: HTTP Request al Whisper API, procesamiento del JSON, publicación en WordPress y notificaciones Telegram.

Para recrearlo en tu n8n: Menu → Workflows → Add → Configura los nodos según los ejemplos anteriores

Rendimiento Real: RTX 5090

Estos son mis benchmarks reales con una RTX 5090 32GB VRAM:

Precisión: 95-98% en español claro, 98% en inglés técnico.

RTX 5080/5070: Rendimiento similar, mismo ratio ~20x tiempo real.

Optimizaciones para RTX 5000 Series

1. Usar Modelo Adecuado según VRAM

Para cambiar el modelo, edita docker-compose.yml:

environment:
  - ASR_MODEL=medium  # Opciones: tiny, base, small, medium, large-v3

2. GPU Compartida con Otros Servicios

Si también usas tu RTX 5090 para Ollama, ComfyUI o SwarmUI:

# Monitorear VRAM en tiempo real
watch -n 1 nvidia-smi

# Si te quedas sin VRAM, detén servicios temporalmente
docker stop ollama swarmui

# Transcribe tus videos
./youtube_to_text.sh "URL" es

# Reinicia servicios
docker start ollama swarmui

Troubleshooting: Problemas Comunes

❌ Error: "could not select device driver nvidia"

Causa: nvidia-container-toolkit no instalado o Docker no configurado.

Solución:

# Verificar instalación
dpkg -l | grep nvidia-container-toolkit

# Si no está instalado, volver al Paso 2

# Verificar configuración Docker
cat /etc/docker/daemon.json

# Debe contener:
# {
#     "runtimes": {
#         "nvidia": {
#             "path": "nvidia-container-runtime",
#             "runtimeArgs": []
#         }
#     }
# }

# Si no, ejecutar:
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

❌ Error: "CUDA out of memory"

Causa: VRAM insuficiente para el modelo.

Solución:

# Opción 1: Liberar VRAM
docker stop ollama swarmui comfyui
docker restart whisper-api

# Opción 2: Usar modelo más pequeño
# Editar docker-compose.yml:
# ASR_MODEL=medium  # En lugar de large-v3

docker compose down
docker compose up -d

⚠️ Transcripción con repeticiones (hallucinations)

Problema: En videos largos (>15 min), Whisper a veces repite frases en loop.

Ejemplo:

Right now, when I say neuron...
Right now, when I say neuron...
Right now, when I say neuron...
[repetido 6 veces]

Causa: Segmentos con música o silencios prolongados.

Solución - Script de limpieza:

Crea limpiar_repeticiones.py:

#!/usr/bin/env python3
"""Elimina repeticiones de transcripciones de Whisper"""

import sys

def remove_consecutive_duplicates(lines):
    """Elimina líneas duplicadas consecutivas"""
    cleaned = []
    prev = None

    for line in lines:
        line = line.strip()
        if line != prev:
            cleaned.append(line)
            prev = line

    return cleaned

def clean_file(input_file, output_file):
    with open(input_file, 'r', encoding='utf-8') as f:
        lines = f.readlines()

    cleaned = remove_consecutive_duplicates(lines)

    with open(output_file, 'w', encoding='utf-8') as f:
        f.write('\n'.join(cleaned))

    original = len(' '.join(lines).split())
    final = len(' '.join(cleaned).split())
    removed = original - final

    print(f"✅ Limpieza completada")
    print(f"📊 Palabras originales: {original}")
    print(f"📊 Palabras finales: {final}")
    print(f"🗑️  Eliminadas: {removed} ({removed/original*100:.1f}%)")

if __name__ == "__main__":
    if len(sys.argv) < 3:
        print("Uso: python3 limpiar_repeticiones.py input.txt output.txt")
        sys.exit(1)

    clean_file(sys.argv[1], sys.argv[2])

Úsalo así:

# Después de transcribir
chmod +x limpiar_repeticiones.py
python3 limpiar_repeticiones.py transcripcion.txt transcripcion_limpia.txt

Comandos Útiles para el Día a Día

# Ver logs del container
docker logs -f whisper-api

# Reiniciar servicio
docker restart whisper-api

# Detener stack
docker compose down

# Iniciar stack
docker compose up -d

# Ver estado
docker ps | grep whisper-api

# Monitorear GPU
watch -n 1 nvidia-smi

# Ver espacio usado por modelos
du -sh whisper-models/

Siguiente Nivel: Fine-Tuning para Jerga Técnica

Si transcribes mucho contenido técnico (Docker, Kubernetes, IA), puedes entrenar el modelo con vocabulario específico:

# Crear glosario de términos
cat > glosario_tech.txt << EOF
Kubernetes
kubectl
containerd
Docker Compose
NVIDIA CUDA
Tensor Cores
EOF

# Usar como prompt en transcripción
curl -X POST http://localhost:9000/asr \
  -F "audio_file=@audio.mp3" \
  -F "initial_prompt=$(cat glosario_tech.txt)" \
  -F "output=txt"

Esto mejora la precisión en términos técnicos específicos.

Caso de uso avanzado: Las transcripciones de Whisper son perfectas para alimentar sistemas RAG (Retrieval Augmented Generation), permitiéndote crear una base de conocimiento donde tu LLM local puede buscar información de todos tus videos/podcasts transcritos.

Conclusión

Con tu RTX 5090, 5080 o 5070 tienes una máquina de transcripción profesional que te ahorra dinero y te da privacidad total.

Recap de lo que montamos:

• ✅ Docker + NVIDIA Container Toolkit
• ✅ Whisper large-v3 en container
• ✅ API REST en localhost:9000
• ✅ Scripts para YouTube y limpieza
• ✅ 20x más rápido que tiempo real
• ✅ Coste: €0 (vs $43/año OpenAI)

Siguiente paso: Transcribe tu primer video ahora:

cd ~/whisper-stack
./youtube_to_text.sh "URL_DE_TU_VIDEO_FAVORITO" es

Y si tienes problemas o quieres optimizaciones avanzadas, déjame un comentario. ¡Happy transcribing! 🎙️

FAQs

¿Funciona con GPUs más antiguas (RTX 4090, 3090)?

Sí, funciona perfectamente. Solo asegúrate de tener 10GB+ VRAM para large-v3, o usa el modelo medium (5GB VRAM).

¿Puedo transcribir en otros idiomas además de español?

Sí, Whisper soporta 99+ idiomas. Solo cambia el parámetro language: en (inglés), fr (francés), de (alemán), etc.

¿Funciona sin conexión a internet?

Sí, una vez descargado el modelo (primera ejecución), funciona 100% offline.

¿Cuánto espacio ocupan los modelos?

large-v3: ~10GB. medium: ~5GB. small: ~2GB.

¿Puedo usar múltiples GPUs simultáneamente?

Sí, en el docker-compose.yml ya está configurado con count: all para usar todas las GPUs disponibles.

¿Es legal transcribir videos de YouTube?

Para uso personal y educativo, generalmente sí. Para uso comercial, verifica los términos del contenido original y considera pedir permiso al creador.