# AnimateDiff

AnimateDiff एक प्लग-एंड-प्ले मॉड्यूल है जो **आपके मौजूदा Stable Diffusion मॉडलों को एनीमेट करता है** किसी अतिरिक्त प्रशिक्षण के बिना। 10,000 से अधिक GitHub स्टार्स के साथ, यह स्थिर-छवि SD चेकपॉइंट्स को स्मूद, समयानुकूलित वीडियो जनरेटर में बदलने के लिए जाने-माने फ्रेमवर्क है। अधिकतम लचीलापन के लिए ComfyUI को फ्रंट-एंड के रूप में उपयोग करके इसे Clore.ai GPU इंस्टेंस पर चलाएँ।

***

## AnimateDiff क्या है?

AnimateDiff एक **मोशन मॉड्यूल** को एक फ्रीज़ किए गए Stable Diffusion U-Net में डालता है। मोशन मॉड्यूल को एक बार वीडियो डेटा पर प्रशिक्षित किया जाता है और इसे किसी भी फाइन-ट्यून किए गए SD 1.5 चेकपॉइंट के साथ — DreamBooth मॉडल्स, LoRA, ControlNet एडाप्टर्स — बिना पुनःप्रशिक्षण के जोड़ा जा सकता है। परिणाम छोटे एनिमेटेड क्लिप होते हैं (आम तौर पर 16–32 फ़्रेम पर 8 fps) जो बेस मॉडल की शैली को संरक्षित करते हैं।

**मुख्य हाइलाइट्स:**

* बॉक्स से बाहर किसी भी SD 1.5 चेकपॉइंट के साथ काम करता है
* ControlNet, IP-Adapter, LoRAs और अन्य एक्सटेंशन्स के साथ अनुकूल
* ComfyUI नोड इकोसिस्टम पूर्ण पाइपलाइन नियंत्रण प्रदान करता है
* उच्च-रिज़ॉल्यूशन आउटपुट के लिए SDXL मोशन मॉड्यूल उपलब्ध
* डोमेन-विशिष्ट मोशन मॉड्यूल के साथ कम्युनिटी-रखरखाव वाला मॉडल ज़ू

***

## पूर्व-आवश्यकताएँ

| आवश्यकता | न्यूनतम  | अनुशंसित        |
| -------- | -------- | --------------- |
| GPU VRAM | 8 GB     | 16–24 GB        |
| GPU      | RTX 3080 | RTX 4090 / A100 |
| RAM      | 16 GB    | 32 GB           |
| स्टोरेज  | 20 GB    | 50+ GB          |

{% hint style="info" %}
मानक 16-फ्रेम सीक्वेंस पर 512×512 में AnimateDiff लगभग 8–10 GB VRAM खपत करता है। 768×768 या लंबी सीक्वेंस के लिए 16+ GB की सिफारिश की जाती है।
{% endhint %}

***

## चरण 1 — Clore.ai पर एक GPU किराए पर लें

