Upscaling Real-ESRGAN

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

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez 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 :

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

pip install realesrgan

Agrandissement de base

# 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

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

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

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

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 rentrent pas dans la VRAM :

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

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

# 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

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

curl -X POST "http://localhost:8000/upscale?scale=4" \
    -F "[email protected]" \
    --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

# 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

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

• Génération vidéo IA

• Stable Diffusion WebUI