AnimateDiff

AnimateDiff est un module prêt à l’emploi qui anime vos modèles Stable Diffusion existants sans aucun entraînement supplémentaire. Avec plus de 10 000 étoiles sur GitHub, c’est le framework de référence pour transformer des checkpoints SD d’images fixes en générateurs vidéo fluides et cohérents dans le temps. Exécutez-le sur une instance GPU Clore.ai en utilisant ComfyUI comme interface front-end pour une flexibilité maximale.

Qu’est-ce qu’AnimateDiff ?

AnimateDiff insère un module de mouvement dans un U-Net Stable Diffusion figé. Le module de mouvement est entraîné une seule fois sur des données vidéo et peut être combiné avec n’importe quel checkpoint SD 1.5 finement ajusté — modèles DreamBooth, LoRA, adaptateurs ControlNet — sans réentraînement. Le résultat est de courts clips animés (généralement 16 à 32 images à 8 ips) qui conservent le style du modèle de base.

Points forts :

Fonctionne immédiatement avec n’importe quel checkpoint SD 1.5
Compatible avec ControlNet, IP-Adapter, LoRA et d’autres extensions
L’écosystème de nœuds ComfyUI offre un contrôle complet du pipeline
Des modules de mouvement SDXL sont disponibles pour une sortie en plus haute résolution
Zoo de modèles maintenu par la communauté avec des modules de mouvement spécialisés par domaine

Prérequis

Exigence

Minimum

Recommandé

VRAM GPU

8 Go

16–24 Go

GPU

RTX 3080

RTX 4090 / A100

RAM

16 Go

32 Go

Stockage

20 Go

50+ Go

AnimateDiff avec une séquence standard de 16 images en 512×512 consomme environ 8 à 10 Go de VRAM. Pour du 768×768 ou des séquences plus longues, 16 Go ou plus sont recommandés.

Étape 1 — Louer un GPU sur Clore.ai

Accédez à clore.ai et connectez-vous.
Cliquez sur Place de marché et filtrez par VRAM (≥ 16 Go pour de meilleurs résultats).
Sélectionnez un serveur — la RTX 4090 ou l’A6000 offrent le meilleur rapport qualité/prix.
Sous Image Docker, saisissez votre image personnalisée (voir l’étape 2 ci-dessous).
Configurer ouvrir les ports: 22 (SSH) et 8188 (interface Web de ComfyUI).
Cliquez sur Louer et attendez le démarrage de l’instance (~1 à 2 minutes).

Utilisez le Avancé configuration des ports pour mapper le port 8188 vers un port public. Notez le port public attribué — vous l’utiliserez pour accéder à l’interface Web de ComfyUI.

Étape 2 — Image Docker

Il n’existe pas une seule image Docker officielle d’AnimateDiff. L’approche recommandée est d’utiliser une image basée sur ComfyUI avec les nœuds AnimateDiff préinstallés.

Image publique recommandée :

yanwk/comfyui-boot:latest

Ou créez la vôtre :

FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

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

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

# Cloner ComfyUI
RUN git clone https://github.com/comfyanonymous/ComfyUI /workspace/ComfyUI && \
    cd /workspace/ComfyUI && pip install -r requirements.txt

# Installer ComfyUI Manager
RUN cd /workspace/ComfyUI/custom_nodes && \
    git clone https://github.com/ltdrdata/ComfyUI-Manager

# Installer les nœuds AnimateDiff-Evolved
RUN cd /workspace/ComfyUI/custom_nodes && \
    git clone https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved && \
    pip install -r ComfyUI-AnimateDiff-Evolved/requirements.txt

# Installer VideoHelperSuite pour la sortie
RUN cd /workspace/ComfyUI/custom_nodes && \
    git clone https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite && \
    pip install -r ComfyUI-VideoHelperSuite/requirements.txt

EXPOSE 22 8188

CMD service ssh start && \
    python /workspace/ComfyUI/main.py --listen 0.0.0.0 --port 8188 --enable-cors-header

Étape 3 — Connectez-vous via SSH

