SD WebUI Forge

Deploye Stable Diffusion WebUI Forge mit optimiertem VRAM-Management und FLUX-Unterstützung auf Clore.ai-GPUs

SD WebUI Forge ist ein optimierter Fork der klassischen AUTOMATIC1111 Stable Diffusion WebUI, entwickelt vom lllyasviel-Team. Es bietet deutlich besseres VRAM-Management (ermöglicht SDXL auf 4-GB-GPUs), native FLUX-Modellunterstützung, schnellere Generierungsgeschwindigkeiten und volle Rückwärtskompatibilität mit allen A1111-Erweiterungen und -Modellen. Der flexible GPU-Marktplatz von CLORE.AI lässt dich die perfekte GPU für Forge auswählen — von günstigen Karten bis hin zu erstklassigen A100s.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	8 GB	16 GB+
VRAM	4 GB	12 GB+
Festplatte	30 GB	200 GB+
GPU	NVIDIA GTX 1650 4GB+	RTX 3090, RTX 4090

Der Hauptvorteil von Forge ist sein VRAM-Optimierer: Er kann SDXL mit nur 4 GB VRAM ausführen (bei langsamerer Geschwindigkeit). Für FLUX-Modelle sind 12 GB VRAM das praktische Minimum, 24 GB sind für volle Qualität und Geschwindigkeit ideal.

Schnellbereitstellung auf CLORE.AI

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

Ports: 22/tcp, 7860/http

Umgebungsvariablen:

Variable	Beispiel	Beschreibung
CLI_ARGS	--xformers --medvram	Zusätzliche CLI-Argumente
COMMANDLINE_ARGS	--api --listen	Alternative CLI-Args-Umgebungsvariable

Schritt-für-Schritt-Einrichtung

1. Mieten Sie einen GPU-Server auf CLORE.AI

Gehe zu CLORE.AI-Marktplatz:

• Günstige SD1.5: GTX 1660/2060 (6 GB) — ausreichend für 512/768px

• SDXL-fähig: RTX 3080/3090 (10–24 GB)

• FLUX-fähig: RTX 4090/A6000 (24+ GB)

• Maximale Qualität: A100 80 GB für Batch-Generierung

2. Verbinden Sie sich per SSH mit Ihrem Server

ssh -p <PORT> root@<SERVER_IP>

3. Speicherverzeichnisse erstellen

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

4. SD WebUI Forge herunterladen und starten

Standardstart:

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

Mit aktivierter API und zusätzlichen Leistungsflags:

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

Niedriger-VRAM-Modus (4–6-GB-GPUs):

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

