# Fooocus

Bilder mit Fooocus erstellen – der einfachste Weg, Stable Diffusion zu nutzen.

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen Sie [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Nach GPU-Typ, VRAM und Preis filtern
3. Wählen **On-Demand** (Festpreis) oder **Spot** (Gebotspreis)
4. Konfigurieren Sie Ihre Bestellung:
   * Docker-Image auswählen
   * Ports festlegen (TCP für SSH, HTTP für Web-UIs)
   * Umgebungsvariablen bei Bedarf hinzufügen
   * Startbefehl eingeben
5. Zahlung auswählen: **CLORE**, **BTC**, oder **USDT/USDC**
6. Bestellung erstellen und auf Bereitstellung warten

### Zugriff auf Ihren Server

* Verbindungsdetails finden Sie in **Meine Bestellungen**
* Webschnittstellen: Verwenden Sie die HTTP-Port-URL
* SSH: `ssh -p <port> root@<proxy-address>`

## Was ist Fooocus?

Fooocus ist eine schlanke Stable Diffusion-Oberfläche, die:

* Keine Konfiguration erfordert
* Standardmäßig SDXL verwendet
* Eingebaute Stile und Voreinstellungen hat
* Alle Optimierungen automatisch durchführt

## Anforderungen

| Qualität      | Min. VRAM | Empfohlen     |
| ------------- | --------- | ------------- |
| Basic         | 4GB       | RTX 3060      |
| Standard      | 8GB       | RTX 3070      |
| Hohe Qualität | 12GB+     | RTX 3090/4090 |

## Schnelle Bereitstellung

**Docker-Image:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Ports:**

```
22/tcp
7865/http
```

**Befehl:**

```bash
apt-get update && apt-get install -y git libgl1 libglib2.0-0 && \
cd /workspace && \
git clone https://github.com/lllyasviel/Fooocus.git && \
cd Fooocus && \
pip install -r requirements_versions.txt && \
python launch.py --listen 0.0.0.0 --port 7865
```

## Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre `http_pub` URL in **Meine Bestellungen**:

1. Gehen Sie zur **Meine Bestellungen** Seite
2. Klicken Sie auf Ihre Bestellung
3. Finden Sie die `http_pub` URL (z. B., `abc123.clorecloud.net`)

Verwenden Sie `https://IHRE_HTTP_PUB_URL` anstelle von `localhost` in den Beispielen unten.

## Erster Start

Beim ersten Start lädt Fooocus automatisch herunter:

* SDXL Basis-Modell (\~6,5GB)
* SDXL Refiner (\~6GB)
* Erforderliche Embeddings

Das dauert beim ersten Start 10–15 Minuten.

## Fooocus verwenden

### Grundlegende Generierung

1. Öffnen `http://<proxy>:<port>`
2. Gib deinen Prompt ein
3. Klicke auf "Generate"

Das war's! Keine Einstellungen nötig.

### Stile

Fooocus enthält 200+ eingebaute Stile:

**Beliebte Stile:**

* Fooocus Enhance – Bessere Details
* Fooocus Sharp – Scharfe Kanten
* Cinematic – Filmlook
* Anime – Japanische Animation
* Photographic – Realistische Fotos

### Qualitätsvoreinstellungen

| Voreinstellung          | Geschwindigkeit | Qualität  |
| ----------------------- | --------------- | --------- |
| Geschwindigkeit         | Schnell         | Gut       |
| Qualität                | Mittel          | Großartig |
| Extreme Geschwindigkeit | Am schnellsten  | Basic     |

## Erweiterte Funktionen

### Erweiterter Modus aktivieren

Aktiviere das Kontrollkästchen "Advanced", um zuzugreifen auf:

* Negative Prompts
* Seitenverhältnisse
* Anzahl der Bilder
* Steuerung des zufälligen Seeds

### Bild-zu-Bild

1. Aktiviere den Reiter "Input Image"
2. Quellbild hochladen
3. Modus wählen:
   * **Upscale** - Auflösung verbessern
   * **Vary** - Variationen erstellen
   * **Inpaint** - Teile bearbeiten

### Inpainting

```
1. Bild hochladen
2. Klicke auf "Inpaint or Outpaint"
3. Maske auf die zu ändernden Bereiche zeichnen
4. Beschreiben, was generiert werden soll
5. Auf Generate klicken
```

### Outpainting

Bilder über die Grenzen hinaus erweitern:

1. Bild hochladen
2. "Inpaint or Outpaint" auswählen
3. Richtungsfelder (Links, Rechts, Oben, Unten) markieren
4. Generieren, um die Leinwand zu erweitern

## Verwendung von LoRAs

### LoRAs herunterladen

```bash
cd /workspace/Fooocus/models/loras
wget https://civitai.com/api/download/models/<model_id> -O my_lora.safetensors
```

### LoRA anwenden

1. Gehe zum Reiter "Model"
2. LoRA im Dropdown auswählen
3. Gewicht anpassen (0.5–1.0)

## Benutzerdefinierte Modelle

### Eigene Checkpoints hinzufügen

```bash
cd /workspace/Fooocus/models/checkpoints

# Modell herunterladen
wget https://huggingface.co/model/file.safetensors
```

UI aktualisieren oder neu starten, um neue Modelle zu sehen.

### Empfohlene Modelle

| Modell         | Stil            | Größe |
| -------------- | --------------- | ----- |
| Juggernaut XL  | Fotorealistisch | 6,5GB |
| DreamShaper XL | Künstlerisch    | 6,5GB |
| RealVisXL      | Realistisch     | 6,5GB |
| Animagine XL   | Anime           | 6,5GB |

## Face Swap

Eingebaute Face-Swap-Funktion:

1. Reiter "Image Prompt" aktivieren
2. Gesichtsbild hochladen
3. "FaceSwap" als Typ einstellen
4. Mit Face-Prompt generieren

## Upscaling

### Eingebauter Upscaler

1. Bild in "Upscale or Vary" hochladen
2. "Upscale (2x)" auswählen
3. Generieren

### Vary-Optionen

* **Vary (Subtil)** - Kleine Änderungen
* **Vary (Stark)** - Bedeutende Änderungen

## Bild beschreiben

Reverse Prompt Engineering:

1. Gehe zum Reiter "Describe"
2. Bild hochladen
3. Prompt-Vorschläge erhalten

## Leistungsoptimierung

### Für 8GB VRAM

```bash
python launch.py --listen 0.0.0.0 --always-offload-from-vram
```

### Für 6GB VRAM

```bash
python launch.py --listen 0.0.0.0 --always-low-vram
```

### Für 4GB VRAM

```bash
python launch.py --listen 0.0.0.0 --always-cpu
```

## Batch-Verarbeitung

### Mehrere Bilder generieren

Im erweiterten Modus:

* Setze "Image Number" auf die gewünschte Anzahl
* Alle Bilder werden mit verschiedenen Seeds generiert

### Prompt-Warteschlange

Verwende Wildcards für Variationen:

```
a {red|blue|green} car on the street
```

Erzeugt 3 Bilder mit unterschiedlichen Farben.

## API-Zugriff

### API aktivieren

```bash
python launch.py --listen 0.0.0.0 --port 7865
```

### API-Endpunkt

```python
import requests

response = requests.post(
    "http://localhost:7865/v1/generation/text-to-image",
    json={
        "prompt": "a beautiful sunset over mountains",
        "negative_prompt": "",
        "style_selections": ["Fooocus Enhance"],
        "performance_selection": "Quality",
        "aspect_ratios_selection": "1024×1024",
        "image_number": 1,
        "image_seed": -1,
    }
)

# Bild erhalten
image_data = response.json()
```

## Voreinstellungen

### Benutzerdefinierte Voreinstellung erstellen

Bearbeiten `presets/default.json`:

```json
{
    "default_model": "juggernautXL.safetensors",
    "default_refiner": "None",
    "default_loras": [
        ["detail_lora.safetensors", 0.5]
    ],
    "default_styles": ["Fooocus Enhance", "Cinematic"]
}
```

### Mit Preset starten

```bash
python launch.py --preset anime
```

## Vergleich: Fooocus vs Andere

| Funktion               | Fooocus  | A1111      | ComfyUI     |
| ---------------------- | -------- | ---------- | ----------- |
| Einrichtung            | Keine    | Mittel     | Komplex     |
| Lernkurve              | Einfach  | Mittel     | Schwierig   |
| Flexibilität           | Gering   | Hoch       | Am höchsten |
| Am besten geeignet für | Anfänger | Power-User | Entwickler  |

## Fehlerbehebung

### Kein Speicher mehr

```bash

# Niedrigen VRAM-Modus verwenden
python launch.py --always-low-vram

# Oder Refiner deaktivieren

# In der UI: Reiter Model > Refiner > None
```

### Langsame Generierung

* Aktiviere die Voreinstellung "Extreme Speed"
* Refiner deaktivieren
* Kleinere Auflösung verwenden

### Modell wird nicht geladen

```bash

# Prüfen, ob Modell existiert
ls -la /workspace/Fooocus/models/checkpoints/

# Dateigröße prüfen (sollte für SDXL ~6GB sein)
du -h /workspace/Fooocus/models/checkpoints/*.safetensors
```

### Schwarze Bilder

* CFG-Skala reduzieren
* Seed ändern
* Anderen Prompt ausprobieren

## Ergebnisse herunterladen

```bash

# Bilder befinden sich im Ordner outputs
scp -P <port> -r root@<proxy>:/workspace/Fooocus/outputs/ ./
```

## Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

| GPU       | Stundensatz | Tagessatz | 4-Stunden-Sitzung |
| --------- | ----------- | --------- | ----------------- |
| RTX 3060  | \~$0.03     | \~$0.70   | \~$0.12           |
| RTX 3090  | \~$0.06     | \~$1.50   | \~$0.25           |
| RTX 4090  | \~$0.10     | \~$2.30   | \~$0.40           |
| A100 40GB | \~$0.17     | \~$4.00   | \~$0.70           |
| A100 80GB | \~$0.25     | \~$6.00   | \~$1.00           |

*Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads (oft 30–50% günstiger)
* Bezahlen mit **CLORE** Token
* Preise bei verschiedenen Anbietern vergleichen

## Nächste Schritte

* Stable Diffusion WebUI – Mehr Kontrolle
* ComfyUI Workflows – Knotenbasiert
* FLUX Generation – Neueres Modell