Mise à l'échelle Real-ESRGAN

Agrandissez et améliorez les images avec Real-ESRGAN sur les GPU Clore.ai

Agrandissez et améliorez les images avec Real-ESRGAN sur GPU.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À 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@<proxy-address>

Qu'est-ce que Real-ESRGAN ?

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

• Agrandit les images de 2x à 4x

• Supprime le bruit et les artefacts

• Améliore les détails

• Fonctionne sur les photos, l'anime et les œuvres d'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	Mise à l'échelle x2	Rapide
RealESRNet_x4plus	Traitement rapide	Le plus rapide

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-runtime

Ports :

22/tcp
7860/http

Commande :

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='Échelle')],
    outputs=gr.Image(type='pil'),
    title='Agrandisseur Real-ESRGAN'
)
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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

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

Utilisation en ligne de commande

Installation

pip install realesrgan

Mise à l'échelle de base

# Mettre à l'échelle une seule image
python -m realesrgan -i input.jpg -o output.jpg -n RealESRGAN_x4plus -s 4

# Mettre à l'échelle un dossier
python -m realesrgan -i ./inputs -o ./outputs -n RealESRGAN_x4plus -s 4

Options

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 du visage
    --fp32 \                 # Utiliser FP32 (plus de VRAM, meilleure qualité)
    --tile 400               # Taille de tuile pour les grandes images

API Python

Utilisation de base

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

# Configurer 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=0,
    tile_pad=10,
    pre_pad=0,
    half=True  # Utiliser FP16
)

# Mise à l'échelle
img = cv2.imread('input.jpg', cv2.IMREAD_UNCHANGED)
output, _ = upsampler.enhance(img, outscale=4)
cv2.imwrite('output.jpg', output)

Avec amélioration du visage

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
)

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

Mise à l'échelle pour l'anime

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

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

#!/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 tiennent pas dans la VRAM :

upsampler = RealESRGANer(
    scale=4,
    model_path='RealESRGAN_x4plus.pth',
    model=model,
    tile=400,      # Traiter en tuiles de 400 px
    tile_pad=10,   # Chevauchement 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
12 Go	600
24GB	0 (pas de tuilage)

Mise à l'échelle vidéo

Utilisation de Real-ESRGAN

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

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

# 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

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

# Mettre à l'échelle 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éajouter 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

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

# Exécuter : uvicorn server:app --host 0.0.0.0 --port 8000

Utilisation

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	4GB+	Photos
x4plus_anime_6B	Meilleur	Moyen	3GB+	Anime
x2plus	Bon	Rapide	2GB+	Rapide x2
RealESRNet	Correct	Le plus rapide	2GB+	Aperçus

Performances

Taille de l'image	GPU	Temps de mise à l'échelle x4
512x512	RTX 3090	~0.5s
1024x1024	RTX 3090	~1.5s
2048x2048	RTX 3090	~5 s
512x512	RTX 4090	~0.3s

Dépannage

Mémoire CUDA insuffisante

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

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

Artefacts dans la sortie

• Utiliser une taille de tuile plus petite avec davantage de chevauchement

• Essayer un modèle différent (anime ou photo)

• Vérifier la qualité de l'image d'entrée

Traitement lent

• Activer FP16 : half=True

• Augmenter la taille de tuile si la VRAM le permet

• Utiliser un modèle plus rapide : RealESRNet

Télécharger les résultats

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

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 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 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Restauration de visage GFPGAN

• Génération vidéo par IA

• Interface web Stable Diffusion