FLUX.1

Führe FLUX.1-Bildgenerierung von Black Forest Labs auf Clore.ai aus

Schnellere Alternative! FLUX.2 Klein erzeugt Bilder in < 0,5 Sekunden (vs. 10–30 s für FLUX.1) bei vergleichbarer Qualität. Diese Anleitung ist weiterhin relevant für LoRA-Training und ControlNet-Workflows.

Hochmodernes Bildgenerierungsmodell von Black Forest Labs auf CLORE.AI-GPUs.

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

Warum FLUX.1?

• Beste Qualität - Überlegen gegenüber SDXL und Midjourney v5

• Textdarstellung - Tatsächlich lesbarer Text in Bildern

• Prompt-Befolgung - Hervorragende Einhaltung von Anweisungen

• Schnelle Varianten - FLUX.1-schnell für schnelle Generierung

Modellvarianten

Modell	Geschwindigkeit	Qualität	VRAM	Lizenz
FLUX.1-schnell	Schnell (4 Schritte)	Gut	12 GB+	Apache 2.0
FLUX.1-dev	Mittel (20 Schritte)	Hervorragend	16 GB+	Nicht-kommerziell
FLUX.1-pro	Nur API	Am besten	-	Kommerziell

Schnellbereitstellung auf CLORE.AI

Docker-Image:

ghcr.io/huggingface/text-generation-inference:latest

Ports:

22/tcp
7860/http

Für die einfachste Bereitstellung verwenden Sie ComfyUI mit FLUX-Nodes.

Installationsmethoden

Methode 1: ComfyUI (empfohlen)

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

# FLUX-Modelle herunterladen
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# Erforderliche Komponenten herunterladen
cd ../clip
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/clip_l.safetensors
wget https://huggingface.co/comfyanonymous/flux_text_encoders/resolve/main/t5xxl_fp16.safetensors

cd ../vae
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/ae.safetensors

# ComfyUI ausführen
python main.py --listen 0.0.0.0

Methode 2: Diffusers

pip install diffusers transformers accelerate torch

python << 'PYEOF'
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    "Eine Katze in einem Raumanzug auf dem Mars",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

Methode 3: Fooocus

Fooocus hat integrierte FLUX-Unterstützung:

git clone https://github.com/lllyasviel/Fooocus
cd Fooocus
pip install -r requirements.txt

# FLUX-Modell in models/checkpoints/ herunterladen
python launch.py --listen

ComfyUI-Workflow

FLUX.1-schnell (Schnell)

Benötigte Nodes:

1. Diffusionsmodell laden → flux1-schnell.safetensors

2. DualCLIPLoader → clip_l.safetensors + t5xxl_fp16.safetensors

3. CLIP-Textkodierung → Ihr Prompt

4. Leeres SD3-Latentbild → Abmessungen festlegen

5. KSampler → Schritte: 4, cfg: 1,0

6. VAE-Dekodierung → ae.safetensors

7. Bild speichern

FLUX.1-dev (Qualität)

Gleicher Workflow, aber:

• Schritte: 20–50

• CFG: 3,5

• guidance_scale im Prompt verwenden

Python-API

Grundlegende Generierung

import torch
from diffusers import FluxPipeline

# Modell laden
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Generieren
image = pipe(
    prompt="Ein ruhiger japanischer Garten mit Kirschblüten",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")

Mit Speicheroptimierung

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)

# Optimierungen aktivieren
pipe.enable_model_cpu_offload()  # Spart ca. 10 GB VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Porträt eines Cyberpunk-Samurai",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]

Stapelgenerierung

prompts = [
    "Ein Sonnenuntergang über Bergen",
    "Eine futuristische Stadt bei Nacht",
    "Ein Unterwasser-Korallenriff",
]

images = pipe(
    prompts,
    height=1024,
    width=1024,
    num_inference_steps=4,
).images

for i, img in enumerate(images):
    img.save(f"output_{i}.png")

FLUX.1-dev (Höhere Qualität)

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Hyperrealistisches Porträt eines älteren Fischers",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]

Prompt-Tipps

FLUX ist besonders gut bei:

• Text in Bildern: "Ein Neonschild mit der Aufschrift 'OPEN 24/7'"

• Komplexen Szenen: "Eine belebte Straße in Tokio bei Nacht mit Reflexionen"

• Spezifischen Stilen: "Ölgemälde im Stil von Monet"

• Detaillierten Beschreibungen: Lange, detaillierte Prompts funktionieren gut

Beispiel-Prompts

# Fotorealistisch
Ein professionelles Foto eines Golden-Retriever-Welpen, der in Herbstblättern spielt, 
geringe Tiefenschärfe, warmes Nachmittagslicht, Canon EOS R5

