Интерполяция RIFE

Увеличивайте частоту кадров видео с интерполяцией RIFE AI на Clore.ai

Увеличьте частоту кадров видео с помощью интерполяции RIFE AI.

Все примеры можно запускать на GPU-серверах, арендуемых через CLORE.AI Marketplace.

Аренда на CLORE.AI

1. Посетите CLORE.AI Marketplace

2. Отфильтруйте по типу GPU, объему VRAM и цене

3. Выберите On-Demand (фиксированная ставка) или Spot (цена по ставке)

4. Настройте ваш заказ:

   • Выберите Docker-образ

   • Установите порты (TCP для SSH, HTTP для веб-интерфейсов)

   • Добавьте переменные окружения при необходимости

   • Введите команду запуска

5. Выберите способ оплаты: CLORE, BTC, или USDT/USDC

6. Создайте заказ и дождитесь развертывания

Доступ к вашему серверу

• Найдите данные для подключения в Моих заказах

• Веб-интерфейсы: используйте URL HTTP-порта

• 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: пакет Python

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 секунд (в 8 раз медленнее)

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

# Это создаёт в 8 раз больше кадров, воспроизводите с оригинальным 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

Устранение неполадок

Артефакты/Двойные контуры (Ghosting)

• Используйте обнаружение сцен, чтобы пропускать резкие смены

• Уменьшите коэффициент интерполяции

• Проверьте наличие быстрого движения

Недостаточно памяти

• Используйте версию 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 Marketplace для текущих тарифов.

Экономьте деньги:

• Используйте Spot рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)

• Платите с помощью CLORE токенов

• Сравнивайте цены у разных провайдеров

Дальнейшие шаги

• FFmpeg NVENC - Кодировать выход

• Real-ESRGAN - Масштабировать видео

• Генерация видео с помощью ИИ - Генерировать видео