# Hunyuan Video

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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](https://huggingface.co/tencent/HunyuanVideo)
* **GitHub :** [Tencent/HunyuanVideo](https://github.com/Tencent/HunyuanVideo)
* **Article :** [Article HunyuanVideo](https://arxiv.org/abs/2412.03603)

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

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

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

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

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

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

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

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

```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 = [
    "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

```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="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 :**

```python

# 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

{% hint style="danger" %}
**Mémoire insuffisante**
{% endhint %}

* 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*](https://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