# Mise à l'échelle Real-ESRGAN

Agrandir et améliorer les images en utilisant Real-ESRGAN sur GPU.

{% 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 Real-ESRGAN ?

Real-ESRGAN est un modèle pratique de restauration d'image qui :

* Agrandit les images 2x-4x
* Supprime le bruit et les artefacts
* Améliore les détails
* Fonctionne sur les photos, l'anime et l'art

## Variantes de modèle

| Modèle                        | Idéal pour        | Vitesse        |
| ----------------------------- | ----------------- | -------------- |
| RealESRGAN\_x4plus            | Photos générales  | Moyen          |
| RealESRGAN\_x4plus\_anime\_6B | Anime/dessins     | Moyen          |
| RealESRGAN\_x2plus            | Agrandissement 2x | Rapide         |
| RealESRNet\_x4plus            | Traitement rapide | Le plus rapide |

## Déploiement rapide

**Image Docker :**

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

**Ports :**

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

**Commande :**

```bash
pip install realesrgan gradio && \
python -c "
import gradio as gr
from realesrgan import RealESRGANer
from basicsr.archs.rrdbnet_arch import RRDBNet
import numpy as np
from PIL import Image
import torch

# Charger le modèle
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(
    scale=4,
    model_path='https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth',
    model=model,
    tile=0,
    tile_pad=10,
    pre_pad=0,
    half=True
)

def upscale(image, scale):
    img = np.array(image)
    output, _ = upsampler.enhance(img, outscale=scale)
    return Image.fromarray(output)

demo = gr.Interface(
    fn=upscale,
    inputs=[gr.Image(type='pil'), gr.Slider(2, 4, value=4, step=1, label='Scale')],
    outputs=gr.Image(type='pil'),
    title='Real-ESRGAN Upscaler'
)
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 realesrgan
```

### Agrandissement de base

```bash

# Agrandir une image unique
python -m realesrgan -i input.jpg -o output.jpg -n RealESRGAN_x4plus -s 4

# Agrandir un dossier
python -m realesrgan -i ./inputs -o ./outputs -n RealESRGAN_x4plus -s 4
```

### Options

```bash
python -m realesrgan \
    -i input.jpg \           # Entrée
    -o output.jpg \          # Sortie
    -n RealESRGAN_x4plus \   # Nom du modèle
    -s 4 \                   # Facteur d'échelle
    --face_enhance \         # Activer l'amélioration des visages
    --fp32 \                 # Utiliser FP32 (plus de VRAM, meilleure qualité)
    --tile 400               # Taille des tuiles pour les grandes images
```

## API Python

### Utilisation de base

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

# Configuration du modèle
model = RRDBNet(
    num_in_ch=3,
    num_out_ch=3,
    num_feat=64,
    num_block=23,
    num_grow_ch=32,
    scale=4
)

upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=0,
    tile_pad=10,
    pre_pad=0,
    half=True  # Utiliser FP16
)

# Agrandir
img = cv2.imread('input.jpg', cv2.IMREAD_UNCHANGED)
output, _ = upsampler.enhance(img, outscale=4)
cv2.imwrite('output.jpg', output)
```

### Avec amélioration du visage

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

# Modèle Real-ESRGAN
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(scale=4, model_path='RealESRGAN_x4plus.pth', model=model, half=True)

# GFPGAN pour les visages
face_enhancer = GFPGANer(
    model_path='GFPGANv1.4.pth',
    upscale=4,
    arch='clean',
    channel_multiplier=2,
    bg_upsampler=upsampler
)

# Traitement
img = cv2.imread('portrait.jpg')
_, _, output = face_enhancer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
cv2.imwrite('output.jpg', output)
```

### Agrandissement Anime

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

# Modèle Anime
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=6, num_grow_ch=32, scale=4)

upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus_anime_6B.pth',
    model=model,
    half=True
)

img = cv2.imread('anime.png')
output, _ = upsampler.enhance(img, outscale=4)
cv2.imwrite('anime_upscaled.png', output)
```

## Traitement par lots

### Traiter un dossier

```python
import os
from realesrgan import RealESRGANer
from basicsr.archs.rrdbnet_arch import RRDBNet
import cv2
from tqdm import tqdm

# Configuration
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(scale=4, model_path='RealESRGAN_x4plus.pth', model=model, half=True)

input_dir = './inputs'
output_dir = './outputs'
os.makedirs(output_dir, exist_ok=True)

# Traiter toutes les images
for filename in tqdm(os.listdir(input_dir)):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
        img_path = os.path.join(input_dir, filename)
        img = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)

        output, _ = upsampler.enhance(img, outscale=4)

        output_path = os.path.join(output_dir, f"upscaled_{filename}")
        cv2.imwrite(output_path, output)
```

### Script Shell

```bash
#!/bin/bash
INPUT_DIR=$1
OUTPUT_DIR=$2

mkdir -p $OUTPUT_DIR

