FLUX.2 lokaal uitvoeren op een RTX 3090: zo doe je dat

In deze tutorial leer je hoe je het FLUX.2-model voor beeldgeneratie lokaal draait. We richten de GPU-omgeving in, downloaden een gequantiseerde versie van FLUX.2, laden die efficiënt in GPU- en RAM-geheugen, voeren inference uit en experimenteren vervolgens met verschillende configuratie-opties.

Een model van dit formaat draaien op een RTX 3090 kan uitdagend zijn, en deze tutorial richt zich op de eenvoudigste, meest praktische manier om FLUX.2 lokaal aan de praat te krijgen zonder onnodige complexiteit.

Als je geïnteresseerd bent in geavanceerde technieken voor modelbeheer en -optimalisatie, waaronder pruning, quantization en logging, raad ik de cursus Scalable AI Models with PyTorch Lightning aan. 

Wat is FLUX.2?

FLUX.2 is een model voor beeldgeneratie gebouwd voor echt creatief werk, niet alleen experimenten. Het maakt hoogwaardige, realistische beelden en houdt personages, stijlen en producten consistent over meerdere referentieafbeeldingen. Voortbouwend op het oorspronkelijke FLUX-model volgt het prompts nauwkeurig, rendert tekst duidelijk en gaat goed om met belichting, lay-outs en branding. 

FLUX.2 ondersteunt ook bewerken op hoge resolutie en is beschikbaar als kant-en-klare API’s en als open modellen die je lokaal kunt draaien, waardoor het praktisch, flexibel en eenvoudig in te passen is in echte productie-workflows.

FLUX.2 komt in vier hoofdvarianten: 

• FLUX.2 [max]
• FLUX.2 [pro]
• FLUX.2 [flex]
• FLUX.2 [dev]

Elke variant is ontworpen voor verschillende niveaus van controle, prestaties en implementatiebehoeften. 

In bredere leaderboard-vergelijkingen staan alle drie FLUX.2-varianten in de top 10 van beeldbewerkingsmodellen op de Artificial Analysis-leaderboard, waarbij FLUX.2 [max] en FLUX.2 [pro] beter presteren dan modellen zoals GPT-5 en de vorige generatie FLUX.1 Kontext-varianten.

Bron: Text to Image Leaderboard | Artificial Analysis

FLUX.2 lokaal draaien: een stapsgewijze gids

In de onderstaande stappen leg ik alles uit wat je moet weten om FLUX.2 lokaal te draaien met een RTX 3090 GPU. 

1. Systeemvereisten en vereisten vooraf

Controleer voordat je FLUX.2 lokaal draait of je systeem goed is ingericht voor GPU-inference.

Hardware

• NVIDIA GPU (RTX 3090 aanbevolen)
• 24 GB VRAM
• 64 GB systeem-RAM aanbevolen

NVIDIA-stuurprogramma’s en CUDA Toolkit

• Installeer NVIDIA-stuurprogramma’s: Zorg dat je de nieuwste NVIDIA GPU-stuurprogramma’s hebt geïnstalleerd met ondersteuning voor recente CUDA-versies (CUDA 12.1+ aanbevolen).
• Installeer CUDA Toolkit: Download en installeer de CUDA Toolkit vanaf de officiële NVIDIA CUDA Downloads-pagina om de compatibiliteit met GPU-extensies en custom kernels te verbeteren.

Voer de volgende opdracht uit in de terminal om de installatie te verifiëren:

nvidia-smiMogelijk gemaakt door

Zoals je ziet, hebben we een RTX 3090 GPU met CUDA-versie 13. 

Python en Jupyter

• Python 3.10+
• Jupyter Notebook of JupyterLab (aanbevolen voor gemakkelijk, interactief experimenteren)

pip install jupyterlab notebookMogelijk gemaakt door

Let op: We gebruiken Jupyter Notebook als onze programmeeromgeving. Dat maakt het eenvoudiger om te experimenteren, inference stap voor stap uit te voeren en direct in de notebook beelden te genereren en te bewerken.

