> 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). # Mochi-1 Video **Mochi-1** est le modèle open source de génération de vidéos à 10 milliards de paramètres de Genmo, produisant des vidéos en 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é en matière de fidélité des mouvements. 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 à 10 milliards de paramètres** modèle vidéo de diffusion entraîné pour produire des vidéos avec : * Mouvements fluides et physiquement plausibles * Forte cohérence temporelle * Forte adhérence au prompt * résolution 848×480 à 30 ips Il utilise un **transformeur de diffusion asymétrique** (AsymmDiT) — avec des 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 licence Genmo Open Source, libre pour la recherche et l’usage commercial. **Points forts du modèle :** * 10 milliards de paramètres * Sortie native 848×480 à 30 ips * Forte fidélité des mouvements (classé parmi les meilleurs 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 | 12.8+ | 12.8+ | {% hint style="warning" %} Mochi-1 est un modèle volumineux (≈40 Go en fp8 / ≈80 Go en bf16). Un seul RTX 4090 (24 Go) peut l’exécuter avec quantification. Pour une qualité optimale, utilisez un A100 40 Go ou plus. Les configurations multi-GPU sont prises en charge. {% endhint %} *** ## Étape 1 — Louer un GPU sur Clore.ai 1. Accédez à [clore.ai](https://clore.ai) et connectez-vous. 2. Cliquez sur **Place de marché** et filtrez : * VRAM : **≥ 24 Go** (RTX 4090 minimum, A100 recommandé) * Pour le multi-GPU : filtrez par nombre de GPU ≥ 2 3. Sélectionnez votre serveur et cliquez sur **Configurer**. 4. Définissez l’image Docker sur `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel` (image de base — nous installons Mochi à l’intérieur). 5. Définissez les ports ouverts : `22` (SSH) et `7860` (interface Gradio). 6. Cliquez sur **Louer**. {% hint style="info" %} Clore.ai propose des instances A100 40 Go à partir de [bare metal](https://clore.ai/bare-metal). Pour Mochi-1 en qualité maximale, 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.11.0-cuda12.8-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. Lancez le script de téléchargement puis démarrez la démo." && \ tail -f /dev/null ``` ### Construire et envoyer à Docker Hub Construisez l’image localement et poussez-la vers votre propre compte Docker Hub (remplacez `YOUR_DOCKERHUB_USERNAME` 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 image Docker dans Clore.ai. {% hint style="info" %} Il n’existe pas d’image Docker officielle préconstruite pour Mochi-1 sur Docker Hub. Vous devez la construire à partir du Dockerfile ci-dessus. Sinon, utilisez `pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel` comme image de base directement et exécutez les commandes de configuration manuellement via SSH. {% endhint %} *** ## Étape 3 — Connectez-vous via SSH Une fois votre instance en cours d’exécution : ```bash ssh root@ -p ``` *** ## É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 ce n’est pas déjà fait 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 bf16 complet fait environ 80 Go. La version `fp8` quantifiée fait \~40 Go et fonctionne sur RTX 4090 (24 Go) avec déchargement CPU. Indiquez `--include "*fp8*"` pour télécharger uniquement 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-vers-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` l’indicateur déplace les couches du modèle vers la RAM CPU lorsqu’elles ne sont pas utilisées, réduisant la VRAM maximale à \~18–20 Go au prix d’une génération environ 2× plus lente. {% endhint %} *** ## Étape 6 — Accéder à l’interface web Ouvrez votre navigateur et rendez-vous sur : ``` http://: ``` Vous verrez l’interface Gradio de Mochi-1 avec : * Un champ de saisie pour le prompt texte * Paramètres de génération (steps, guidance scale, seed) * Lecteur de sortie vidéo *** ## Étape 7 — Générer votre première vidéo ### Exemples de prompts **Scène naturelle :** ``` Une majestueuse cascade dévalant des rochers couverts de mousse dans une forêt tropicale luxuriante, la lumière dorée de l’heure dorée filtrant à travers la canopée, panoramique cinématographique lent ``` **Scène d’action :** ``` Un guépard sprintant à pleine vitesse à travers une savane ouverte, soulevant de la poussière derrière lui, plan large dramatique, documentaire animalier 4K ``` **Abstrait / artistique :** ``` Peinture colorée tourbillonnant dans l’eau en très ralenti, pigments bleu et orange vifs se mélangeant, objectif macro, éclairage de studio ``` ### Paramètres recommandés | Paramètre | Valeur | | ----------------- | ------------------------- | | Étapes | 64 | | Scale de guidance | 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 considérablement selon le GPU. Sur un A100 80 Go, une vidéo de 5 secondes prend environ **2–4 minutes**. Sur RTX 4090 avec déchargement CPU, prévoyez **8–15 minutes**. {% endhint %} *** ## Utilisation de l’API Python Pour une 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 dans output.mp4") ``` ### Script de génération par lots ```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, macrophotographie", "Des vagues de l’océan se brisant contre des falaises rocheuses au coucher du soleil, prise de vue par drone", "Des aurores boréales dansant dans 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 GPU : ```python import torch from diffusers import MochiPipeline # Utiliser device_map pour la distribution automatique multi-GPU pipe = MochiPipeline.from_pretrained( "/workspace/mochi-weights", torch_dtype=torch.bfloat16, device_map="balanced" ) # Pas besoin de cpu_offload avec plusieurs GPU 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 tombe à moins de 60 secondes pour un clip de 5 secondes. {% endhint %} *** ## Dépannage ### Mémoire CUDA insuffisante ``` torch.cuda.OutOfMemoryError : mémoire CUDA insuffisante ``` **Solutions :** 1. Ajoutez `--cpu_offload` à la commande gradio 2. Activez le découpage VAE : `pipe.enable_vae_slicing()` 3. Réduisez `num_frames` (essayez 24 au lieu de 84) 4. Utilisez les poids quantifiés fp8 au lieu de bf16 ### Chargement du modèle lent **Solution :** Assurez-vous que les poids sont sur un disque NVMe rapide, pas sur un HDD. Vérifiez la vitesse du 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 un seed 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 est lié à `0.0.0.0`: ```bash ss -tlnp | grep 7860 ``` *** ## Estimation des coûts | GPU | VRAM | Prix estimé | Temps vidéo 5 s | | ------------- | ------ | ----------------------------------------- | --------------- | | RTX 4090 | 24 Go | 0,14–0,42 $/h | \~10–15 min | | A100 40 Go | 40 Go | [bare metal](https://clore.ai/bare-metal) | \~3–5 min | | A100 80 Go | 80 Go | [bare metal](https://clore.ai/bare-metal) | \~2–3 min | | 2× A100 80 Go | 160 Go | [bare metal](https://clore.ai/bare-metal) | \~60–90 s | *** ## Recommandations GPU Clore.ai {% hint style="warning" %} **Les configurations multi-GPU de classe 80 Go ne sont pas répertoriées sur la place de marché Clore.ai.** Les plus grosses machines répertoriées aujourd’hui sont 4× RTX PRO 6000 Blackwell (96 Go chacune, 380 Go au total) et 8–11× RTX 5090 (32 Go chacune). La capacité A100 / H200 / B200 est proposée en bare metal sur demande. Consultez [bare metal](https://clore.ai/bare-metal) sur demande. Consultez [Tarifs et disponibilité des GPU](/guides/guides_v2-fr/premiers-pas/pricing.md) avant de dimensionner un déploiement. {% endhint %} Mochi-1 consomme beaucoup de VRAM — le modèle à 10 milliards de paramètres nécessite une sélection soignée du GPU. | GPU | VRAM | Prix Clore.ai | Mode | Temps de génération d’une vidéo de 5 s | | ------------- | ------ | ----------------------------------------- | -------------------------------------- | -------------------------------------- | | RTX 4090 | 24 Go | 0,14–0,42 $/h | fp8 quantifié uniquement | \~10–15 min | | A100 40 Go | 40 Go | [bare metal](https://clore.ai/bare-metal) | bf16 recommandé | \~3–5 min | | A100 80 Go | 80 Go | [bare metal](https://clore.ai/bare-metal) | bf16 complet, rapide | \~2–3 min | | 2× A100 80 Go | 160 Go | [bare metal](https://clore.ai/bare-metal) | parallélisme tensoriel, le plus rapide | \~60–90 s | {% hint style="warning" %} **RTX 3090 (24 Go) non recommandé** — le mode fp8 de Mochi-1 nécessite au minimum 24 Go et laisse presque aucune marge. La RTX 4090 (24 Go) fonctionne en fp8 mais manque fréquemment de mémoire sur les séquences plus longues. Commencez avec un A100 40 Go pour des résultats fiables. {% endhint %} **Meilleur rapport qualité-prix :** A100 40 Go à [bare metal](https://clore.ai/bare-metal) génère un clip de 5 secondes en 3–5 minutes. Cela revient à environ 0,08–0,10 $ par clip vidéo — nettement moins cher que Runway ML (0,25–0,50 $/clip) ou les abonnements Pika Labs. *** ## Ressources utiles * [Mochi-1 GitHub](https://github.com/genmoai/mochi) * [Mochi-1 sur Hugging Face](https://huggingface.co/genmo/mochi-1-preview) * [Blog Genmo — Lancement de Mochi-1](https://www.genmo.ai/blog/mochi-1) * [Documentation Mochi pour Diffusers](https://huggingface.co/docs/diffusers/api/pipelines/mochi) * [Guide des 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, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-fr/generation-video/mochi-1.md?ask=&goal= ``` `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.