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 CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita 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

• GitHub: Tencent/HunyuanVideo

• Artículo: Documento de HunyuanVideo

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:

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

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

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

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

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

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

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

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:

# 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

Fuera de memoria

• 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 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