SD WebUI Forge

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

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 Abwärtskompatibilität mit allen A1111-Erweiterungen und -Modellen. CLORE.AI's flexibler GPU-Marktplatz lässt dich die perfekte GPU für Forge wählen — von budgetfreundlichen Karten bis hin zu Spitzenmodellen wie A100.

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

Serveranforderungen

Parameter

Minimum

Schnelle Bereitstellung 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-Umgebung

Schritt-für-Schritt-Einrichtung

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

Gehe zu CLORE.AI Marketplace:

Budget 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 80GB für Batch-Generierung

2. SSH auf Ihren Server

ssh -p <PORT> root@<SERVER_IP>

3. Erstelle Speicherverzeichnisse

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

4. Ziehe und starte SD WebUI Forge

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 Performance-Flags:

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

Low-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. Starte Überwachung

docker logs -f sd-forge

Achten Sie auf:

Running on local URL:  http://0.0.0.0:7860

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

6. Auf die Weboberfläche zugreifen

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

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

7. Modelle hinzufügen

Methode 1: In der Web-UI über CivitAI herunterladen

Gehe zu Extensions → Installed → Models (einige Versionen)
Oder benutze den URL-Downloader in den Einstellungen

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

Beispielanwendungen

Beispiel 1: Text-zu-Bild über die Web-UI

Öffne die Forge-UI an deiner CLORE.AI-URL
Wähle dein Modell aus dem Checkpoint Dropdown
Gib Prompt ein: "cinematic portrait of a warrior, golden hour, 8k photography"
Setzen Sie den negativen Prompt: "blurry, low resolution, watermark, ugly"
Setze Breite/Höhe: 1024x1024 für SDXL, 512x768 für SD1.5
Setze Schritte: 20–30, CFG: 7
Klicken Sie Generieren

Beispiel 2: FLUX-Generierung

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

Wähle FLUX-Checkpoint (flux1-dev.safetensors)
Unter Forge, wähle entsprechendes Unet und VAE falls separate Dateien

Gib Prompt ein (kein negativer Prompt nötig):

Eine atemberaubende Landschaft bei Sonnenuntergang, Berge, die sich in einem makellosen See spiegeln,
fotorealistisch, ultra-detailreich, professionelle Fotografie

Schritte: 20, CFG: 1.0 (FLUX verwendet niedrigere CFG)
Sampler: Euler oder DPM++ 2M

Beispiel 3: ControlNet-geführte Generierung

Installiere die ControlNet-Erweiterung (falls nicht vorinstalliert):
- Gehe zu Extensions → Available → Load from
- Suche nach „ControlNet“ und installiere es
Lade ControlNet-Modelle nach /root/sd-forge/models/ControlNet/
Erweitere in txt2img ControlNet Abschnitt
Lade Referenzbild hoch (Pose, Tiefe, Canny-Kanten)
Wähle Preprocessor und Modell passend zum Referenztyp
Generieren — Ausgabe folgt der Referenzstruktur

Beispiel 4: API-Nutzung

Mit --api Flag gibt Forge eine REST-API frei:

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()

# Speichere das Bild
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: Batch-Generierungsskript

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"Generating: {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"  Saved batch_output/{filename}.png")
    else:
        print(f"  Error: {response.status_code}")

Konfiguration

Wichtige CLI-Argumente

Argument

Beschreibung

--api

REST-API aktivieren

--listen

Auf allen Schnittstellen lauschen (erforderlich für CLORE.AI)

--port 7860

Port ändern

--xformers

xFormers-Attention aktivieren (schneller, weniger VRAM)

--medvram

Medium-VRAM-Modus (SD1.5 auf 6 GB)

--medvram-sdxl

Medium-VRAM für SDXL (SDXL auf 8 GB)

--lowvram

Low-VRAM-Modus (sehr langsam, jede GPU)

--no-half

Nutze float32 (mehr VRAM, stabiler)

--no-half-vae

VAE in float32 belassen (verhindert schwarze Bilder)

--opt-sdp-attention

PyTorch scaled dot product attention

--enable-insecure-extension-access

Erlaube Installation von Erweiterungen

--skip-version-check

Python/torch Versionschecks überspringen

Forge-spezifische Einstellungen

Forge fügt ein Forge Panel in der UI hinzu mit:

Forge Unet: Auswahl des Optimierungs-Backends (default, bnb, etc.)
Diffusers Torch-Kompilierung: Aktivieren für 20–30% schnellere Generierung (erster Lauf kompiliert)
GPU-Gewichte: Wie viel auf der GPU gegenüber der CPU gehalten wird

Leistungs-Tipps

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

--xformers

Verbessert automatisch die Leistung auf den meisten GPUs.

2. Forges VRAM-Optimizer

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

3. Torch-Kompilierung aktivieren (Ampere+)

Aktiviere im Forge-Reiter in der UI Diffusers Torch-Kompilierung. Die erste Generierung benötigt 2–3 Minuten zum Kompilieren, danach sind die folgenden 20–30% schneller.

4. Optimale Schritte/Sampler-Kombinationen

Ziel

Sampler

Schritte

CFG

Geschwindigkeit

DPM++ SDE Karras

15-20

Qualität

DPM++ 2M Karras

25-35

Künstlerisch

Euler a

20-30

5-7

FLUX

Euler

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

