# Восстановление лиц 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)


---

# Agent Instructions: 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-izobrazhenii/gfpgan-face-restore.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.