# Künstlerisch
Ein impressionistisches Gemälde eines Pariser Cafés im Regen, 
Öl auf Leinwand, sichtbare Pinselstriche, warme Farben

# Textdarstellung
Ein Vintage-Filmposter mit dem Titel "COSMIC VOYAGE" in fetten Retro-Buchstaben,
Sci-Fi-Ästhetik der 1960er, Astronautenillustration

# Komplexe Szene
Ein gemütliches Bibliotheksinterieur mit Bücherregalen bis zur Decke, 
ein Ledersessel neben einem Kamin, Regen durch ein Fenster sichtbar,
warmes Lampenlicht, fotorealistisch

Speicheroptimierung

Für 12 GB VRAM (RTX 3060)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # Verwenden Sie fp16 statt bf16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# In geringerer Auflösung generieren
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]

Für 8 GB VRAM

Verwenden Sie die quantisierte Version oder ComfyUI mit GGUF:

# In ComfyUI die GGUF-Nodes installieren
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# Quantisiertes Modell herunterladen
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf

Leistungsvergleich

Modell	Schritte	Zeit (4090)	Qualität
FLUX.1-schnell	4	~3 Sek.	Gut
FLUX.1-dev	20	~12 Sek.	Hervorragend
FLUX.1-dev	50	~30 Sek.	Am besten
SDXL	30	~8 Sek.	Gut

GPU-Anforderungen

Einrichtung	Minimum	Empfohlen
FLUX.1-schnell	12 GB	16 GB+
FLUX.1-dev	16 GB	24 GB+
Mit CPU-Offload	8 GB	12 GB+
Quantisiert (GGUF)	6 GB	8 GB+

GPU-Voreinstellungen

RTX 3060 12 GB (Budget)

# Quantisiertes Modell verwenden
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Einstellungen:
# - nur schnell (dev kann OOM verursachen)
# - 512x512 bis 768x768
# - 4 Schritte
# - Batch-Größe 1

RTX 3090 24 GB (Optimal)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_vae_tiling()

# Einstellungen:
# - schnell: 1024x1024, Batch 2
# - dev: 1024x1024, Batch 1
# - 20–30 Schritte für dev
# - VAE-Tiling für hohe Auflösung aktivieren

RTX 4090 24 GB (Leistung)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.float16
)
pipe.to("cuda")

# Einstellungen:
# - schnell: 1024x1024, Batch 4
# - dev: 1024x1024, Batch 2
# - 30–50 Schritte für beste Qualität
# - 1536x1536 mit Tiling möglich

A100 40 GB/80 GB (Produktion)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Einstellungen:
# - schnell: 1024x1024, Batch 8+
# - dev: 1024x1024, Batch 4
# - 50 Schritte für maximale Qualität
# - 2048x2048 möglich

Kostenschätzung

GPU	Stündlich	Bilder/Stunde
RTX 3060 12 GB	~$0.03	~200 (schnell)
RTX 3090 24 GB	~$0.06	~600 (schnell)
RTX 4090 24 GB	~$0.10	~1000 (schnell)
A100 40GB	~$0.17	~1500 (schnell)

Fehlerbehebung

Speicher voll

# CPU-Offload verwenden
pipe.enable_model_cpu_offload()

# Oder sequentielles CPU-Offload (langsamer, aber weniger VRAM)
pipe.enable_sequential_cpu_offload()

# Auflösung reduzieren
height=768, width=768

Langsame Generierung

• FLUX.1-schnell verwenden (4 Schritte)

• torch.compile aktivieren: pipe.unet = torch.compile(pipe.unet)

• Auf älteren GPUs fp16 statt bf16 verwenden

Schlechte Qualität

• Mehr Schritte verwenden (FLUX-dev: 30–50)

• guidance_scale erhöhen (3,0–4,0 für dev)

• Detailliertere Prompts schreiben

---

FLUX LoRA

LoRA-(Low-Rank-Adaptation)-Gewichte ermöglichen es Ihnen, FLUX für bestimmte Stile, Charaktere oder Konzepte feinzujustieren, ohne das gesamte Modell neu zu trainieren. Hunderte von Community-LoRAs sind auf HuggingFace und CivitAI verfügbar.

Installation

pip install diffusers transformers accelerate peft

Eine einzelne LoRA laden

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# LoRA-Gewichte aus einer lokalen Datei laden
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "Ein Porträt im Stil von Van Gogh, wirbelnde Pinselstriche",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")

