Interpolación RIFE

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

Aumenta la frecuencia de imagen de video con interpolación AI RIFE.

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

Alquilar en CLORE.AI

Visita CLORE.AI Marketplace
Filtrar por tipo de GPU, VRAM y precio
Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)
Configura tu pedido:
- Selecciona imagen Docker
- Establece puertos (TCP para SSH, HTTP para interfaces web)
- Agrega variables de entorno si es necesario
- Introduce el comando de inicio
Selecciona pago: CLORE, BTC, o USDT/USDC
Crea el pedido y espera el 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 (Estimación de Flujo Intermedio en Tiempo Real) puede:

Aumentar FPS (24→60, 30→120)
Crear cámara lenta suave
Arreglar metraje entrecortado
Procesamiento en tiempo real

Despliegue rápido

Imagen Docker:

pytorch/pytorch:2.5.1-cuda12.4-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

4x Tasa de fotogramas

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

# Salida: 4x FPS

8x Tasa de fotogramas

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 fotograma único

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 suave:


# 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 FPS original 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 FPS original
    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 FPS original
        (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}")

Ajustes de calidad

Versiones del modelo

Modelo

Calidad

Velocidad

RIFE v4.6

Mejor

Lento

RIFE v4.0

Genial

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 tamaño de mosaico para fotogramas grandes

# model.inference maneja el enlosado internamente

Reducir memoria


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

Rendimiento

Resolución

GPU

2x Interpolación FPS

1080p

RTX 3090

~60 fps

1080p

RTX 4090

~100 fps

RTX 3090

~15 fps

RTX 4090

~30 fps

Solución de problemas

Artefactos/Fantasmeo

Usar detección de escenas para omitir cortes
Reducir el factor de interpolación
Comprobar el movimiento rápido

Memoria insuficiente

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
Habilitar aceleración por GPU
Usar un modelo más pequeño

Detección de escenas

Omitir la interpolación a través de 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 fecha 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 CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)
Paga con CLORE tokens
Compara precios entre diferentes proveedores

Próximos pasos

FFmpeg NVENC - Codificar salida
Real-ESRGAN - Reescalar video
Generación de video AI - Generar videos

AnteriorFFmpeg NVENC SiguienteResumen

Última actualización hace 1 día

¿Te fue útil?

hashtagAlquilar en CLORE.AI

hashtagAccede a tu servidor

hashtag¿Qué es RIFE?

hashtagDespliegue rápido

hashtagInstalación

hashtagOpción 1: Paquete de Python

hashtagOpción 2: Desde el código fuente

hashtagUso básico

hashtagDuplicar la tasa de fotogramas

hashtag4x Tasa de fotogramas

hashtag8x Tasa de fotogramas

hashtagAPI de Python

hashtagCargar modelo

hashtagInterpolar fotograma único

hashtagProcesar video

hashtagUsando rife-ncnn-vulkan

hashtagProcesamiento de video

hashtagCámara lenta

hashtagScript de cámara lenta

hashtagProcesamiento por lotes

hashtagAjustes de calidad

hashtagVersiones del modelo

hashtagModo UHD

hashtagOptimización de memoria

hashtagPara VRAM limitada

hashtagReducir memoria

hashtagRendimiento

hashtagSolución de problemas

hashtagArtefactos/Fantasmeo

hashtagMemoria insuficiente

hashtagProcesamiento lento

hashtagDetección de escenas

hashtagEstimación de costos

hashtagPróximos pasos

Alquilar en CLORE.AI

Accede a tu servidor

¿Qué es RIFE?

Despliegue rápido

Instalación

Opción 1: Paquete de Python

Opción 2: Desde el código fuente

Uso básico

Duplicar la tasa de fotogramas

4x Tasa de fotogramas

8x Tasa de fotogramas

API de Python

Cargar modelo

Interpolar fotograma único

Procesar video

Usando rife-ncnn-vulkan

Procesamiento de video

Cámara lenta

Script de cámara lenta

Procesamiento por lotes

Ajustes de calidad

Versiones del modelo

Modo UHD

Optimización de memoria

Para VRAM limitada

Reducir memoria

Rendimiento

Solución de problemas

Artefactos/Fantasmeo

Memoria insuficiente

Procesamiento lento

Detección de escenas

Estimación de costos

Próximos pasos