# Wan2.1 Video

CLORE.AI GPUs पर Alibaba के Wan2.1 टेक्स्ट-टू-वीडियो और इमेज-टू-वीडियो मॉडल से उच्च-गुणवत्ता वाले वीडियो जनरेट करें।

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

## क्यों Wan2.1?

* **उच्च गुणवत्ता** - उन्नत वीडियो जनरेशन
* **कई मोड** - टेक्स्ट-टू-वीडियो, इमेज-टू-वीडियो
* **विभिन्न आकार** - 1.3B से 14B पैरामीटर
* **लंबे वीडियो** - अधिकतम 81 फ्रेम तक
* **ओपन वेट्स** - Apache 2.0 लाइसेंस

## मॉडल वेरिएंट

| मॉडल            | पैरामीटर | VRAM | रिज़ॉल्यूशन | फ्रेम्स |
| --------------- | -------- | ---- | ----------- | ------- |
| Wan2.1-T2V-1.3B | 1.3B     | 8GB  | 480p        | 81      |
| Wan2.1-T2V-14B  | 14B      | 24GB | 720p        | 81      |
| Wan2.1-I2V-14B  | 14B      | 24GB | 720p        | 81      |

## CLORE.AI पर त्वरित डिप्लॉय

**Docker इमेज:**

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

**पोर्ट:**

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

**कमांड:**

```bash
pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained('alibaba-pai/Wan2.1-T2V-1.3B', torch_dtype=torch.float16)
pipe.to('cuda')
pipe.enable_model_cpu_offload()

def generate(prompt, steps, frames, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    output = pipe(prompt, num_frames=frames, num_inference_steps=steps, generator=generator)
    export_to_video(output.frames[0], 'output.mp4', fps=16)
    return 'output.mp4'

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Prompt'),
        gr.Slider(20, 100, value=50, label='Steps'),
        gr.Slider(16, 81, value=49, step=8, label='Frames'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Video(),
    title='Wan2.1 - Text to Video'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

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

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

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

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

## हार्डवेयर आवश्यकताएँ

| मॉडल     | न्यूनतम GPU   | अनुशंसित      | सर्वोत्तम |
| -------- | ------------- | ------------- | --------- |
| 1.3B T2V | RTX 3070 8GB  | RTX 3090 24GB | RTX 4090  |
| 14B T2V  | RTX 4090 24GB | A100 40GB     | A100 80GB |
| 14B I2V  | RTX 4090 24GB | A100 40GB     | A100 80GB |

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

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

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

### बुनियादी उपयोग (1.3B)

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-1.3B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompt = "A cat playing with a ball in a sunny garden"

output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "cat_video.mp4", fps=16)
```

### उच्च गुणवत्ता (14B)

```python
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-T2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

prompt = "Cinematic shot of a dragon flying over mountains at sunset, 4K, detailed"

output = pipe(
    prompt=prompt,
    negative_prompt="blurry, low quality, distorted",
    num_frames=81,
    height=720,
    width=1280,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "dragon.mp4", fps=24)
```

## इमेज-टू-वीडियो

### एक इमेज को एनिमेट करें

```python
import torch
from diffusers import WanI2VPipeline
from diffusers.utils import load_image, export_to_video

pipe = WanI2VPipeline.from_pretrained(
    "alibaba-pai/Wan2.1-I2V-14B",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Load input image
image = load_image("input.jpg")

prompt = "The person in the image starts walking forward"

output = pipe(
    prompt=prompt,
    image=image,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

export_to_video(output.frames[0], "animated.mp4", fps=16)
```

## Wan2.1-I2V-14B के साथ इमेज-टू-वीडियो

{% hint style="info" %}
Wan2.1-I2V-14B स्थिर छवि को टेक्स्ट प्रॉम्प्ट के निर्देश से मूवमेंट के साथ एनिमेट करता है। आवश्यक है **24GB VRAM** (RTX 4090 या A100 40GB की सिफारिश की जाती है).
{% endhint %}

### मॉडल विवरण

| संपत्ति            | मान                               |
| ------------------ | --------------------------------- |
| मॉडल आईडी          | `Wan-AI/Wan2.1-I2V-14B-480P`      |
| पैरामीटर           | 14 बिलियन                         |
| आवश्यक VRAM        | **24GB**                          |
| अधिकतम रिज़ॉल्यूशन | 480p (854×480) या 720p (1280×720) |
| अधिकतम फ्रेम्स     | 81                                |
| लाइसेंस            | Apache 2.0                        |

