# Wie man Diffusion-Image-GGUFs in ComfyUI ausführt

ComfyUI ist eine Open-Source-GUI, API und Backend für Diffusionsmodelle, die eine nodenbasierte (Graph/Flussdiagramm-) Oberfläche verwendet. [ComfyUI](https://github.com/comfyanonymous/ComfyUI) ist die beliebteste Methode, Workflows für Bildmodelle wie Qwen-Image-Edit oder FLUX auszuführen.

GGUF ist eines der besten und effizientesten Formate, um Diffusionsmodelle lokal auszuführen, und [Unsloth Dynamic](https://unsloth.ai/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs) GGUFs verwenden intelligente Quantisierung, um die Genauigkeit selbst bei niedrigen Bitraten zu erhalten.

Sie lernen, wie man ComfyUI (Windows, Linux, macOS) installiert, Workflows erstellt und abstimmt [Hyperparameter](#workflow-and-hyperparameters-1) in diesem schrittweisen Tutorial.

#### Voraussetzungen & Anforderungen

Du benötigst keine GPU, um diffusions-GGUFs auszuführen, nur eine CPU mit RAM. VRAM ist nicht erforderlich, beschleunigt die Inferenz jedoch erheblich. Für beste Ergebnisse sollte dein insgesamt nutzbarer Speicher (RAM + VRAM / vereinigt) etwas größer sein als die GGUF-Größe; zum Beispiel ist die 4-Bit (Q4\_K\_M) `unsloth/Qwen-Image-Edit-2511-GGUF` ist 13,1 GB groß, daher solltest du mindestens \~13,2 GB kombinierten Speicher haben. Du findest alle Unsloth Diffusion-GGUFs in [unserer Sammlung](https://huggingface.co/collections/unsloth/unsloth-diffusion-ggufs).

Wir empfehlen mindestens 3-Bit-Quantisierung für Diffusionsmodelle, da ihre Schichten, insbesondere die Vision-Komponenten, sehr empfindlich gegenüber Quantisierung sind. Unsloth Dynamic Quants hebt wichtige Schichten hoch, um so viel Genauigkeit wie möglich wiederherzustellen.

## 📖 ComfyUI-Anleitung

ComfyUI stellt die gesamte Bildgenerierungspipeline als Graph von verbundenen Nodes dar. Diese Anleitung konzentriert sich auf Maschinen mit CUDA, aber die Anweisungen zum Erstellen auf Apple oder CPU sind ähnlich.

### #1. Installation & Einrichtung

Um ComfyUI zu installieren, können Sie die Desktop-App für Windows- oder Mac-Geräte herunterladen [hier](https://www.comfy.org/download). Andernfalls führen Sie zur Einrichtung von ComfyUI zum Ausführen von GGUF-Modellen Folgendes aus:

```bash
mkdir comfy_ggufs
cd comfy_ggufs
python -m venv .venv
source .venv/bin/activate

git clone https://github.com/comfyanonymous/ComfyUI.git
cd ComfyUI
pip install -r requirements.txt

cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF
cd ComfyUI-GGUF
pip install -r requirements.txt
cd ../..
```

### #2. Modelle herunterladen

Diffusionsmodelle benötigen typischerweise 3 Modelle. Einen Variational AutoEncoder (VAE), der den Bildpixelraum in den latenten Raum kodiert, einen Textencoder, der Text in Eingabe-Embeddings übersetzt, und den eigentlichen Diffusions-Transformer. Sie finden alle Unsloth-Diffusions-GGUFs in unserer [Sammlung hier](https://huggingface.co/collections/unsloth/unsloth-diffusion-ggufs).

Sowohl das Diffusionsmodell als auch der Text-Encoder können im GGUF-Format vorliegen, während wir typischerweise safetensors für das VAE verwenden. Laden wir die Modelle herunter, die wir verwenden werden.

```bash
cd models

curl -L -C - -o vae/flux2-vae.safetensors \
  https://huggingface.co/Comfy-Org/flux2-dev/resolve/main/split_files/vae/flux2-vae.safetensors
  
curl -L -C - -o text_encoders/Mistral-Small-3.2-24B-Instruct-2506-UD-Q4_K_XL.gguf \
  https://huggingface.co/unsloth/Mistral-Small-3.2-24B-Instruct-2506-GGUF/resolve/main/Mistral-Small-3.2-24B-Instruct-2506-UD-Q4_K_XL.gguf

curl -L -C - -o text_encoders/Mistral-Small-3.2-24B-Instruct-2506-mmproj-BF16.gguf \
  https://huggingface.co/unsloth/Mistral-Small-3.2-24B-Instruct-2506-GGUF/resolve/main/mmproj-BF16.gguf
  
curl -L -C - -o unet/flux2-dev-Q4_K_M.gguf \
  https://huggingface.co/unsloth/FLUX.2-dev-GGUF/resolve/main/flux2-dev-Q4_K_M.gguf
```

Siehe GGUF-Uploads für: [Qwen-Image-Edit-2511](https://huggingface.co/unsloth/Qwen-Image-Edit-2511-GGUF), [FLUX.2-dev](https://huggingface.co/unsloth/FLUX.2-dev-GGUF) und [Qwen-Image-Layered](https://huggingface.co/unsloth/Qwen-Image-Layered-GGUF)

{% hint style="warning" %}
Das Format des VAE und des Diffusionsmodells kann sich von den Diffusers-Checkpoints unterscheiden. Verwende nur Checkpoints, die mit ComfyUI kompatibel sind.
{% endhint %}

Diese Dateien müssen in den richtigen Ordnern liegen, damit ComfyUI sie sehen kann. Außerdem muss der Vision-Tower in der mmproj-Datei dasselbe Präfix wie der Text-Encoder verwenden.

Lade später auch Referenzbilder herunter, die verwendet werden sollen.

```bash
curl -L -C - -o ../input/sloth1.jpg \
    https://unsloth.ai/cgi/image/_1d5a5685-2d88-44ca-b50f-ba432cd646ef_9CGCY8lvw4D9JkOdueqsk.jpeg?width=1920&quality=80&format=auto

curl -L -C - -o ../input/sloth2.jpg \
    https://unsloth.ai/cgi/image/UnSloth_GPU_Front_-_Confetti_ArcSk-MR4MMN215UutOFZ.png?width=1920&quality=80&format=auto
```

#### Workflow und Hyperparameter

Du kannst dir auch unsere detaillierte [#workflow-and-hyperparameters-1](#workflow-and-hyperparameters-1 "mention") Anleitung.

Wechsle in das ComfyUI-Verzeichnis und führe aus:

```bash
python main.py
```

Dies startet einen Webserver, der Ihnen Zugriff erlaubt auf `https://127.0.0.1:8188` . Wenn Sie dies in der Cloud ausführen, müssen Sie sicherstellen, dass Portweiterleitung eingerichtet ist, um von Ihrer lokalen Maschine darauf zugreifen zu können.

Workflows werden als JSON-Dateien gespeichert, die in Ausgabebilder (PNG-Metadaten) eingebettet sind oder als separate `.json` Dateien. Sie können:

* Ein Bild per Drag & Drop in ComfyUI ziehen, um dessen Workflow zu laden
* Workflows über das Menü exportieren/importieren
* Workflows als JSON-Dateien teilen

Im Folgenden zwei Beispiele für FLUX 2 JSON-Dateien, die du herunterladen und verwenden kannst:

{% file src="<https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FpDft2nBJR3D1ti1zxr9v%2Funsloth_flux2_t2i_gguf.json?alt=media&token=43f65886-0a81-4bad-b6dd-f6d4daa89a9b>" %}

{% file src="<https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FnCcWbaZDgETpESU0jrml%2Funsloth_flux2_i2i_gguf.json?alt=media&token=24c6926e-5b49-4aa5-93d7-9b6a63a0a3fa>" %}

{% columns %}
{% column %}
Anstatt den Workflow von Grund auf neu einzurichten, können Sie den Workflow hier herunterladen.

Laden Sie ihn auf der Browserseite, indem Sie auf das Comfy-Logo -> Datei -> Öffnen klicken -> Wählen Sie dann die `unsloth_flux2_t2i_gguf.json` Datei, die Sie gerade heruntergeladen haben. Es sollte wie unten aussehen:
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FqoxBnRlnYrmzLfZshE1Z%2FScreenshot%20from%202025-12-29%2014-37-00.png?alt=media&#x26;token=1b1517b7-d44f-4e95-a5ed-759a4e0f74ec" alt="" width="254"><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FWCVbmRbpijuj78M1rBtK%2FScreenshot%20from%202025-12-29%2021-41-52.png?alt=media&#x26;token=8378c519-1610-4752-bb71-4b95fdf00037" alt="" width="563"><figcaption></figcaption></figure>

Dieser Workflow basiert auf dem offiziell veröffentlichten ComfyUI-Workflow, verwendet jedoch die GGUF-Loader-Erweiterung und ist vereinfacht, um die Text-zu-Bild-Funktionalität zu veranschaulichen.&#x20;

### #3. Inferenz

ComfyUI ist hochgradig anpassbar. Sie können Modelle mischen und extrem komplexe Pipelines erstellen. Für eine grundlegende Text-zu-Bild-Konfiguration müssen wir das Modell laden, Prompt- und Bilddetails angeben und eine Sampling-Strategie festlegen.&#x20;

**Modelle hochladen + Prompt setzen**

Wir haben die Modelle bereits heruntergeladen, daher müssen wir nur die richtigen auswählen. Für Unet Loader wählen Sie `flux2-dev-Q4_K_M.gguf`, für CLIPLoader wählen Sie `Mistral-Small-3.2-24B-Instruct-2506-UD-Q4_K_XL.gguf`, und für Load VAE wählen Sie `flux2-vae.safetensors`.&#x20;

Du kannst jeden gewünschten Prompt setzen. Da classifier free guidance im Modell integriert ist, müssen wir keinen negativen Prompt angeben.

**Bildgröße + Sampler-Parameter**

Flux2-dev unterstützt verschiedene Bildgrößen. Du kannst rechteckige Formen erstellen, indem du die Werte für Breite und Höhe setzt. Bei den Sampler-Parametern kannst du mit anderen Samplern als euler experimentieren und mehr oder weniger Sampling-Schritte verwenden. Ändere die RandomNoise-Einstellung von randomize auf fixed, wenn du sehen möchtest, wie sich unterschiedliche Einstellungen auf die Ausgaben auswirken.

**Ausführen**

Klicke auf Ausführen und ein Bild wird in 45–60 Sekunden erzeugt. Dieses Ausgabebild kann gespeichert werden. Das Interessante ist, dass die Metadaten des gesamten Comfy-Workflows im Bild gespeichert werden. Du kannst es teilen und jeder kann sehen, wie es erstellt wurde, indem er es in der UI lädt.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FfSKbmlievhyLzNmQxD88%2Funsloth_flux2_t2i_gguf.png?alt=media&#x26;token=e9e1d8f0-777c-4083-823d-aeb3e77f5cf8" alt="" width="188"><figcaption></figcaption></figure>

**Mehrfach-Referenz-Generierung**

Ein wichtiges Merkmal von Flux2 ist die Multi-Reference-Generierung, bei der du mehrere Bilder angeben kannst, die zur Steuerung der Generierung verwendet werden. Lade dieses Mal die `unsloth_flux2_i2i_gguf.json`. Wir werden dieselben Modelle verwenden; der einzige Unterschied diesmal sind zusätzliche Nodes, um die Referenzbilder auszuwählen, die wir zuvor heruntergeladen haben. Du wirst bemerken, dass sich der Prompt auf beide bezieht `Bild 1` und `Bild 2` bezieht, welche als Prompt-Anker für die Bilder fungieren. Sobald geladen, klicken Sie auf Ausführen, und Sie sehen eine Ausgabe, die unsere zwei einzigartigen Faultier-Charaktere zusammen erstellt, während deren Ähnlichkeit bewahrt wird.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2FYyWL5368gfbwPAl8bhQ0%2Funsloth_flux2_i2i_gguf.png?alt=media&#x26;token=8857c028-5079-4eae-aec2-b02387bf2b23" alt="" width="188"><figcaption></figcaption></figure>

## 🎯 Workflow und Hyperparameter

Für Text-zu-Bild-Workflows müssen wir einen Prompt, Sampling-Parameter, Bildgröße, Guidance-Scale und alle Optimierungskonfigurationen angeben.

#### **Sampling**

Sampling funktioniert anders als bei LLMs. Anstatt ein Token nach dem anderen zu sampeln, sampeln wir das gesamte Bild über mehrere Schritte. Jeder Schritt „entrauscht" das Bild progressiv, was bedeutet, dass bei mehr Schritten das Bild tendenziell eine höhere Qualität hat. Es gibt auch verschiedene Sampling-Algorithmen, die von First-Order- und Second-Order-Algorithmen bis hin zu deterministischen und stochastischen Algorithmen reichen. Für dieses Tutorial verwenden wir euler, einen standardmäßigen Sampler, der Qualität und Geschwindigkeit ausbalanciert.

#### **Guidance**

Guidance ist ein weiterer wichtiger Hyperparameter für Diffusionsmodelle. Es gibt viele Varianten von Guidance, aber die zwei am weitesten verbreiteten Formen sind **classifier free guidance (CFG)** und Guidance-Distillation. Das Konzept der classifier free guidance stammt aus [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). Historisch brauchte man ein separates Klassifizierungsmodell, um das Modell an die Eingabebedingung anzupassen, aber dieses Paper zeigt tatsächlich, dass CFG die Differenz zwischen den konditionalen und unbedingten Vorhersagen des Modells verwendet, um eine Guidance-Richtung zu bilden.

In der Praxis ist es keine unbedingte Vorhersage, sondern eine Vorhersage für einen negativen Prompt, das heißt ein Prompt, das wir auf keinen Fall möchten und von dem wir uns fernsteuern sollten. Bei der Verwendung von CFG benötigst du kein separates Modell, aber du brauchst einen zweiten Inferenzschritt vom unbedingten oder negativen Prompt. Andere Modelle haben CFG bereits beim Training integriert, aber du kannst dennoch die Stärke der Guidance einstellen. Dies ist getrennt von CFG, da es keinen zweiten Inferenzschritt benötigt, aber es ist trotzdem ein einstellbarer Hyperparameter, um zu bestimmen, wie stark seine Wirkung ist.

#### **Fazit**

Alles zusammengefasst: Du setzt einen Prompt, um dem Modell zu sagen, was es erzeugen soll, der Text-Encoder kodiert den Text, das VAE kodiert das Bild, beide Embeddings werden entsprechend den Sampling-Parametern + Guidance durch das Diffusionsmodell geführt, und schließlich wird die Ausgabe vom VAE decodiert, was zu einem nutzbaren Bild führt.

### Kernkonzepte & Glossar

* **Latent**: Komprimierte Bildrepräsentation (worauf das Modell arbeitet).
* **Conditioning**: Text-/Bildinformationen, die die Generierung steuern.
* **Diffusionsmodell / UNet**: Neuronales Netzwerk, das das Entrauschen durchführt.
* **VAE**: Encoder/Decoder zwischen Pixelebene und latenter Darstellung.
* **CLIP (Text-Encoder)**: Wandelt einen Prompt in Embeddings um.
* **Sampler**: Algorithmus, der das Latent iterativ entrauscht.
* **Scheduler**: Steuert den Rauschplan über die Schritte.
* **Nodes**: Operationen (Modell laden, Text encodieren, sampeln, decodieren usw.).
* **Edges**: Datenfluss zwischen den Nodes.
