# Как улучшить качество видео нейросетью на GPU: апскейл, интерполяция кадров и настройка пайплайна

> AI Release · @ai_release1 · https://ai-release.org/guides/kak-uluchshit-kachestvo-video-neyrosetyu-na-gpu-apskeyl.html

## TL;DR
- Время выполнения: 40–60 минут на настройку и прогон 10-секундного теста (полный рендер считается отдельно и зависит от длины ролика)
- Уровень сложности: Intermediate
- Понадобится: GPU NVIDIA с рабочим драйвером (`nvidia-smi`), FFmpeg и ffprobe одной сборки, фильтры `scale`, `hqdn3d`, `minterpolate` (`ffmpeg -filters`), энкодер NVENC (`ffmpeg -encoders`), ~20 ГБ свободного места, тестовый отрезок 10 секунд

## Требования и подготовка
![Иллюстрация к разделу «Требования и подготовка»](https://ai-release.org/guides/img/kak-uluchshit-kachestvo-video-neyrosetyu-na-gpu-apskeyl-ru-1.jpg?v=1795121334)


Два факта ломают типовой план «включил GPU — стало быстро». Первый: в FFmpeg фильтр интерполяции кадров `minterpolate` считается на CPU, GPU при этом занят только декодированием и кодированием, поэтому «ускорение на видеокарте» к нему не применяется. Второй: апскейл не восстанавливает информацию — он достраивает пиксели по правилу, и если в исходнике лицо сжато в кашу на 360p, никакой алгоритм не вернёт из него поры.

- ОС: Windows 10/11 или Linux x86_64.
- Драйвер NVIDIA, установленный и рабочий. Проверка: `nvidia-smi` печатает таблицу с именем GPU, объёмом памяти и версией драйвера.
- FFmpeg + ffprobe из одной сборки (смешанные сборки дают расхождения по доступным фильтрам). Установка — через пакетный менеджер вашей ОС; сверьтесь с документацией FFmpeg по своей платформе.
- Свободное место: считайте по арифметике. Один кадр 1920×1080 в RGB — 1920×1080×3 ≈ 6,2 МБ до сжатия; минута при 24 fps — это 1440 кадров, то есть десятки гигабайт под промежуточную PNG-последовательность.
- Права на запись в рабочую папку, например `D:\video\work` или `~/video/work`.

Проверка окружения — четыре команды:

```bash
ffmpeg -version
ffmpeg -hwaccels
ffmpeg -filters | grep -E "minterpolate|hqdn3d|scale"
ffmpeg -encoders | grep nvenc
```

**Пример вывода последней команды:**

```text
 V....D h264_nvenc           NVIDIA NVENC H.264 encoder
 V....D hevc_nvenc           NVIDIA NVENC HEVC encoder
```

Если строки `nvenc` нет — у вас сборка без NVENC, и шаги с `-c:v hevc_nvenc` нужно заменить на `-c:v libx264` (медленнее, но работает). Имена пресетов NVENC (`p1`…`p7`) зависят от версии FFmpeg: сверьтесь с выводом `ffmpeg -h encoder=hevc_nvenc`.

**Что чинится каким этапом — и где НЕ работает:**

| Симптом в исходнике | Инструмент | Где это НЕ поможет |
|---|---|---|
| Малое разрешение, «мыло» | `scale:flags=lanczos` или внешний нейросетевой апскейлер | потерянный текст, мелкие лица, водяные знаки |
| Рваное движение при 24→60 fps | `minterpolate` | быстрое движение, титры, склейки кадров |
| Шум и блочность компрессии | `hqdn3d` до апскейла | если битрейт убит полностью, детали уже потеряны |
| Апскейл «звенит» по контурам | снижение резкости после масштабирования | не убирает исходную блочность |

## Шаг 1. Аудит исходника и GPU: что вообще имеет смысл улучшать

**Что сделать:** снять паспорт файла через ffprobe — разрешение, fps, кодек, пиксельный формат, битрейт; отдельно зафиксировать состояние GPU. Затем отрезать 10-секундный тестовый фрагмент и дальше работать только с ним.

**Зачем:** параметры исходника определяют, какой этап даст эффект, а какой сожжёт часы впустую. Битрейт ниже примерно 1–2 Мбит/с на 1080p означает, что детали уже уничтожены кодеком — и апскейл будет увеличивать артефакты вместе с картинкой.

**Как проверить:** в выводе ffprobe должны появиться все запрошенные поля, а `r_frame_rate` совпасть с тем, что вы видите в плеере.

```bash
ffprobe -v error -select_streams v:0 ^
 -show_entries stream=codec_name,width,height,r_frame_rate,avg_frame_rate,pix_fmt,bit_rate ^
 -of default=noprint_wrappers=1 input.mp4
```

**Пример вывода:**

```text
codec_name=h264
width=1280
height=720
pix_fmt=yuv420p
r_frame_rate=24/1
avg_frame_rate=24/1
bit_rate=1800000
```

Читается так: 720p, 24 кадра/с, H.264, 1,8 Мбит/с — рабочий кандидат на апскейл до 1920×1080. На Windows используйте `^` для переноса строк в `cmd` или обратный апостроф в PowerShell.

Теперь GPU:

```bash
nvidia-smi --query-gpu=name,memory.total,driver_version --format=csv
```

**Пример вывода:** `NVIDIA GeForce RTX 3060, 12288 MiB, 5xx.xx`. Точную матрицу поддержки кодеков и 10-битного энкода сверьте с документацией NVIDIA для своей карты.

Тестовый отрезок (первые 10 секунд, без перекодирования):

```bash
ffmpeg -ss 00:00:10 -i input.mp4 -t 10 -c copy clip.mp4
```

`-ss` до `-i` — быстрый переход по ключевому кадру; `-c copy` не трогает видео. Если этот фрагмент выглядит «дёргано» на склейке — сдвиньте `-ss` на пару секунд.

Если до апскейла нужно вырезать лишние куски, удобнее сделать это заранее — см. [как обрезать видео без потери качества в FFmpeg GUI](https://ai-release.org/guides/kak-obrezat-video-bez-poteri-kachestva-v-ffmpeg-gui-na.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

## Шаг 2. Сборка пайплайна: денойз → апскейл → интерполяция → энкод

**Что сделать:** собрать цепочку из четырёх стадий и прогнать её на `clip.mp4` в двух порядках — «интерполяция до апскейла» и «после» — замерив время. Порядок стадий — главный рычаг производительности, потому что `minterpolate` работает на CPU и его стоимость растёт вместе с числом пикселей.

**Зачем:** денойз до апскейла убирает блочность, которую апскейлер иначе увеличит. Интерполяция до апскейла обрабатывает меньше пикселей, но апскейлер потом получает вдвое больше кадров — поэтому решать нужно замером, а не на глаз.

**Как проверить:** каждый прогон печатает строку `bench:` с `utime`/`rtime`; сравните `rtime` двух вариантов.

Стадия 1 — базовый вариант без нейросети (денойз + масштаб + энкод):

```bash
ffmpeg -y -i clip.mp4 -vf "hqdn3d=2:1.5:3:3,scale=1920:1080:flags=lanczos" ^
 -c:v hevc_nvenc -preset p5 -cq 19 -pix_fmt yuv420p ^
 -c:a copy -benchmark step1_upscale.mp4
```

`hqdn3d=2:1.5:3:3` — пространственный и временной денойз (порядок: яркость, цветность, яркость во времени, цветность во времени). `flags=lanczos` — ресемплинг с более резким результатом, чем билинейный. `-cq 19` — режим постоянного качества NVENC; меньше число — выше качество и битрейт.

Стадия 2 — интерполяция до 60 fps:

```bash
ffmpeg -y -i step1_upscale.mp4 -vf "minterpolate=fps=60:mi_mode=mci:mc_mode=aobmc:me_mode=bidir:vsbmc=1:scd=fdiff" ^
 -c:v hevc_nvenc -preset p5 -cq 19 -pix_fmt yuv420p -c:a copy -benchmark step2_60fps.mp4
```

`mi_mode=mci` — оценка движения и компенсация, `mc_mode=aobmc` — сглаживание границ блоков, `me_mode=bidir` — поиск движения в обе стороны, `scd=fdiff` — детектор смены сцен. Без детектора сцен на склейках появятся «каша» и двойные контуры. Порог детектора настраивается отдельным параметром — сверьтесь с документацией по `minterpolate`.

Стадия 3 — нейросетевой апскейл вместо `scale`. FFmpeg здесь выступает транспортом: разбирает видео на кадры и собирает обратно. Команда апскейлера зависит от выбранного проекта — сверьтесь с его документацией; ниже плейсхолдер, а не рабочий синтаксис.

```bash
mkdir -p frames up
ffmpeg -y -i clip.mp4 -vsync 0 frames/%06d.png
<команда-апскейлера> --input frames --output up --scale 2
ffmpeg -y -framerate 24 -i up/%06d.png -i clip.mp4 -map 0:v -map 1:a ^
 -c:v hevc_nvenc -preset p5 -cq 19 -pix_fmt yuv420p10le -c:a copy step3_neural.mp4
```

`-vsync 0` отключает дублирование/выбрасывание кадров при разборе — иначе нумерация PNG разъедется с таймлайном. `-framerate 24` обязан совпадать с `r_frame_rate` из Шага 1: иначе видео ускорится или замедлится. `-pix_fmt yuv420p10le` даёт 10-битную глубину и меньше бандинга на градиентах; поддержку 10-битного энкода проверьте для своей карты, иначе оставьте `yuv420p`.

**Пример:** на 10-секундном 720p-фрагменте вариант «интерполяция → апскейл» даёт вдвое больше кадров на входе апскейлера, а вариант «апскейл → интерполяция» — вчетверо больше пикселей на входе `minterpolate`. Какой из них быстрее у вас — покажет только `benchmark`.

## Шаг 3. Проверка результата
![Иллюстрация к разделу «Шаг 3. Проверка результата»](https://ai-release.org/guides/img/kak-uluchshit-kachestvo-video-neyrosetyu-na-gpu-apskeyl-ru-3.jpg?v=1795121347)


**Что сделать:** проверить, что разрешение и fps действительно изменились, что файл декодируется без ошибок, и что интерполяция не испортила склейки.

**Зачем:** NVENC при нехватке памяти или несовместимом пиксельном формате может молча выдать файл с другим fps или оборванным концом — глазами на превью это не видно.

**Как проверить:** три команды подряд.

```bash
ffprobe -v error -select_streams v:0 -count_frames ^
 -show_entries stream=width,height,r_frame_rate,nb_read_frames,pix_fmt ^
 -of default=noprint_wrappers=1 step3_neural.mp4
```

**Пример успешного вывода:**

```text
width=1920
height=1080
pix_fmt=yuv420p10le
r_frame_rate=60/1
nb_read_frames=600
```

Сверьте арифметику: 10 секунд × 60 fps = 600 кадров. Если `nb_read_frames` меньше — часть кадров потерялась на этапе PNG или при энкоде.

Проверка целостности (пустой вывод = ошибок декодирования нет):

```bash
ffmpeg -v error -i step3_neural.mp4 -f null -
```

Сравнение с исходником по SSIM (структурное сходство; SSIM требует одинакового размера кадров, поэтому результат сначала приводят к разрешению источника):

```bash
ffmpeg -i step3_neural.mp4 -i clip.mp4 -lavfi "[0:v]scale=1280:720,format=yuv420p[a];[1:v]format=yuv420p[b];[a][b]ssim" -f null -
```

В строке появится `SSIM ... All:<число>`. Абсолютного «правильного» порога нет: сравнивайте между собой два своих варианта (нейросеть против `lanczos`) и смотрите, какой выше. Методику сравнения метрик без самообмана разбирает [гайд по тестированию и оценке качества ИИ-моделей](https://ai-release.org/guides/kak-testirovat-i-otsenivat-kachestvo-ii-modeley-gayd-po.html?utm_source=tg&utm_medium=channel&utm_campaign=guide_inline&utm_content=guide_to_guide).

Финальный чек-лист перед полным рендером:

- [ ] `r_frame_rate` в результате равен целевому, `nb_read_frames` совпадает с расчётом
- [ ] `ffmpeg -v error -i out.mp4 -f null -` ничего не печатает
- [ ] звук на месте и не разъехался (`-c:a copy` и `-map 1:a` из Шага 2)
- [ ] на склейках и титрах нет двойных контуров
- [ ] SSIM вашего варианта не ниже, чем у варианта-конкурента на том же клипе
- [ ] свободное место позволяет полный прогон (для PNG-пути — десятки гигабайт)

## Возможные проблемы и решения

**Проблема. Энкодер NVENC недоступен, рендер падает сразу.**

- Ошибка: `Unknown encoder 'hevc_nvenc'`
- Причина: сборка FFmpeg без NVENC либо драйвер не видит карту.
- Решение: проверьте `ffmpeg -encoders | grep nvenc` и `nvidia-smi`. Если список пуст — поставьте сборку с поддержкой NVENC (сверьтесь с документацией FFmpeg по своей платформе) или временно перейдите на CPU-энкод: замените `-c:v hevc_nvenc -preset p5 -cq 19` на `-c:v libx264 -crf 19 -preset medium`.

**Проблема. Фильтр не принимает кадры после включения аппаратного декодирования.**

- Ошибка: `Impossible to convert between the formats supported by the filter 'graph 0 input from stream 0:0' and the filter 'auto_scale_0'`
- Причина: вы добавили `-hwaccel cuda`, но следующий фильтр (`hqdn3d`, `minterpolate`) работает в системной памяти, а кадры остались в памяти GPU.
- Решение: либо уберите `-hwaccel cuda` и декодируйте на CPU, либо верните кадры в системную память перед CPU-фильтром: `-hwaccel cuda -hwaccel_output_format cuda -vf "hwdownload,format=nv12,hqdn3d=2:1.5:3:3,scale=1920:1080:flags=lanczos"`. Набор GPU-фильтров зависит от сборки — проверьте `ffmpeg -filters | grep -i cuda`.

**Проблема. Апскейл падает на нечётном разрешении.**

- Ошибка: `width not divisible by 2 (1921x1081)`
- Причина: `yuv420p` — цветовой формат с прореживанием цветности, он требует чётных ширины и высоты, а коэффициент масштабирования дал нечётное значение.
- Решение: задайте чётные размеры явно, например `scale=1920:1080:flags=lanczos` вместо множителя, либо округлите через `scale=trunc(iw*1.5/2)*2:trunc(ih*1.5/2)*2:flags=lanczos`.

## Резюме и следующие шаги

Рабочий пайплайн — это аудит исходника через ffprobe, затем денойз, апскейл и интерполяция с обязательным замером `benchmark` на 10-секундном отрезке и финальной проверкой через `ffprobe -count_frames` и SSIM. Полный рендер запускайте только после того, как чек-лист из Шага 3 пройден на тестовом фрагменте.

## FAQ

**Почему при апскейле на GPU видеокарта загружена не полностью?**
Потому что фильтр интерполяции `minterpolate` в FFmpeg считается на CPU. GPU в этой цепочке работает только на декодировании и кодировании, поэтому узкое место — процессор. Проверьте это через `-benchmark`: высокий `rtime` при низкой загрузке GPU в `nvidia-smi dmon` подтверждает диагноз.

**Можно ли апскейлить видео без нейросети?**
Да. `scale=1920:1080:flags=lanczos` даёт более резкий результат, чем билинейный ресемплинг, но принципиально это интерполяция пикселей: новых деталей не появляется. Нейросетевой апскейлер подключается отдельным процессом через PNG-последовательность (Шаг 2), и его команда зависит от выбранного проекта — сверьтесь с документацией.

**Почему после интерполяции на склейках каша?**
Скорее всего не включён детектор смены сцен. Добавьте в фильтр `scd=fdiff`: на резкой смене плана алгоритм не будет искать движение между несвязанными кадрами. Порог детектора настраивается отдельным параметром — сверьтесь с документацией по `minterpolate`.

**Сколько места нужно для промежуточных кадров?**
Считайте по арифметике: 1920×1080×3 байта ≈ 6,2 МБ на кадр в RGB. Минута при 24 fps — 1440 кадров, то есть порядка десятков гигабайт. Если места мало, режьте ролик на части по 30–60 секунд и собирайте результат конкатенацией.