2. PyTorch installeren met CUDA-ondersteuning

In deze stap installeren we PyTorch met CUDA-ondersteuning zodat inference op de GPU draait in plaats van de CPU. De opdracht hieronder installeert PyTorch, TorchVision en TorchAudio met vooraf gecompileerde CUDA-binaries, zodat je CUDA niet from scratch hoeft te bouwen.

!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130Mogelijk gemaakt door

Na installatie gebruikt PyTorch automatisch de GPU als die beschikbaar is en correct is geconfigureerd.

3. FLUX.2 en vereiste dependencies installeren

Vervolgens installeren we de kernbibliotheken die nodig zijn om FLUX.2 lokaal te draaien. Deze pakketten verzorgen modelladen, inference, GPU-versnelling, quantization en efficiënte datatransfer.

!pip install -q diffusers transformers accelerate bitsandbytes huggingface_hub protobuf sentencepiece hf_transferMogelijk gemaakt door

Eenmaal geïnstalleerd is je omgeving klaar om FLUX.2 te laden en te starten met beeldgeneratie en -bewerking.

4. GPU- en quantization-ondersteuning verifiëren

Voordat we FLUX.2 laden, controleren we of PyTorch de GPU ziet en of 4-bit quantization wordt ondersteund. Deze stap is belangrijk om te zorgen dat het model efficiënt binnen de geheugengrenzen van een RTX 3090 kan draaien.

import torch
import bitsandbytes as bnb

print(f"PyTorch Version: {torch.__version__}")
print(f"CUDA Version: {torch.version.cuda}")
print(f"Is CUDA available? {torch.cuda.is_available()}")
print(f"GPU Name: {torch.cuda.get_device_name(0)}")

# Check if 4-bit quantization is supported (Ampere 3090 supports this natively)
try:
    print(f"BitsAndBytes Version: {bnb.__version__}")
    print("4-bit quantization check: PASSED")
except ImportError:
    print("BitsAndBytes not installed correctly.")Mogelijk gemaakt door

De output bevestigt dat PyTorch correct is geïnstalleerd met CUDA-ondersteuning, je RTX 3090 GPU wordt gedetecteerd en bitsandbytes goed werkt met 4-bit quantization ingeschakeld, dus het systeem is klaar voor efficiënte GPU-inference.

PyTorch Version: 2.8.0+cu128
CUDA Version: 12.8
Is CUDA available? True
GPU Name: NVIDIA GeForce RTX 3090
BitsAndBytes Version: 0.49.0
4-bit quantization check: PASSEDMogelijk gemaakt door

5. FLUX.2 laden met 4-bit quantization

In deze stap laden we FLUX.2 [dev] met een 4-bit gequantiseerde checkpoint om het GPU-geheugenverbruik te verminderen en toch hoge beeldkwaliteit te behouden. Dit is essentieel om een groot model als FLUX.2 op een RTX 3090 te draaien.

We beginnen met het importeren van de vereiste bibliotheken en het definiëren van een paar belangrijke instellingen.

• repo_id verwijst naar de 4-bit FLUX.2 dev-checkpoint.
• device selecteert je GPU (eerste CUDA-device).
• torch_dtype stelt de rekprecision tijdens inference in. bfloat16 wordt vaak gebruikt omdat het geheugen reduceert en de snelheid kan verbeteren, terwijl de output stabiel blijft.

import torch
from transformers import Mistral3ForConditionalGeneration
from diffusers import Flux2Pipeline, Flux2Transformer2DModel

repo_id = "diffusers/FLUX.2-dev-bnb-4bit"
device = "cuda:0"
torch_dtype = torch.bfloat16Mogelijk gemaakt door

Vervolgens laden we de FLUX.2 image transformer-backbone (de hoofdcomponent die de image latents genereert) eerst op de CPU. Dit voorkomt dat VRAM volloopt tijdens het initiële laden en geeft de pipeline meer flexibiliteit om modules alleen naar de GPU te verplaatsen wanneer dat nodig is.