Une fois l’instance en cours d’exécution, connectez-vous en SSH pour télécharger les modèles :

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

Remplacer <clore-host> et <assigned-ssh-port> avec les valeurs affichées dans votre tableau de bord Clore.ai.

Étape 4 — Télécharger les modèles

AnimateDiff nécessite au minimum un checkpoint SD 1.5 de base et un module de mouvement.

Télécharger le module de mouvement

cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models

# module de mouvement v3 (recommandé)
wget -O v3_sd15_mm.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/v3_sd15_mm.ckpt"

# module de mouvement v2 (compatibilité plus large)
wget -O mm_sd_v15_v2.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt"

Télécharger un checkpoint SD 1.5 de base

cd /workspace/ComfyUI/models/checkpoints

# Realistic Vision (populaire pour AnimateDiff)
wget -O realisticVisionV60B1_v51VAE.safetensors \
  "https://huggingface.co/SG161222/Realistic_Vision_V6.0_B1_noVAE/resolve/main/Realistic_Vision_V6.0_B1_fp16-no-ema.safetensors"

Vous pouvez utiliser n’importe quel fine-tuning SD 1.5. Parmi les choix populaires : DreamShaper, Deliberate et Epicphotogasm. Téléchargez depuis CivitAI ou Hugging Face.

(Facultatif) Télécharger le module de mouvement SDXL

cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models

wget -O temporaldiff-v1-animatediff.safetensors \
  "https://huggingface.co/CiaraRowles/TemporalDiff/resolve/main/temporaldiff-v1-animatediff.safetensors"

Étape 5 — Accéder à ComfyUI

Ouvrez votre navigateur et rendez-vous sur :

http://<clore-host>:<public-port-8188>

Vous devriez voir l’interface de l’éditeur de nœuds ComfyUI.

Ajoutez cette URL à vos favoris. ComfyUI enregistre automatiquement votre workflow pendant que vous travaillez — pas besoin d’enregistrer manuellement sauf si vous exportez le JSON.

Étape 6 — Charger un workflow AnimateDiff

Workflow AnimateDiff de base (JSON)

Dans ComfyUI, appuyez sur Charger et collez ou importez ce JSON de workflow, ou construisez-le manuellement avec ces nœuds :

Chaîne de nœuds principale :

Charger un checkpoint → votre checkpoint SD 1.5
Encodage de texte CLIP (prompt) → prompts positifs et négatifs
Chargeur AnimateDiff → sélectionnez votre module de mouvement
KSampler (efficace) → paramètres d’échantillonnage
Décodage VAE → décoder les latents
Combiner vidéo (VideoHelperSuite) → exporter en GIF/MP4

Paramètres d’échantillonnage recommandés

Paramètre

Valeur

Étapes

20–25

Échelle CFG

7–8

Échantillonneur

DPM++ 2M Karras

Largeur × Hauteur

512 × 512

Images

Longueur de contexte

Étape 7 — Lancer votre première animation

Dans le Encodage de texte CLIP nœud, saisissez votre prompt :

Un lion majestueux marchant dans de hautes herbes au coucher du soleil, cinématographique, 4k

Dans le nœud de prompt négatif :

pire qualité, faible qualité, flou, filigrane, déformé, nsfw

Dans Chargeur AnimateDiff, sélectionnez v3_sd15_mm.ckpt
Cliquez sur Mettre l'invite en file d'attente

Le temps de génération pour 16 images en 512×512 avec 20 étapes est d’environ 30 à 60 secondes sur une RTX 4090. Les séquences plus longues et les résolutions plus élevées évoluent linéairement.

Techniques avancées

Utiliser ControlNet avec AnimateDiff

AnimateDiff fonctionne avec ControlNet pour la génération vidéo guidée :

# Télécharger le modèle ControlNet
cd /workspace/ComfyUI/models/controlnet
wget -O control_v11p_sd15_openpose.pth \
  "https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth"

Ajoutez un Appliquer ControlNet nœud entre Charger le modèle ControlNet et KSampler. Utilisez une image squelette OpenPose comme entrée de conditionnement.

Voyage de prompt (animation d’images clés)