for file in $INPUT_DIR/*.{jpg,png,jpeg}; do
    if [ -f "$file" ]; then
        filename=$(basename "$file")
        python -m realesrgan -i "$file" -o "$OUTPUT_DIR/upscaled_$filename" -n RealESRGAN_x4plus -s 4
        echo "Traité : $filename"
    fi
done
```

## Traitement en tuiles (grandes images)

Pour les images qui ne rentrent pas dans la VRAM :

```python
upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,      # Traiter en tuiles de 400px
    tile_pad=10,   # Recouvrement entre les tuiles
    pre_pad=0,
    half=True
)
```

### Recommandations de taille de tuile

| VRAM  | Taille maximale de tuile |
| ----- | ------------------------ |
| 4 Go  | 200                      |
| 6 Go  | 300                      |
| 8 Go  | 400                      |
| 12Go  | 600                      |
| 24 Go | 0 (pas de tuilage)       |

## Amélioration vidéo (upscaling)

### Utilisation de Real-ESRGAN

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

# Configuration du modèle
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(scale=4, model_path='RealESRGAN_x4plus.pth', model=model, tile=400, half=True)

# Ouvrir la vidéo
cap = cv2.VideoCapture('input.mp4')
fps = cap.get(cv2.CAP_PROP_FPS)
width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) * 4
height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) * 4
total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))

# Sortie
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
out = cv2.VideoWriter('output.mp4', fourcc, fps, (width, height))

# Traiter les images
for _ in tqdm(range(total_frames)):
    ret, frame = cap.read()
    if not ret:
        break

    output, _ = upsampler.enhance(frame, outscale=4)
    out.write(output)

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

### Pipeline FFmpeg

```bash

# Extraire les images
ffmpeg -i input.mp4 -qscale:v 1 frames/frame_%06d.png

# Agrandir les images
python -m realesrgan -i frames -o upscaled -n RealESRGAN_x4plus -s 4

# Réassembler la vidéo
ffmpeg -framerate 30 -i upscaled/frame_%06d.png -c:v libx264 -pix_fmt yuv420p output.mp4

# Réincorporer l'audio
ffmpeg -i output.mp4 -i input.mp4 -c:v copy -c:a aac -map 0:v:0 -map 1:a:0 final.mp4
```

## Serveur API

### Serveur FastAPI

```python
from fastapi import FastAPI, UploadFile
from fastapi.responses import Response
from realesrgan import RealESRGANer
from basicsr.archs.rrdbnet_arch import RRDBNet
import cv2
import numpy as np
import io

app = FastAPI()

# Charger le modèle
model = RRDBNet(num_in_ch=3, num_out_ch=3, num_feat=64, num_block=23, num_grow_ch=32, scale=4)
upsampler = RealESRGANer(scale=4, model_path='RealESRGAN_x4plus.pth', model=model, tile=400, half=True)

@app.post("/upscale")
async def upscale(file: UploadFile, scale: int = 4):
    contents = await file.read()
    nparr = np.frombuffer(contents, np.uint8)
    img = cv2.imdecode(nparr, cv2.IMREAD_UNCHANGED)

    output, _ = upsampler.enhance(img, outscale=scale)

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

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

### Utilisation

```bash
curl -X POST "http://localhost:8000/upscale?scale=4" \
    -F "file=@input.jpg" \
    --output upscaled.png
```

## Comparaison des modèles

| Modèle            | Qualité  | Vitesse        | VRAM  | Idéal pour |
| ----------------- | -------- | -------------- | ----- | ---------- |
| x4plus            | Meilleur | Lent           | 4 Go+ | Photos     |
| x4plus\_anime\_6B | Meilleur | Moyen          | 3 Go+ | Anime      |
| x2plus            | Bon      | Rapide         | 2 Go+ | Rapide 2x  |
| RealESRNet        | OK       | Le plus rapide | 2 Go+ | Aperçus    |

## Performances

| Taille de l'image | GPU      | Temps pour agrandir x4 |
| ----------------- | -------- | ---------------------- |
| 512x512           | RTX 3090 | \~0.5s                 |
| 1024x1024         | RTX 3090 | \~1.5s                 |
| 2048x2048         | RTX 3090 | \~5s                   |
| 512x512           | RTX 4090 | \~0.3s                 |

## Dépannage

### CUDA Out of Memory

```python

# Utiliser le tuilage
upsampler = RealESRGANer(..., tile=200, ...)

# Ou réduire l'échelle
output, _ = upsampler.enhance(img, outscale=2)  # Au lieu de 4
```

### Artefacts en sortie

* Utiliser une taille de tuile plus petite avec plus de recouvrement
* Essayer un modèle différent (anime vs photo)
* Vérifier la qualité de l'image d'entrée

### Traitement lent

* Activer FP16 : `half=True`
* Augmenter la taille des tuiles si la VRAM le permet
* Utiliser un modèle plus rapide : RealESRNet

## Télécharger les résultats

```bash
scp -P <port> -r root@<proxy>:/workspace/outputs/ ./upscaled_images/
```

## 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

* [Restauration de visages GFPGAN](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/gfpgan-face-restore)
* [Génération vidéo IA](https://docs.clore.ai/guides/guides_v2-fr/generation-video/ai-video-generation)
* Stable Diffusion WebUI