Vom HuggingFace Hub laden

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# LoRA direkt aus dem HuggingFace-Repo laden
pipe.load_lora_weights(
    "username/my-flux-lora",          # HF-Repo-ID
    weight_name="my_lora.safetensors" # Dateiname im Repo
)

image = pipe(
    "trigger_word eine schöne Landschaft",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

LoRA-Skala (Stärke)

# Den Einfluss der LoRA mit cross_attention_kwargs steuern
image = pipe(
    "Eine Cyberpunk-Figur, Neonlichter",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0,0 = kein Effekt, 1,0 = voller Effekt
).images[0]

Mehrere LoRAs kombinieren

from diffusers import FluxPipeline
import torch

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Erste LoRA laden
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Zweite LoRA laden
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# Mit Gewichten kombinieren
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger in aufwendigem Kostüm, artistic_trigger-Stil,",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

LoRA entladen

# LoRA-Gewichte entfernen, um das Basismodell wiederherzustellen
pipe.unload_lora_weights()

Ihre eigene FLUX LoRA trainieren

# Verwenden Sie kohya-ss oder ai-toolkit für das FLUX-LoRA-Training
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# Datensatz vorbereiten: 10–30 Bilder mit Bildunterschriften
# Config-YAML bearbeiten, dann:
python run.py config/flux_lora_train.yaml

Empfohlene LoRA-Quellen

Quelle	URL	Hinweise
CivitAI	civitai.com	Große Community-Bibliothek
HuggingFace	huggingface.co/models	Nach FLUX filtern
Replicate	replicate.com	Trainierte Modelle durchsuchen

---

ControlNet für FLUX

ControlNet ermöglicht die Steuerung der FLUX-Generierung mit strukturellen Eingaben wie Canny-Kanten, Tiefenkarten und Poseskeletten. XLabs-AI hat die ersten ControlNet-Modelle speziell für FLUX.1 veröffentlicht.

Installation

pip install diffusers transformers accelerate controlnet-aux pillow

FLUX ControlNet Canny (XLabs-AI)

import torch
import numpy as np
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Das FLUX-ControlNet-Modell laden (Canny-Variante)
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# Die Pipeline mit ControlNet laden
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Das Steuerbild vorbereiten (Canny-Kanten)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# Mit ControlNet-Steuerung generieren
image = pipe(
    prompt="Eine futuristische Stadtlandschaft mit Neonschildern, fotorealistisch, 8K",
    control_image=control_image,
    controlnet_conditioning_scale=0.7,
    num_inference_steps=25,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(0),
).images[0]

image.save("controlnet_flux_output.png")

FLUX ControlNet Depth

import torch
from PIL import Image
from diffusers import FluxControlNetPipeline, FluxControlNetModel
from diffusers.utils import load_image
from transformers import pipeline as hf_pipeline

# Tiefenschätzer laden
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# Tiefenkarte vorbereiten
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# ControlNet Depth laden
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Eine Marmorskulptur eines Kriegers, dramatische Beleuchtung, Museumsfoto",
    control_image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("depth_controlnet_output.png")

Multi-ControlNet für FLUX

import torch
from diffusers import FluxControlNetPipeline, FluxMultiControlNetModel, FluxControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector

# Mehrere ControlNets laden
controlnet_canny = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)
controlnet_depth = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-depth-diffusers",
    torch_dtype=torch.bfloat16
)

# Zu MultiControlNet zusammenführen
multi_controlnet = FluxMultiControlNetModel([controlnet_canny, controlnet_depth])

pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=multi_controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Ein Ritter in Rüstung, der in einem Wald steht, dramatische Beleuchtung",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]

Verfügbare FLUX-ControlNet-Modelle

Modell	Repo	Anwendungsfall
Canny	XLabs-AI/flux-controlnet-canny-diffusers	Kanten-geführte Generierung
Depth	XLabs-AI/flux-controlnet-depth-diffusers	Tiefen-geführte Generierung
HED/Soft Edge	XLabs-AI/flux-controlnet-hed-diffusers	Weiche strukturelle Steuerung
Pose	XLabs-AI/flux-controlnet-openpose-diffusers	Pose-geführte Porträts

ControlNet-Tipps

• conditioning_scale 0,5–0,8 funktioniert am besten für FLUX (zu hoch verliert Kreativität)

• Verwende 1024×1024 oder Vielfache für beste Qualität

• Mit LoRA kombinieren für Stil- + Strukturkontrolle

• Niedrigere Schritte (20–25) reichen mit ControlNet meist aus

---

FLUX.1-schnell: Modus für schnelle Generierung