### हार्डवेयर आवश्यकताएँ

| GPU       | VRAM | स्थिति               |
| --------- | ---- | -------------------- |
| RTX 4090  | 24GB | ✅ अनुशंसित           |
| RTX 3090  | 24GB | ✅ समर्थित            |
| A100 40GB | 40GB | ✅ इष्टतम             |
| A100 80GB | 80GB | ✅ सर्वोत्तम गुणवत्ता |
| RTX 3080  | 10GB | ❌ अपर्याप्त          |

### त्वरित CLI स्क्रिप्ट

इसे के रूप में सहेजें `generate_i2v.py` और चलाएँ:

```bash
python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P --image input.jpg --prompt "camera slowly zooms out"
```

### generate\_i2v.py — पूर्ण स्क्रिप्ट

```python
#!/usr/bin/env python3
"""
Wan2.1 इमेज-टू-वीडियो CLI स्क्रिप्ट।
उपयोग: python generate_i2v.py --model Wan-AI/Wan2.1-I2V-14B-480P \
           --image input.jpg --prompt "camera slowly zooms out"
"""

import argparse
import os
पूर्ण कार्यशील उदाहरण
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image


def parse_args():
    parser = argparse.ArgumentParser(description="Wan2.1 Image-to-Video Generator")
    parser.add_argument(
        "--model",
        type=str,
        default="Wan-AI/Wan2.1-I2V-14B-480P",
        help="Model ID from Hugging Face (default: Wan-AI/Wan2.1-I2V-14B-480P)",
    )
    parser.add_argument(
        "--image",
        type=str,
        required=True,
        help="Path to input image (JPEG or PNG)",
    )
    parser.add_argument(
        "--prompt",
        type=str,
        required=True,
        help='Text prompt describing the desired motion (e.g. "camera slowly zooms out")',
    )
    parser.add_argument(
        "--negative-prompt",
        type=str,
        default="blurry, low quality, distorted, jerky motion, artifacts",
        help="Negative prompt to avoid unwanted artifacts",
    )
    parser.add_argument(
        "--frames",
        type=int,
        default=49,
        help="Number of video frames to generate (default: 49, max: 81)",
    )
    parser.add_argument(
        "--steps",
        type=int,
        default=50,
        help="Number of diffusion steps (default: 50)",
    )
    parser.add_argument(
        "--guidance",
        type=float,
        default=7.0,
        help="Classifier-free guidance scale (default: 7.0)",
    )
    parser.add_argument(
        "--seed",
        type=int,
        default=-1,
        help="Random seed for reproducibility (-1 = random)",
    )
    parser.add_argument(
        "--fps",
        type=int,
        default=16,
        help="Output video FPS (default: 16)",
    )
    parser.add_argument(
        "--output",
        type=str,
        default="output_i2v.mp4",
        help="Output video file path (default: output_i2v.mp4)",
    )
    parser.add_argument(
        "--height",
        type=int,
        default=480,
        help="Output video height in pixels (default: 480)",
    )
    parser.add_argument(
        "--width",
        type=int,
        default=854,
        help="Output video width in pixels (default: 854)",
    )
    parser.add_argument(
        "--cpu-offload",
        action="store_true",
        default=True,
        help="Enable model CPU offloading to save VRAM (default: True)",
    )
    parser.add_argument(
        "--vae-tiling",
        action="store_true",
        default=False,
        help="Enable VAE tiling for high-resolution outputs",
    )
    return parser.parse_args()


def load_and_resize_image(image_path: str, width: int, height: int) -> Image.Image:
    """Load image from path and resize to target dimensions."""
    if not os.path.exists(image_path):
        print(f"[ERROR] Image not found: {image_path}", file=sys.stderr)
        sys.exit(1)

    img = Image.open(image_path).convert("RGB")
    original_size = img.size
    img = img.resize((width, height), Image.LANCZOS)
    print(f"[INFO] Loaded image: {image_path} ({original_size[0]}x{original_size[1]}) → resized to {width}x{height}")
    return img


def load_pipeline(model_id: str, cpu_offload: bool, vae_tiling: bool):
    """Load the Wan I2V pipeline with memory optimizations."""
    print(f"[INFO] Loading model: {model_id}")
    print(f"[INFO] CUDA available: {torch.cuda.is_available()}")
    if torch.cuda.is_available():
        vram_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
        print(f"[INFO] GPU: {torch.cuda.get_device_name(0)} ({vram_gb:.1f} GB VRAM)")
        if vram_gb < 23:
            print("[WARN] Less than 24GB VRAM detected — enable --cpu-offload or use the 1.3B model")

    pipe = WanImageToVideoPipeline.from_pretrained(
        model_id,
        torch_dtype=torch.float16,
    )

    if cpu_offload:
        print("[INFO] Enabling model CPU offload")
        pipe.enable_model_cpu_offload()
    else:
        pipe.to("cuda")

    if vae_tiling:
        print("[INFO] Enabling VAE tiling for high-res generation")
        pipe.enable_vae_tiling()

    return pipe


def generate_video(pipe, args) -> None:
    """Run the I2V pipeline and save the output video."""
    image = load_and_resize_image(args.image, args.width, args.height)

    generator = None
    if args.seed >= 0:
        generator = torch.Generator("cuda").manual_seed(args.seed)
        print(f"[INFO] Using seed: {args.seed}")
    else:
        print("[INFO] Using random seed")

    print(f"[INFO] Generating {args.frames} frames at {args.width}x{args.height}")
    print(f"[INFO] Steps: {args.steps} | Guidance: {args.guidance} | FPS: {args.fps}")
    print(f"[INFO] Prompt: {args.prompt}")

    output = pipe(
        prompt=args.prompt,
        negative_prompt=args.negative_prompt,
        image=image,
        num_frames=args.frames,
        height=args.height,
        width=args.width,
        num_inference_steps=args.steps,
        guidance_scale=args.guidance,
        generator=generator,
    )

    export_to_video(output.frames[0], args.output, fps=args.fps)
    print(f"[INFO] Video saved to: {os.path.abspath(args.output)}")
    duration = args.frames / args.fps
    print(f"[INFO] Duration: {duration:.1f}s at {args.fps}fps ({args.frames} frames)")


def main():
    args = parse_args()

    if not torch.cuda.is_available():
        print("[ERROR] CUDA GPU not found. Wan2.1-I2V-14B requires a CUDA-capable GPU.", file=sys.stderr)
        sys.exit(1)

    pipe = load_pipeline(args.model, args.cpu_offload, args.vae_tiling)
    generate_video(pipe, args)
    print("[DONE] Image-to-video generation complete!")


if __name__ == "__main__":
    main()
```