Maximale Leistung (24+ GB 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. Start überwachen

docker logs -f sd-forge

Achte auf:

Wird unter lokaler URL ausgeführt:  http://0.0.0.0:7860

Der Start dauert beim ersten Lauf typischerweise 2–5 Minuten.

6. Auf die Weboberfläche zugreifen

Deine CLORE.AI-http_pub-URL für Port 7860:

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

7. Modelle hinzufügen

Methode 1: Über CivitAI in der Weboberfläche herunterladen

• Gehe zu Erweiterungen → Installiert → Modelle (einige Versionen)

• Oder den URL-Downloader in den Einstellungen verwenden

Methode 2: Direkt auf dem Server herunterladen

# SDXL-Basismodell herunterladen
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"

# FLUX.1-schnell herunterladen (schnelles FLUX-Modell)
wget -O "flux1-schnell.safetensors" \
  "https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors"

Methode 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/
"

---

Anwendungsbeispiele

Beispiel 1: Text-zu-Bild über die Weboberfläche

1. Öffne die Forge-Oberfläche unter deiner CLORE.AI-URL

2. Wähle dein Modell aus dem Kontrollpunkt Dropdown

3. Prompt eingeben: "cinematic portrait of a warrior, golden hour, 8k photography"

4. Negativen Prompt festlegen: "blurry, low resolution, watermark, ugly"

5. Breite/Höhe festlegen: 1024x1024 für SDXL, 512x768 für SD1.5

6. Schritte festlegen: 20–30, CFG: 7

7. Klicken Sie auf Generieren

Beispiel 2: FLUX-Generierung

FLUX-Modelle funktionieren anders — kein negativer Prompt, höhere Qualität:

1. Wähle den FLUX-Checkpoint (flux1-dev.safetensors)

2. Unter Forge, wähle das passende UNet und VAE falls separate Dateien

3. Prompt eingeben (kein negativer Prompt nötig):

   Eine atemberaubende Landschaft bei Sonnenuntergang, Berge, die sich in einem klaren See spiegeln,
   fotorealistisch, ultradetailliert, professionelle Fotografie

4. Schritte: 20, CFG: 1.0 (FLUX verwendet einen niedrigeren CFG)

5. Sampler: Euler oder DPM++ 2M

Beispiel 3: ControlNet-gesteuerte Generierung

1. ControlNet-Erweiterung installieren (falls nicht vorinstalliert):

   • Gehe zu Erweiterungen → Verfügbar → Laden von

   • Suche nach "ControlNet" und installiere es

2. Lade ControlNet-Modelle herunter nach /root/sd-forge/models/ControlNet/

3. In txt2img den ControlNet Abschnitt

4. Referenzbild hochladen (Pose, Tiefe, Canny-Kante)

5. Wähle den Vorverarbeiter und das Modell passend zu deinem Referenztyp

6. Generieren — die Ausgabe folgt der Referenzstruktur

Beispiel 4: API-Nutzung

Mit --api Flag stellt Forge eine REST-API bereit:

import requests
import base64
import io
from PIL import Image

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

# Text zu Bild
payload = {
    "prompt": "a serene Japanese garden with cherry blossoms, watercolor style",
    "negative_prompt": "ugly, blurry, low quality",
    "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()

# Das Bild speichern
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")

Beispiel 5: Skript für die Batch-Generierung

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

BASE_URL = "http://localhost:7860"

prompts = [
    ("cyberpunk city at night, neon lights, rain", "cyberpunk"),
    ("ancient forest, mystical fog, fantasy art", "fantasy"),
    ("minimalist logo design, geometric shapes, white background", "logo"),
    ("portrait of an elderly sailor, weathered face, oil painting", "portrait"),
]

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

for prompt_text, filename in prompts:
    print(f"Generiere: {filename}...")
    response = requests.post(
        f"{BASE_URL}/sdapi/v1/txt2img",
        json={
            "prompt": prompt_text,
            "negative_prompt": "low quality, blurry, watermark",
            "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"  Gespeichert: batch_output/{filename}.png")
    else:
        print(f"  Fehler: {response.status_code}")

---

Konfiguration

Wichtige CLI-Argumente

Argument	Beschreibung
--api	REST-API aktivieren
--listen	Auf allen Schnittstellen lauschen (für CLORE.AI erforderlich)
--port 7860	Port ändern
--xformers	xFormers-Attention aktivieren (schneller, weniger VRAM)
--medvram	Mittlerer-VRAM-Modus (SD1.5 auf 6 GB)
--medvram-sdxl	Mittlerer VRAM für SDXL (SDXL auf 8 GB)
--lowvram	Niedriger-VRAM-Modus (sehr langsam, jede GPU)
--no-half	float32 verwenden (mehr VRAM, stabiler)
--no-half-vae	VAE in float32 belassen (verhindert schwarze Bilder)
--opt-sdp-attention	Skalierte Punktprodukt-Attention von PyTorch
--enable-insecure-extension-access	Installation von Erweiterungen erlauben
--skip-version-check	Python-/Torch-Versionsprüfungen überspringen

Forge-spezifische Einstellungen

Forge fügt ein Forge Panel in der Oberfläche hinzu mit:

• Forge-UNet: Optimierungs-Backend auswählen (Standard, bnb usw.)

• Diffusers-Torch-Kompilierung: Aktivieren für 20–30 % schnellere Generierung (beim ersten Lauf wird kompiliert)

• GPU-Gewichte: Wie viel auf der GPU gegenüber der CPU behalten werden soll

---

Leistungstipps

1. Verwende xFormers für 20–30 % weniger VRAM

--xformers

Verbessert die Leistung auf den meisten GPUs automatisch.

2. Forges VRAM-Optimierer

Forge verwaltet den VRAM automatisch besser als A1111. Verwende einfach das --medvram-sdxl Flag für SDXL auf 8–12-GB-GPUs und überlasse ihm den Rest.

3. Torch-Kompilierung aktivieren (Ampere+)

Aktiviere im Forge-Tab in der Oberfläche Diffusers-Torch-Kompilierung. Die erste Generierung dauert 2–3 Minuten für die Kompilierung, danach sind die folgenden 20–30 % schneller.

4. Optimale Schritt-/Sampler-Kombinationen

Ziel	Sampler	Schritte	CFG
Geschwindigkeit	DPM++ SDE Karras	15-20	7
Qualität	DPM++ 2M Karras	25-35	7
Künstlerisch	Euler a	20-30	5-7
FLUX	Euler	20	1

5. Verwende Tile-VAE für Auflösungen ab 2K

Für ultra-hohe Auflösung (2048×2048+), aktiviere Gekacheltes VAE im SD-Tab, um VAE-OOM-Fehler zu verhindern.

6. Lokal mit der API in Stapeln generieren

Anstatt in der Oberfläche jeweils nur eines zu generieren, verwende die API mit batch_size für höheren Durchsatz:

payload = {
    "prompt": "...",
    "batch_size": 4,  # 4 Bilder auf einmal generieren
    "n_iter": 2,      # 2 Iterationen ausführen = 8 Bilder insgesamt
}

---

Fehlerbehebung

Problem: Schwarze oder grüne Bilder

VAE-Präzisionsproblem. Füge das Flag hinzu:

--no-half-vae

Oder verwende das sdxl-vae-fp16-fix.safetensors VAE.

Problem: "CUDA out of memory"

Versuche es in dieser Reihenfolge:

1. --medvram-sdxl (für SDXL)

2. --medvram (für SD1.5)

3. Bildauflösung reduzieren

4. --lowvram (letzter Ausweg, sehr langsam)

Problem: Erweiterungen werden nicht geladen

# Zugriff auf Erweiterungen erlauben
-e CLI_ARGS="--enable-insecure-extension-access"

Dann über den Reiter „Extensions“ in der Oberfläche installieren.

Problem: Der Start dauert zu lange

Beim ersten Lauf normal — PyTorch- und Modell-Hashes werden berechnet. Nachfolgende Starts sind schneller.

docker logs -f sd-forge  # Fortschritt beobachten

Problem: Kann nicht über den Browser auf die Oberfläche zugreifen

Stelle sicher, dass der Forge-Prozess an 0.0.0.0:

• Fügen Sie --listen zu CLI_ARGS

• Überprüfe, ob Port 7860 in der Portliste deiner CLORE.AI-Bestellung enthalten ist

Problem: Modell wird im Dropdown nicht angezeigt

Nachdem du .safetensors Dateien im richtigen Ordner platziert hast, klicke auf 🔄 Aktualisieren neben dem Checkpoint-Dropdown.

---

Links

• GitHub (Forge)

• GitHub (A1111-Basis)

• Docker Hub (nykk3)

• CivitAI (Modelle)

• FLUX-Modelle

• CLORE.AI-Marktplatz

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktion	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Großflächig	A100 80GB	Bare Metal

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.