SD WebUI Forge

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

SD WebUI Forge est une branche optimisée de l'AUTOMATIC1111 Stable Diffusion WebUI classique, développée par l'équipe lllyasviel. Elle offre une gestion de la VRAM nettement meilleure (permettant SDXL sur des GPU 4 Go), un support natif des modèles FLUX, des vitesses de génération plus rapides et une compatibilité totale avec toutes les extensions et modèles A1111. La marketplace 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 CLORE.AI Marketplace.

Exigences 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

L'avantage clé de Forge est son optimiseur de VRAM : il peut exécuter SDXL avec seulement 4 Go de VRAM (à vitesse réduite). Pour les modèles FLUX, 12 Go de VRAM est le minimum pratique, 24 Go pour qualité et 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	Variable d'environnement alternative pour les arguments CLI

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Rendez-vous sur CLORE.AI Marketplace:

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

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

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

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

2. SSH sur 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 exécuter 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 API activée et drapeaux 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

Performance maximale (24+ Go 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 :

En cours d'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 http_pub CLORE.AI pour le port 7860 :

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

7. Ajouter des modèles

Méthode 1 : Télécharger via CivitAI depuis l'interface web

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

• Ou utilisez le téléchargeur d'URL dans 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 : HuggingFace CLI

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 depuis le Checkpoint menu déroulant

3. Saisir le prompt : "portrait cinématique d'un guerrier, heure dorée, photographie 8k"

4. Définir l’invite négative : "flou, faible résolution, filigrane, laid"

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

6. Définir les steps : 20–30, CFG : 7

7. Cliquez 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 si fichiers séparés

3. Saisir le prompt (aucun prompt négatif requis) :

   Un paysage à couper le souffle au coucher du soleil, montagnes se reflétant dans un lac immaculé,
   photorealiste, ultra détaillé, photographie professionnelle

4. Steps : 20, CFG : 1.0 (FLUX utilise un CFG plus bas)

5. Sampler : Euler ou DPM++ 2M

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

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

   • Aller à Extensions → Disponibles → Charger depuis

   • Recherchez « ControlNet » et installez

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

3. Dans txt2img, développez ControlNet section

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

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

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

Exemple 4 : Utilisation de l'API

Avec --api le drapeau, Forge expose une API REST :

import requests
import base64
import io
from PIL import Image

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

# Texte vers image
payload = {
    "prompt": "un jardin japonais serein avec des cerisiers en fleurs, style aquarelle",
    "negative_prompt": "laid, flou, faible 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"Saved 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"),
    ("forêt ancienne, brume mystique, art fantastique", "fantasy"),
    ("conception de logo minimaliste, formes géométriques, fond blanc", "logo"),
    ("portrait d'un vieux marin, visage marqué, 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": "faible qualité, 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"  Saved 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 de port
--xformers	Activer l'attention xFormers (plus rapide, moins de VRAM)
--medvram	Mode VRAM moyen (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	Garder le VAE en float32 (empêche les images noires)
--opt-sdp-attention	Attention produit scalaire mise à l'échelle PyTorch
--enable-insecure-extension-access	Autoriser l'installation d'extensions
--skip-version-check	Ignorer les vérifications de version Python/torch

Paramètres spécifiques à Forge

Forge ajoute un Forge panneau dans l'interface avec :

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

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

• Poids GPU: Combien garder sur GPU vs 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 la VRAM mieux que A1111. Utilisez simplement le --medvram-sdxl drapeau pour SDXL sur GPU 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 de Diffusers. La première génération prend 2-3 minutes pour compiler, mais les suivantes sont 20-30% plus rapides.

4. Combinaisons optimales Steps/Sampler

Objectif	Échantillonneur	Steps	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 résolutions 2K+

Pour très haute résolution (2048×2048+), activez VAE en tuiles dans l'onglet SD pour éviter les erreurs OOM du VAE.

6. Traiter par lots 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 drapeau :

--no-half-vae

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

Problème : "CUDA out of memory"

Essayer dans l'ordre :

1. --medvram-sdxl (pour SDXL)

2. --medvram (pour SD1.5)

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

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

Problème : Extensions ne se chargent pas

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

Ensuite, 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 hash des modèles sont calculés. Les démarrages suivants sont plus rapides.

docker logs -f sd-forge  # Surveiller 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:

• Ajouter --listen à 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 fichiers dans le dossier correct, cliquez sur 🔄 Actualiser à côté du menu Checkpoint.

---

Liens

• GitHub (Forge)

• GitHub (base A1111)

• Docker Hub (nykk3)

• CivitAI (Modèles)

• Modèles FLUX

• CLORE.AI Marketplace

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Production	RTX 4090 (24GB)	~$0.70/gpu/hr
Grande échelle	A100 80GB	~$1.20/gpu/hr

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