### उन्नत I2V पाइपलाइन (Python API)

```python
import torch
from diffusers import WanImageToVideoPipeline
from diffusers.utils import load_image, export_to_video
from PIL import Image

# ── पाइपलाइन लोड करें ──────────────────────────────────────────────────────────────
pipe = WanImageToVideoPipeline.from_pretrained(
    "Wan-AI/Wan2.1-I2V-14B-480P",
    torch_dtype=torch.float16,
)
pipe.enable_model_cpu_offload()   # VRAM को 24GB से कम रखने में मदद करता है
pipe.enable_vae_tiling()          # वैकल्पिक: 720p के लिए सहायक

# ── इनपुट इमेज लोड और तैयार करें ─────────────────────────────────────────────────
image = load_image("input.jpg").resize((854, 480))

# ── जनरेट करें ───────────────────────────────────────────────────────────────────
prompt = "camera slowly zooms out, revealing the full landscape"
negative_prompt = "blurry, low quality, distorted, flickering, artifacts"

generator = torch.Generator("cuda").manual_seed(42)

output = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    image=image,
    num_frames=49,          # ~3 सेकंड 16fps पर
    height=480,
    width=854,
    num_inference_steps=50,
    guidance_scale=7.5,
    generator=generator,
)

export_to_video(output.frames[0], "i2v_output.mp4", fps=16)
print("Saved: i2v_output.mp4")
```

### I2V प्रॉम्प्ट टिप्स

| लक्ष्य            | प्रॉम्प्ट उदाहरण                                   |
| ----------------- | -------------------------------------------------- |
| कैमरा मूवमेंट     | `"camera slowly zooms out from the subject"`       |
| पैरालैक्स इफ़ेक्ट | `"subtle parallax motion, depth of field shift"`   |
| किरदार एनिमेशन    | `"the figure turns their head and smiles"`         |
| प्रकृति एनिमेशन   | `"leaves rustle in a gentle breeze, light shifts"` |
| अमूर्त मूवमेंट    | `"colors swirl and blend, fluid motion"`           |

