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

Clore.ai पर SVD, AnimateDiff और अन्य के साथ वीडियो जेनरेट करें

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

सभी उदाहरण GPU सर्वरों पर चलाए जा सकते हैं जिन्हें द्वारा किराए पर लिया गया है CLORE.AI मार्केटप्लेस.

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

1. पर जाएँ CLORE.AI मार्केटप्लेस

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

कमांड:

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 स्क्रिप्ट

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

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

इंस्टॉलेशन

pip install diffusers transformers accelerate

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

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

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

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

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

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

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

CogVideoX

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

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

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 फ्रेम इंटरपोलेशन

# इंस्टॉल करें
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 (रीयल-टाइम)

pip install rife-ncnn-vulkan-python

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

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

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

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 के लिए

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

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

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

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

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

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

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

GIF से MP4

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

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

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

ऑडियो जोड़ें

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 मार्केटप्लेस वर्तमान दरों के लिए।

पैसे बचाएँ:

• उपयोग करें स्पॉट लचीले वर्कलोड के लिए मार्केट (अक्सर 30-50% सस्ता)

• भुगतान करें CLORE टोकन के साथ

• विभिन्न प्रदाताओं के बीच कीमतों की तुलना करें

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

OOM त्रुटि

• num_frames घटाएँ

• CPU ऑफलोड सक्षम करें

• छोटा decode_chunk_size उपयोग करें

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

• num_inference_steps बढ़ाएँ

• विभिन्न motion_bucket_id आज़माएँ

• फ्रेम इंटरपोलेशन का उपयोग करें

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

• उच्च रिजॉल्यूशन इनपुट का उपयोग करें (SVD)

• बेहतर प्रॉम्प्ट्स (AnimateDiff)

• guidance_scale बढ़ाएँ