> 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/mochi-1.md).

# Vidéo Mochi-1

**Mochi-1** est le modèle de génération vidéo open-source à 10 milliards de paramètres de Genmo produisant une sortie 848×480 @ 30 ips avec un mouvement physiquement réaliste. Il utilise une architecture de transformeur de diffusion asymétrique (AsymmDiT) et se classe parmi les modèles vidéo open-source de la plus haute qualité pour la fidélité du mouvement. Déployez-le sur le cloud GPU de Clore.ai pour générer des vidéos de qualité professionnelle à une fraction du coût des API commerciales.

***

## Qu'est-ce que Mochi-1 ?

Mochi-1 est un **modèle de 10 milliards de paramètres** modèle de diffusion vidéo entraîné pour produire des vidéos avec :

* Mouvement fluide et physiquement plausible
* Forte cohérence temporelle
* Bonne fidélité aux instructions (prompt)
* Résolution 848×480 à 30 ips

Il utilise un **transformeur de diffusion asymétrique** (architecture AsymmDiT) — profondeurs d'encodeur différentes pour la vidéo et le texte — permettant une inférence efficace à grande échelle. Les poids sont publiés sous la Genmo Open Source License, gratuits pour la recherche et un usage commercial.

**Points forts du modèle :**

* 10 milliards de paramètres
* Sortie native 848×480 @ 30 ips
* Haute fidélité de mouvement (classé en tête dans les benchmarks communautaires)
* Disponible sur Hugging Face avec intégration diffusers
* Interface de démonstration Gradio pour une interaction facile

***

## Prérequis

| Exigence | Minimum  | Recommandé  |
| -------- | -------- | ----------- |
| VRAM GPU | 24 Go    | 40–80 Go    |
| GPU      | RTX 4090 | A100 / H100 |
| RAM      | 32 Go    | 64 Go       |
| Stockage | 60 Go    | 100 Go      |
| CUDA     | 11.8+    | 12.1+       |

{% hint style="warning" %}
Mochi-1 est un grand modèle (≈40 Go en fp8 / ≈80 Go en bf16). Un seul RTX 4090 (24 Go) peut l'exécuter avec quantification. Pour une qualité complète, utilisez une A100 40 Go ou plus. Les configurations multi-GPU sont prises en charge.
{% endhint %}

***

## Étape 1 — Louez un GPU sur Clore.ai

1. Aller à [clore.ai](https://clore.ai) et connectez-vous.
2. Cliquez **Place de marché** et filtrez :
   * VRAM : **≥ 24 Go** (RTX 4090 minimum, A100 recommandé)
   * Pour multi-GPU : filtrez par nombre de GPU ≥ 2
3. Sélectionnez votre serveur et cliquez **Configurer**.
4. Définissez l'image Docker sur `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` (image de base — nous installons Mochi à l'intérieur).
5. Définir les ports ouverts : `22` (SSH) et `7860` (UI Gradio).
6. Cliquez **Louez**.

{% hint style="info" %}
Clore.ai propose des instances A100 40 Go à partir d'environ 0,60–0,90 $/h. Pour Mochi-1 à pleine qualité, c'est le choix le plus rentable.
{% endhint %}

***

## Étape 2 — Dockerfile personnalisé

Créez votre propre image ou utilisez ceci `Dockerfile` pour créer un environnement Mochi-1 prêt à l'emploi :

```dockerfile
FROM pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel

ENV DEBIAN_FRONTEND=noninteractive

RUN apt-get update && apt-get install -y \
    git wget curl ffmpeg \
    libgl1 libglib2.0-0 \
    openssh-server \
    && rm -rf /var/lib/apt/lists/*

# Configurer SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config && \
    sed -i 's/UsePAM yes/UsePAM no/' /etc/ssh/sshd_config

WORKDIR /workspace

# Cloner le dépôt Mochi-1
RUN git clone https://github.com/genmoai/mochi /workspace/mochi

# Installer les dépendances Python
RUN cd /workspace/mochi && \
    pip install --upgrade pip && \
    pip install -e . && \
    pip install gradio huggingface_hub

EXPOSE 22 7860

CMD service ssh start && \
    echo "Environnement Mochi-1 prêt. Exécutez le script de téléchargement puis lancez la démo." && \
    tail -f /dev/null
```

### Construire et pousser sur Docker Hub

Construisez l'image localement et poussez-la sur votre propre compte Docker Hub (remplacez `VOTRE_NOM_UTILISATEUR_DOCKERHUB` par votre nom d'utilisateur réel) :

```bash
docker build -t YOUR_DOCKERHUB_USERNAME/mochi-1:latest .
docker push YOUR_DOCKERHUB_USERNAME/mochi-1:latest
```

Puis utilisez `YOUR_DOCKERHUB_USERNAME/mochi-1:latest` comme votre image Docker sur Clore.ai.

{% hint style="info" %}
Il n'existe pas d'image Docker préconstruite officielle pour Mochi-1 sur Docker Hub. Vous devez construire à partir du Dockerfile ci-dessus. Alternativement, utilisez `pytorch/pytorch:2.4.1-cuda12.4-cudnn9-devel` comme image de base directement et exécutez les commandes d'installation manuellement via SSH.
{% endhint %}

