# 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          |

{% hint style="info" %}
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.
{% endhint %}

***

## Paso 1 — Alquila una GPU en Clore.ai

1. Ve a [clore.ai](https://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).

{% hint style="info" %}
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.
{% endhint %}

***

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

```dockerfile
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:

```bash
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

```bash
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

```bash
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"
```

{% hint style="info" %}
Puedes usar cualquier fine-tune de SD 1.5. Las opciones populares incluyen DreamShaper, Deliberate y Epicphotogasm. Descarga desde CivitAI o Hugging Face.
{% endhint %}

### (Opcional) Descargar Módulo de Movimiento SDXL

```bash
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.

{% hint style="info" %}
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.
{% endhint %}

***

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

{% hint style="info" %}
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.
{% endhint %}

***

## Técnicas Avanzadas

### Usando ControlNet con AnimateDiff

AnimateDiff funciona con ControlNet para generación de vídeo guiada:

```bash
# 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

```bash
# 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

```bash
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  |

{% hint style="info" %}
**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.
{% endhint %}

**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](https://github.com/guoyww/AnimateDiff)
* [ComfyUI-AnimateDiff-Evolved](https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved)
* [ComfyUI Oficial](https://github.com/comfyanonymous/ComfyUI)
* [Modelos de Movimiento AnimateDiff (HuggingFace)](https://huggingface.co/guoyww/animatediff)
* [CivitAI — Puntos de Control SD](https://civitai.com)


---

# Agent Instructions: 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:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/animatediff.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.