> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/generation-video/framepack.md).

# Génération vidéo FramePack

Générez des vidéos IA avec seulement 6 Go de VRAM grâce à FramePack sur Clore.ai

FramePack est une avancée majeure dans la génération vidéo par IA : il peut créer des vidéos allant jusqu’à 2 minutes en utilisant **seulement 6 Go de VRAM**. Construit sur l’architecture HunyuanVideo, l’innovation clé de FramePack consiste à empaqueter les images efficacement afin que la mémoire GPU reste constante quelle que soit la durée de la vidéo. Cela rend la génération vidéo par IA accessible sur des GPU abordables qui étaient auparavant trop limités.

## Caractéristiques clés

* **Minimum 6 Go de VRAM**: Fonctionne sur RTX 3060, RTX 3070, même GTX 1060 !
* **Vidéos jusqu’à 2 minutes**: Utilisation de VRAM constante quelle que soit la durée de la vidéo
* **Image vers vidéo**: Animez n’importe quelle image avec une invite textuelle
* **Interface Web incluse**: Interface basée sur Gradio pour une utilisation facile
* **Construit sur HunyuanVideo**: Exploite l’architecture de diffusion vidéo de Tencent
* **Code source ouvert**: GitHub avec un développement actif

## Exigences

| Composant | Minimum       | Recommandé     |
| --------- | ------------- | -------------- |
| GPU       | GTX 1060 6 Go | RTX 4090 24 Go |
| VRAM      | 6 Go          | 12 Go+         |
| RAM       | 16 Go         | 32 Go          |
| Disque    | 30 Go         | 50 Go          |
| CUDA      | 12.8+         | 12.8+          |
| Python    | 3.10+         | 3.11           |

**GPU Clore.ai recommandé**: RTX 3080 10 Go (0,05–0,19 $/h) — excellente qualité à bas coût !

### Référence de vitesse

| GPU            | Temps par image | Vidéo de 60 images (\~2 s à 30 fps) |
| -------------- | --------------- | ----------------------------------- |
| RTX 3060 12 Go | \~30 s          | \~30 min                            |
| RTX 3080 10 Go | \~18 s          | \~18 min                            |
| RTX 4080 16 Go | \~12 s          | \~12 min                            |
| RTX 4090 24 Go | \~8 s           | \~8 min                             |
| RTX 5090 32 Go | \~5 s           | \~5 min                             |

## Installation

```bash
# Cloner le dépôt
git clone https://github.com/lllyasviel/FramePack.git
cd FramePack

# Créer un environnement conda (recommandé)
conda create -n framepack python=3.11 -y
conda activate framepack

# Installer les dépendances
pip install -r requirements.txt

# Installer PyTorch avec CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu128
```

### Configuration Docker

```bash
docker run --gpus all -p 7860:7860 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  -v ./outputs:/app/outputs \
  ghcr.io/lllyasviel/framepack:latest
```

## Démarrage rapide — interface Web

La façon la plus simple d’utiliser FramePack :

```bash
cd FramePack
python app.py --port 7860

# Pour une faible VRAM (6 Go) :
python app.py --port 7860 --low-vram

# Accéder à http://localhost:7860
```

**Flux de travail de l’interface Web :**

1. Téléversez une image source (sera la première image)
2. Saisissez une invite textuelle décrivant le mouvement ("la caméra zoome lentement", "la personne avance")
3. Définissez la durée de la vidéo (nombre d’images)
4. Cliquez sur Générer
5. Téléchargez le MP4

## Utilisation

FramePack est une **application Web Gradio**, pas une bibliothèque Python. L’interface principale est l’interface Web.

### Flux de travail de l’interface Web

1. Ouvrez `http://localhost:7860` après le lancement
2. Téléversez une image source (sera la première image)
3. Saisissez une invite textuelle décrivant le mouvement souhaité
4. Définissez le nombre d’images (plus = vidéo plus longue)
5. Cliquez sur **Générer** → attendre → télécharger MP4

### Accès à l’API via le client Gradio

Vous pouvez appeler FramePack par programmation à l’aide de l’API Gradio :

