AnimateDiff

AnimateDiff es un módulo plug-and-play que anima tus modelos Stable Diffusion existentes sin ningún entrenamiento adicional. Con más de 10.000 estrellas en GitHub, es el marco de referencia para convertir checkpoints SD de imagen fija en generadores de video suaves y temporalmente coherentes. Ejecútalo en una instancia de GPU de Clore.ai usando ComfyUI como front-end para máxima flexibilidad.

---

¿Qué es AnimateDiff?

AnimateDiff inserta un módulo de movimiento en un U-Net de Stable Diffusion congelado. El módulo de movimiento se entrena una sola vez con datos de video y puede combinarse con cualquier checkpoint de SD 1.5 ajustado — modelos DreamBooth, LoRAs, adaptadores ControlNet — sin reentrenamiento. El resultado son clips animados cortos (normalmente 16–32 fotogramas a 8 fps) que conservan el estilo del modelo base.

Puntos destacados clave:

• Funciona con cualquier checkpoint de SD 1.5 desde el primer momento

• Compatible con ControlNet, IP-Adapter, LoRAs y otras extensiones

• El ecosistema de nodos de ComfyUI proporciona control total del flujo de trabajo

• Módulos de movimiento SDXL disponibles para salida de mayor resolución

• Zoo de modelos mantenido por la comunidad con módulos de movimiento específicos por dominio

---

Requisitos previos

Requisito	Mínimo	Recomendado
VRAM de GPU	8 GB	16–24 GB
GPU	RTX 3080	RTX 4090 / A100
RAM	16 GB	32 GB
Almacenamiento	20 GB	50+ GB

AnimateDiff con una secuencia estándar de 16 fotogramas a 512×512 consume aproximadamente 8–10 GB de VRAM. Para 768×768 o secuencias más largas, se recomiendan 16+ GB.

---

Paso 1 — Alquila una GPU en Clore.ai

1. Ve a clore.ai y entra.

2. Haz clic en Marketplace y filtra por VRAM (≥ 16 GB para mejores resultados).

3. Selecciona un servidor — RTX 4090 o A6000 ofrece la mejor relación precio/rendimiento.

4. En Imagen Docker, introduce tu imagen personalizada (ver el Paso 2 abajo).

5. Configurar abrir puertos: 22 (SSH) y 8188 (interfaz web de ComfyUI).

6. Haz clic en Alquilar y espera a que la instancia se inicie (~1–2 minutos).

Usa el Avanzado configuración de puertos para mapear el puerto 8188 a un puerto público. Anota el puerto público asignado — lo usarás para acceder a la interfaz web de ComfyUI.

---

Paso 2 — Imagen Docker

No existe una única imagen Docker oficial de AnimateDiff. El enfoque recomendado es usar una imagen basada en ComfyUI con los nodos de AnimateDiff preinstalados.

Imagen pública recomendada:

yanwk/comfyui-boot:latest

