Procesador de Video/Audio
Procesa grabaciones de video y audio en transcripciones de texto y capturas de fotogramas visuales para su análisis. Detecta automáticamente tu hardware y elige el modelo de transcripción, dispositivo y configuración óptimos.
Fase 0: Detectar Entorno de Cómputo
Ejecuta esto al inicio de cada invocación. Determina todo el flujo posterior.
python3 -c "
import platform, shutil, subprocess, json
info = {'os': platform.system(), 'arch': platform.machine(), 'ram_gb': 0, 'gpu': 'none', 'vram_gb': 0, 'device': 'cpu', 'dtype': 'float32'}
# RAM
try:
if platform.system() == 'Darwin':
import os; info['ram_gb'] = round(os.sysconf('SC_PAGE_SIZE') * os.sysconf('SC_PHYS_PAGES') / (1024**3))
elif platform.system() == 'Linux':
with open('/proc/meminfo') as f:
for line in f:
if line.startswith('MemTotal'):
info['ram_gb'] = round(int(line.split()[1]) / (1024**2))
break
else:
import ctypes
mem = ctypes.c_ulonglong(0)
ctypes.windll.kernel32.GetPhysicallyInstalledMemory(ctypes.byref(mem))
info['ram_gb'] = round(mem.value / (1024**2))
except: pass
# Detección de GPU
try:
import torch
if torch.cuda.is_available():
info['gpu'] = torch.cuda.get_device_name(0)
info['vram_gb'] = round(torch.cuda.get_device_properties(0).total_mem / (1024**3))
info['device'] = 'cuda'
info['dtype'] = 'float16'
elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
info['gpu'] = 'Apple Silicon (MPS)'
info['vram_gb'] = info['ram_gb'] # memoria unificada
info['device'] = 'mps'
info['dtype'] = 'float16'
elif hasattr(torch, 'hip') or 'AMD' in str(getattr(torch, '_C', '')):
info['gpu'] = 'AMD (ROCm)'
info['device'] = 'cuda' # ROCm usa la API de cuda
info['dtype'] = 'float16'
except ImportError:
pass
# Detección de ffmpeg
info['ffmpeg'] = shutil.which('ffmpeg') is not None
info['ffprobe'] = shutil.which('ffprobe') is not None
print(json.dumps(info))
"
Analiza la salida JSON y guárdala internamente como COMPUTE. Presenta los resultados al usuario:
Hardware detectado:
- SO: {os} ({arch})
- RAM: {ram_gb} GB
- GPU: {gpu} ({vram_gb} GB VRAM)
- Dispositivo de cómputo: {device}
- ffmpeg: {instalado/falta}
Selección del Motor Whisper
Basado en el hardware, elige el motor de transcripción:
| Condición | Motor | Motivo |
|---|---|---|
| GPU CUDA disponible | faster-whisper | CTranslate2 acelerado por GPU, 4x más rápido que Whisper estándar |
| MPS (Apple Silicon) | openai-whisper | Whisper estándar, usa aceleración MPS cuando está disponible |
| Solo CPU | openai-whisper | Whisper estándar en CPU, respaldo confiable |
Matriz de Selección de Modelo
Basado en el hardware y la duración de la grabación, recomienda un modelo:
| Condición | Modelo Recomendado | Velocidad (1 hora de grabación) | Precisión |
|---|---|---|---|
| CUDA >= 8 GB VRAM | large-v3 | ~5 min | Mejor |
| CUDA 4-7 GB VRAM | medium | ~8 min | Alta |
| MPS (Apple Silicon, 16+ GB) | medium | ~15 min | Alta |
| MPS (Apple Silicon, 8 GB) | small | ~10 min | Buena |
| CPU + RAM >= 16 GB | small | ~30 min | Buena |
| CPU + RAM < 16 GB | base | ~15 min | Adecuada |
Presenta la recomendación y deja que el usuario elija:
AskUserQuestion: "¿Qué modelo de transcripción debería usar?"
Options:
- [Modelo recomendado] (Recomendado) - [motivo basado en su hardware]
- large-v3 - Mejor precisión, necesita 8+ GB VRAM o mucha RAM
- medium - Alta precisión, velocidad equilibrada
- small - Buena precisión, procesamiento más rápido
- base - Adecuado para la mayoría de reuniones, más rápido
Almacena el modelo elegido como WHISPER_MODEL y el motor como WHISPER_ENGINE.
Fase 1: Identificar la Grabación
Encuentra el archivo. Las grabaciones de Zoom suelen seguir el patrón:
GMT{date}-{time}_Recording_{resolution}.mp4(video)GMT{date}-{time}_Recording.m4a(solo audio)GMT{date}-{time}_RecordingnewChat.txt(registro de chat)
Busca los tres artefactos. Lee primero el archivo de chat (es pequeño y da contexto inmediato).
Fase 2: Instalar Dependencias
Verifica e instala lo necesario según la plataforma.
ffmpeg
# Verificar si ffmpeg está disponible
ffmpeg -version 2>&1 | head -1
ffprobe -version 2>&1 | head -1
Si ffmpeg falta, instala según la plataforma:
| Plataforma | Comando de instalación |
|---|---|
| macOS (Homebrew) | brew install ffmpeg |
| macOS (sin Homebrew) | Guía al usuario para instalar Homebrew primero, luego ffmpeg |
| Ubuntu/Debian | sudo apt update && sudo apt install -y ffmpeg |
| Fedora/RHEL | sudo dnf install -y ffmpeg |
| Arch Linux | sudo pacman -S ffmpeg |
| Windows (winget) | winget install Gyan.FFmpeg |
| Windows (choco) | choco install ffmpeg |
| Windows (scoop) | scoop install ffmpeg |
Python + Whisper
python3 -c "import torch; print(torch.__version__)" 2>&1
Si torch falta, instala según la plataforma:
| Plataforma | Comando de instalación |
|---|---|
| macOS (MPS) | pip3 install torch torchvision torchaudio |
| Linux (CUDA) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 |
| Linux (ROCm) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/rocm6.0 |
| Linux/Windows (CPU) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu |
| Windows (CUDA) | pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 |
Luego instala el motor de transcripción:
# Para sistemas CUDA (faster-whisper con aceleración CTranslate2)
pip3 install faster-whisper
# Para sistemas MPS / CPU (OpenAI Whisper estándar)
pip3 install openai-whisper
Fase 3: Obtener Duración
Usa ffprobe (multiplataforma) para obtener la duración del archivo:
ffprobe -v quiet -show_entries format=duration -of csv=p=0 "/ruta/al/archivo"
Esto devuelve la duración en segundos. Conviértelo a formato legible y muéstralo al usuario. Úsalo para estimar el tiempo de transcripción basado en el modelo y hardware seleccionados.
Presenta el plan:
Plan de procesamiento:
- Archivo: {nombre} ({duración})
- Motor: {WHISPER_ENGINE} con modelo {WHISPER_MODEL} en {device}
- Tiempo estimado de transcripción: {estimación}
- Extracción de fotogramas: 1 por minuto ({cantidad_fotogramas} fotogramas)
¿Quieres ajustar algo antes de empezar?
Estimaciones de Tiempo
| Dispositivo | base | small | medium | large-v3 |
|---|---|---|---|---|
| CUDA (RTX 3060+) | ~1 min/h | ~2 min/h | ~4 min/h | ~5 min/h |
| CUDA (faster-whisper) | ~30s/h | ~1 min/h | ~2 min/h | ~3 min/h |
| MPS (M1/M2/M3/M4) | ~3 min/h | ~6 min/h | ~15 min/h | ~25 min/h |
| CPU (16GB+ RAM) | ~8 min/h | ~15 min/h | ~30 min/h | ~60 min/h |
Fase 4: Extraer Fotogramas Visuales
Extrae un fotograma por minuto para obtener contexto visual. Usa un directorio temporal multiplataforma:
# Crear directorio temporal (multiplataforma)
python3 -c "import tempfile, os; d = os.path.join(tempfile.gettempdir(), 'av-frames'); os.makedirs(d, exist_ok=True); print(d)"
Luego extrae los fotogramas:
ffmpeg -i "/ruta/al/video.mp4" \
-vf "fps=1/60,scale=1280:-1" -q:v 3 {TEMP_DIR}/frame_%03d.jpg
Usa la herramienta de Lectura en cada fotograma para verlo. Los fotogramas muestran:
- Comparticiones de pantalla (código, diapositivas, interfaces de usuario)
- Nombres de participantes (en la esquina inferior izquierda de cada mosaico de video)
- Marcas de tiempo (si son visibles en la compartición de pantalla)
Fase 5: Transcribir Audio
Ejecuta el motor de transcripción. Elige el código correcto según WHISPER_ENGINE:
faster-whisper (sistemas CUDA)
from faster_whisper import WhisperModel
import json
model = WhisperModel("{WHISPER_MODEL}", device="cuda", compute_type="float16")
segments, info = model.transcribe("/ruta/al/audio", beam_size=5, language="en")
results = []
for segment in segments:
results.append({
"start": segment.start,
"end": segment.end,
"text": segment.text.strip()
})
# Guardar transcripción con marcas de tiempo
with open("{TEMP_DIR}/transcript.json", "w") as f:
json.dump({"language": info.language, "segments": results}, f, indent=2)
with open("{TEMP_DIR}/transcript.txt", "w") as f:
for seg in results:
start = int(seg["start"])
mins, secs = divmod(start, 60)
f.write(f"[{mins:02d}:{secs:02d}] {seg['text']}\n")
print(f"Transcritos {len(results)} segmentos")
openai-whisper (sistemas MPS / CPU)
import whisper, json
model = whisper.load_model("{WHISPER_MODEL}")
result = model.transcribe("/ruta/al/audio", verbose=False)
# Guardar transcripción con marcas de tiempo
with open("{TEMP_DIR}/transcript.json", "w") as f:
json.dump(result, f, indent=2)
with open("{TEMP_DIR}/transcript.txt", "w") as f:
for seg in result["segments"]:
start = int(seg["start"])
mins, secs = divmod(start, 60)
f.write(f"[{mins:02d}:{secs:02d}] {seg['text'].strip()}\n")
print(f"Transcritos {len(result['segments'])} segmentos")
Ejecuta la transcripción en segundo plano porque lleva un tiempo significativo. Mientras se ejecuta, revisa visualmente los fotogramas extraídos.
Fase 6: Sintetizar
Combina fotogramas visuales + transcripción + chat para construir una comprensión:
- Quién: Identifica a los participantes a partir de las etiquetas de nombre en el video y la atribución de voz
- Qué: Lo que se mostró en pantalla (demostraciones, diapositivas, código)
- Dicho: Citas clave, decisiones, requisitos, retroalimentación
- Elementos de acción: Compromisos explícitos y seguimientos
Referencia del Modelo
| Modelo | Parámetros | Velocidad | Precisión | Mejor Para |
|---|---|---|---|---|
tiny | 39M | Muy rápida | Baja | Escaneo rápido, verificar si el audio es utilizable |
base | 74M | Rápida | Adecuada | Predeterminado para reuniones cortas/claras |
small | 244M | Moderada | Buena | Reuniones generales con acentos |
medium | 769M | Lenta | Alta | Reuniones importantes, orientadas al cliente |
large-v3 | 1.5B | Muy lenta | Mejor | Grabaciones críticas, mala calidad de audio |
Consejos
- Siempre ejecuta la transcripción en segundo plano mientras revisas los fotogramas visualmente
- Lee los fotogramas en lotes de 8 (límite de paralelismo de la herramienta)
- Whisper estándar usa FP32 en CPU y MPS; faster-whisper usa CTranslate2 con FP16 en CUDA
- Para grabaciones muy largas (>1 hora), considera dividir el audio primero
- Los archivos de chat de Zoom contienen marcas de tiempo y enlaces compartidos, léelos primero para contexto rápido
- En Windows, usa barras diagonales o cadenas sin procesar para rutas de archivos en Python
Manejo de Errores
| Error | Causa | Solución |
|---|---|---|
ffmpeg: command not found | ffmpeg no instalado | Instalar según la tabla de plataforma anterior |
No module named 'whisper' | Whisper no instalado | pip3 install openai-whisper |
No module named 'faster_whisper' | faster-whisper no instalado | pip3 install faster-whisper |
CUDA out of memory | Modelo demasiado grande para VRAM | Cambiar a un modelo más pequeño |
RuntimeError: MPS backend | Problema MPS en macOS antiguo | Actualizar macOS, o retroceder a CPU con PYTORCH_MPS_HIGH_WATERMARK_RATIO=0.0 |
torch not found | Dependencias Python faltantes | Instalar torch según la tabla de plataforma anterior |
| Transcripción confusa | Idioma incorrecto o audio deficiente | Intenta especificar language="es" o usa un modelo más grande |
| Transcripción muy lenta | Ejecutando modelo grande en CPU | Cambiar al modelo base o small |