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

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

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

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

Аренда на CLORE.AI

1. Перейдите на маркетплейс CLORE.AI

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.11.0-cuda12.8-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

# Результат: FPS в 2 раза выше

Увеличить частоту кадров в 4 раза

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

# Результат: FPS в 4 раза выше

Увеличить частоту кадров в 8 раз

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

# Результат: FPS в 8 раз выше

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 кадров/с, 10 секунд = 300 кадров

# 8-кратная интерполяция: 2400 кадров

# Воспроизведение при 30 кадрах/с: 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"Готово: {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	FPS после 2-кратной интерполяции
1080p	RTX 3090	~60 кадров/с
1080p	RTX 4090	~100 кадров/с
4K	RTX 3090	~15 кадров/с
4K	RTX 4090	~30 кадров/с

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

Артефакты/шлейфы

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

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

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

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

• Используйте версию NCNN

• Обрабатывайте в меньшем разрешении, затем масштабируйте

• Уменьшите размер пакета

Медленная обработка

• Используйте версию NCNN-Vulkan

• Включите ускорение GPU

• Используйте меньшую модель

Обнаружение сцен

Пропускайте интерполяцию на склейках сцен:

from scenedetect import detect, ContentDetector

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

# Не интерполировать между сценами
for scene in scenes:
    print(f"Сцена: {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 40 ГБ	~$0.17	~$4.00	~$0.70
A100 80 ГБ	~$0.25	~$6.00	~$1.00

Цены зависят от провайдера и спроса. Проверьте маркетплейс CLORE.AI актуальные тарифы.

Сэкономьте деньги:

• Используйте Spot рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана ~13% скидки), остальные совпадают с ними

• Платите CLORE токенами

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

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

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

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

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