```python
from gradio_client import Client

# Se connecter à une instance FramePack en cours d’exécution
client = Client("http://localhost:7860")

# Générer une vidéo à partir d’une image + d’une invite
result = client.predict(
    "input_photo.jpg",                              # image source
    "the person smiles and turns their head slowly", # invite
    60,                                              # nombre d’images
    7.5,                                             # échelle de guidage
    30,                                              # étapes d’inférence
    42,                                              # graine
    api_name="/generate"
)
print(f"Vidéo enregistrée dans : {result}")
```

### Traitement par lots avec le client Gradio

```python
from gradio_client import Client
import glob

client = Client("http://localhost:7860")

prompts = [
    ("photo1.jpg", "zoom doux de la caméra avec un éclairage doux"),
    ("photo2.jpg", "vent soufflant dans les cheveux, nuages en mouvement"),
    ("photo3.jpg", "zoom arrière lent révélant toute la scène"),
]

for img_path, prompt in prompts:
    result = client.predict(img_path, prompt, 60, 7.5, 30, -1, api_name="/generate")
    print(f"Terminé : {img_path} → {result}")
```

## Guide des résolutions

| VRAM  | Résolution maximale | Qualité                      |
| ----- | ------------------- | ---------------------------- |
| 6 Go  | 512×512             | Bon pour les réseaux sociaux |
| 8 Go  | 640×640             | Meilleur niveau de détail    |
| 10GB  | 512×768             | Portrait/paysage             |
| 12 Go | 768×768             | Haute qualité                |
| 24GB  | 1024×768            | Meilleure qualité            |

## Conseils pour les utilisateurs de Clore.ai

* **Économique**: C’est l’un des rares modèles vidéo d’IA qui fonctionne sur des GPU bon marché (0,03–0,07 $/h pour RTX 3060 !)
* **Utilisez `--low-vram` indicateur**: Indispensable pour les GPU de 6 à 8 Go — active automatiquement le déchargement vers le CPU
* **512×512 convient très bien**: Pour les réseaux sociaux (TikTok, Reels), 512 px est tout à fait acceptable
* **Plus long ≠ plus de VRAM**: Contrairement à d’autres modèles vidéo, FramePack maintient la VRAM constante — générez librement des vidéos plus longues
* **Pré-télécharger les modèles**: Le premier lancement télécharge \~15 Go. Exécutez-le une fois, puis votre session Clore aura les modèles en cache
* **Combiner avec l’upscaling**: Générez en 512×512, puis utilisez Real-ESRGAN pour upscaler en 2K/4K

## Conseils pour les invites

Les bonnes invites décrivent **le mouvement**, pas seulement l’apparence :

```
✅ "la caméra effectue un panoramique lent vers la droite, révélant un paysage de montagne"
✅ "la personne cligne des yeux et sourit doucement, le vent bouge ses cheveux"
✅ "zoomer lentement vers l’arrière, montrant tout le bâtiment"

❌ "un beau coucher de soleil" (aucun mouvement décrit)
❌ "haute qualité, 4K, détaillé" (les mots de style n’aident pas beaucoup)
```

## Dépannage

| Problème                              | Solution                                                                                   |
| ------------------------------------- | ------------------------------------------------------------------------------------------ |
| Mémoire CUDA insuffisante             | Utilisez `--low-vram` indicateur, réduisez la résolution à 512×512                         |
| Génération très lente                 | Normal pour les GPU de 6 Go (\~30 s/image). Utilisez une RTX 4090 pour une vitesse x4      |
| Images noires/corrompues              | Mettez PyTorch à jour : `pip install torch --upgrade`                                      |
| Le téléchargement du modèle se bloque | Vérifiez l’espace disque (30 Go libres nécessaires). Essayez `HF_HUB_ENABLE_HF_TRANSFER=1` |
| L’interface Web ne démarre pas        | Vérifiez que le port 7860 est libre : `lsof -i :7860`                                      |

## Pour aller plus loin

* [Dépôt GitHub](https://github.com/lllyasviel/FramePack)
* [HunyuanVideo (modèle de base)](https://github.com/Tencent/HunyuanVideo)
* [Comparaison des GPU sur Clore.ai](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md) — trouvez le GPU le moins cher adapté à vos besoins


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/framepack.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.