***

## Étape 3 — Connectez-vous via SSH

Une fois votre instance en cours d'exécution :

```bash
ssh root@<clore-host> -p <assigned-ssh-port>
```

***

## Étape 4 — Télécharger les poids de Mochi-1

Les poids du modèle sont hébergés sur Hugging Face. Téléchargez-les via le `huggingface_hub` CLI :

```bash
cd /workspace

# Installer huggingface-cli si absent
pip install -U huggingface_hub

# Télécharger les poids de Mochi-1 (~40 Go pour bf16)
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*.safetensors" "*.json" "*.txt"
```

{% hint style="info" %}
Le modèle complet en bf16 fait approximativement 80 Go. La `fp8` version quantifiée est \~40 Go et fonctionne sur RTX 4090 (24 Go) avec déchargement CPU. Spécifiez `--include "*fp8*"` pour ne télécharger que les poids quantifiés.
{% endhint %}

### Alternative : télécharger uniquement les poids quantifiés fp8

```bash
huggingface-cli download genmo/mochi-1-preview \
    --local-dir /workspace/mochi-weights \
    --include "*fp8*" "*.json" "*.txt"
```

***

## Étape 5 — Lancer la démo Gradio

Mochi-1 est livré avec une interface web Gradio pour une génération texte-vidéo facile :

```bash
cd /workspace/mochi

python demos/gradio_ui.py \
    --model_dir /workspace/mochi-weights \
    --share False \
    --host 0.0.0.0 \
    --port 7860
```

**Pour le mode faible VRAM (RTX 4090, 24 Go) :**

```bash
python demos/gradio_ui.py \
    --model_dir /workspace/mochi-weights \
    --cpu_offload \
    --share False \
    --host 0.0.0.0 \
    --port 7860
```

{% hint style="info" %}
Le `--cpu_offload` le flag déplace les couches du modèle vers la RAM CPU lorsqu'elles ne sont pas utilisées, réduisant la VRAM de pointe à \~18–20 Go au prix d'une génération \~2× plus lente.
{% endhint %}

***

## Étape 6 — Accéder à l'interface web

Ouvrez votre navigateur et rendez-vous sur :

```
http://<clore-host>:<public-port-7860>
```

Vous verrez l'interface Gradio de Mochi-1 avec :

* Un champ d'entrée pour le prompt texte
* Paramètres de génération (steps, guidance scale, seed)
* Lecteur de sortie vidéo

***

## Étape 7 — Générez votre première vidéo

### Prompts d'exemple

**Scène de nature :**

```
Une chute d'eau majestueuse dévalant des rochers moussus dans une forêt tropicale luxuriante, 
lumière de l'heure dorée filtrant à travers la canopée, panoramique cinématographique lent
```

**Scène d'action :**

```
Un guépard sprintant à travers une savane ouverte à pleine vitesse, 
de la poussière se soulevant derrière lui, plan large dramatique, documentaire animalier 4K
```

**Abstrait/artistique :**

```
Peinture colorée tourbillonnant dans l'eau en très slow motion, 
pigments bleu vif et orange se mélangeant, objectif macro, éclairage de studio
```

### Paramètres recommandés

| Paramètre      | Valeur                    |
| -------------- | ------------------------- |
| Steps          | 64                        |
| Guidance Scale | 4.5                       |
| Durée          | 5,1 secondes (par défaut) |
| Résolution     | 848×480 (natif)           |

{% hint style="info" %}
Le temps de génération varie significativement selon le GPU. Sur une A100 80 Go, une vidéo de 5 secondes prend environ **2–4 minutes**. Sur RTX 4090 avec déchargement CPU, comptez **8–15 minutes**.
{% endhint %}

***

## Utilisation de l'API Python

Pour la génération programmatique, utilisez le pipeline diffusers :

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video

# Charger le pipeline
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Générer la vidéo
with torch.autocast("cuda", torch.bfloat16, cache_enabled=False):
    frames = pipe(
        prompt="Un golden retriever jouant à rapporter sur une plage ensoleillée, cinématique",
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
        generator=torch.Generator("cuda").manual_seed(42)
    ).frames[0]

# Exporter
export_to_video(frames, "output.mp4", fps=30)
print("Vidéo enregistrée sous output.mp4")
```

### Script de génération par lot

```python
import torch
from diffusers import MochiPipeline
from diffusers.utils import export_to_video
import os

pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

prompts = [
    "Un papillon se posant sur une fleur au ralenti, photographie macro",
    "Les vagues de l'océan s'écrasant contre des falaises rocheuses au coucher du soleil, prise par drone",
    "Aurores boréales dansant à travers un ciel étoilé au-dessus d'un lac gelé",
]

os.makedirs("/workspace/outputs", exist_ok=True)

