> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-video/rife-interpolation.md).

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

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

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Аренда на CLORE.AI

1. Посетите [CLORE.AI Marketplace](https://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
```

**Команда:**

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

## Установка

### Вариант 1: пакет Python

```bash
pip install rife-ncnn-vulkan-python
```

### Вариант 2: из исходников

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

## Базовое использование

### Удвоение частоты кадров

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

# Выход: 2x FPS
```

### 4x Частота кадров

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

# Выход: 4x FPS
```

### 8x Частота кадров

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

# Выход: 8x FPS
```

## Python API

### Загрузить модель

```python
import torch
from model.RIFE import Model

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

### Интерполировать одиночный кадр

```python
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)
```

### Обработать видео

```python
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:

```python
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')
```

### Обработка видео

```python
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()
```

## Замедленное воспроизведение

Создание плавного замедленного движения:

```python

# Оригинал: 30 fps, 10 секунд = 300 кадров

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

# Воспроизведение при 30 fps: 80 секунд (в 8 раз медленнее)

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

# Это создаёт в 8 раз больше кадров, воспроизводите с оригинальным FPS для замедленного эффекта
```

### Скрипт для замедления

```python
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()
```

## Пакетная обработка

```python
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 и выше:

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

## Оптимизация памяти

### Для ограниченной видеопамяти (VRAM)

```python

# Обрабатывать по плиткам
from model.RIFE import Model

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

# Установить размер плитки для больших кадров

# model.inference самостоятельно обрабатывает разбиение на плитки
```

### Сократить использование памяти

```bash

# Используйте версию 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
* Используйте меньшую модель

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

Пропускать интерполяцию через смены сцен:

```python
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*](https://clore.ai/marketplace) *для текущих тарифов.*

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

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **CLORE** токенов
* Сравнивайте цены у разных провайдеров

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

* [FFmpeg NVENC](/guides/guides_v2-ru/obrabotka-video/ffmpeg-nvenc.md) - Кодировать выход
* [Real-ESRGAN](/guides/guides_v2-ru/obrabotka-izobrazhenii/real-esrgan-upscaling.md) - Масштабировать видео
* [Генерация видео с помощью ИИ](/guides/guides_v2-ru/generaciya-video/ai-video-generation.md) - Генерировать видео


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/obrabotka-video/rife-interpolation.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.