transformer = Flux2Transformer2DModel.from_pretrained(
  repo_id, subfolder="transformer", torch_dtype=torch_dtype, device_map="cpu"
)Mogelijk gemaakt door

Daarna laden we ook de text encoder op de CPU. De text encoder zet je prompt om in embeddings die de beeldgeneratie sturen. Door deze tijdens de setup op de CPU te houden, blijft er GPU-geheugen vrij voor de zwaardere onderdelen van het generatieproces.

text_encoder = Mistral3ForConditionalGeneration.from_pretrained(
  repo_id, subfolder="text_encoder", dtype=torch_dtype, device_map="cpu"
)Mogelijk gemaakt door

Tot slot assembleren we de volledige Diffusers-pipeline door de zojuist geladen transformer en text encoder in te voegen. 

De sleutelregel hier is enable_model_cpu_offload(): dit schakelt automatische CPU ↔ GPU-offloading in, wat betekent dat de pipeline delen van het model alleen op de GPU plaatst wanneer ze actief nodig zijn, en ze daarna weer terugzet naar de CPU. Dit is een van de eenvoudigste manieren om grote modellen op consumentengpu’s te draaien zonder handmatig device placement te beheren.

pipe = Flux2Pipeline.from_pretrained(
  repo_id, transformer=transformer, text_encoder=text_encoder, torch_dtype=torch_dtype
)
pipe.enable_model_cpu_offload()Mogelijk gemaakt door

6. Je eerste tekst-naar-beeld-generatie draaien

We zijn nu klaar om onze eerste afbeelding te genereren met FLUX.2. Om het eenvoudig te houden, beginnen we met één tekstprompt die een hyperrealistische macrofoto van een lieveheersbeestje beschrijft.

prompt = (
    "Realistic macro photo of a ladybug perched on the edge of a dew-covered rose petal, "
    "early morning mist, soft natural light, shallow depth of field, crisp detail, creamy bokeh."
)
Mogelijk gemaakt door

Vervolgens geven we de prompt door aan de pipeline en draaien we inference.

• We gebruiken 28 inference-stappen voor een balans tussen snelheid en beeldkwaliteit.
• Een guidance scale van 4 houdt het resultaat natuurlijk zonder de prompt te hard te forceren.
• Een vaste random seed zorgt voor reproduceerbare resultaten.

image = pipe(
  prompt=prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=28,
  guidance_scale=4,
).images[0]Mogelijk gemaakt door

Om te monitoren hoeveel GPU-geheugen tijdens inference wordt gebruikt, open je een terminal en voer je uit:

nvidia-smiMogelijk gemaakt door

Je zou ongeveer 21 GB aan GPU-VRAM in gebruik moeten zien met hoge GPU-belasting. Dat duidt erop dat het model de beschikbare resources efficiënt benut en op volle snelheid draait op de RTX 3090.

Zodra inference klaar is, kun je de gegenereerde afbeelding direct in de Jupyter Notebook bekijken door simpelweg het image-object te tonen:

imageMogelijk gemaakt door

Het resultaat is zeer gedetailleerd en realistisch. Het model volgt de prompt nauwkeurig en voegt subtiele details toe, zoals belichting en textuur, die niet expliciet waren gespecificeerd.

Tot slot slaan we de gegenereerde afbeelding lokaal op:

output_path = "flux2_local_full.png"
image.save(output_path)
print(f"Image saved to {output_path}")Mogelijk gemaakt door

Output:

Image saved to flux2_local_full.pngMogelijk gemaakt door

7. Geavanceerde prompting met gestructureerde JSON

FLUX.2 ondersteunt geavanceerde prompting-technieken die verder gaan dan platte tekst en veel fijnere controle over het eindbeeld mogelijk maken. Met gestructureerde JSON-prompts kun je scène-indeling, onderwerpen, belichting, camera-instellingen, sfeer en zelfs kleurpaletten met precieze hex-codes expliciet definiëren.

