# Restauration de visage GFPGAN

Restaurer et améliorer les visages sur les photos avec GFPGAN.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Qu'est-ce que GFPGAN ?

GFPGAN (Generative Facial Prior GAN) est spécialisé dans :

* Restaurer les photos anciennes/endommagées
* Améliorer les visages flous
* Améliorer les visages générés par l'IA
* Corriger les portraits en basse résolution

## Déploiement rapide

**Image Docker :**

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

**Ports :**

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

**Commande :**

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

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Utilisation en ligne de commande (CLI)

### Installation

```bash
pip install gfpgan
```

### Télécharger des modèles

```bash

# Télécharger le modèle de restauration de visages
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/GFPGANv1.4.pth -P ./models

# Télécharger le modèle de détection
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/detection_Resnet50_Final.pth -P ./models

# Télécharger le modèle de parsing
wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/parsing_parsenet.pth -P ./models
```

### Utilisation de base

```bash

# Restaurer une image unique
python inference_gfpgan.py -i input.jpg -o results -v 1.4 -s 2

# Restaurer un dossier
python inference_gfpgan.py -i ./inputs -o ./results -v 1.4 -s 2
```

### Options

```bash
python inference_gfpgan.py \
    -i input.jpg \      # Image/dossier d'entrée
    -o results \        # Dossier de sortie
    -v 1.4 \            # Version de GFPGAN (1.2, 1.3, 1.4)
    -s 2 \              # Facteur d'agrandissement
    --bg_upsampler realesrgan \  # Sur-échantillonneur d'arrière-plan
    --only_center_face  # Restaurer uniquement le visage central
```

## API Python

### Restauration de visage basique

```python
from gfpgan import GFPGANer
import cv2

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

# Charger l'image
img = cv2.imread('photo.jpg')

# Restaurer les visages
cropped_faces, restored_faces, restored_img = restorer.enhance(
    img,
    has_aligned=False,
    only_center_face=False,
    paste_back=True
)

# Enregistrer le résultat
cv2.imwrite('restored.jpg', restored_img)
```

### Avec amélioration de l'arrière-plan

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

# Configurer le sur-échantillonneur d'arrière-plan
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
)

# Configurer le restaurateur de visages avec amélioration de l'arrière-plan
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    arch='clean',
    channel_multiplier=2,
    bg_upsampler=bg_upsampler
)

# Traitement
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)
```

### Traiter uniquement les visages (sans recoller)

```python

# Obtenir les visages restaurés individuellement
cropped_faces, restored_faces, _ = restorer.enhance(
    img,
    has_aligned=False,
    only_center_face=False,
    paste_back=False
)

# Enregistrer chaque visage séparément
for i, face in enumerate(restored_faces):
    cv2.imwrite(f'face_{i}.jpg', face)
```

## Traitement par lots

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

CodeFormer est un autre excellent restaurateur de visages :

```python

# Installation
pip install codeformer-pip

# Utilisation
from codeformer import CodeFormer
import cv2

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

## Restauration de visages vidéo

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

restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=1,  # Conserver la taille d'origine pour la vidéo
    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)  # Conserver l'original si la restauration échoue

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

## Serveur 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")

# Lancer : uvicorn server:app --host 0.0.0.0 --port 8000
```

## Versions du modèle

| Version | Qualité   | Vitesse        | Remarques        |
| ------- | --------- | -------------- | ---------------- |
| v1.4    | Meilleur  | Moyen          | Recommandé       |
| v1.3    | Excellent | Rapide         | Bon équilibre    |
| v1.2    | Bon       | Le plus rapide | Ancienne version |

## Cas d'utilisation

### Restauration de vieilles photos

```python

# Meilleurs réglages pour les vieilles photos
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=4,  # Agrandissement plus élevé pour les vieilles photos basse résolution
    bg_upsampler=bg_upsampler
)
```

### Amélioration d'art IA

```python

# Pour les images générées par IA avec artefacts faciaux
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=1,  # Conserver la taille d'origine
    only_center_face=True  # Se concentrer sur le visage principal
)
```

### Photos de groupe

```python

# Traiter tous les visages dans une photo de groupe
restorer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=2,
    only_center_face=False  # Traiter TOUS les visages
)
```

## Performances

| Taille de l'image | Visages | GPU      | Temps  |
| ----------------- | ------- | -------- | ------ |
| 512x512           | 1       | RTX 3090 | \~0.2s |
| 1024x1024         | 1       | RTX 3090 | \~0.3s |
| 1024x1024         | 5       | RTX 3090 | \~0.8s |
| 2048x2048         | 1       | RTX 4090 | \~0.3s |

## Dépannage

### Aucun visage détecté

```python

# Abaisser le seuil de détection
from gfpgan.utils import GFPGANer

# Ou recadrer manuellement la zone du visage d'abord
```

### Résultats trop lissés

* Utiliser CodeFormer avec un poids de fidélité plus faible
* Mélanger avec l'original en utilisant la composition alpha

### Problèmes de VRAM

```python

# Utiliser le CPU pour la détection des visages
import torch
torch.cuda.empty_cache()

# Traiter les visages un par un
only_center_face=True
```

## Estimation des coûts

Tarifs typiques du marché CLORE.AI (à partir de 2024) :

| GPU       | Tarif horaire | Tarif journalier | Session de 4 heures |
| --------- | ------------- | ---------------- | ------------------- |
| 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             |

*Les prix varient selon le fournisseur et la demande. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

**Économisez de l'argent :**

* Utilisez **Spot** market pour les charges de travail flexibles (souvent 30-50 % moins cher)
* Payer avec **CLORE** jetons
* Comparer les prix entre différents fournisseurs

## Prochaines étapes

* [Upscaling Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling)
* Stable Diffusion WebUI
* [Génération vidéo IA](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ai-video-generation)