RIFE Interpolation

Clore.ai पर RIFE AI interpolation के साथ video frame rate बढ़ाएं

RIFE AI इंटरपोलेशन से वीडियो फ्रेम रेट बढ़ाएँ।

सभी उदाहरण 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>

RIFE क्या है?

RIFE (रियल-टाइम इंटरमीडिएट फ्लो एस्टिमेशन) कर सकता है:

• FPS बढ़ाएँ (24→60, 30→120)

• मुलायम स्लो मोशन बनाएं

• टूटी-फूटी फुटेज ठीक करें

• रियल-टाइम प्रोसेसिंग

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

Docker इमेज:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

पोर्ट:

22/tcp

कमांड:

pip install torch torchvision && \
git clone https://github.com/megvii-research/ECCV2022-RIFE.git && \
cd ECCV2022-RIFE && \
pip install -r requirements.txt

इंस्टॉलेशन

विकल्प 1: पाइथन पैकेज

pip install rife-ncnn-vulkan-python

विकल्प 2: स्रोत से

git clone https://github.com/megvii-research/ECCV2022-RIFE.git
cd ECCV2022-RIFE
pip install -r requirements.txt

मूल उपयोग

डबल फ्रेम रेट

python inference_video.py --exp=1 --video=input.mp4

# आउटपुट: 2x FPS

4x फ्रेम रेट

python inference_video.py --exp=2 --video=input.mp4

# आउटपुट: 4x FPS

8x फ्रेम रेट

python inference_video.py --exp=3 --video=input.mp4

# आउटपुट: 8x FPS

Python API

मॉडल लोड करें

import torch
from model.RIFE import Model

device = torch.device("cuda")
model = Model()
model.load_model('./train_log', -1)
model.eval()
model.device()

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

import cv2
import numpy as np
import torch

def interpolate_frames(frame1, frame2, model, num_frames=1):
    """दो इमेजों के बीच फ्रेम इंटरपोलेट करें"""
    # टेन्सर तैयार करें
    img0 = torch.from_numpy(frame1).permute(2, 0, 1).float() / 255.0
    img1 = torch.from_numpy(frame2).permute(2, 0, 1).float() / 255.0

    img0 = img0.unsqueeze(0).cuda()
    img1 = img1.unsqueeze(0).cuda()

    # इंटरपोलेट करें
    with torch.no_grad():
        middle = model.inference(img0, img1)

    # वापस कन्वर्ट करें
    middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
    return middle

# फ्रेम लोड करें
frame1 = cv2.imread('frame1.png')
frame2 = cv2.imread('frame2.png')

# इंटरपोलेटेड फ्रेम प्राप्त करें
middle_frame = interpolate_frames(frame1, frame2, model)
cv2.imwrite('interpolated.png', middle_frame)

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

import cv2
import torch
from model.RIFE import Model

model = Model()
model.load_model('./train_log', -1)
model.eval()
model.device()

def process_video(input_path, output_path, multiplier=2):
    cap = cv2.VideoCapture(input_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    out = cv2.VideoWriter(
        output_path,
        cv2.VideoWriter_fourcc(*'mp4v'),
        fps * multiplier,
        (width, height)
    )

    ret, prev_frame = cap.read()
    if not ret:
        return

    out.write(prev_frame)

    while True:
        ret, curr_frame = cap.read()
        if not ret:
            break

        # टेन्सर तैयार करें
        img0 = torch.from_numpy(prev_frame).permute(2, 0, 1).float() / 255.0
        img1 = torch.from_numpy(curr_frame).permute(2, 0, 1).float() / 255.0

        img0 = img0.unsqueeze(0).cuda()
        img1 = img1.unsqueeze(0).cuda()

        # मध्यवर्ती फ्रेम जनरेट करें
        for i in range(multiplier - 1):
            t = (i + 1) / multiplier
            with torch.no_grad():
                middle = model.inference(img0, img1, timestep=t)
            middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
            out.write(middle)

        out.write(curr_frame)
        prev_frame = curr_frame

    cap.release()
    out.release()

process_video('input.mp4', 'output_60fps.mp4', multiplier=2)

rife-ncnn-vulkan का उपयोग करना

तेज़ NCNN कार्यान्वयन:

from rife_ncnn_vulkan import Rife

rife = Rife(gpu_id=0)

# इंटरपोलेट करें
frame1 = Image.open('frame1.png')
frame2 = Image.open('frame2.png')
middle = rife.process(frame1, frame2)
middle.save('interpolated.png')

वीडियो प्रोसेसिंग

from rife_ncnn_vulkan import Rife
import cv2
from PIL import Image

rife = Rife(gpu_id=0, num_threads=4)

def interpolate_video(input_path, output_path, factor=2):
    cap = cv2.VideoCapture(input_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))

    out = cv2.VideoWriter(
        output_path,
        cv2.VideoWriter_fourcc(*'mp4v'),
        fps * factor,
        (width, height)
    )

    ret, prev = cap.read()
    out.write(prev)

    while True:
        ret, curr = cap.read()
        if not ret:
            break

        # PIL में कन्वर्ट करें
        prev_pil = Image.fromarray(cv2.cvtColor(prev, cv2.COLOR_BGR2RGB))
        curr_pil = Image.fromarray(cv2.cvtColor(curr, cv2.COLOR_BGR2RGB))

        # इंटरपोलेट करें
        for i in range(factor - 1):
            t = (i + 1) / factor
            mid = rife.process(prev_pil, curr_pil, timestep=t)
            mid_cv = cv2.cvtColor(np.array(mid), cv2.COLOR_RGB2BGR)
            out.write(mid_cv)

        out.write(curr)
        prev = curr

    cap.release()
    out.release()

