# Generación de video FramePack

FramePack es un avance en la generación de video por IA: puede crear videos de hasta 2 minutos usando **solo 6GB de VRAM**. Construido sobre la arquitectura HunyuanVideo, la innovación clave de FramePack es empaquetar los fotogramas de manera eficiente para que la memoria GPU se mantenga constante independientemente de la duración del video. Esto hace que la generación de video por IA sea accesible en GPUs económicas que antes eran demasiado limitadas.

## Características clave

* **Mínimo 6GB de VRAM**: Funciona en RTX 3060, RTX 3070, ¡incluso GTX 1060!
* **Videos de hasta 2 minutos**: Uso de VRAM constante sin importar la duración del video
* **Imagen a video**: Anima cualquier imagen con un prompt de texto
* **Interfaz web incluida**: Interfaz basada en Gradio para uso sencillo
* **Construido sobre HunyuanVideo**: Aprovecha la arquitectura de difusión de video de Tencent
* **Código abierto**: GitHub con desarrollo activo

## Requisitos

| Componente | Mínimo       | Recomendado   |
| ---------- | ------------ | ------------- |
| GPU        | GTX 1060 6GB | RTX 4090 24GB |
| VRAM       | 6GB          | 12GB+         |
| RAM        | 16GB         | 32GB          |
| Disco      | 30GB         | 50GB          |
| CUDA       | 11.8+        | 12.0+         |
| Python     | 3.10+        | 3.11          |

**GPU recomendada de Clore.ai**: RTX 3080 10GB (\~$0.2–0.5/día) — ¡excelente calidad a bajo costo!

### Referencia de velocidad

| GPU           | Tiempo por fotograma | Video de 60 fotogramas (\~2s a 30fps) |
| ------------- | -------------------- | ------------------------------------- |
| RTX 3060 12GB | \~30 seg             | \~30 min                              |
| RTX 3080 10GB | \~18 seg             | \~18 min                              |
| RTX 4080 16GB | \~12 seg             | \~12 min                              |
| RTX 4090 24GB | \~8 seg              | \~8 min                               |
| RTX 5090 32GB | \~5 seg              | \~5 min                               |

## Instalación

```bash
# Clonar repositorio
git clone https://github.com/lllyasviel/FramePack.git
cd FramePack

# Crear entorno conda (recomendado)
conda create -n framepack python=3.11 -y
conda activate framepack

# Instalar dependencias
pip install -r requirements.txt

# Instalar PyTorch con CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
```

### Configuración con Docker

```bash
docker run --gpus all -p 7860:7860 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -v ./outputs:/app/outputs \
  ghcr.io/lllyasviel/framepack:latest
```

## Inicio rápido — Interfaz web

La forma más fácil de usar FramePack:

```bash
cd FramePack
python app.py --port 7860

# Para baja VRAM (6GB):
python app.py --port 7860 --low-vram

# Acceder en http://localhost:7860
```

**Flujo de trabajo de la interfaz web:**

1. Sube una imagen fuente (el primer fotograma)
2. Introduce un prompt de texto que describa el movimiento ("la cámara hace un zoom lento", "la persona camina hacia adelante")
3. Establece la duración del video (número de fotogramas)
4. Haz clic en Generar
5. Descarga el MP4

## Uso

FramePack es una **aplicación web Gradio**, no una biblioteca de Python. La interfaz principal es la interfaz web.

### Flujo de trabajo de la interfaz web

1. Abrir `http://localhost:7860` después de iniciar
2. Sube una imagen fuente (será el primer fotograma)
3. Introduce un prompt de texto que describa el movimiento deseado
4. Establece el número de fotogramas (más = video más largo)
5. Hacer clic **Generar** → espera → descarga MP4

### Acceso a la API vía Gradio Client

Puedes llamar a FramePack de forma programática usando la API de Gradio:

