# Восстановление лиц GFPGAN

Восстановление и улучшение лиц на фотографиях с помощью GFPGAN.

{% 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>`

## Что такое GFPGAN?

GFPGAN (Generative Facial Prior GAN) специализируется на:

* Восстановлении старых/повреждённых фотографий
* Улучшении размытых лиц
* Улучшении лиц, сгенерированных ИИ
* Исправлении портретов низкого разрешения

## Быстрое развертывание

**Docker-образ:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime
```

**Порты:**

```
22/tcp
7860/http
```

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

```bash
pip install gfpgan gradio && \
python -c "
import gradio as gr
from gfpgan import GFPGANer
import cv2
import numpy as np

restorer = GFPGANer(
    model_path='https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2,
    bg_upsampler=None
)

def restore(image):
    img = np.array(image)
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
    _, _, output = restorer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
    output = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
    return output

demo = gr.Interface(fn=restore, inputs=gr.Image(), outputs=gr.Image(), title='GFPGAN Face Restorer')
demo.launch(server_name='0.0.0.0', server_port=7860)
"
```

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

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

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

### Установка

```bash
pip install gfpgan
```

### Загрузка моделей

```bash

# Скачайте модель для восстановления лиц
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/GFPGANv1.4.pth -P ./models

# Скачайте модель детекции
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/detection_Resnet50_Final.pth -P ./models

# Скачайте модель парсинга
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/parsing_parsenet.pth -P ./models
```

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

```bash

# Восстановление одного изображения
python inference_gfpgan.py -i input.jpg -o results -v 1.4 -s 2

# Восстановление папки
python inference_gfpgan.py -i ./inputs -o ./results -v 1.4 -s 2
```

### Параметры

```bash
python inference_gfpgan.py \
    -i input.jpg \      # Входное изображение/папка
    -o results \        # Папка вывода
    -v 1.4 \            # Версия GFPGAN (1.2, 1.3, 1.4)
    -s 2 \              # Коэффициент увеличения
    --bg_upsampler realesrgan \  # Апскейлер фона
    --only_center_face  # Восстанавливать только центральное лицо
```

## Python API

### Базовое восстановление лиц

```python
from gfpgan import GFPGANer
import cv2

# Инициализация
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2,
    bg_upsampler=None
)

# Загрузить изображение
img = cv2.imread('photo.jpg')

# Восстановить лица
cropped_faces, restored_faces, restored_img = restorer.enhance(
    img,
    has_aligned=False,
    only_center_face=False,
    paste_back=True
)

# Сохранить результат
cv2.imwrite('restored.jpg', restored_img)
```

### С улучшением фона

```python
from gfpgan import GFPGANer
from realesrgan import RealESRGANer
from basicsr.archs.rrdbnet_arch import RRDBNet
import cv2

# Настроить апскейлер фона
bg_model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=2)
bg_upsampler = RealESRGANer(
    scale=2,
    model_path='RealESRGAN_x2plus.pth',
    model=bg_model,
    half=True
)

# Настроить восстановитель лиц с улучшением фона
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2,
    bg_upsampler=bg_upsampler
)

# Обработка
img = cv2.imread('old_photo.jpg')
_, _, output = restorer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
cv2.imwrite('enhanced.jpg', output)
```

### Обработка только лиц (без возвращения на изображение)

```python

# Получить отдельные восстановленные лица
cropped_faces, restored_faces, _ = restorer.enhance(
    img,
    has_aligned=False,
    only_center_face=False,
    paste_back=False
)

# Сохранить каждое лицо отдельно
for i, face in enumerate(restored_faces):
    cv2.imwrite(f'face_{i}.jpg', face)
```

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

```python
import os
from gfpgan import GFPGANer
import cv2
from tqdm import tqdm

restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2
)

input_dir = './old_photos'
output_dir = './restored'
os.makedirs(output_dir, exist_ok=True)

for filename in tqdm(os.listdir(input_dir)):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
        img = cv2.imread(os.path.join(input_dir, filename))

        try:
            _, _, output = restorer.enhance(
                img,
                has_aligned=False,
                only_center_face=False,
                paste_back=True
            )
            cv2.imwrite(os.path.join(output_dir, filename), output)
        except Exception as e:
            print(f"Failed: {filename} - {e}")
```

## CodeFormer (Альтернатива)

CodeFormer — ещё один отличный восстановитель лиц:

```python

# Установка
pip install codeformer-pip

# Пример использования
from codeformer import CodeFormer
import cv2

restorer = CodeFormer()
img = cv2.imread('blurry_face.jpg')
result = restorer.restore(img)
cv2.imwrite('restored.jpg', result)
```

## Восстановление лиц в видео

```python
import cv2
from gfpgan import GFPGANer
from tqdm import tqdm

restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=1,  # Сохранить оригинальный размер для видео
    arch='clean',
    channel_multiplier=2
)

cap = cv2.VideoCapture('video.mp4')
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))
total = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

out = cv2.VideoWriter('restored_video.mp4', cv2.VideoWriter_fourcc(*'mp4v'), fps, (width, height))

for _ in tqdm(range(total)):
    ret, frame = cap.read()
    if not ret:
        break

    try:
        _, _, restored = restorer.enhance(frame, paste_back=True)
        out.write(restored)
    except:
        out.write(frame)  # Сохранить оригинал, если восстановление не удалось

cap.release()
out.release()
```

## API-сервер

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import Response
from gfpgan import GFPGANer
import cv2
import numpy as np

app = FastAPI()

restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2
)

