> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling.md).

# 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](/guides/guides_v2-fr/traitement-dimages/gfpgan-face-restore.md)
* [Génération vidéo IA](/guides/guides_v2-fr/generation-video/ai-video-generation.md)
* Stable Diffusion WebUI


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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-fr/traitement-dimages/real-esrgan-upscaling.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.