In deze sectie gebruiken we een gestructureerde JSON-prompt om de scène in detail te beschrijven. In plaats van één zin definiëren we de omgeving, onderwerpen, stijl, kleuren, belichting, cameragegevens en negatieve constraints in een helder en georganiseerd formaat. 

Dit helpt FLUX.2 om complexe instructies beter te begrijpen en voorspelbare, hoogwaardige resultaten te leveren.

advanced_prompt = """
{
  "scene": "New Year's Eve night on a rooftop overlooking a glowing city skyline",
  "subjects": [
    {
      "description": "Group of close friends including men and women in winter clothing, natural facial proportions, diverse appearances",
      "position": "center and slightly spread across the frame",
      "action": "standing together in a loose circle, some smiling softly, others quietly reflective, sharing the moment before midnight"
    }
  ],
  "style": "Cinematic semi-realistic illustration with grounded realism, subtle painterly softness",
  "color_palette": ["#0B132B", "#1C2541", "#EAEAEA", "#F4D35E"],
  "lighting": "Soft moonlight as ambient key light, warm glow from sparklers and nearby string lights illuminating faces, gentle contrast",
  "mood": "Warm, intimate, reflective, hopeful",
  "background": "Out-of-focus city skyline with distant fireworks softly lighting the sky, minimal visual noise",
  "composition": "Wide medium shot, balanced framing, friends forming a natural arc, negative space above for sky and fireworks",
  "camera": {
    "angle": "eye-level",
    "lens": "50mm cinematic look",
    "depth_of_field": "sharp focus on group, gentle background blur"
  },
  "details": [
    "subtle breath vapor in cold air",
    "soft fabric textures on coats and scarves",
    "sparklers emitting warm golden particles",
    "natural body language and expressions",
    "no exaggerated poses or faces"
  ],
  "negative_prompt": [
    "cartoon style",
    "emote proportions",
    "chibi",
    "oversized heads",
    "text",
    "watermark",
    "logo",
    "overcrowded scene",
    "harsh neon lighting",
    "over-saturation",
    "extra limbs",
    "distorted faces"
  ]
}
"""Mogelijk gemaakt door

Daarna draaien we inference met een hoger aantal stappen om meer detail vast te leggen, terwijl we de guidance scale gematigd houden voor een natuurlijke uitstraling.

image_2 = pipe(
  prompt=advanced_prompt,
  generator=torch.Generator(device=device).manual_seed(42),
  num_inference_steps=50,
  guidance_scale=4,
).images[0]Mogelijk gemaakt door

Om de gegenereerde afbeelding in de Jupyter Notebook te tonen:

image_2Mogelijk gemaakt door

De resulterende afbeelding volgt de gestructureerde prompt nauwgezet en legt de scène, sfeer, belichting en compositie vast zoals gespecificeerd. 

8. Afbeeldingen bewerken met FLUX.2 (image-to-image)

FLUX.2 ondersteunt ook bewerking van afbeeldingen, waarbij een referentieafbeelding als basis wordt gebruikt en het model veranderingen toepast gestuurd door een tekstprompt. Dit is vooral handig als je identiteit, gelaatskenmerken en huidskleur wilt behouden, terwijl je de scène, sfeer of omgeving rondom het onderwerp verandert.

Voor dit voorbeeld gebruiken we een foto van een Indiase vrouw van Pexels.com als referentieafbeelding:

Foto door cottonbro studio: https://www.pexels.com/photo/a-woman-with-a-nose-piercing-9317190/

We ontwerpen de prompt zorgvuldig om het model te instrueren het gezicht en de natuurlijke huidskleuren van de vrouw intact te houden, terwijl we de setting, belichting en emotionele expressie veranderen. Het doel is de afbeelding te bewerken zonder haar identiteit te veranderen.

from diffusers.utils import load_image

prompt = (
    "Using the provided reference image, generate a realistic photograph of a woman with a similar face, "
    "standing at night and looking up at the sky with stars with a subtle, sad expression. "
    "Natural skin tones, soft moonlight, gentle shadows, shallow depth of field, "
    "with blurred city lights in the background."
)Mogelijk gemaakt door