### I2V के लिए मेमोरी टिप्स (24GB GPUs)

```python
# 24GB GPUs पर अनिवार्य
pipe.enable_model_cpu_offload()

# वैकल्पिक: पीक VRAM ~10% कम करता है
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# रन के बीच साफ़ करें
import gc
gc.collect()
torch.cuda.empty_cache()
```

## प्रॉम्प्ट उदाहरण

### प्रकृति और परिदृश्य

```python
prompts = [
    "Time-lapse of clouds moving over mountain peaks, dramatic lighting",
    "Ocean waves crashing on rocks, slow motion, cinematic",
    "Northern lights dancing in the night sky, vibrant colors",
    "Forest in autumn with leaves falling, peaceful atmosphere"
]
```

### जानवर और किरदार

```python
prompts = [
    "A golden retriever running through a field of flowers",
    "A butterfly emerging from its cocoon, macro shot",
    "Samurai warrior drawing sword, dramatic lighting",
    "Robot walking through futuristic city streets"
]
```

### Abstract & Artistic

```python
prompts = [
    "Colorful paint swirling in water, abstract art",
    "Geometric shapes transforming and morphing, neon colors",
    "Ink drops spreading in milk, macro photography"
]
```

## उन्नत सेटिंग्स

### गुणवत्ता बनाम गति

```python
# तेज प्रीव्यू
output = pipe(
    prompt=prompt,
    num_frames=17,
    num_inference_steps=25,
    guidance_scale=5.0
)

# संतुलित
output = pipe(
    prompt=prompt,
    num_frames=49,
    num_inference_steps=50,
    guidance_scale=7.0
)

# अधिकतम गुणवत्ता
output = pipe(
    prompt=prompt,
    num_frames=81,
    num_inference_steps=100,
    guidance_scale=7.5
)
```

### रिज़ॉल्यूशन विकल्प

```python
# 480p (1.3B मॉडल)
output = pipe(prompt, height=480, width=854, num_frames=49)

# 720p (14B मॉडल)
output = pipe(prompt, height=720, width=1280, num_frames=49)

# 1080p (14B मॉडल, उच्च VRAM)
output = pipe(prompt, height=1080, width=1920, num_frames=33)
```

## बैच जनरेशन

```python
import os
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

prompts = [
    "A rocket launching into space",
    "Fish swimming in coral reef",
    "Rain falling on a city street at night"
]

output_dir = "./videos"
os.makedirs(output_dir, exist_ok=True)

for i, prompt in enumerate(prompts):
    print(f"Generating {i+1}/{len(prompts)}: {prompt[:40]}...")

    output = pipe(
        prompt=prompt,
        num_frames=49,
        num_inference_steps=50
    )

    export_to_video(output.frames[0], f"{output_dir}/video_{i:03d}.mp4", fps=16)
    torch.cuda.empty_cache()
```

## Gradio इंटरफ़ेस

```python
import gradio as gr
import torch
from diffusers import WanPipeline
from diffusers.utils import export_to_video
import tempfile

pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B", torch_dtype=torch.float16)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

def generate_video(prompt, negative_prompt, frames, steps, guidance, seed):
    generator = torch.Generator("cuda").manual_seed(seed) if seed > 0 else None

    output = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_frames=frames,
        num_inference_steps=steps,
        guidance_scale=guidance,
        generator=generator
    )

    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as f:
        export_to_video(output.frames[0], f.name, fps=16)
        return f.name

demo = gr.Interface(
    fn=generate_video,
    inputs=[
        gr.Textbox(label="Prompt", lines=2),
        gr.Textbox(label="Negative Prompt", value="blurry, low quality"),
        gr.Slider(17, 81, value=49, step=8, label="Frames"),
        gr.Slider(20, 100, value=50, step=5, label="Steps"),
        gr.Slider(3, 12, value=7, step=0.5, label="Guidance"),
        gr.Number(value=-1, label="Seed")
    ],
    outputs=gr.Video(label="Generated Video"),
    title="Wan2.1 - Text to Video Generation",
    description="टेक्स्ट प्रॉम्प्ट से वीडियो जनरेट करें। CLORE.AI पर चल रहा है."
)

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

## मेमोरी अनुकूलन

```python
# सभी ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()
pipe.enable_vae_slicing()

