SD WebUI Forge

Déployez Stable Diffusion WebUI Forge avec gestion optimisée de la VRAM et prise en charge de FLUX sur les GPU Clore.ai

SD WebUI Forge est une version dérivée optimisée du classique Stable Diffusion WebUI AUTOMATIC1111, développée par l’équipe lllyasviel. Elle offre une gestion de la VRAM nettement meilleure (permettant SDXL sur des GPU de 4 Go), la prise en charge native des modèles FLUX, des vitesses de génération plus rapides et une compatibilité ascendante complète avec toutes les extensions et tous les modèles A1111. La place de marché GPU flexible de CLORE.AI vous permet de choisir le GPU parfait pour Forge — des cartes économiques aux A100 haut de gamme.

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

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	8 Go	16 Go+
VRAM	4 Go	12 Go+
Disque	30 Go	200 Go+
GPU	NVIDIA GTX 1650 4 Go+	RTX 3090, RTX 4090

Le principal avantage de Forge est son optimiseur de VRAM : il peut exécuter SDXL avec seulement 4 Go de VRAM (à une vitesse plus lente). Pour les modèles FLUX, 12 Go de VRAM constituent le minimum pratique, avec 24 Go pour une qualité et une vitesse optimales.

Déploiement rapide sur CLORE.AI

Image Docker : nykk3/stable-diffusion-webui-forge:latest

Ports : 22/tcp, 7860/http

Variables d'environnement :

Variable	Exemple	Description
CLI_ARGS	--xformers --medvram	Arguments CLI supplémentaires
COMMANDLINE_ARGS	--api --listen	Variables d’environnement alternatives pour les arguments CLI

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Allez à la place de marché CLORE.AI:

• SD1.5 économique: GTX 1660/2060 (6 Go) — largement suffisant pour 512/768 px

• Compatible SDXL: RTX 3080/3090 (10–24 Go)

• Compatible FLUX: RTX 4090/A6000 (24+ Go)

• Qualité maximale: A100 80 Go pour la génération par lot

2. Connectez-vous en SSH à votre serveur

ssh -p <PORT> root@<SERVER_IP>

3. Créer les répertoires de stockage

mkdir -p /root/sd-forge/{models,outputs,extensions,configs}
mkdir -p /root/sd-forge/models/{Stable-diffusion,VAE,Lora,ControlNet,embeddings,ESRGAN}

4. Récupérer et lancer SD WebUI Forge

Lancement standard :

docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  nykk3/stable-diffusion-webui-forge:latest

Avec l’API activée et des indicateurs de performance supplémentaires :

docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -v /root/sd-forge/extensions:/app/stable-diffusion-webui/extensions \
  -e CLI_ARGS="--api --xformers --enable-insecure-extension-access" \
  nykk3/stable-diffusion-webui-forge:latest

Mode faible VRAM (GPU 4 à 6 Go) :

docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --medvram-sdxl --opt-sdp-attention" \
  nykk3/stable-diffusion-webui-forge:latest

Performances maximales (24+ Go de VRAM) :

docker run -d \
  --name sd-forge \
  --gpus all \
  -p 7860:7860 \
  -v /root/sd-forge/models:/app/stable-diffusion-webui/models \
  -v /root/sd-forge/outputs:/app/stable-diffusion-webui/outputs \
  -e CLI_ARGS="--api --xformers --no-half-vae" \
  nykk3/stable-diffusion-webui-forge:latest

5. Surveiller le démarrage

docker logs -f sd-forge

Recherchez :

Exécution sur l’URL locale :  http://0.0.0.0:7860

Le démarrage prend généralement 2 à 5 minutes lors de la première exécution.

6. Accéder à l’interface Web

Votre URL CLORE.AI http_pub pour le port 7860 :

https://<order-id>-7860.clore.ai/

7. Ajouter des modèles

Méthode 1 : télécharger via CivitAI dans l’interface Web

• Accédez à Extensions → Installées → Modèles (certaines versions)

• Ou utilisez le téléchargeur d’URL dans les paramètres

Méthode 2 : télécharger directement sur le serveur

# Télécharger le modèle de base SDXL
cd /root/sd-forge/models/Stable-diffusion
wget -O "sd_xl_base_1.0.safetensors" \
  "https://huggingface.co/stabilityai/stable-diffusion-xl-base-1.0/resolve/main/sd_xl_base_1.0.safetensors"

# Télécharger FLUX.1-schnell (modèle FLUX rapide)
wget -O "flux1-schnell.safetensors" \
  "https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors"