Le nœud AnimateDiff-Evolved prend en charge le voyage de prompt — différents prompts textuels à différentes images :

"Une forêt à l’aube" → image 0
"Une forêt à midi" → image 8
"Une forêt au coucher du soleil" → image 16

Cela crée des transitions fluides entre les scènes sans keyframes manuelles.

Utiliser LoRA avec AnimateDiff

# Télécharger la LoRA de mouvement
cd /workspace/ComfyUI/models/loras
wget -O v2_lora_PanLeft.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/v2_lora_PanLeft.ckpt"

Ajoutez un Chargeur LoRA nœud pour appliquer des effets de mouvement de caméra : PanLeft, PanRight, ZoomIn, ZoomOut, RollingAnticlockwise.

Formats de sortie

AnimateDiff via VideoHelperSuite prend en charge :

Format

Nœud

Remarques

GIF

Combiner vidéo

Idéal pour le partage

MP4 (h264)

Combiner vidéo

Fichier le plus léger

WebP

Combiner vidéo

Bon rapport qualité/taille

Images PNG

Enregistrer l'image

Pour le post-traitement

Dépannage

Mémoire insuffisante (OOM CUDA)

RuntimeError : mémoire CUDA insuffisante

Solutions :

Réduisez le nombre d’images (essayez 8 au lieu de 16)
Réduisez la résolution (512×512 est le point idéal pour SD 1.5)
Activer --lowvram option dans la commande de démarrage de ComfyUI
Utilisez fp16 précision en Charger un checkpoint nœud

Module de mouvement introuvable

Erreur : module de mouvement introuvable

Solution : Vérifiez que le .ckpt fichier se trouve dans :

/workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models/

Actualisez la page ComfyUI pour recharger les modèles disponibles.

Scintillement / images incohérentes

Solutions :

Augmentez context_length pour correspondre au nombre total d’images
Utilisez v3_sd15_mm.ckpt au lieu de v2 (meilleure cohérence temporelle)
Réduisez l’échelle CFG (essayez 7 au lieu de 9)
Utilisez un échantillonneur à plus faible variance : DPM++ 2M Karras ou Euler a

Connexion SSH refusée

ssh : connexion à l’hôte <ip> port <port> : connexion refusée

Solution : Attendez 1 à 2 minutes que le démon SSH démarre, ou vérifiez si le conteneur a complètement initialisé via les journaux du tableau de bord Clore.ai.

Recommandations GPU Clore.ai

AnimateDiff utilise l’ossature SD 1.5 — les besoins en VRAM sont modestes comparés aux modèles vidéo modernes, ce qui en fait une solution économique.

GPU

VRAM

Prix Clore.ai

16 images à 512 px

Remarques

RTX 3090

24 Go

0,07–0,21 $/h

~50s

Meilleur rapport qualité/prix — exécutez plusieurs lots en file d’attente

RTX 4090

24 Go

0,14–0,42 $/h

~30s

GPU grand public le plus rapide

A100 40 Go

40 Go

bare metal

~18s

Surdimensionnée pour SD 1.5, mais bonne pour SDXL + AnimateDiff

RTX 3080 10 Go

10 Go

0,05–0,19 $/h

~90s

Budget minimal — limité à 512 px, clips plus courts

La RTX 3090 est le point idéal pour AnimateDiff à 0,07 à 0,21 $/h. Une animation de 16 images prend environ 50 secondes, ce qui signifie que vous pouvez générer plus de 70 clips par dollar dépensé. Pour la création de contenu à grand volume, mettez les lots en file d’attente dans ComfyUI et laissez tourner la nuit.

Utilisateurs d’AnimateDiff SDXL : Les modules de mouvement SDXL nécessitent plus de 12 Go de VRAM pour 768 px. Les RTX 3090/4090 gèrent cela sans problème. La RTX 3080 (10 Go) est trop limitée pour les workflows SDXL.

Ressources utiles

PrécédentSkyReels-V3

SuivantMochi-1 Video

Mis à jour il y a 1 mois

Ce contenu vous a-t-il été utile ?