Vervolgens laden we de referentieafbeelding en geven die door aan de pipeline. FLUX.2 ondersteunt meerdere referentieafbeeldingen, maar hier gebruiken we één afbeelding om de bewerking te sturen.

indian_woman = load_image("https://images.pexels.com/photos/9317190/pexels-photo-9317190.jpeg")
image_3 = pipe(
    prompt=prompt,
    image=[indian_woman], 
    generator=torch.Generator(device=device).manual_seed(42),
    num_inference_steps=28,
    guidance_scale=4,
).images[0]Mogelijk gemaakt door

Om het bewerkte resultaat in de Jupyter Notebook te bekijken:

image_3Mogelijk gemaakt door

De output is zeer realistisch. Het model behoudt de gelaatsstructuur en huidskleur van de vrouw, terwijl het haar op natuurlijke wijze in een nieuwe scène met andere belichting, sfeer en achtergrond plaatst. 

Het resultaat voelt minder als een AI-bewerking en meer als een foto die door een professionele fotograaf op een andere plek en tijd is gemaakt.

Tips voor geheugenoptimalisatie met FLUX.2

Uit mijn ervaring werd FLUX.2 lokaal draaien pas betrouwbaar na de overstap naar het 4-bit gequantiseerde model en een code-first setup met Transformers en Diffusers. 

Eerder liep ik steeds tegen out-of-memory-fouten aan op een 24 GB RTX 3090 wanneer ik te veel direct op CUDA probeerde te laden. 

UI-tools zoals Stable Diffusion WebUI en ComfyUI kunnen ook sneller tegen geheugenlimieten aanlopen omdat ze vaak extra intermediaire buffers, previews en workflowstatus in het geheugen houden, tenzij je hun low-VRAM-opties zorgvuldig afstemt.

VRAM-optimalisatietips (wat mij daadwerkelijk hielp):

• Gebruik de 4-bit-checkpoint (bitsandbytes) in plaats van full-precision gewichten.
• Laad componenten eerst op de CPU (device_map="cpu") en vermijd het in één keer naar CUDA duwen van alles.
• Schakel CPU–GPU-offloading in (pipe.enable_model_cpu_offload()) zodat alleen actieve delen op de GPU leven.
• Houd het aantal inference-stappen redelijk (bijvoorbeeld 28–35 stappen voor snelle runs; verhogen alleen wanneer nodig).
• Houd de guidance scale gematigd (rond 3–5) om onnodige compute en instabiliteit te vermijden.
• Monitor VRAM live met nvidia-smi en sluit andere GPU-zware applicaties.
• Als je nog steeds OOM krijgt, herstart dan de notebook-kernel om het GPU-geheugen volledig te legen voordat je het opnieuw probeert.

Als je na deze stappen nog steeds out-of-memory-problemen ondervindt, raadpleeg dan deze DataLab-notebook voor extra troubleshooting- en geheugenoptimalisatievoorbeelden.

Tot slot

Ik ben oprecht onder de indruk van hoe ver open-source modellen voor beeldgeneratie zijn gekomen. 

Modellen zoals FLUX.2 zijn nu duidelijk competitief met propriëtaire systemen, zowel qua visuele kwaliteit als begrip van prompts. Met de juiste setup, wat experimenteren en een beetje geheugenoptimalisatie kun je lokaal en gratis hoogwaardige, realistische beelden genereren, zelfs op consumentengpu’s.

Wat vooral opvalt is het niveau van controle. Geavanceerde prompting, gestructureerde JSON, multireferentie-bewerking en image-to-image-workflows maken het eenvoudig om verder te gaan dan simpele generaties. 

Je kunt filmische scènes creëren, beelden verder uitwerken voor storytelling, beeldbewerking op professioneel niveau uitvoeren en snel itereren zonder afhankelijk te zijn van gesloten platformen. 

Voor creators, onderzoekers en developers biedt dit veel creatieve vrijheid en maakt het high-end beeldgeneratie toegankelijker dan ooit.