> 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

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

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

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

1. Перейдите на [маркетплейс CLORE.AI](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.11.0-cuda12.8-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

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

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

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

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

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

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

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

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

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

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

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

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

* Используйте обнаружение сцен, чтобы пропускать склейки
* Уменьшите коэффициент интерполяции
* Проверьте наличие быстрого движения

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

* Используйте версию NCNN
* Обрабатывайте в меньшем разрешении, затем масштабируйте
* Уменьшите размер пакета

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

* Используйте версию NCNN-Vulkan
* Включите ускорение GPU
* Используйте меньшую модель

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

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

```python
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*](https://clore.ai/marketplace) *актуальные тарифы.*

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

* Используйте **Spot** рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана \~13% скидки), остальные совпадают с ними
* Платите **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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.