स्लो मोशन

मुलायम स्लो मोशन बनाएं:

# मूल: 30 fps, 10 सेकंड = 300 फ्रेम

# 8x इंटरपोलेशन: 2400 फ्रेम

# 30 fps पर चलाएँ: 80 सेकंड (8x धीमा)

python inference_video.py --exp=3 --video=input.mp4

# यह 8x फ्रेम बनाता है, स्लो मोशन के लिए मूल FPS पर चलाएँ

स्लो मोशन स्क्रिप्ट

def create_slow_motion(input_path, output_path, slowdown_factor=4):
    """स्लो मोशन वीडियो बनाएं"""
    cap = cv2.VideoCapture(input_path)
    original_fps = cap.get(cv2.CAP_PROP_FPS)

    # अधिक फ्रेम प्राप्त करने के लिए इंटरपोलेट करें
    exp = int(np.log2(slowdown_factor))
    interpolate_video(input_path, 'temp_interpolated.mp4', factor=slowdown_factor)

    # मूल FPS पर फिर से एन्कोड करें
    cap2 = cv2.VideoCapture('temp_interpolated.mp4')
    width = int(cap2.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap2.get(cv2.CAP_PROP_FRAME_HEIGHT))

    out = cv2.VideoWriter(
        output_path,
        cv2.VideoWriter_fourcc(*'mp4v'),
        original_fps,  # मूल FPS रखें
        (width, height)
    )

    while True:
        ret, frame = cap2.read()
        if not ret:
            break
        out.write(frame)

    cap.release()
    cap2.release()
    out.release()

बैच प्रोसेसिंग

import os
from concurrent.futures import ThreadPoolExecutor

def process_single(input_path, output_dir, factor=2):
    filename = os.path.basename(input_path)
    output_path = os.path.join(output_dir, f"interpolated_{filename}")
    interpolate_video(input_path, output_path, factor)
    return output_path

input_dir = './videos'
output_dir = './interpolated'
os.makedirs(output_dir, exist_ok=True)

videos = [os.path.join(input_dir, f) for f in os.listdir(input_dir)
          if f.endswith(('.mp4', '.mkv', '.avi'))]

for video in videos:
    result = process_single(video, output_dir, factor=2)
    print(f"Completed: {result}")

गुणवत्ता सेटिंग्स

मॉडल वर्ज़न

मॉडल	गुणवत्ता	स्पीड
RIFE v4.6	सर्वोत्तम	धीमा
RIFE v4.0	बहुत अच्छा	मध्यम
RIFE-NCNN	अच्छा	सबसे तेज

UHD मोड

4K+ वीडियो के लिए:

python inference_video.py --exp=1 --video=input.mp4 --UHD

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

सीमित VRAM के लिए

# टाइल्स में प्रोसेस करें
from model.RIFE import Model

model = Model()
model.load_model('./train_log', -1)
model.eval()

# बड़े फ्रेम के लिए टाइल साइज सेट करें

# model.inference आंतरिक रूप से टाइलिंग संभालता है

मेमोरी घटाएँ

# NCNN संस्करण का उपयोग करें (अधिक मेमोरी कुशल)
pip install rife-ncnn-vulkan-python

प्रदर्शन

रिज़ॉल्यूशन	GPU	2x इंटरप FPS
1080p	RTX 3090	~60 fps
1080p	RTX 4090	~100 fps
4K	RTX 3090	~15 fps
4K	RTX 4090	~30 fps

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

आर्टिफैक्ट/घोस्टिंग

• कट्स छोड़ने के लिए सीन डिटेक्शन का उपयोग करें

• इंटरपोलेशन फैक्टर घटाएँ

• तेज़ मूवमेंट के लिए जाँच करें

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

• NCNN संस्करण का उपयोग करें

• कम रिज़ॉल्यूशन पर प्रोसेस करें, बाद में अपस्केल करें

• बैच साइज घटाएँ

धीमा प्रोसेसिंग

• NCNN-Vulkan संस्करण का उपयोग करें

• GPU त्वरण सक्षम करें

• छोटा मॉडल उपयोग करें

सीन डिटेक्शन

सीन कट्स के पार इंटरपोलेशन छोड़ें:

from scenedetect import detect, ContentDetector

scenes = detect('input.mp4', ContentDetector())

# सीनों के बीच इंटरपोलेट न करें
for scene in scenes:
    print(f"Scene: {scene[0].get_frames()} - {scene[1].get_frames()}")

लागत अनुमान

सामान्य 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 टोकन के साथ

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

अगले कदम

• FFmpeg NVENC - आउटपुट एन्कोड करें

• Real-ESRGAN - वीडियो अपस्केल करें

• AI वीडियो जनरेशन - वीडियो生成