Méthode 3 : CLI HuggingFace

docker exec -it sd-forge bash -c "
pip install huggingface_hub
huggingface-cli download stabilityai/stable-diffusion-xl-base-1.0 \
  sd_xl_base_1.0.safetensors \
  --local-dir /app/stable-diffusion-webui/models/Stable-diffusion/
"

---

Exemples d'utilisation

Exemple 1 : texte vers image via l’interface Web

1. Ouvrez l’interface Forge à votre URL CLORE.AI

2. Sélectionnez votre modèle dans le Checkpoint menu déroulant

3. Saisissez le prompt : "portrait cinématographique d’un guerrier, lumière dorée de fin de journée, photographie 8K"

4. Définissez le prompt négatif : "flou, basse résolution, filigrane, laid"

5. Définissez la largeur/hauteur : 1024x1024 pour SDXL, 512x768 pour SD1.5

6. Réglez les étapes : 20–30, CFG : 7

7. Cliquez sur Générer

Exemple 2 : génération FLUX

Les modèles FLUX fonctionnent différemment — pas de prompt négatif, qualité supérieure :

1. Sélectionnez le checkpoint FLUX (flux1-dev.safetensors)

2. Sous Forge, sélectionnez le Unet et VAE approprié

3. Saisissez le prompt (aucun prompt négatif n’est nécessaire) :

   Un paysage à couper le souffle au coucher du soleil, des montagnes reflétées dans un lac immaculé,
   photoréaliste, ultra détaillé, photographie professionnelle

4. Étapes : 20, CFG : 1,0 (FLUX utilise un CFG plus bas)

5. Échantillonneur : Euler ou DPM++ 2M

Exemple 3 : génération guidée par ControlNet

1. Installez l’extension ControlNet (si elle n’est pas préinstallée) :

   • Accédez à Extensions → Disponibles → Charger depuis

   • Recherchez « ControlNet » et installez-le

2. Téléchargez les modèles ControlNet dans /root/sd-forge/models/ControlNet/

3. Dans txt2img, développez la ControlNet section

4. Téléversez une image de référence (pose, profondeur, contour canny)

5. Sélectionnez le préprocesseur et le modèle correspondant à votre type de référence

6. Générez — la sortie suit la structure de référence

Exemple 4 : utilisation de l’API

Avec --api flag, Forge expose une API REST :

import requests
import base64
import io
from PIL import Image

BASE_URL = "http://localhost:7860"  # ou l’URL CLORE.AI http_pub

# Texte vers image
payload = {
    "prompt": "un jardin japonais serein avec des fleurs de cerisier, style aquarelle",
    "negative_prompt": "laid, flou, basse qualité",
    "steps": 25,
    "cfg_scale": 7,
    "width": 1024,
    "height": 1024,
    "sampler_name": "DPM++ 2M",
    "batch_size": 1,
}

response = requests.post(f"{BASE_URL}/sdapi/v1/txt2img", json=payload)
result = response.json()

# Enregistrer l’image
for i, img_b64 in enumerate(result["images"]):
    img_data = base64.b64decode(img_b64)
    img = Image.open(io.BytesIO(img_data))
    img.save(f"output_{i}.png")
    print(f"Enregistré output_{i}.png")

Exemple 5 : script de génération par lots

import requests
import base64
import io
from PIL import Image
import os

BASE_URL = "http://localhost:7860"

prompts = [
    ("ville cyberpunk la nuit, lumières néon, pluie", "cyberpunk"),
    ("ancienne forêt, brouillard mystique, art fantastique", "fantasy"),
    ("design de logo minimaliste, formes géométriques, fond blanc", "logo"),
    ("portrait d’un marin âgé, visage buriné, peinture à l’huile", "portrait"),
]

os.makedirs("batch_output", exist_ok=True)

for prompt_text, filename in prompts:
    print(f"Génération : {filename}...")
    response = requests.post(
        f"{BASE_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt_text,
            "negative_prompt": "qualité médiocre, flou, filigrane",
            "steps": 25,
            "cfg_scale": 7,
            "width": 1024,
            "height": 1024,
        },
    )
    
    if response.status_code == 200:
        img_b64 = response.json()["images"][0]
        img = Image.open(io.BytesIO(base64.b64decode(img_b64)))
        img.save(f"batch_output/{filename}.png")
        print(f"  Enregistré batch_output/{filename}.png")
    else:
        print(f"  Erreur : {response.status_code}")

