Interpolation RIFE

Augmentez la fréquence d'images vidéo avec l'interpolation IA RIFE sur Clore.ai

Augmentez la fréquence d'images vidéo avec l'interpolation IA RIFE.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

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

Qu'est-ce que RIFE ?

RIFE (Real-Time Intermediate Flow Estimation) peut :

• Augmenter les FPS (24→60, 30→120)

• Créer un ralenti fluide

• Corriger les vidéos saccadées

• Traitement en temps réel

Déploiement rapide

Image Docker :

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

Ports :

22/tcp

Commande :

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 : Paquet Python

pip install rife-ncnn-vulkan-python

Option 2 : depuis le code स्रोत

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

Utilisation de base

Doubler la fréquence d'images

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

# Sortie : 2x FPS

Fréquence d'images x4

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

# Sortie : 4x FPS

Fréquence d'images x8

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

# Sortie : 8x FPS

API Python

Charger le modèle

import torch
from model.RIFE import Model

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

Interpoler une seule image

import cv2
import numpy as np
import torch

def interpolate_frames(frame1, frame2, model, num_frames=1):
    """Interpoler des images entre deux photos"""
    # Préparer les tenseurs
    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()

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

    # Convertir обратно
    middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
    return middle

# Charger les images
frame1 = cv2.imread('frame1.png')
frame2 = cv2.imread('frame2.png')

# Obtenir l'image interpolée
middle_frame = interpolate_frames(frame1, frame2, model)
cv2.imwrite('interpolated.png', middle_frame)

Traiter la vidéo

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

        # Préparer les tenseurs
        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()

        # Générer des images intermédiaires
        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)

Utilisation de rife-ncnn-vulkan

Implémentation NCNN plus rapide :

from rife_ncnn_vulkan import Rife

rife = Rife(gpu_id=0)

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

Traitement vidéo

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

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

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

Ralenti

Créer un ralenti fluide :

# Original : 30 fps, 10 secondes = 300 images

# Interpolation x8 : 2400 images

# Lecture à 30 fps : 80 secondes (8x plus lent)

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

# Cela crée 8x d'images, lecture à la fréquence d'images d'origine pour le ralenti

Script de ralenti

def create_slow_motion(input_path, output_path, slowdown_factor=4):
    """Créer une vidéo au ralenti"""
    cap = cv2.VideoCapture(input_path)
    original_fps = cap.get(cv2.CAP_PROP_FPS)

    # Interpoler pour obtenir plus d'images
    exp = int(np.log2(slowdown_factor))
    interpolate_video(input_path, 'temp_interpolated.mp4', factor=slowdown_factor)

    # Réencoder à la fréquence d'images d'origine
    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,  # Conserver le FPS d'origine
        (width, height)
    )

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

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

Traitement par lots

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

Paramètres de qualité

Versions du modèle

Modèle	Qualité	Vitesse
RIFE v4.6	Meilleur	Lent
RIFE v4.0	Excellent	Moyen
RIFE-NCNN	Bon	Le plus rapide

Mode UHD

Pour les vidéos 4K+ :

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

Optimisation de la mémoire

Pour VRAM limitée

# Traiter en tuiles
from model.RIFE import Model

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

# Définir la taille des tuiles pour les grandes images

# model.inference gère le découpage en tuiles en interne

Réduire la mémoire

# Utiliser la version NCNN (plus économe en mémoire)
pip install rife-ncnn-vulkan-python

Performances

Résolution	GPU	FPS interpolés x2
1080p	RTX 3090	~60 fps
1080p	RTX 4090	~100 fps
4K	RTX 3090	~15 fps
4K	RTX 4090	~30 fps

Dépannage

Artefacts/Effet fantôme

• Utiliser la détection de scènes pour ignorer les coupes

• Réduire le facteur d'interpolation

• Vérifier les mouvements rapides

Mémoire insuffisante

• Utiliser la version NCNN

• Traiter à une résolution inférieure, puis mettre à l'échelle ensuite

• Réduire la taille du lot

Traitement lent

• Utiliser la version NCNN-Vulkan

• Activer l'accélération GPU

• Utiliser un modèle plus petit

Détection de scènes

Ignorer l'interpolation aux coupes de scène :

from scenedetect import detect, ContentDetector

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

# Ne pas interpoler entre les scènes
for scene in scenes:
    print(f"Scène : {scene[0].get_frames()} - {scene[1].get_frames()}")

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• FFmpeg NVENC - Encoder la sortie

• Real-ESRGAN - Mettre la vidéo à l'échelle supérieure

• Génération vidéo par IA - Générer des vidéos