# Hunyuan Video

Genera videos de alta calidad con Hunyuan Video de código abierto de Tencent.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrar por tipo de GPU, VRAM y precio
3. Elegir **Bajo demanda** (tarifa fija) o **Spot** (precio de puja)
4. Configura tu pedido:
   * Selecciona imagen Docker
   * Establece puertos (TCP para SSH, HTTP para interfaces web)
   * Agrega variables de entorno si es necesario
   * Introduce el comando de inicio
5. Selecciona pago: **CLORE**, **BTC**, o **USDT/USDC**
6. Crea el pedido y espera el despliegue

### Accede a tu servidor

* Encuentra los detalles de conexión en **Mis Pedidos**
* Interfaces web: Usa la URL del puerto HTTP
* SSH: `ssh -p <port> root@<proxy-address>`

## ¿Qué es Hunyuan Video?

Hunyuan Video de Tencent ofrece:

* Generación de texto a video de alta calidad
* Clips de video de más de 5 segundos
* Resolución 720p
* Código abierto y utilizable comercialmente

## Recursos

* **Modelo:** [tencent/HunyuanVideo](https://huggingface.co/tencent/HunyuanVideo)
* **GitHub:** [Tencent/HunyuanVideo](https://github.com/Tencent/HunyuanVideo)
* **Artículo:** [Documento de HunyuanVideo](https://arxiv.org/abs/2412.03603)

## Hardware recomendado

| Componente     | Mínimo        | Recomendado | Óptimo     |
| -------------- | ------------- | ----------- | ---------- |
| GPU            | RTX 4090 24GB | A100 40GB   | A100 80GB  |
| VRAM           | 24GB          | 40GB        | 80GB       |
| CPU            | 8 núcleos     | 16 núcleos  | 32 núcleos |
| RAM            | 32GB          | 64GB        | 128GB      |
| Almacenamiento | 100GB NVMe    | 200GB NVMe  | 500GB NVMe |
| Internet       | 500 Mbps      | 1 Gbps      | 1 Gbps     |

## Despliegue rápido en CLORE.AI

**Imagen Docker:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Puertos:**

```
22/tcp
7860/http
```

**Comando:**

```bash
git clone https://github.com/Tencent/HunyuanVideo.git && \
cd HunyuanVideo && \
pip install -r requirements.txt && \
python sample_video.py --prompt "Un gato caminando en un jardín"
```

## Accediendo a tu servicio

Después del despliegue, encuentra tu `http_pub` URL en **Mis Pedidos**:

1. Ir a **Mis Pedidos** página
2. Haz clic en tu pedido
3. Encuentra la `http_pub` URL (por ejemplo, `abc123.clorecloud.net`)

Usa `https://TU_HTTP_PUB_URL` en lugar de `localhost` en los ejemplos abajo.

## Instalación

```bash
git clone https://github.com/Tencent/HunyuanVideo.git
cd HunyuanVideo
pip install -r requirements.txt

# Descargar modelos
python download_models.py
```

## Lo que puedes crear

### Contenido de marketing

* Videos de demostración de producto
* Clips para redes sociales
* Animaciones promocionales

### Proyectos creativos

* Conceptos para videos musicales
* Prototipos de cortometrajes
* Instalaciones artísticas

### Educación y formación

* Borradores de videos explicativos
* Conceptos de material de formación
* Visualización de conceptos

## Uso básico

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompt = "Un majestuoso águila sobrevolando montañas nevadas, iluminación cinematográfica, 4K"

video_frames = pipe(
    prompt=prompt,
    num_frames=45,
    num_inference_steps=50,
    guidance_scale=7.0
).frames[0]

export_to_video(video_frames, "eagle.mp4", fps=15)
```

## Generación avanzada

```python
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained(
    "tencent/HunyuanVideo",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

video_frames = pipe(
    prompt="Time-lapse de una flor floreciendo, fotografía macro, pétalos detallados",
    negative_prompt="borroso, baja calidad, distorsionado, feo",
    num_frames=45,
    height=544,
    width=960,
    num_inference_steps=50,
    guidance_scale=7.0,
    generator=torch.Generator("cuda").manual_seed(42)
).frames[0]

export_to_video(video_frames, "flower_bloom.mp4", fps=15)
```

## Ejemplos de prompts

### Naturaleza y paisajes

```python
prompts = [
    "Aurora boreal danzando sobre un lago helado, time-lapse, etérea",
    "Olas del océano chocando en una playa de arena volcánica negra, cámara lenta",
    "Tormenta eléctrica sobre un campo de trigo, iluminación dramática, 4K",
    "Pétalos de cerezo cayendo en un jardín japonés, primavera, tranquilo"
]
```

### Ciencia ficción y fantasía

```python
prompts = [
    "Nave espacial despegando desde una ciudad futurista, cinematográfico, detallado",
    "Dragón volando entre nubes al atardecer, épico, fantasía",
    "Robot caminando por calles iluminadas con neón, cyberpunk, lluvia",
    "Portal mágico abriéndose en un bosque antiguo, luces místicas"
]
```

### Abstracto y artístico

```python
prompts = [
    "Gotas de tinta difundiendo en agua, macro, colorido, abstracto",
    "Formas geométricas transformándose y morphing, motion graphics",
    "Pintura de luz en la oscuridad, efecto de larga exposición, vibrante"
]
```

## Generación por lotes

```python
import os
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

prompts = [
    "Arrecife de coral submarino con peces coloridos nadando",
    "Time-lapse del tráfico de la ciudad por la noche, estelas de luz",
    "Mariposa emergiendo de un capullo, documental de naturaleza"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generando {i+1}/{len(prompts)}: {prompt[:50]}...")

    video_frames = pipe(
        prompt=prompt,
        num_frames=45,
        num_inference_steps=50,
        guidance_scale=7.0
    ).frames[0]

    export_to_video(video_frames, f"{output_dir}/video_{i:03d}.mp4", fps=15)
```

## Interfaz Gradio

```python
import gradio as gr
import torch
from diffusers import HunyuanVideoPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = HunyuanVideoPipeline.from_pretrained("tencent/HunyuanVideo", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.vae.enable_tiling()

def generate(prompt, negative_prompt, num_frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    video_frames = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=num_frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(video_frames, f.name, fps=15)
        return f.name

demo = gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label="Prompt", lines=3),
        gr.Textbox(label="Negative Prompt", value="borroso, baja calidad"),
        gr.Slider(16, 60, value=45, step=1, label="Fotogramas"),
        gr.Slider(20, 100, value=50, step=5, label="Pasos"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guía"),
        gr.Number(value=-1, label="Semilla")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Hunyuan Video - Texto a Video en CLORE.AI"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Rendimiento

| Resolución | Fotogramas | GPU       | Tiempo  |
| ---------- | ---------- | --------- | ------- |
| 544x960    | 45         | RTX 4090  | \~5 min |
| 544x960    | 45         | A100 40GB | \~3 min |
| 544x960    | 45         | A100 80GB | \~2 min |
| 720x1280   | 45         | A100 80GB | \~4 min |

## Problemas comunes y soluciones

### Memoria insuficiente

**Problema:** CUDA fuera de memoria en GPU de 24GB

**Soluciones:**

```python

# Habilitar todas las optimizaciones de memoria
pipe.enable_model_cpu_offload()
pipe.enable_sequential_cpu_offload()  # Más agresivo
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

# Reducir fotogramas y resolución
video = pipe(prompt, num_frames=24, height=480, width=720).frames[0]
```

### Generación lenta

**Problema:** Tarda demasiado en generar

**Soluciones:**

* Reducir `num_inference_steps` (30-40 aún da buenos resultados)
* Reducir `num_frames` (24 fotogramas = 1.6 s a 15 fps)
* Usar GPU A100 para procesamiento más rápido
* Asegúrate de tener almacenamiento NVMe para la carga del modelo

### Mala calidad de video

**Problema:** Movimiento borroso o inconsistente

**Soluciones:**

* Aumente `num_inference_steps` a 75-100
* Ajustar `guidance_scale` (6-8 funciona mejor)
* Escribe prompts más detallados
* Agrega prompts negativos para evitar problemas

### Artefactos en el video

**Problema:** Parpadeo o inconsistencias temporales

**Soluciones:**

* Usa una semilla consistente para reproducibilidad
* Evita prompts con movimiento rápido
* Postprocesa con estabilización de video

## Solución de problemas

{% hint style="danger" %}
**Fuera de memoria**
{% endhint %}

* Hunyuan requiere mínimo 24GB+ de VRAM
* Usa A100 40GB/80GB para mejores resultados
* Reduce la duración/resolución del video

### La generación de video falla

* Comprueba que todos los archivos del modelo se descargaron correctamente
* Asegura suficiente espacio en disco (100GB+)
* Verifica la compatibilidad de CUDA y PyTorch

### Mala calidad de video

* Aumenta los pasos de inferencia
* Usa prompts más descriptivos
* Comprueba que la resolución de entrada coincide con la esperada

### Generación lenta

* La generación de video requiere mucha computación
* Usa A100/H100 para resultados más rápidos
* Considera primero clips más cortos

## Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

| GPU       | Tarifa por hora | Tarifa diaria | Sesión de 4 horas |
| --------- | --------------- | ------------- | ----------------- |
| RTX 3060  | \~$0.03         | \~$0.70       | \~$0.12           |
| RTX 3090  | \~$0.06         | \~$1.50       | \~$0.25           |
| RTX 4090  | \~$0.10         | \~$2.30       | \~$0.40           |
| A100 40GB | \~$0.17         | \~$4.00       | \~$0.70           |
| A100 80GB | \~$0.25         | \~$6.00       | \~$1.00           |

*Los precios varían según el proveedor y la demanda. Consulta* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *para las tarifas actuales.*

**Ahorra dinero:**

* Usa **Spot** market para cargas de trabajo flexibles (a menudo 30-50% más barato)
* Paga con **CLORE** tokens
* Compara precios entre diferentes proveedores

## Próximos pasos

* CogVideoX - Alternativa T2V
* Wan2.1 Video - Otra opción T2V
* AnimateDiff - Animación de imágenes