```python
from gradio_client import Client

# Conectar con la instancia de FramePack en ejecución
client = Client("http://localhost:7860")

# Generar video desde imagen + prompt
result = client.predict(
    "input_photo.jpg",                              # imagen fuente
    "la persona sonríe y gira la cabeza lentamente", # prompt
    60,                                              # número de fotogramas
    7.5,                                             # escala de guía
    30,                                              # pasos de inferencia
    42,                                              # semilla
    api_name="/generate"
)
print(f"Video guardado en: {result}")
```

### Procesamiento por lotes con Gradio Client

```python
from gradio_client import Client
import glob

client = Client("http://localhost:7860")

prompts = [
    ("photo1.jpg", "zoom de cámara suave con iluminación suave"),
    ("photo2.jpg", "viento moviendo el cabello, nubes en movimiento"),
    ("photo3.jpg", "zoom hacia afuera lento mostrando la escena completa"),
]

for img_path, prompt in prompts:
    result = client.predict(img_path, prompt, 60, 7.5, 30, -1, api_name="/generate")
    print(f"Hecho: {img_path} → {result}")
```

## Guía de resolución

| VRAM | Resolución máxima | Calidad                   |
| ---- | ----------------- | ------------------------- |
| 6GB  | 512×512           | Bueno para redes sociales |
| 8GB  | 640×640           | Mejor detalle             |
| 10GB | 512×768           | Retrato/paisaje           |
| 12GB | 768×768           | Alta calidad              |
| 24GB | 1024×768          | Mejor calidad             |

## Consejos para usuarios de Clore.ai

* **Económico**: Este es uno de los pocos modelos de video IA que funciona en GPUs baratas ($0.15–0.3/día para RTX 3060!)
* **Usa `--low-vram` bandera**: Esencial para GPUs de 6–8GB — habilita el volcado a CPU automáticamente
* **512×512 está bien**: Para redes sociales (TikTok, Reels), 512px es perfectamente aceptable
* **Más largo ≠ más VRAM**: A diferencia de otros modelos de video, FramePack mantiene la VRAM constante — genera videos más largos libremente
* **Pre-descarga los modelos**: La primera ejecución descarga \~15GB. Ejecuta una vez y tu sesión Clore tendrá los modelos en caché
* **Combinar con escalado**: Genera a 512×512, luego usa Real-ESRGAN para ampliar a 2K/4K

## Consejos para prompts

Los buenos prompts describen **movimiento**, no solo la apariencia:

```
✅ "la cámara se desplaza lentamente hacia la derecha, revelando un paisaje montañoso"
✅ "la persona parpadea y sonríe suavemente, el viento mueve su cabello"
✅ "hacer zoom hacia afuera lentamente, mostrando todo el edificio"

❌ "un hermoso atardecer" (no se describe movimiento)
❌ "alta calidad, 4K, detallado" (las palabras de estilo no ayudan mucho)
```

## Solución de problemas

| Problema                                | Solución                                                                                |
| --------------------------------------- | --------------------------------------------------------------------------------------- |
| CUDA fuera de memoria                   | Usa `--low-vram` bandera, reducir la resolución a 512×512                               |
| Generación muy lenta                    | Normal para GPUs de 6GB (\~30s/fotograma). Usa RTX 4090 para 4x de velocidad            |
| Fotogramas negros/corruptos             | Actualiza PyTorch: `pip install torch --upgrade`                                        |
| La descarga del modelo se queda colgada | Revisa el espacio en disco (necesita 30GB libres). Prueba `HF_HUB_ENABLE_HF_TRANSFER=1` |
| La interfaz web no arranca              | Comprueba que el puerto 7860 esté libre: `lsof -i :7860`                                |

## Lecturas adicionales

* [Repositorio de GitHub](https://github.com/lllyasviel/FramePack)
* [HunyuanVideo (modelo base)](https://github.com/Tencent/HunyuanVideo)
* [Comparativa de GPU de Clore.ai](https://docs.clore.ai/guides/guides_v2-es/primeros-pasos/gpu-comparison) — encuentra la GPU más barata para tus necesidades