Interpolación RIFE

Aumenta la tasa de fotogramas de video con interpolación RIFE AI en Clore.ai

Aumenta la tasa de fotogramas del video con interpolación de IA RIFE.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Alquilar en CLORE.AI

1. Visita Marketplace de CLORE.AI

2. Filtra por tipo de GPU, VRAM y precio

3. Elige Bajo demanda (tarifa fija) o Spot (precio ofertado)

4. Configura tu pedido:

   • Selecciona la imagen de Docker

   • Configura los puertos (TCP para SSH, HTTP para interfaces web)

   • Añade variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona el método de pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera al despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis pedidos

• Interfaces web: Usa la URL del puerto HTTP

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

¿Qué es RIFE?

RIFE (Real-Time Intermediate Flow Estimation) puede:

• Aumentar los FPS (24→60, 30→120)

• Crear cámara lenta fluida

• Corregir metraje entrecortado

• Procesamiento en tiempo real

Despliegue rápido

Imagen de Docker:

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

Puertos:

22/tcp

Comando:

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

Instalación

Opción 1: Paquete de Python

pip install rife-ncnn-vulkan-python

Opción 2: Desde el código fuente

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

Uso básico

Duplicar la tasa de fotogramas

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

# Salida: 2x FPS

Tasa de fotogramas 4x

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

# Salida: 4x FPS

Tasa de fotogramas 8x

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

# Salida: 8x FPS

API de Python

Cargar modelo

import torch
from model.RIFE import Model

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

Interpolar un solo fotograma

import cv2
import numpy as np
import torch

def interpolate_frames(frame1, frame2, model, num_frames=1):
    """Interpolar fotogramas entre dos imágenes"""
    # Preparar tensores
    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()

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

    # Convertir de nuevo
    middle = (middle[0] * 255).byte().cpu().numpy().transpose(1, 2, 0)
    return middle

# Cargar fotogramas
frame1 = cv2.imread('frame1.png')
frame2 = cv2.imread('frame2.png')

# Obtener fotograma interpolado
middle_frame = interpolate_frames(frame1, frame2, model)
cv2.imwrite('interpolated.png', middle_frame)

Procesar video

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

        # Preparar tensores
        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()

        # Generar fotogramas intermedios
        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)

Usando rife-ncnn-vulkan

Implementación NCNN más rápida:

from rife_ncnn_vulkan import Rife

rife = Rife(gpu_id=0)

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

Procesamiento de video

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 a PIL
        prev_pil = Image.fromarray(cv2.cvtColor(prev, cv2.COLOR_BGR2RGB))
        curr_pil = Image.fromarray(cv2.cvtColor(curr, cv2.COLOR_BGR2RGB))

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

Cámara lenta

Crear cámara lenta fluida:

# Original: 30 fps, 10 segundos = 300 fotogramas

# Interpolación 8x: 2400 fotogramas

# Reproducir a 30 fps: 80 segundos (8x más lento)

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

# Esto crea fotogramas 8x, reproducir a los FPS originales para cámara lenta

Script de cámara lenta

def create_slow_motion(input_path, output_path, slowdown_factor=4):
    """Crear video en cámara lenta"""
    cap = cv2.VideoCapture(input_path)
    original_fps = cap.get(cv2.CAP_PROP_FPS)

    # Interpolar para obtener más fotogramas
    exp = int(np.log2(slowdown_factor))
    interpolate_video(input_path, 'temp_interpolated.mp4', factor=slowdown_factor)

    # Volver a codificar a los FPS originales
    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,  # Mantener los FPS originales
        (width, height)
    )

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

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

Procesamiento por lotes

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}")

Configuración de calidad

Versiones del modelo

Modelo	Calidad	Velocidad
RIFE v4.6	Mejor	Lento
RIFE v4.0	Excelente	Medio
RIFE-NCNN	Bueno	El más rápido

Modo UHD

Para videos 4K+:

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

Optimización de memoria

Para VRAM limitada

# Procesar en mosaicos
from model.RIFE import Model

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

# Establecer el tamaño de mosaico para fotogramas grandes

# model.inference maneja el mosaico internamente

Reducir memoria

# Usar la versión NCNN (más eficiente en memoria)
pip install rife-ncnn-vulkan-python

Rendimiento

Resolución	GPU	FPS de interpolación 2x
1080p	RTX 3090	~60 fps
1080p	RTX 4090	~100 fps
4K	RTX 3090	~15 fps
4K	RTX 4090	~30 fps

Solución de problemas

Artefactos/efecto fantasma

• Usar detección de escenas para omitir cortes

• Reducir el factor de interpolación

• Comprobar si hay movimiento rápido

Sin memoria

• Usar la versión NCNN

• Procesar a menor resolución y escalar después

• Reducir el tamaño del lote

Procesamiento lento

• Usar la versión NCNN-Vulkan

• Activar la aceleración de GPU

• Usar un modelo más pequeño

Detección de escenas

Omitir la interpolación en los cortes de escena:

from scenedetect import detect, ContentDetector

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

# No interpolar entre escenas
for scene in scenes:
    print(f"Scene: {scene[0].get_frames()} - {scene[1].get_frames()}")

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a partir de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta Marketplace de CLORE.AI las tarifas actuales.

Ahorra dinero:

• Usa el Spot mercado para trabajo interrumpible — alrededor de un tercio de los servidores fija el precio spot por debajo del precio bajo demanda (mediana de ~13% de descuento), el resto lo iguala

• Paga con CLORE tokens

• Compara precios entre distintos proveedores

Siguientes pasos

• FFmpeg NVENC - Codificar salida

• Real-ESRGAN - Escalar video

• Generación de video con IA - Generar videos