---

Configuration

Arguments CLI clés

Argument	Description
--api	Activer l’API REST
--listen	Écouter sur toutes les interfaces (requis pour CLORE.AI)
--port 7860	Changer le port
--xformers	Activer l’attention xFormers (plus rapide, moins de VRAM)
--medvram	Mode VRAM moyenne (SD1.5 sur 6 Go)
--medvram-sdxl	VRAM moyenne pour SDXL (SDXL sur 8 Go)
--lowvram	Mode faible VRAM (très lent, n’importe quel GPU)
--no-half	Utiliser float32 (plus de VRAM, plus stable)
--no-half-vae	Conserver le VAE en float32 (évite les images noires)
--opt-sdp-attention	Attention PyTorch scaled dot product
--enable-insecure-extension-access	Autoriser l’installation d’extensions
--skip-version-check	Ignorer les vérifications de version de Python/torch

Paramètres spécifiques à Forge

Forge ajoute un Forge panneau dans l’interface avec :

• Forge Unet: Sélectionnez le backend d’optimisation (par défaut, bnb, etc.)

• Compilation Torch Diffusers: Activez-la pour une génération 20 à 30 % plus rapide (la première exécution compile)

• Poids GPU: Combien conserver sur le GPU par rapport au CPU

---

Conseils de performance

1. Utiliser xFormers pour 20 à 30 % de VRAM en moins

--xformers

Améliore automatiquement les performances sur la plupart des GPU.

2. L’optimiseur de VRAM de Forge

Forge gère automatiquement mieux la VRAM qu’A1111. Utilisez simplement le --medvram-sdxl flag pour SDXL sur les GPU de 8 à 12 Go et laissez-le gérer le reste.

3. Activer la compilation Torch (Ampere+)

Dans l’onglet Forge de l’interface, activez Compilation Torch Diffusers. La première génération prend 2 à 3 minutes à compiler, mais les suivantes sont 20 à 30 % plus rapides.

4. Combinaisons optimales d’étapes/échantillonneur

Objectif	Échantillonneur	Étapes	CFG
Vitesse	DPM++ SDE Karras	15-20	7
Qualité	DPM++ 2M Karras	25-35	7
Artistique	Euler a	20-30	5-7
FLUX	Euler	20	1

5. Utiliser Tile VAE pour les résolutions 2K+

Pour une résolution ultra-élevée (2048×2048+), activez VAE en tuiles dans l’onglet SD pour éviter les erreurs VAE OOM.

6. Générer localement avec l’API

Au lieu de générer une image à la fois dans l’interface, utilisez l’API avec batch_size pour un débit plus rapide :

payload = {
    "prompt": "...",
    "batch_size": 4,  # Générer 4 images à la fois
    "n_iter": 2,      # Exécuter 2 itérations = 8 images au total
}

---

Dépannage

Problème : images noires ou vertes

Problème de précision du VAE. Ajoutez le flag :

--no-half-vae

Ou utilisez le sdxl-vae-fp16-fix.safetensors VAE.

Problème : "CUDA out of memory"

Essayez dans cet ordre :

1. --medvram-sdxl (pour SDXL)

2. --medvram (pour SD1.5)

3. Réduisez la résolution de l'image

4. --lowvram (en dernier recours, très lent)

Problème : les extensions ne se chargent pas

# Autoriser l’accès aux extensions
-e CLI_ARGS="--enable-insecure-extension-access"

Puis installez depuis l’onglet Extensions dans l’interface.

Problème : le démarrage prend trop de temps

Normal lors de la première exécution — PyTorch et les empreintes des modèles sont calculés. Les démarrages suivants sont plus rapides.

docker logs -f sd-forge  # Observer la progression

Problème : impossible d’accéder à l’interface depuis le navigateur

Assurez-vous que le processus Forge se lie à 0.0.0.0:

• Ajoutez --listen dans CLI_ARGS

• Vérifiez que le port 7860 figure dans la liste des ports de votre commande CLORE.AI

Problème : le modèle n’apparaît pas dans le menu déroulant

Après avoir placé .safetensors les fichiers dans le bon dossier, cliquez sur 🔄 Actualiser à côté du menu déroulant Checkpoint.

---

Liens

• GitHub (Forge)

• GitHub (base A1111)

• Docker Hub (nykk3)

• CivitAI (modèles)

• Modèles FLUX

• la place de marché CLORE.AI

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Production	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grande échelle	A100 80 Go	bare metal

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, accès root complet.