for i, prompt in enumerate(prompts):
    frames = pipe(
        prompt=prompt,
        num_frames=84,
        guidance_scale=4.5,
        num_inference_steps=64,
    ).frames[0]
    
    output_path = f"/workspace/outputs/video_{i:03d}.mp4"
    export_to_video(frames, output_path, fps=30)
    print(f"Enregistré : {output_path}")
```

***

## Inférence multi-GPU

Pour une génération plus rapide avec plusieurs GPUs :

```python
import torch
from diffusers import MochiPipeline

# Utilisez device_map pour une distribution multi-GPU automatique
pipe = MochiPipeline.from_pretrained(
    "/workspace/mochi-weights",
    torch_dtype=torch.bfloat16,
    device_map="balanced"
)

# Pas besoin de cpu_offload avec plusieurs GPUs
frames = pipe(
    prompt="Votre prompt ici",
    num_frames=84,
    guidance_scale=4.5,
    num_inference_steps=64,
).frames[0]
```

{% hint style="info" %}
Clore.ai propose des serveurs multi-GPU (2×, 4× RTX 4090 ou A100). Avec 2× A100 80 Go, le temps de génération descend à moins de 60 secondes pour un clip de 5 secondes.
{% endhint %}

***

## Dépannage

### CUDA : mémoire insuffisante

```
torch.cuda.OutOfMemoryError : mémoire CUDA insuffisante
```

**Solutions :**

1. Ajouter `--cpu_offload` à la commande gradio
2. Activer le découpage VAE : `pipe.enable_vae_slicing()`
3. Réduire `num_frames` (essayez 24 au lieu de 84)
4. Utilisez des poids quantifiés fp8 au lieu de bf16

### Chargement lent du modèle

**Solution :** Assurez-vous que les poids sont sur un disque NVMe rapide, pas sur un HDD. Vérifiez la vitesse de stockage :

```bash
dd if=/dev/zero of=/workspace/test bs=1M count=1000 conv=fdatasync
```

### Artefacts vidéo / Scintillement temporel

**Solutions :**

* Augmentez les étapes d'inférence (essayez 80–100)
* Ajustez la guidance scale (la plage 3.5–5.0 est généralement la meilleure)
* Utilisez une graine spécifique pour la reproductibilité et l'itération

### Le port 7860 n'est pas accessible

Vérifiez que le port a été correctement ouvert dans Clore.ai et que le serveur Gradio se lie à `0.0.0.0`:

```bash
ss -tlnp | grep 7860
```

***

## Estimation des coûts

| GPU          | VRAM   | Prix estimé | Temps pour une vidéo de 5 s |
| ------------ | ------ | ----------- | --------------------------- |
| RTX 4090     | 24 Go  | \~0,35 $/h  | \~10–15 min                 |
| A100 40GB    | 40 Go  | \~0,70 $/h  | \~3–5 min                   |
| A100 80GB    | 80 Go  | \~1,20 $/h  | \~2–3 min                   |
| 2× A100 80Go | 160 Go | \~2,20 $/h  | \~60–90 sec                 |

***

## Recommandations GPU Clore.ai

Mochi-1 est gourmand en VRAM — le modèle de 10 milliards de paramètres exige une sélection attentive du GPU.

| GPU          | VRAM   | Prix Clore.ai | Mode                                   | Temps de génération pour vidéo de 5 s |
| ------------ | ------ | ------------- | -------------------------------------- | ------------------------------------- |
| RTX 4090     | 24 Go  | \~0,70 $/h    | fp8 quantifié uniquement               | \~10–15 min                           |
| A100 40GB    | 40 Go  | \~1,20 $/h    | bf16 recommandé                        | \~3–5 min                             |
| A100 80GB    | 80 Go  | \~2,00 $/h    | bf16 complet, rapide                   | \~2–3 min                             |
| 2× A100 80Go | 160 Go | \~4,00 $/h    | parallélisme tensoriel, le plus rapide | \~60–90 sec                           |

{% hint style="warning" %}
**RTX 3090 (24Go) n'est pas recommandé** — Mochi-1 en mode fp8 nécessite 24 Go minimum et laisse presque aucune marge. Le RTX 4090 (24 Go) fonctionne en fp8 mais provoque fréquemment des OOM sur des séquences plus longues. Commencez avec une A100 40 Go pour des résultats fiables.
{% endhint %}

**Meilleur rapport qualité/prix :** Une A100 40Go à \~1,20 $/h génère un clip de 5 secondes en 3–5 minutes. Cela revient à \~0,08–0,10 $ par clip vidéo — considérablement moins cher que Runway ML (0,25–0,50 $/clip) ou les abonnements Pika Labs.

***

## Ressources utiles

* [Mochi-1 sur GitHub](https://github.com/genmoai/mochi)
* [Mochi-1 sur Hugging Face](https://huggingface.co/genmo/mochi-1-preview)
* [Blog Genmo — Publication de Mochi-1](https://www.genmo.ai/blog/mochi-1)
* [Documentation Diffusers Mochi](https://huggingface.co/docs/diffusers/api/pipelines/mochi)
* [Guide de prompts Mochi (Communauté)](https://github.com/genmoai/mochi/blob/main/README.md)


---

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

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/mochi-1.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.