AnimateDiff

AnimateDiff es un módulo plug-and-play que anima tus modelos existentes de Stable Diffusion sin necesidad de entrenamiento adicional. Con más de 10.000 estrellas en GitHub, es el marco de referencia para convertir puntos de control de SD de imágenes estáticas en generadores de vídeo suaves y temporalmente coherentes. Ejecútalo en una instancia GPU de Clore.ai usando ComfyUI como interfaz para máxima flexibilidad.

---

¿Qué es AnimateDiff?

AnimateDiff inserta un módulo de movimiento en una U-Net de Stable Diffusion congelada. El módulo de movimiento se entrena una vez con datos de vídeo y puede combinarse con cualquier punto de control afinado de SD 1.5 — modelos DreamBooth, LoRAs, adaptadores ControlNet — sin volver a entrenar. El resultado son clips animados cortos (típicamente 16–32 fotogramas a 8 fps) que preservan el estilo del modelo base.

Aspectos destacados:

• Funciona con cualquier punto de control SD 1.5 listo para usar

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

• El ecosistema de nodos de ComfyUI ofrece control completo del pipeline

• 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

---

Prerrequisitos

Requisito	Mínimo	Recomendado
VRAM 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 e inicie sesión.

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

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

4. Bajo imagen Docker, introduce tu imagen personalizada (ver Paso 2 abajo).

5. Configurar puertos abiertos: 22 (SSH) y 8188 (Interfaz web de ComfyUI).

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

Usa la Avanzado configuración de puerto 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:

FROM pytorch/pytorch:2.1.2-cuda12.1-cudnn8-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 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 vía SSH

Una vez que la instancia esté en funcionamiento, conéctate vía 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 punto de control base 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 (mayor compatibilidad)
wget -O mm_sd_v15_v2.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt"

Descargar un Punto de Control Base 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 fine-tune de SD 1.5. Las opciones populares incluyen DreamShaper, Deliberate y Epicphotogasm. Descarga 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

Abra su navegador y navegue a:

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

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

Añade esta URL a favoritos. ComfyUI guarda automáticamente tu flujo de trabajo mientras trabajas — no es necesario guardar manualmente a menos que exportes JSON.

---

Paso 6 — Cargar un Flujo de Trabajo de AnimateDiff

Flujo de Trabajo Básico de AnimateDiff (JSON)

En ComfyUI, presiona 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 punto de control SD 1.5

2. CLIP Text Encode (Prompt) → prompts positivos y negativos

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

4. KSampler (Efficient) → ajustes de muestreo

5. VAE Decode → 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
Ancho × Alto	512 × 512
Fotogramas	16
Longitud de Contexto	16

---

Paso 7 — Ejecuta Tu Primera Animación

1. En el CLIP Text Encode 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 Poner en cola Prompt

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

---

Técnicas Avanzadas

Usando ControlNet con AnimateDiff

AnimateDiff funciona con ControlNet para generación de vídeo 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"

Agrega un Aplicar ControlNet nodo entre Cargar Modelo ControlNet y KSampler. Usa una imagen de esqueleto OpenPose como entrada de condicionamiento.

Prompt Travel (Animación por fotogramas clave)

El nodo AnimateDiff-Evolved soporta prompt travel — diferentes 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 fotogramado manual.

Usando 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"

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

---

Formatos de Salida

AnimateDiff a través de VideoHelperSuite soporta:

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 postprocesado

---

Solución de problemas

Fuera de Memoria (OOM de CUDA)

RuntimeError: CUDA out of memory

Soluciones:

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

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

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

• Usa fp16 precisión en Cargar Punto de Control nodo

Módulo de Movimiento No Encontrado

Error: módulo de movimiento no encontrado

Solución: Verifica el .ckpt archivo está en:

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

Actualiza la página de ComfyUI para recargar los modelos disponibles.

Parpadeo / Fotogramas Inconsistentes

Soluciones:

• Aumente context_length para coincidir con el recuento total de fotogramas

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

• Reducir 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 el daemon SSH se inicie, o verifica si el contenedor se ha inicializado completamente mediante los registros del panel de Clore.ai.

---

Recomendaciones de GPU en Clore.ai

AnimateDiff usa la base SD 1.5 — los requisitos de VRAM son modestos comparados con modelos de vídeo modernos, lo que lo hace económico.

GPU	VRAM	Precio en Clore.ai	16 fotogramas @ 512px	Notas
RTX 3090	24 GB	~$0.12/h	~50s	Mejor valor — ejecuta varios lotes en cola
RTX 4090	24 GB	~$0.70/h	~30 s	GPU de consumo más rápida
A100 40GB	40 GB	~$1.20/h	~18s	Excesivo para SD 1.5, pero bueno para SDXL+AnimateDiff
RTX 3080 10GB	10 GB	~$0.07/h	~90s	Mínimo económico — limitado a 512px, clips más cortos

RTX 3090 es el punto óptimo para AnimateDiff a ~ $0.12/h. Una animación de 16 fotogramas toma ~50 segundos, lo que significa que puedes generar más de 70 clips por dólar gastado. Para creación de contenido en alto volumen, pon en cola lotes en ComfyUI y ejecútalos durante la noche.

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

---

Recursos Útiles

• AnimateDiff en GitHub

• ComfyUI-AnimateDiff-Evolved

• ComfyUI Oficial

• Modelos de Movimiento AnimateDiff (HuggingFace)

• CivitAI — Puntos de Control SD