Mochi-1 Vidéo

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+

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.

---

Étape 1 — Louez un GPU sur Clore.ai

1. Aller à 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.

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.

---

Étape 2 — Dockerfile personnalisé

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

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

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.

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.

---

Étape 3 — Connectez-vous via SSH

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

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 :

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"

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.

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

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 :

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

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

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.

---

É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)

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.

---

Utilisation de l'API Python

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

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

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 :

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]

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.

---

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 :

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:

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

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.

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

• Mochi-1 sur Hugging Face

• Blog Genmo — Publication de Mochi-1

• Documentation Diffusers Mochi

• Guide de prompts Mochi (Communauté)