> 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/generation-dimages/sd-webui-forge.md).

# SD WebUI Forge

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.

{% 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 %}

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

{% hint style="info" %}
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.
{% endhint %}

## 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](https://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

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Créer les répertoires de stockage

```bash
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 :**

```bash
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 :**

```bash
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) :**

```bash
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) :**

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

```bash
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**

```bash
# 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**

```bash
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 :

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

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

```bash
--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 :

```python
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 :

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

```bash
# 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.

```bash
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)](https://github.com/lllyasviel/stable-diffusion-webui-forge)
* [GitHub (base A1111)](https://github.com/AUTOMATIC1111/stable-diffusion-webui)
* [Docker Hub (nykk3)](https://hub.docker.com/r/nykk3/stable-diffusion-webui-forge)
* [CivitAI (Modèles)](https://civitai.com)
* [Modèles FLUX](https://huggingface.co/black-forest-labs)
* [CLORE.AI Marketplace](https://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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

# 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/generation-dimages/sd-webui-forge.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.