O construye la tuya propia:

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/*

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

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

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

# Instalar nodos de 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

# Instalar VideoHelperSuite para la salida
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

---

Paso 3 — Conéctate por SSH

Una vez que la instancia esté en ejecución, conéctate por SSH para descargar modelos:

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

Reemplaza <clore-host> y <assigned-ssh-port> con los valores mostrados en tu panel de Clore.ai.

---

Paso 4 — Descargar modelos

AnimateDiff requiere como mínimo un checkpoint base de SD 1.5 y un módulo de movimiento.

Descargar módulo de movimiento

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

# módulo de movimiento v3 (recomendado)
wget -O v3_sd15_mm.ckpt \\
  "https://huggingface.co/guoyww/animatediff/resolve/main/v3_sd15_mm.ckpt"

# módulo de movimiento v2 (compatibilidad más amplia)
wget -O mm_sd_v15_v2.ckpt \\
  "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt"

Descargar un checkpoint base de SD 1.5

cd /workspace/ComfyUI/models/checkpoints

# Realistic Vision (popular para 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"

Puedes usar cualquier ajuste fino de SD 1.5. Las opciones populares incluyen DreamShaper, Deliberate y Epicphotogasm. Descárgalos desde CivitAI o Hugging Face.

(Opcional) Descargar módulo de movimiento 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"

---

Paso 5 — Acceder a ComfyUI

Abre tu navegador y navega a:

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

Deberías ver la interfaz del editor de nodos de ComfyUI.

Guarda esta URL en favoritos. ComfyUI guarda automáticamente tu flujo de trabajo mientras trabajas — no hace falta guardarlo manualmente salvo que exportes JSON.

---

Paso 6 — Cargar un flujo de trabajo de AnimateDiff

Flujo de trabajo básico de AnimateDiff (JSON)

En ComfyUI, pulsa Cargar y pega o importa este JSON de flujo de trabajo, o constrúyelo manualmente con estos nodos:

Cadena de nodos principal:

1. Cargar punto de control → tu checkpoint de SD 1.5

2. CLIP Text Encode (Prompt) → prompts positivo y negativo

3. AnimateDiff Loader → selecciona tu módulo de movimiento

4. KSampler (Efficient) → ajustes de muestreo

5. Decodificación VAE → decodificar latentes

6. Video Combine (VideoHelperSuite) → exportar como GIF/MP4

Ajustes de muestreo recomendados

Parámetro	Valor
Pasos	20–25
Escala CFG	7–8
Sampler	DPM++ 2M Karras
Anchura × Altura	512 × 512
Fotogramas	16
Longitud del contexto	16

---

Paso 7 — Ejecuta tu primera animación

1. En la Codificación de texto CLIP nodo, introduce tu prompt:

   Un majestuoso león caminando entre hierba alta al atardecer, cinematográfico, 4k

2. En el nodo de prompt negativo:

   peor calidad, baja calidad, borroso, marca de agua, deformado, nsfw

3. En AnimateDiff Loader, selecciona v3_sd15_mm.ckpt

4. Haz clic en Encolar prompt

El tiempo de generación para 16 fotogramas a 512×512 con 20 pasos es aproximadamente 30–60 segundos en una RTX 4090. Las secuencias más largas y resoluciones más altas escalan linealmente.

---

Técnicas avanzadas

Usar ControlNet con AnimateDiff

AnimateDiff funciona con ControlNet para generación de video guiada:

# Descargar modelo 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"

Añade un ControlNet Apply nodo entre Load ControlNet Model y KSampler. Usa una imagen de esqueleto OpenPose como entrada de condicionamiento.

Prompt Travel (animación por fotogramas clave)

El nodo AnimateDiff-Evolved admite prompt travel — distintos prompts de texto en distintos fotogramas:

"Un bosque al amanecer" → fotograma 0
"Un bosque al mediodía" → fotograma 8
"Un bosque al atardecer" → fotograma 16

Esto crea transiciones suaves entre escenas sin necesidad de keyframes manuales.

Usar LoRA con AnimateDiff

# Descargar LoRA de movimiento
cd /workspace/ComfyUI/models/loras
wget -O v2_lora_PanLeft.ckpt \\
  "https://huggingface.co/guoyww/animatediff/resolve/main/v2_lora_PanLeft.ckpt"

Añade un LoRA Loader nodo para aplicar efectos de movimiento de cámara: PanLeft, PanRight, ZoomIn, ZoomOut, RollingAnticlockwise.

---

Formatos de salida

AnimateDiff mediante VideoHelperSuite admite:

Formato	Nodo	Notas
GIF	Video Combine	Mejor para compartir
MP4 (h264)	Video Combine	Tamaño de archivo más pequeño
WebP	Video Combine	Buena calidad/tamaño
Fotogramas PNG	Guardar imagen	Para posprocesado

---

Solución de problemas

Falta de memoria (CUDA OOM)

RuntimeError: falta de memoria CUDA

Soluciones:

• Reduce el número de fotogramas (prueba 8 en lugar de 16)

• Reduce la resolución (512×512 es el punto ideal para SD 1.5)

• Habilita --lowvram bandera en el comando de inicio de ComfyUI

• Usa fp16 precisión en Cargar punto de control nodo

No se encontró el módulo de movimiento

Error: no se encontró el módulo de movimiento

Solución: Verifica que el archivo .ckpt esté en:

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

Actualiza la página de ComfyUI para volver a cargar los modelos disponibles.

Parpadeo / fotogramas inconsistentes

Soluciones:

• Aumenta context_length para que coincida con el recuento total de fotogramas

• Usa v3_sd15_mm.ckpt en lugar de v2 (mejor coherencia temporal)

• Reduce la escala CFG (prueba 7 en lugar de 9)

• Usa un sampler de menor varianza: DPM++ 2M Karras o Euler a

Conexión SSH rechazada

ssh: connect to host <ip> port <port>: Connection refused

Solución: Espera 1–2 minutos a que arranque el demonio SSH, o comprueba si el contenedor se ha inicializado completamente en los registros del panel de Clore.ai.

---

Recomendaciones de GPU para Clore.ai

AnimateDiff usa la base de SD 1.5 — los requisitos de VRAM son modestos en comparación con los modelos de video modernos, lo que lo hace económico.

GPU	VRAM	Precio de Clore.ai	16 fotogramas @ 512px	Notas
RTX 3090	24 GB	$0.07–0.21/h	~50 s	Mejor relación calidad-precio — ejecuta varios lotes en cola
RTX 4090	24 GB	$0.14–0.42/h	~30 s	GPU de consumo más rápida
A100 40GB	40 GB	bare metal	~18 s	Excesivo para SD 1.5, pero bueno para SDXL+AnimateDiff
RTX 3080 10GB	10 GB	$0,05–0,19/h	~90 s	Mínimo económico — limitado a 512px, clips más cortos

La RTX 3090 es el punto ideal para AnimateDiff a 0,07–0,21 $/h. Una animación de 16 fotogramas tarda ~50 segundos, lo que significa que puedes generar 70+ clips por dólar gastado. Para la creación de contenido de alto volumen, usa la cola por lotes en ComfyUI y ejecútalo durante la noche.

Usuarios de SDXL AnimateDiff: Los módulos de movimiento de SDXL requieren 12 GB+ de VRAM para 768px. RTX 3090/4090 lo manejan bien. La RTX 3080 (10 GB) está demasiado limitada para flujos de trabajo de SDXL.

---

Recursos útiles

• AnimateDiff en GitHub

• ComfyUI-AnimateDiff-Evolved

• ComfyUI oficial

• Modelos de movimiento AnimateDiff (HuggingFace)

• CivitAI — Checkpoints SD