# बहुत कम VRAM के लिए
pipe.enable_sequential_cpu_offload()

# जेनरेशन के बीच कैश साफ़ करें
torch.cuda.empty_cache()
```

## प्रदर्शन

| मॉडल | रिज़ॉल्यूशन | फ्रेम्स | GPU       | समय        |
| ---- | ----------- | ------- | --------- | ---------- |
| 1.3B | 480p        | 49      | RTX 4090  | \~2 मिनट   |
| 1.3B | 480p        | 49      | A100 40GB | \~1.5 मिनट |
| 14B  | 720p        | 49      | A100 40GB | \~5 मिनट   |
| 14B  | 720p        | 81      | A100 80GB | \~8 मिनट   |

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

सामान्य CLORE.AI मार्केटप्लेस दरें:

| GPU           | घंटात्मक दर | \~49 फ्रेम वीडियो/घंटा     |
| ------------- | ----------- | -------------------------- |
| RTX 3090 24GB | \~$0.06     | \~20 (1.3B)                |
| RTX 4090 24GB | \~$0.10     | \~30 (1.3B)                |
| A100 40GB     | \~$0.17     | \~40 (1.3B) / \~12 (14B)   |
| A100 80GB     | \~$0.25     | \~8 (14B उच्च-रिज़ॉल्यूशन) |

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

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

### आउट ऑफ़ मेमोरी

```python
# छोटे मॉडल का उपयोग करें
pipe = WanPipeline.from_pretrained("alibaba-pai/Wan2.1-T2V-1.3B")

# सभी ऑप्टिमाइज़ेशन सक्षम करें
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# फ्रेम्स घटाएं
output = pipe(prompt, num_frames=17)

# रिज़ॉल्यूशन घटाएँ
output = pipe(prompt, height=480, width=854)
```

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

* स्टेप्स बढ़ाएँ (75-100)
* और अधिक विस्तृत प्रॉम्प्ट लिखें
* नेगेटिव प्रॉम्प्ट का उपयोग करें
* बेहतर गुणवत्ता के लिए 14B मॉडल आज़माएँ

### वीडियो बहुत छोटा है

* बढ़ाएँ `num_frames` (अधिकतम 81)
* फ्रेम इंटरपोलिशन के लिए RIFE इंटरपोलेशन का उपयोग करें
* कई जेनरेशन चेन करें

### आर्टिफैक्ट्स/फ्लिकरिंग

* guidance scale बढ़ाएँ
* सुसंगतता के लिए फिक्स्ड सीड उपयोग करें
* वीडियो स्थिरीकरण से पोस्ट-प्रोसेस करें

## Wan2.1 बनाम अन्य

| फ़ीचर          | Wan2.1     | Hunyuan  | SVD   | CogVideoX  |
| -------------- | ---------- | -------- | ----- | ---------- |
| गुणवत्ता       | उत्कृष्ट   | उत्कृष्ट | अच्छा | बहुत अच्छा |
| स्पीड          | तेज़       | मध्यम    | तेज़  | धीमा       |
| अधिकतम फ्रेम्स | 81         | 129      | 25    | 49         |
| रिज़ॉल्यूशन    | 720p       | 720p     | 576p  | 720p       |
| I2V समर्थन     | हां        | हां      | हां   | हां        |
| लाइसेंस        | Apache 2.0 | खोलें    | खोलें | खोलें      |

**कब Wan2.1 का उपयोग करें:**

* ओपन-सोर्स वीडियो जनरेशन चाहिए
* तेज़ जनरेशन स्पीड चाहिये
* Apache 2.0 लाइसेंस आवश्यक है
* संतुलित गुणवत्ता/गति चाहिए

## अगले कदम

* [Hunyuan Video](https://docs.clore.ai/guides/guides_v2-hi/video-generation/hunyuan-video) - वैकल्पिक T2V
* [OpenSora](https://docs.clore.ai/guides/guides_v2-hi/video-generation/opensora) - Open Sora विकल्प
* [Stable Video Diffusion](https://docs.clore.ai/guides/guides_v2-hi/video-generation/stable-video-diffusion) - इमेज एनिमेशन
* [RIFE इंटरपोलेशन](https://docs.clore.ai/guides/guides_v2-hi/video-processing/rife-interpolation) - फ्रेम इंटरपोलेशन