> 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

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.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [la place de marché CLORE.AI](https://clore.ai/marketplace).
{% endhint %}

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

{% hint style="info" %}
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.
{% 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`       | 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](https://clore.ai/marketplace):

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

```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 lancer 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 l’API activée et des indicateurs 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
```

**Performances maximales (24+ Go de 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 :

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

```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 : CLI HuggingFace**

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

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

```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"),
    ("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

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

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

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

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

```bash
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)](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)
* [la place de marché CLORE.AI](https://clore.ai/marketplace)

***

## 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](https://clore.ai/bare-metal) |

> 💡 Tous les exemples de ce guide peuvent être déployés sur [Clore.ai](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/sd-webui-forge.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.