FLUX.1-schnell ist die destillierte, auf Geschwindigkeit optimierte Variante von FLUX. Sie erzeugt hochwertige Bilder in nur 4 Schritten (vs. 20–50 für FLUX.1-dev) und ist damit ideal für schnelles Prototyping und Workflows mit hohem Durchsatz.

Wesentliche Unterschiede zu FLUX.1-dev

Funktion	FLUX.1-schnell	FLUX.1-dev
Schritte	4	20–50
Geschwindigkeit (4090)	~3 Sek.	~12–30 Sek.
Lizenz	Apache 2.0 (frei kommerziell)	Nicht-kommerziell
guidance_scale	0,0 (kein CFG)	3.5
Qualität	Gut	Hervorragend
VRAM	12 GB+	16 GB+

Lizenzhinweis: FLUX.1-schnell ist unter Apache 2.0 lizenziert — Sie können es frei in kommerziellen Produkten verwenden. FLUX.1-dev benötigt eine separate kommerzielle Lizenz von Black Forest Labs.

Schnellstart

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

image = pipe(
    prompt="Ein atemberaubender Luftblick auf New York City zur goldenen Stunde, fotorealistisch",
    height=1024,
    width=1024,
    num_inference_steps=4,   # Nur 4 Schritte nötig!
    guidance_scale=0.0,       # CFG für schnell deaktiviert
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("In ~3 Sekunden auf einer RTX 4090 generiert!")

Hochdurchsatz-Stapelgenerierung

import torch
from diffusers import FluxPipeline
from pathlib import Path

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")  # Für Geschwindigkeit auf der GPU belassen, kein cpu_offload verwenden

output_dir = Path("schnell_outputs")
output_dir.mkdir(exist_ok=True)

prompts = [
    "Ein ruhiger Bergsee im Morgengrauen, neblige Atmosphäre",
    "Ein geschäftiger Tokyoter Straßenmarkt bei Nacht, Neon-Reflexionen",
    "Ein Makrofoto eines von Tau bedeckten Spinnennetzes",
    "Eine alte Bibliothek mit schwebenden Büchern und magischem Licht",
    "Eine futuristische Unterwasserstadt mit biolumineszentem Meeresleben",
]

# Stapelgenerierung
for i, prompt in enumerate(prompts):
    image = pipe(
        prompt=prompt,
        height=1024,
        width=1024,
        num_inference_steps=4,
        guidance_scale=0.0,
        generator=torch.Generator(device="cuda").manual_seed(i),
    ).images[0]
    image.save(output_dir / f"image_{i:04d}.png")
    print(f"{i+1}/{len(prompts)} generiert: {prompt[:50]}...")

Mehrere Seitenverhältnisse mit schnell

import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# FLUX unterstützt flexible Seitenverhältnisse
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "Ein majestätischer Wolf in einem verschneiten Wald, professionelle Wildlife-Fotografie"

for name, (width, height) in resolutions.items():
    image = pipe(
        prompt=prompt,
        height=height,
        width=width,
        num_inference_steps=4,
        guidance_scale=0.0,
    ).images[0]
    image.save(f"schnell_{name}.png")
    print(f"{name} gespeichert: {width}x{height}")

schnell mit Speicheroptimierungen

import torch
from diffusers import FluxPipeline

# Für 12 GB VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 spart Speicher auf älteren GPUs
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="Eine gemütliche Hütte in einem Herbstwald, warmes Licht durch die Fenster",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")

Leistungs-Benchmarks (schnell)

GPU	VRAM	Zeit/Bild (1024 px)	Bilder/Stunde
RTX 3060 12 GB	12 GB	~8 Sek.	~450
RTX 3090 24 GB	24 GB	~4 Sek.	~900
RTX 4090 24 GB	24 GB	~3 Sek.	~1200
A100 40GB	40 GB	~2 Sek.	~1800

Wann man schnell vs. dev verwenden sollte

Verwende FLUX.1-schnell, wenn:

• Schnelles Prototyping / Testen von Prompts

• Batch-Generierung mit hohem Volumen

• Kommerzielle Projekte (Apache 2.0)

• Begrenztes GPU-Budget

• Echtzeit- oder nahezu Echtzeitanwendungen

Verwende FLUX.1-dev, wenn:

• Maximale Bildqualität hat Priorität

• Feine Details und komplexe Szenen

• Forschung / künstlerische Arbeit

• Kombination mit LoRA/ControlNet (dev neigt dazu, besser zu reagieren)

---

Nächste Schritte

• ComfyUI - Beste Oberfläche für FLUX

• Fooocus - Einfache Alternative

• ControlNet - Geführte Generierung

• Kohya-Training - Trainiere FLUX-LoRAs