Hunyuan Video

Générez des vidéos de haute qualité avec Hunyuan Video de Tencent sur Clore.ai

Générez des vidéos de haute qualité avec Hunyuan Video open-source de Tencent.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces Web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<adresse-proxy>

Qu'est-ce que Hunyuan Video ?

Hunyuan Video de Tencent propose :

• Génération texte‑vers‑vidéo de haute qualité

• Clips vidéo de plus de 5 secondes

• Résolution 720p

• Open-source et utilisable commercialement

Ressources

• Modèle : tencent/HunyuanVideo

• GitHub : Tencent/HunyuanVideo

• Article : Article HunyuanVideo

Matériel recommandé

Composant	Minimum	Recommandé	Optimal
GPU	RTX 4090 24GB	A100 40GB	A100 80GB
VRAM	24 Go	40Go	80Go
CPU	8 cœurs	16 cœurs	32 cœurs
RAM	32Go	64Go	128Go
Stockage	100Go NVMe	200 Go NVMe	500 Go NVMe
Internet	500 Mbps	1 Gbps	1 Gbps

Déploiement rapide sur CLORE.AI

Image Docker :

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

Ports :

22/tcp
7860/http

Commande :

git clone https://github.com/Tencent/HunyuanVideo.git && \
cd HunyuanVideo && \
pip install -r requirements.txt && \
python sample_video.py --prompt "Un chat se promenant dans un jardin"

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://VOTRE_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

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

# Télécharger les modèles
python download_models.py

Ce que vous pouvez créer

Contenu marketing

• Vidéos de présentation de produit

• Clips pour les réseaux sociaux

• Animations promotionnelles

Projets créatifs

• Concepts de clips musicaux

• Prototypes de courts métrages

• Installations artistiques

Éducation et formation

• Brouillons de vidéos explicatives

• Concepts de matériel de formation

• Visualisation de concepts

Utilisation de base

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 aigle majestueux planant au‑dessus de montagnes enneigées, éclairage cinématographique, 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)

Génération avancée

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 d'une fleur épanouie, macrophotographie, pétales détaillés",
    negative_prompt="flou, basse qualité, déformé, laid",
    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)

Exemples de prompts

Nature et paysages

prompts = [
    "Aurore boréale dansant au‑dessus d'un lac gelé, time‑lapse, éthéré",
    "Vagues de l'océan s'écrasant sur une plage de sable noir volcanique, ralenti",
    "Orage sur un champ de blé, éclairage dramatique, 4K",
    "Fleurs de cerisier tombant dans un jardin japonais, printemps, paisible"
]

Science‑fiction et fantasy

prompts = [
    "Vaisseau spatial lançant depuis une ville futuriste, cinématographique, détaillé",
    "Dragon volant à travers les nuages au coucher du soleil, épique, fantasy",
    "Robot marchant dans des rues éclairées au néon, cyberpunk, pluie",
    "Portail magique s'ouvrant dans une forêt ancienne, lumières mystiques"
]

Abstrait et artistique

prompts = [
    "Gouttes d'encre se diffusant dans l'eau, macro, coloré, abstrait",
    "Formes géométriques se transformant et se métamorphosant, infographie en mouvement",
    "Peinture lumineuse dans l'obscurité, effet longue exposition, vibrant"
]

Génération par lot

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 = [
    "Récif corallien sous‑marin avec des poissons colorés nageant",
    "Time‑lapse du trafic en ville la nuit, traînées lumineuses",
    "Papillon sortant d'un cocon, documentaire nature"
]

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

for i, prompt in enumerate(prompts):
    print(f"Génération {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)

Interface 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="flou, basse qualité"),
        gr.Slider(16, 60, value=45, step=1, label="Images"),
        gr.Slider(20, 100, value=50, step=5, label="Étapes"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidage"),
        gr.Number(value=-1, label="Graine")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Hunyuan Video - Texte vers Vidéo sur CLORE.AI"
)

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

Performances

Résolution	Images	GPU	Temps
544x960	45	RTX 4090	~5 min
544x960	45	A100 40GB	~3 min
544x960	45	A100 80GB	~2 min
720x1280	45	A100 80GB	~4 min

Problèmes courants et solutions

Mémoire insuffisante

Problème : CUDA manque de mémoire sur GPU 24GB

Solutions :

# Activer toutes les optimisations de mémoire
pipe.enable_model_cpu_offload()
pipe.enable_sequential_cpu_offload()  # Plus agressif
pipe.vae.enable_tiling()
pipe.vae.enable_slicing()

# Réduire les images et la résolution
video = pipe(prompt, num_frames=24, height=480, width=720).frames[0]

Génération lente

Problème : La génération prend trop de temps

Solutions :

• Réduire num_inference_steps (30‑40 donne encore de bons résultats)

• Réduire num_frames (24 images = 1,6 s à 15fps)

• Utiliser un GPU A100 pour un traitement plus rapide

• Assurez‑vous d'avoir un stockage NVMe pour le chargement des modèles

Mauvaise qualité vidéo

Problème : Flou ou mouvement incohérent

Solutions :

• Augmentez num_inference_steps à 75‑100

• Ajuster guidance_scale (6‑8 fonctionne le mieux)

• Rédigez des prompts plus détaillés

• Ajoutez des prompts négatifs pour éviter les problèmes

Artefacts vidéo

Problème : Scintillement ou incohérences temporelles

Solutions :

• Utiliser une graine cohérente pour la reproductibilité

• Éviter les prompts avec des mouvements rapides

• Post‑traiter avec une stabilisation vidéo

Dépannage

Mémoire insuffisante

• Hunyuan requiert un minimum de 24 Go de VRAM

• Utiliser A100 40GB/80GB pour de meilleurs résultats

• Réduire la longueur/la résolution de la vidéo

La génération de vidéo échoue

• Vérifiez que tous les fichiers du modèle ont été correctement téléchargés

• Assurez‑vous d'avoir suffisamment d'espace disque (100 Go+)

• Vérifiez la compatibilité CUDA et PyTorch

Mauvaise qualité vidéo

• Augmenter le nombre d'étapes d'inférence

• Utiliser des prompts plus descriptifs

• Vérifiez que la résolution d'entrée correspond à celle attendue

Génération lente

• La génération vidéo est gourmande en calcul

• Utiliser A100/H100 pour des résultats plus rapides

• Envisagez d'abord des clips plus courts

Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

• Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)

• Payer avec CLORE jetons

• Comparer les prix entre différents fournisseurs

Prochaines étapes

• CogVideoX - Alternative T2V

• Wan2.1 Video - Une autre option T2V

• AnimateDiff - Animation d'image