Hunyuan Video

Genera videos de alta calidad con Hunyuan Video de Tencent en Clore.ai

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

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al 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

• De código abierto y utilizable comercialmente

Recursos

• Modelo: tencent/HunyuanVideo

• GitHub: Tencent/HunyuanVideo

• Artículo: Artículo de HunyuanVideo

Hardware recomendado

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

Despliegue rápido en CLORE.AI

Imagen de Docker:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Puertos:

22/tcp
7860/http

Comando:

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. Ve a Mis pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (p. ej., abc123.clorecloud.net)

Usa https://YOUR_HTTP_PUB_URL en lugar de localhost en los ejemplos a continuación.

Instalación

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 presentación de productos

• Clips para redes sociales

• Animaciones promocionales

Proyectos creativos

• Conceptos de videos musicales

• Prototipos de cortometrajes

• Instalaciones artísticas

Educación y capacitación

• Borradores de videos explicativos

• Conceptos de material de capacitación

• Visualización de conceptos

Uso básico

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 águila majestuosa surcando 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

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="Lapso de tiempo 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

prompts = [
    "Aurora boreal danzando sobre un lago congelado, lapso de tiempo, etéreo",
    "Olas del océano rompiendo en una playa de arena negra volcánica, cámara lenta",
    "Tormenta eléctrica sobre un campo de trigo, iluminación dramática, 4K",
    "Flores de cerezo cayendo en un jardín japonés, primavera, pacífico"
]

Ciencia ficción y fantasía

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

prompts = [
    "Gotas de tinta difundiéndose en agua, macro, colorido, abstracto",
    "Formas geométricas mutando y transformándose, gráficos en movimiento",
    "Pintura de luz en la oscuridad, efecto de larga exposición, vibrante"
]

Generación por lotes

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",
    "Lapso de tiempo del tráfico de la ciudad de noche, estelas de luz",
    "Mariposa saliendo del 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 de Gradio

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="Prompt negativo", 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="Video generado"),
    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

Sin memoria

Problema: CUDA sin memoria en GPU de 24 GB

Soluciones:

# 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:

• Reduce num_inference_steps (30-40 todavía da buenos resultados)

• Reduce num_frames (24 fotogramas = 1.6 s a 15 fps)

• Usa una GPU A100 para un procesamiento más rápido

• Asegúrate de tener almacenamiento NVMe para cargar el modelo

Mala calidad de video

Problema: Movimiento borroso o inconsistente

Soluciones:

• Aumenta num_inference_steps a 75-100

• Ajusta guidance_scale (6-8 funciona mejor)

• Escribe prompts más detallados

• Añade prompts negativos para evitar problemas

Artefactos de video

Problema: Parpadeo o inconsistencias temporales

Soluciones:

• Usa una semilla constante para la reproducibilidad

• Evita prompts con movimiento rápido

• Posprocesa con estabilización de video

Solución de problemas

Sin memoria

• Hunyuan requiere un mínimo de 24 GB de VRAM

• Usa A100 de 40 GB/80 GB para obtener los mejores resultados

• Reduce la duración/resolución del video

La generación de video falla

• Verifica que todos los archivos del modelo se hayan descargado correctamente

• Asegúrate de tener suficiente espacio en disco (100 GB+)

• Verifica la compatibilidad de CUDA y PyTorch

Mala calidad de video

• Aumenta los pasos de inferencia

• Usa prompts más descriptivos

• Verifica que la resolución de entrada coincida con la esperada

Generación lenta

• La generación de video requiere mucho cómputo

• Usa A100/H100 para obtener resultados más rápidos

• Considera primero clips más cortos

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir 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 Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• CogVideoX - Alternativa T2V

• Wan2.1 Video - Otra opción T2V

• AnimateDiff - Animación de imágenes