1. जाएँ [clore.ai](https://clore.ai) और साइन इन करें।
2. पर क्लिक करें **मार्केटप्लेस** और VRAM द्वारा फ़िल्टर करें (सर्वोत्तम परिणामों के लिए ≥ 16 GB)।
3. एक सर्वर चुनें — RTX 4090 या A6000 सबसे अच्छा मूल्य/प्रदर्शन प्रदान करते हैं।
4. के अंतर्गत **Docker इमेज**में अपना कस्टम इमेज दर्ज करें (नीचे चरण 2 देखें)।
5. कॉन्फ़िगर **ओपन पोर्ट्स**: `22` (SSH) और `8188` (ComfyUI वेब UI)।
6. पर क्लिक करें **किराए पर लें** और इंस्टेंस के शुरु होने का इंतज़ार करें (\~1–2 मिनट)।

{% hint style="info" %}
उपयोग करें **⚙️** पोर्ट कॉन्फ़िगरेशन को मैप करने के लिए `8188` को एक सार्वजनिक पोर्ट पर। निर्दिष्ट सार्वजनिक पोर्ट को नोट करें — आप इसे ComfyUI वेब इंटरफ़ेस तक पहुँचने के लिए उपयोग करेंगे।
{% endhint %}

***

## चरण 2 — Docker इमेज

कोई एकल आधिकारिक AnimateDiff Docker इमेज नहीं है। सुझाया गया तरीका यह है कि आप एक **ComfyUI-आधारित इमेज** का उपयोग करें जिसमें AnimateDiff नोड्स पूर्व-इंस्टॉल्ड हों।

**सुझावित सार्वजनिक इमेज:**

```
yanwk/comfyui-boot:latest
```

या अपनी खुद की बनाएं:

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

# SSH सेटअप करें
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

# ComfyUI क्लोन करें
RUN git clone https://github.com/comfyanonymous/ComfyUI /workspace/ComfyUI && \
    cd /workspace/ComfyUI && pip install -r requirements.txt

# ComfyUI Manager इंस्टॉल करें
RUN cd /workspace/ComfyUI/custom_nodes && \
    git clone https://github.com/ltdrdata/ComfyUI-Manager

# 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

# आउटपुट के लिए VideoHelperSuite इंस्टॉल करें
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
```

***

## स्टेप 3 — SSH के जरिए कनेक्ट करें

एक बार इंस्टेंस चलने पर, मॉडल डाउनलोड करने के लिए SSH के माध्यम से कनेक्ट करें:

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

बदलिए `<clore-host>` और `<assigned-ssh-port>` अपने Clore.ai डैशबोर्ड में दिखाए गए मानों के साथ।

***

## चरण 4 — मॉडल डाउनलोड करें

AnimateDiff के लिए कम से कम एक **बेस SD 1.5 चेकपॉइंट** और एक **मोशन मॉड्यूल**.

### मोशन मॉड्यूल डाउनलोड करें

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

# v3 मोशन मॉड्यूल (सुझावित)
wget -O v3_sd15_mm.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/v3_sd15_mm.ckpt"

# v2 मोशन मॉड्यूल (चौड़ी संगतता)
wget -O mm_sd_v15_v2.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt"
```

### एक बेस SD 1.5 चेकपॉइंट डाउनलोड करें

```bash
cd /workspace/ComfyUI/models/checkpoints

# Realistic Vision (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" %}
आप किसी भी SD 1.5 फाइन-ट्यून का उपयोग कर सकते हैं। लोकप्रिय विकल्पों में DreamShaper, Deliberate, और Epicphotogasm शामिल हैं। CivitAI या Hugging Face से डाउनलोड करें।
{% endhint %}

### (वैकल्पिक) 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"
```

***

## चरण 5 — ComfyUI तक पहुँचें

अपने ब्राउज़र को खोलें और नेविगेट करें:

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

आपको ComfyUI नोड एडिटर इंटरफ़ेस दिखाई देना चाहिए।

{% hint style="info" %}
इस URL को बुकमार्क करें। ComfyUI आपके वर्कफ़्लो को कार्य करते समय ऑटोसेव करता है — JSON एक्सपोर्ट करने के अलावा मैन्युअली सेव करने की आवश्यकता नहीं।
{% endhint %}

***

## चरण 6 — एक AnimateDiff वर्कफ़्लो लोड करें

### बेसिक AnimateDiff वर्कफ़्लो (JSON)

ComfyUI में प्रेस करें **लोड** और इस वर्कफ़्लो JSON को पेस्ट या इम्पोर्ट करें, या इन नोड्स के साथ इसे मैन्युअल रूप से बनाएं:

**कोर नोड चेन:**

1. `चेकपॉइंट लोड करें` → आपका SD 1.5 चेकपॉइंट
2. `CLIP टेक्स्ट एन्कोड (प्रॉम्प्ट)` → पॉज़िटिव और नेगेटिव प्रॉम्प्ट
3. `AnimateDiff लोडर` → अपना मोशन मॉड्यूल चुनें
4. `KSampler (Efficient)` → सैंपलिंग सेटिंग्स
5. `VAE डीकोड` → लेटेंट्स को डिकोड करें
6. `वीडियो कॉम्बाइन` (VideoHelperSuite) → GIF/MP4 के रूप में एक्स्पोर्ट करें

### सुझावित सैंपलिंग सेटिंग्स

| पैरामीटर          | मान             |
| ----------------- | --------------- |
| स्टेप्स           | 20–25           |
| CFG स्केल         | 7–8             |
| सैंपलर            | DPM++ 2M Karras |
| चौड़ाई × ऊँचाई    | 512 × 512       |
| फ़्रेम            | 16              |
| कॉन्टेक्स्ट लंबाई | 16              |

***

## चरण 7 — अपनी पहली एनीमेशन चलाएँ

1. में `CLIP टेक्स्ट एन्कोड` नोड में, अपना प्रॉम्प्ट दर्ज करें:

   ```
   सूर्यास्त में ऊँघा घास के बीच चल रहा एक भव्य शेर, सिनेमाई, 4k
   ```
2. नेगेटिव प्रॉम्प्ट नोड में:

   ```
   सबसे खराब गुणवत्ता, कम गुणवत्ता, धुंधला, वॉटरमार्क, विकृत, nsfw
   ```
3. में `AnimateDiff लोडर`, चुनें `v3_sd15_mm.ckpt`
4. पर क्लिक करें **क्यू प्रॉम्प्ट**

{% hint style="info" %}
512×512 पर 20 स्टेप्स के साथ 16 फ़्रेम का जनरेशन समय लगभग है **30–60 सेकंड** एक RTX 4090 पर। लंबी सीक्वेंस और उच्च रिज़ॉल्यूशन लाइनियर रूप से बढ़ते हैं।
{% endhint %}

***

## एडवांस्ड तकनीकें

### AnimateDiff के साथ ControlNet का उपयोग

AnimateDiff निर्देशित वीडियो जनरेशन के लिए ControlNet के साथ काम करता है:

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

एक जोड़ें `ControlNet Apply` नोड के बीच `ControlNet मॉडल लोड करें` और `KSampler`। कंडीशनिंग इनपुट के रूप में OpenPose स्केलेटन इमेज का उपयोग करें।

### प्रॉम्प्ट ट्रैवल (कीफ्रेम एनीमेशन)

AnimateDiff-Evolved नोड का समर्थन है **प्रॉम्प्ट ट्रैवल** — अलग-अलग फ्रेमों पर अलग टेक्स्ट प्रॉम्प्ट:

```
"सुबह के समय एक जंगल" → फ्रेम 0
"दोपहर में एक जंगल" → फ्रेम 8
"सूर्यास्त में एक जंगल" → फ्रेम 16
```

यह मैनुअल कीफ्रेमिंग के बिना दृश्यों के बीच स्मूद ट्रांज़िशन बनाता है।

### AnimateDiff के साथ LoRA का उपयोग

```bash
# मोशन LoRA डाउनलोड करें
cd /workspace/ComfyUI/models/loras
wget -O v2_lora_PanLeft.ckpt \
  "https://huggingface.co/guoyww/animatediff/resolve/main/v2_lora_PanLeft.ckpt"
```

एक जोड़ें `LoRA लोडर` नोड कैमरा मोशन इफ़ेक्ट लागू करने के लिए: PanLeft, PanRight, ZoomIn, ZoomOut, RollingAnticlockwise.

***

## आउटपुट फॉर्मैट

VideoHelperSuite के माध्यम से AnimateDiff समर्थन करता है:

| फॉर्मेट    | नोड               | नोट्स                        |
| ---------- | ----------------- | ---------------------------- |
| GIF        | `वीडियो कॉम्बाइन` | शेयर करने के लिए सर्वश्रेष्ठ |
| MP4 (h264) | `वीडियो कॉम्बाइन` | सबसे छोटा फ़ाइल आकार         |
| WebP       | `वीडियो कॉम्बाइन` | अच्छा गुणवत्ता/आकार          |
| PNG फ़्रेम | `Save Image`      | पोस्ट-प्रोसेसिंग के लिए      |

***

## समस्या निवारण

### आउट ऑफ़ मेमोरी (CUDA OOM)

```
RuntimeError: CUDA out of memory
```

**समाधान:**

* फ़्रेम काउंट घटाएँ (16 के बजाय 8 आज़माएँ)
* रिज़ॉल्यूशन घटाएँ (SD 1.5 के लिए 512×512 सर्वोत्तम है)
* सक्षम करें `--lowvram` ComfyUI स्टार्टअप कमांड में फ़्लैग
* उपयोग करें `fp16` प्रिसिजन इन `चेकपॉइंट लोड करें` नोड

### मोशन मॉड्यूल नहीं मिला

```
त्रुटि: मोशन मॉड्यूल नहीं मिला
```

**समाधान:** सत्यापित करें कि `.ckpt` फ़ाइल इस स्थान पर है:

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

उपलब्ध मॉडलों को रीलोड करने के लिए ComfyUI पेज को रिफ्रेश करें।

### फ़्लिकरिंग / असंगत फ़्रेम

**समाधान:**

* बढ़ाएँ `context_length` कुल फ़्रेम काउंट से मेल खाने के लिए
* उपयोग करें `v3_sd15_mm.ckpt` v2 के बजाय (बेहतर समयानुकूल संगति)
* CFG स्केल कम करें (9 के बजाय 7 आज़माएँ)
* कम-वैरिएन्स सैंपलर का उपयोग करें: `DPM++ 2M Karras` इमेज जेनरेट करें `Euler a`

### SSH कनेक्शन अस्वीकार किया गया

```bash
ssh: होस्ट <ip> पोर्ट <port> से कनेक्ट करें: कनेक्शन अस्वीकार किया गया
```

**समाधान:** SSH डेमन के स्टार्ट होने के लिए 1–2 मिनट प्रतीक्षा करें, या Clore.ai डैशबोर्ड लॉग्स के माध्यम से जांचें कि क्या कंटेनर पूरी तरह से इनिशियलाइज़ हुआ है।

***

## Clore.ai GPU सिफारिशें

AnimateDiff SD 1.5 बैकबोन का उपयोग करता है — आधुनिक वीडियो मॉडलों की तुलना में VRAM आवश्यकताएँ मामूली हैं, जिससे यह बजट-फ्रेंडली है।

| GPU           | VRAM  | Clore.ai कीमत | 16-फ़्रेम @ 512px | नोट्स                                                       |
| ------------- | ----- | ------------- | ----------------- | ----------------------------------------------------------- |
| RTX 3090      | 24 GB | \~$0.12/घंटा  | \~50s             | सर्वोत्तम मूल्य — कई कतारबद्ध बैच चलाएँ                     |
| RTX 4090      | 24 GB | \~$0.70/घंटा  | \~30s             | सबसे तेज़ कंज्यूमर GPU                                      |
| A100 40GB     | 40 GB | \~$1.20/घंटा  | \~18s             | SD 1.5 के लिए अतिरंजित, लेकिन SDXL+AnimateDiff के लिए अच्छा |
| RTX 3080 10GB | 10 GB | \~$0.07/hr    | \~90s             | बजट न्यूनतम — 512px तक सीमित, छोटे क्लिप्स                  |

{% hint style="info" %}
**RTX 3090 AnimateDiff के लिए सबसे अनुकूल है** लगभग \~$0.12/hr पर। 16-फ़्रेम एनीमेशन में \~50 सेकंड लगते हैं, जिसका अर्थ है कि आप प्रति डॉलर खर्च पर 70+ क्लिप जेनरेट कर सकते हैं। उच्च-वॉल्यूम कंटेंट क्रिएशन के लिए, ComfyUI में बैच कतार बनाकर रात भर चलाएँ।
{% endhint %}

**SDXL AnimateDiff उपयोगकर्ता:** SDXL मोशन मॉड्यूल्स को 768px के लिए 12GB+ VRAM की आवश्यकता होती है। RTX 3090/4090 इसे अच्छी तरह संभालते हैं। RTX 3080 (10GB) SDXL वर्कफ़्लो के लिए बहुत सीमित है।

***

## उपयोगी संसाधन

* [AnimateDiff GitHub](https://github.com/guoyww/AnimateDiff)
* [ComfyUI-AnimateDiff-Evolved](https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved)
* [ComfyUI Official](https://github.com/comfyanonymous/ComfyUI)
* [AnimateDiff Motion Models (HuggingFace)](https://huggingface.co/guoyww/animatediff)
* [CivitAI — SD चेकपॉइंट्स](https://civitai.com)