# Génération vidéo FramePack

FramePack est une avancée dans la génération vidéo par IA : il peut créer des vidéos jusqu'à 2 minutes en utilisant **seulement 6 Go de VRAM**. Basé sur l'architecture HunyuanVideo, l'innovation clé de FramePack est l'optimisation du stockage des images de façon efficace afin que la mémoire GPU reste constante indépendamment de la durée de la vidéo. Cela rend la génération vidéo par IA accessible sur des GPU économiques auparavant trop limités.

## Principales caractéristiques

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

## Exigences

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

**GPU recommandé par Clore.ai** : RTX 3080 10 Go (\~0,2–0,5 $/jour) — excellente qualité à faible coût !

### Référence de vitesse

| GPU           | Temps par image | Vidéo de 60 images (\~2 s à 30 ips) |
| ------------- | --------------- | ----------------------------------- |
| RTX 3060 12GB | \~30 s          | \~30 min                            |
| RTX 3080 10Go | \~18 s          | \~18 min                            |
| RTX 4080 16GB | \~12 s          | \~12 min                            |
| RTX 4090 24GB | \~8 s           | \~8 min                             |
| RTX 5090 32GB | \~5 sec         | \~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/cu121
```

### 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 manière la plus simple d'utiliser FramePack :

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

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

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

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

1. Téléversez une image source (la première image)
2. Saisissez un prompt texte décrivant le mouvement ("la caméra effectue un zoom lent", "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. Ouvrir `http://localhost:7860` après le lancement
2. Téléversez une image source (sera la première image)
3. Saisissez un prompt texte décrivant le mouvement souhaité
4. Définissez le nombre d'images (plus = vidéo plus longue)
5. Cliquez **Générer** → attendez → téléchargez le MP4

### Accès API via Gradio Client

Vous pouvez appeler FramePack de manière programmatique en utilisant l'API Gradio :

```python
from gradio_client import Client

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

# Générer une vidéo à partir d'une image + prompt
result = client.predict(
    "input_photo.jpg",                              # image source
    "la personne sourit et tourne lentement la tête", # prompt
    60,                                              # nombre d'images
    7.5,                                             # échelle de guidance
    30,                                              # étapes d'inférence
    42,                                              # seed
    api_name="/generate"
)
print(f"Vidéo sauvegardée dans : {result}")
```

### Traitement par lot avec Gradio Client

```python
from gradio_client import Client
import glob

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

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

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 de résolution

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

## Conseils pour les utilisateurs de Clore.ai

* **Économique** : C'est l'un des rares modèles vidéo IA qui fonctionne sur des GPU bon marché (0,15–0,3 $/jour pour RTX 3060 !)
* **Utilisez `--low-vram` option** : Essentiel pour les GPU 6–8 Go — active automatiquement le déchargement sur CPU
* **512×512 suffit** : Pour les réseaux sociaux (TikTok, Reels), 512 px est parfaitement acceptable
* **Plus long ≠ plus de VRAM** : Contrairement à d'autres modèles vidéo, FramePack garde la VRAM constante — générez des vidéos plus longues librement
* **Pré-téléchargez les modèles** : Le premier lancement télécharge \~15 Go. Exécutez une fois, puis votre session Clore a les modèles en cache
* **Combiner avec suréchantillonnage** : Générez en 512×512, puis utilisez Real-ESRGAN pour monter en 2K/4K

## Conseils pour les prompts

Les bons prompts décrivent **le mouvement**, pas seulement l'apparence :

```
✅ "la caméra se déplace lentement vers la droite, révélant un paysage de montagne"
✅ "la personne cligne des yeux et sourit doucement, le vent agite ses cheveux"
✅ "zoom arrière lentement, montrant le bâtiment complet"

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

## Dépannage

| Problème                        | Solution                                                                                 |
| ------------------------------- | ---------------------------------------------------------------------------------------- |
| CUDA out of memory              | Utilisez `--low-vram` option, réduire la résolution à 512×512                            |
| Génération très lente           | Normal pour les GPU 6 Go (\~30 s/image). Utilisez RTX 4090 pour une vitesse 4x           |
| Images noires/corrompues        | Mettre à jour PyTorch : `pip install torch --upgrade`                                    |
| Téléchargement du modèle bloqué | Vérifiez l'espace disque (nécessite 30 Go libres). 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`                                    |

## Lectures complémentaires

* [Dépôt GitHub](https://github.com/lllyasviel/FramePack)
* [HunyuanVideo (modèle de base)](https://github.com/Tencent/HunyuanVideo)
* [Comparaison GPU Clore.ai](https://docs.clore.ai/guides/guides_v2-fr/pour-commencer/gpu-comparison) — trouvez le GPU le moins cher répondant à vos besoins