# AI वीडियो जनरेशन

Stable Video Diffusion, AnimateDiff और अन्य मॉडल का उपयोग करके वीडियो जेनरेट करें।

{% hint style="success" %}
सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace).
{% endhint %}

## CLORE.AI पर किराये पर लेना

1. पर जाएँ [CLORE.AI मार्केटप्लेस](https://clore.ai/marketplace)
2. GPU प्रकार, VRAM, और मूल्य के अनुसार फ़िल्टर करें
3. चुनें **ऑन-डिमांड** (निश्चित दर) या **स्पॉट** (बिड प्राइस)
4. अपना ऑर्डर कॉन्फ़िगर करें:
   * Docker इमेज चुनें
   * पोर्ट सेट करें (SSH के लिए TCP, वेब UI के लिए HTTP)
   * यदि आवश्यक हो तो एनवायरनमेंट वेरिएबल जोड़ें
   * स्टार्टअप कमांड दर्ज करें
5. भुगतान चुनें: **CLORE**, **BTC**, या **USDT/USDC**
6. ऑर्डर बनाएं और डिप्लॉयमेंट का इंतज़ार करें

### अपने सर्वर तक पहुँचें

* कनेक्शन विवरण में खोजें **मेरे ऑर्डर**
* वेब इंटरफेस: HTTP पोर्ट URL का उपयोग करें
* SSH: `ssh -p <port> root@<proxy-address>`

## उपलब्ध मॉडल

| मॉडल        | प्रकार            | VRAM | अवधि      |
| ----------- | ----------------- | ---- | --------- |
| SVD         | इमेज-टू-वीडियो    | 16GB | 4 सेकंड   |
| SVD-XT      | इमेज-टू-वीडियो    | 20GB | 4 सेकंड   |
| AnimateDiff | टेक्स्ट-टू-वीडियो | 12GB | 2-4 सेकंड |
| CogVideoX   | टेक्स्ट-टू-वीडियो | 24GB | 6 सेकंड   |

## Stable Video Diffusion (SVD)

### त्वरित तैनाती

**Docker इमेज:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**पोर्ट:**

```
22/tcp
7860/http
```

**कमांड:**

```bash
pip install diffusers transformers accelerate gradio imageio && \
python svd_server.py
```

## अपनी सेवा तक पहुँचना

डिप्लॉयमेंट के बाद, अपना खोजें `http_pub` URL में **मेरे ऑर्डर**:

1. जाएँ **मेरे ऑर्डर** पृष्ठ
2. अपने ऑर्डर पर क्लिक करें
3. खोजें `http_pub` URL (उदा., `abc123.clorecloud.net`)

उपयोग करें `https://YOUR_HTTP_PUB_URL` की बजाय `localhost` नीचे दिए उदाहरणों में।

### SVD स्क्रिप्ट

```python
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio

# मॉडल लोड करें
pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# इमेज लोड करें और आकार बदलें
image = Image.open("input.png").resize((1024, 576))

# वीडियो जनरेट करें
frames = pipe(
    image,
    decode_chunk_size=8,
    num_frames=25,
    motion_bucket_id=127,
    noise_aug_strength=0.02
).frames[0]

# GIF के रूप में सहेजें
imageio.mimsave("output.gif", frames, fps=6)

# MP4 के रूप में सहेजें
imageio.mimsave("output.mp4", frames, fps=6)
```

### Gradio UI के साथ SVD

```python
import gradio as gr
import torch
from diffusers import StableVideoDiffusionPipeline
from PIL import Image
import imageio
import tempfile

pipe = StableVideoDiffusionPipeline.from_pretrained(
    "stabilityai/stable-video-diffusion-img2vid-xt",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()

def generate_video(image, motion_bucket, fps, num_frames):
    image = image.resize((1024, 576))

    frames = pipe(
        image,
        decode_chunk_size=4,
        num_frames=num_frames,
        motion_bucket_id=motion_bucket,
    ).frames[0]

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        imageio.mimsave(f.name, frames, fps=fps)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Image(type="pil", label="इनपुट इमेज"),
        gr.Slider(1, 255, value=127, label="Motion Amount"),
        gr.Slider(1, 30, value=6, label="FPS"),
        gr.Slider(14, 25, value=25, label="Frames")
    ],
    outputs=gr.Video(label="Generated Video"),
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## AnimateDiff

### इंस्टॉलेशन

```bash
pip install diffusers transformers accelerate
```

### टेक्स्ट से वीडियो जेनरेट करें

```python
import torch
from diffusers import AnimateDiffPipeline, MotionAdapter, DDIMScheduler
import imageio

# मोशन एडाप्टर लोड करें
adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# पाइपलाइन लोड करें
pipe = AnimateDiffPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
pipe.scheduler = DDIMScheduler.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    subfolder="scheduler",
    clip_sample=False,
    timestep_spacing="linspace",
    beta_schedule="linear",
    steps_offset=1,
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# जनरेट करें
output = pipe(
    prompt="A cat walking through a garden, beautiful flowers, sunny day",
    negative_prompt="bad quality, blurry",
    num_frames=16,
    guidance_scale=7.5,
    num_inference_steps=25,
)

# सहेजें
frames = output.frames[0]
imageio.mimsave("animatediff.gif", frames, fps=8)
```

### कस्टम मॉडल के साथ AnimateDiff

```python
from diffusers import AnimateDiffPipeline, MotionAdapter, EulerDiscreteScheduler

adapter = MotionAdapter.from_pretrained("guoyww/animatediff-motion-adapter-v1-5-2")

# कस्टम चेकपॉइंट का उपयोग करें (उदाहरण: RealisticVision)
pipe = AnimateDiffPipeline.from_pretrained(
    "SG161222/Realistic_Vision_V5.1_noVAE",
    motion_adapter=adapter,
    torch_dtype=torch.float16,
)
```

## ComfyUI में AnimateDiff

### नोड्स इंस्टॉल करें

```bash
cd /workspace/ComfyUI/custom_nodes
git clone https://github.com/Kosinkadink/ComfyUI-AnimateDiff-Evolved.git
git clone https://github.com/Kosinkadink/ComfyUI-VideoHelperSuite.git
```

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

```bash
cd /workspace/ComfyUI/custom_nodes/ComfyUI-AnimateDiff-Evolved/models
wget https://huggingface.co/guoyww/animatediff/resolve/main/mm_sd_v15_v2.ckpt
```

## CogVideoX

### टेक्स्ट-टू-वीडियो

```python
import torch
from diffusers import CogVideoXPipeline
import imageio

pipe = CogVideoXPipeline.from_pretrained(
    "THUDM/CogVideoX-2b",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "A drone flying over a beautiful mountain landscape at sunset"

video = pipe(
    prompt=prompt,
    num_videos_per_prompt=1,
    num_inference_steps=50,
    num_frames=49,
    guidance_scale=6,
).frames[0]

imageio.mimsave("cogvideo.mp4", video, fps=8)
```

## वीडियो अपस्केलिंग

### वीडियो के लिए Real-ESRGAN

```python
import cv2
import torch
from basicsr.archs.rrdbnet_arch import RRDBNet
from realesrgan import RealESRGANer

model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,
    tile_pad=10,
    pre_pad=0,
    half=True
)

# वीडियो को फ्रेम-दर-फ्रेम प्रोसेस करें
cap = cv2.VideoCapture("input.mp4")

# ... प्रत्येक फ्रेम को अपस्केल करें
```

## इंटरपोलेशन (स्मूथ वीडियो)

### FILM फ्रेम इंटरपोलेशन

```python

# इंस्टॉल करें
pip install tensorflow tensorflow_hub

import tensorflow as tf
import tensorflow_hub as hub

model = hub.load("https://tfhub.dev/google/film/1")

def interpolate(frame1, frame2, num_interpolations=3):
    # frame1 और frame2 के बीच इंटरपोलेटेड फ्रेम्स लौटाता है
    ...
```

### RIFE (रीयल-टाइम)

```bash
pip install rife-ncnn-vulkan-python

from rife_ncnn_vulkan import Rife
rife = Rife(gpu_id=0)

# फ्रेम इंटरपोलेट करें
```

## बैच वीडियो जेनरेशन

```python
prompts = [
    "A rocket launching into space",
    "Ocean waves crashing on rocks",
    "A butterfly flying through flowers",
]

for i, prompt in enumerate(prompts):
    print(f"Generating {i+1}/{len(prompts)}")
    output = pipe(prompt, num_frames=16)
    imageio.mimsave(f"video_{i:03d}.mp4", output.frames[0], fps=8)
```

## मेमोरी टिप्स

### सीमित VRAM के लिए

```python

# CPU ऑफलोड सक्षम करें
pipe.enable_model_cpu_offload()

# VAE स्लाइसिंग सक्षम करें
pipe.enable_vae_slicing()

# अटेंशन स्लाइसिंग सक्षम करें
pipe.enable_attention_slicing()

# फ्रेम की संख्या घटाएँ
num_frames = 14  # 25 के बजाय
```

### चंक्स में डिकोडिंग

```python
frames = pipe(
    image,
    decode_chunk_size=2,  # एक बार में 2 फ्रेम डिकोड करें
    num_frames=25,
).frames[0]
```

## आउटपुट कनवर्ट करना

### GIF से MP4

```bash
ffmpeg -i input.gif -movflags faststart -pix_fmt yuv420p -vf "scale=trunc(iw/2)*2:trunc(ih/2)*2" output.mp4
```

### फ्रेम सीक्वेंस से वीडियो

```bash
ffmpeg -framerate 8 -i frame_%04d.png -c:v libx264 -pix_fmt yuv420p output.mp4
```

### ऑडियो जोड़ें

```bash
ffmpeg -i video.mp4 -i audio.mp3 -c:v copy -c:a aac -shortest output_with_audio.mp4
```

## प्रदर्शन

| मॉडल        | GPU      | फ्रेम्स | समय    |
| ----------- | -------- | ------- | ------ |
| SVD-XT      | RTX 3090 | 25      | \~120s |
| SVD-XT      | RTX 4090 | 25      | \~80s  |
| SVD-XT      | A100     | 25      | \~50s  |
| AnimateDiff | RTX 3090 | 16      | \~30s  |
| CogVideoX   | A100     | 49      | \~180s |

## लागत अनुमान

सामान्य CLORE.AI मार्केटप्लेस दरें (2024 के अनुसार):

| GPU       | घंटात्मक दर | दैनिक दर | 4-घंटे सत्र |
| --------- | ----------- | -------- | ----------- |
| RTX 3060  | \~$0.03     | \~$0.70  | \~$0.12     |
| RTX 3090  | \~$0.06     | \~$1.50  | \~$0.25     |
| RTX 4090  | \~$0.10     | \~$2.30  | \~$0.40     |
| A100 40GB | \~$0.17     | \~$4.00  | \~$0.70     |
| A100 80GB | \~$0.25     | \~$6.00  | \~$1.00     |

*कीमतें प्रदाता और मांग के अनुसार बदलती हैं। जाँच करें* [*CLORE.AI मार्केटप्लेस*](https://clore.ai/marketplace) *वर्तमान दरों के लिए।*

**पैसे बचाएँ:**

* उपयोग करें **स्पॉट** लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)
* भुगतान करें **CLORE** टोकन के साथ
* विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

## समस्याओं का निवारण

### OOM त्रुटि

* num\_frames घटाएँ
* CPU ऑफलोड सक्षम करें
* छोटा decode\_chunk\_size उपयोग करें

### फ्लिकरिंग वीडियो

* num\_inference\_steps बढ़ाएँ
* विभिन्न motion\_bucket\_id आज़माएँ
* फ्रेम इंटरपोलेशन का उपयोग करें

### खराब गुणवत्ता

* उच्च रिजॉल्यूशन इनपुट का उपयोग करें (SVD)
* बेहतर प्रॉम्प्ट्स (AnimateDiff)
* guidance\_scale बढ़ाएँ