Für ultra-hohe Auflösungen (2048×2048+) aktiviere Tiled VAE im SD-Reiter, um VAE-OOM-Fehler zu vermeiden.

6. Lokal mit der API batchen

Anstatt einzeln in der UI zu generieren, nutze die API mit batch_size für höheren Durchsatz:

payload = {
    "prompt": "...",
    "batch_size": 4,  # Erzeuge 4 Bilder auf einmal
    "n_iter": 2,      # Führe 2 Iterationen aus = insgesamt 8 Bilder
}

Fehlerbehebung

Problem: Schwarze oder grüne Bilder

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

--no-half-vae

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

Problem: "CUDA out of memory"

Versuche der Reihe nach:

--medvram-sdxl (für SDXL)
--medvram (für SD1.5)
Reduziere die Bildauflösung
--lowvram (letzte Option, sehr langsam)

Problem: Erweiterungen werden nicht geladen

# Erlaube Erweiterungszugriff
-e CLI_ARGS="--enable-insecure-extension-access"

Dann aus dem Extensions-Tab in der UI installieren.

Problem: Start dauert zu lange

Normal beim ersten Start — PyTorch und Modell-Hashes werden berechnet. Nachfolgende Starts sind schneller.

docker logs -f sd-forge  # Fortschritt beobachten

Problem: Kann nicht aus dem Browser auf die UI zugreifen

Stelle sicher, dass der Forge-Prozess an 0.0.0.0:

Fügen Sie --listen an CLI_ARGS bindet
Überprüfe, ob Port 7860 in deiner CLORE.AI-Bestellungsliste von Ports vorhanden ist

Nachdem du .safetensors Dateien in den richtigen Ordner gelegt hast, klicke 🔄 Aktualisieren neben dem Checkpoint-Dropdown.

Clore.ai GPU-Empfehlungen

Anwendungsfall

Empfohlene GPU

Geschätzte Kosten auf Clore.ai

Entwicklung/Tests

RTX 3090 (24GB)

~$0.12/gpu/hr

Produktion

RTX 4090 (24GB)

~$0.70/gpu/hr

Großmaßstab

A100 80GB

~$1.20/gpu/hr

💡 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.

VorherigeInvokeAI NächsteÜbersicht

Zuletzt aktualisiert vor 5 Tagen

War das hilfreich?

hashtagServeranforderungen

hashtagSchnelle Bereitstellung auf CLORE.AI

hashtagSchritt-für-Schritt-Einrichtung

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

hashtag2. SSH auf Ihren Server

hashtag3. Erstelle Speicherverzeichnisse

hashtag4. Ziehe und starte SD WebUI Forge

hashtag5. Starte Überwachung

hashtag6. Auf die Weboberfläche zugreifen

hashtag7. Modelle hinzufügen

hashtagBeispielanwendungen

hashtagBeispiel 1: Text-zu-Bild über die Web-UI

hashtagBeispiel 2: FLUX-Generierung

hashtagBeispiel 3: ControlNet-geführte Generierung

hashtagBeispiel 4: API-Nutzung

hashtagBeispiel 5: Batch-Generierungsskript

hashtagKonfiguration

hashtagWichtige CLI-Argumente

hashtagForge-spezifische Einstellungen

hashtagLeistungs-Tipps

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

hashtag2. Forges VRAM-Optimizer

hashtag3. Torch-Kompilierung aktivieren (Ampere+)

hashtag4. Optimale Schritte/Sampler-Kombinationen

hashtag5. Verwende Tile VAE für 2K+ Auflösungen

hashtag6. Lokal mit der API batchen

hashtagFehlerbehebung

hashtagProblem: Schwarze oder grüne Bilder

hashtagProblem: "CUDA out of memory"

hashtagProblem: Erweiterungen werden nicht geladen

hashtagProblem: Start dauert zu lange

hashtagProblem: Kann nicht aus dem Browser auf die UI zugreifen

hashtagProblem: Modell wird nicht im Dropdown angezeigt

hashtagLinks

hashtagClore.ai GPU-Empfehlungen

Serveranforderungen

Schnelle Bereitstellung auf CLORE.AI

Schritt-für-Schritt-Einrichtung

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

2. SSH auf Ihren Server

3. Erstelle Speicherverzeichnisse

4. Ziehe und starte SD WebUI Forge

5. Starte Überwachung

6. Auf die Weboberfläche zugreifen

7. Modelle hinzufügen

Beispielanwendungen

Beispiel 1: Text-zu-Bild über die Web-UI

Beispiel 2: FLUX-Generierung

Beispiel 3: ControlNet-geführte Generierung

Beispiel 4: API-Nutzung

Beispiel 5: Batch-Generierungsskript

Konfiguration

Wichtige CLI-Argumente

Forge-spezifische Einstellungen

Leistungs-Tipps

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

2. Forges VRAM-Optimizer

3. Torch-Kompilierung aktivieren (Ampere+)

4. Optimale Schritte/Sampler-Kombinationen

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

6. Lokal mit der API batchen

Fehlerbehebung

Problem: Schwarze oder grüne Bilder

Problem: "CUDA out of memory"

Problem: Erweiterungen werden nicht geladen

Problem: Start dauert zu lange

Problem: Kann nicht aus dem Browser auf die UI zugreifen

Problem: Modell wird nicht im Dropdown angezeigt

Links

Clore.ai GPU-Empfehlungen