> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/generacion-de-video/animatediff.md).

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

{% 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) 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).

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

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

```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 **checkpoint base de 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 (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

```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 ajuste fino de SD 1.5. Las opciones populares incluyen DreamShaper, Deliberate y Epicphotogasm. Descárgalos 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

Abre tu navegador y navega a:

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

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

{% hint style="info" %}
Guarda esta URL en favoritos. ComfyUI guarda automáticamente tu flujo de trabajo mientras trabajas — no hace falta guardarlo manualmente salvo que exportes JSON.
{% endhint %}

***

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

{% 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. Las secuencias más largas y resoluciones más altas escalan linealmente.
{% endhint %}

***

## Técnicas avanzadas

### Usar ControlNet con AnimateDiff

AnimateDiff funciona con ControlNet para generación de video 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"
```

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

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

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

```bash
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](https://clore.ai/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        |

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

**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](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 — Checkpoints SD](https://civitai.com)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.
