RIFE-Interpolation

Erhöhe die Bildrate von Videos mit RIFE-KI-Interpolation auf Clore.ai

Erhöhe die Videobildrate mit RIFE-KI-Interpolation.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

• SSH: ssh -p <port> root@<proxy-address>

Was ist RIFE?

RIFE (Real-Time Intermediate Flow Estimation) kann:

• FPS erhöhen (24→60, 30→120)

• Ruckelfreie Zeitlupe erstellen

• Ruckeliges Material verbessern

• Echtzeitverarbeitung

Schnell bereitstellen

Docker-Image:

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Ports:

22/tcp

Befehl:

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

Installation

Option 1: Python-Paket

pip install rife-ncnn-vulkan-python

Option 2: Aus dem Quellcode

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

Grundlegende Verwendung

Doppelte Bildrate

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

# Ausgabe: 2x FPS

4-fache Bildrate

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

# Ausgabe: 4x FPS

8-fache Bildrate

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

# Ausgabe: 8x FPS

Python-API

Modell laden

import torch
from model.RIFE import Model

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

Einzelnes Bild interpolieren

import cv2
import numpy as np
import torch

def interpolate_frames(frame1, frame2, model, num_frames=1):
    """Bilder zwischen zwei Aufnahmen interpolieren"""
    # Tensoren vorbereiten
    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()

    # Interpolieren
    with torch.no_grad():
        middle = model.inference(img0, img1)

    # Zurück konvertieren
    middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
    return middle

# Bilder laden
frame1 = cv2.imread('frame1.png')
frame2 = cv2.imread('frame2.png')

# Interpoliertes Bild abrufen
middle_frame = interpolate_frames(frame1, frame2, model)
cv2.imwrite('interpolated.png', middle_frame)

Video verarbeiten

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

        # Tensoren vorbereiten
        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()

        # Zwischenbilder erzeugen
        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)

Verwendung von rife-ncnn-vulkan

Schnellere NCNN-Implementierung:

from rife_ncnn_vulkan import Rife

rife = Rife(gpu_id=0)

# Interpolieren
frame1 = Image.open('frame1.png')
frame2 = Image.open('frame2.png')
middle = rife.process(frame1, frame2)
middle.save('interpolated.png')

Videoverarbeitung

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

        # In PIL konvertieren
        prev_pil = Image.fromarray(cv2.cvtColor(prev, cv2.COLOR_BGR2RGB))
        curr_pil = Image.fromarray(cv2.cvtColor(curr, cv2.COLOR_BGR2RGB))

        # Interpolieren
        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()

Zeitlupe

Ruckelfreie Zeitlupe erstellen:

# Original: 30 fps, 10 Sekunden = 300 Bilder

# 8-fache Interpolation: 2400 Bilder

# Bei 30 fps abspielen: 80 Sekunden (8x langsamer)

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

# Dadurch entstehen 8x so viele Bilder, für Zeitlupe mit der ursprünglichen FPS abspielen

Zeitlupenskript

def create_slow_motion(input_path, output_path, slowdown_factor=4):
    """Zeitlupenvideo erstellen"""
    cap = cv2.VideoCapture(input_path)
    original_fps = cap.get(cv2.CAP_PROP_FPS)

    # Interpolieren, um mehr Bilder zu erhalten
    exp = int(np.log2(slowdown_factor))
    interpolate_video(input_path, 'temp_interpolated.mp4', factor=slowdown_factor)

    # Mit ursprünglicher FPS neu kodieren
    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,  # Ursprüngliche FPS beibehalten
        (width, height)
    )

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

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

Batch-Verarbeitung

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"Abgeschlossen: {result}")

Qualitätseinstellungen

Modellversionen

Modell	Qualität	Geschwindigkeit
RIFE v4.6	Am besten	Langsam
RIFE v4.0	Großartig	Mittel
RIFE-NCNN	Gut	Am schnellsten

UHD-Modus

Für 4K+-Videos:

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

Speicheroptimierung

Bei begrenztem VRAM

# In Kacheln verarbeiten
from model.RIFE import Model

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

# Kachelgröße für große Bilder festlegen

# model.inference behandelt das Kacheln intern

Speicher reduzieren

# NCNN-Version verwenden (speichereffizienter)
pip install rife-ncnn-vulkan-python

Leistung

Auflösung	GPU	2x interpolierte FPS
1080p	RTX 3090	~60 fps
1080p	RTX 4090	~100 fps
4K	RTX 3090	~15 fps
4K	RTX 4090	~30 fps

Fehlerbehebung

Artefakte/Ghosting

• Szenenerkennung verwenden, um Schnitte zu überspringen

• Interpolationsfaktor reduzieren

• Auf schnelle Bewegungen prüfen

Speicher erschöpft

• NCNN-Version verwenden

• In niedrigerer Auflösung verarbeiten, danach hochskalieren

• Batch-Größe reduzieren

Langsame Verarbeitung

• NCNN-Vulkan-Version verwenden

• GPU-Beschleunigung aktivieren

• Kleineres Modell verwenden

Szenenerkennung

Interpolation über Szenenschnitte hinweg überspringen:

from scenedetect import detect, ContentDetector

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

# Nicht zwischen Szenen interpolieren
for scene in scenes:
    print(f"Scene: {scene[0].get_frames()} - {scene[1].get_frames()}")

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise (Stand 2024):

GPU	Stundensatz	Tagessatz	4-Stunden-Sitzung
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

Die Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für unterbrechbare Arbeit — etwa ein Drittel der Server bietet Spot-Preise unter dem On-Demand-Preis (Median ca. 13 % Rabatt), der Rest ist gleichauf

• Bezahlen Sie mit CLORE Tokens

• Vergleichen Sie Preise zwischen verschiedenen Anbietern

Nächste Schritte

• FFmpeg NVENC - Ausgabe kodieren

• Real-ESRGAN - Video hochskalieren

• KI-Videogenerierung - Videos generieren