@app.post("/restore")
async def restore_face(file: UploadFile, upscale: int = 2):
    contents = await file.read()
    nparr = np.frombuffer(contents, np.uint8)
    img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)

    _, _, output = restorer.enhance(img, paste_back=True)

    _, encoded = cv2.imencode('.jpg', output)
    return Response(content=encoded.tobytes(), media_type="image/jpeg")

# Запуск: uvicorn server:app --host 0.0.0.0 --port 8000
```

## Версии модели

| Версия | Качество | Скорость      | Примечания     |
| ------ | -------- | ------------- | -------------- |
| v1.4   | Лучшее   | Средне        | Рекомендуется  |
| v1.3   | Отлично  | Быстро        | Хороший баланс |
| v1.2   | Хорошо   | Самая быстрая | Устаревшая     |

## Сценарии использования

### Восстановление старых фотографий

```python

# Лучшие настройки для старых фотографий
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=4,  # Большее увеличение для старых фото с низким разрешением
    bg_upsampler=bg_upsampler
)
```

### Улучшение арта ИИ

```python

# Для изображений, сгенерированных ИИ, с артефактами лиц
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=1,  # Сохранить оригинальный размер
    only_center_face=True  # Сосредоточиться на главном лице
)
```

### Групповые фотографии

```python

# Обработать все лица на групповой фотографии
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    only_center_face=False  # Обработать ВСЕ лица
)
```

## Производительность

| Размер изображения | Лица | GPU      | Время   |
| ------------------ | ---- | -------- | ------- |
| 512x512            | 1    | RTX 3090 | \~0.2s  |
| 1024x1024          | 1    | RTX 3090 | \~0.3 с |
| 1024x1024          | 5    | RTX 3090 | \~0.8s  |
| 2048x2048          | 1    | RTX 4090 | \~0.3 с |

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

### Лицо не обнаружено

```python

# Понизить порог детекции
from gfpgan.utils import GFPGANer

# Или вручную обрезать область лица заранее
```

### Переусреднённые результаты

* Используйте CodeFormer с меньшим весом fidelity
* Смешайте с оригиналом с помощью альфа-композитинга

### Проблемы с VRAM

```python

# Использовать CPU для детекции лиц
import torch
torch.cuda.empty_cache()

# Обрабатывать лица по одному
only_center_face=True
```

## Оценка стоимости

Типичные ставки на маркетплейсе 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** токенов
* Сравнивайте цены у разных провайдеров

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

* [Апскейл с помощью Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/real-esrgan-upscaling)
* Stable Diffusion WebUI
* [Генерация видео с помощью ИИ](https://docs.clore.ai/guides/guides_v2-ru/generaciya-video/ai-video-generation)