Come eseguire FLUX.2 in locale su una RTX 3090

In questo tutorial vedremo come eseguire in locale il modello di generazione di immagini FLUX.2. Imposteremo l’ambiente GPU, scaricheremo una versione quantizzata di FLUX.2, la caricheremo in modo efficiente nella memoria di GPU e RAM, eseguiremo l’inferenza e poi sperimenteremo con diverse opzioni di configurazione.

Eseguire un modello di queste dimensioni su una RTX 3090 può essere impegnativo, e questo tutorial si concentra sul modo più semplice e pratico per far funzionare FLUX.2 in locale senza complessità inutili.

Se ti interessano tecniche avanzate di gestione e ottimizzazione dei modelli, tra cui pruning, quantizzazione e logging, ti consiglio il corso Scalable AI Models with PyTorch Lightning. 

Che cos’è FLUX.2?

FLUX.2 è un modello di generazione di immagini pensato per il vero lavoro creativo, non solo per esperimenti. Crea immagini di alta qualità e realistiche mantenendo coerenza di personaggi, stili e prodotti su più immagini di riferimento. Basato sul modello FLUX originale, segue i prompt con precisione, rende il testo chiaramente e gestisce bene illuminazione, composizioni e branding. 

FLUX.2 supporta anche l’editing di immagini in alta risoluzione ed è disponibile sia come API pronte all’uso sia come modelli aperti che puoi eseguire in locale, rendendolo pratico, flessibile e facile da integrare in flussi di lavoro reali di produzione.

FLUX.2 è disponibile in quattro varianti principali: 

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

Ognuna è pensata per diversi livelli di controllo, prestazioni ed esigenze di deployment. 

Nei confronti più ampi, tutte e tre le varianti di FLUX.2 rientrano nella top 10 dei modelli di image editing sulla leaderboard di Artificial Analysis, con FLUX.2 [max] e FLUX.2 [pro] che superano modelli come GPT-5 e le varianti FLUX.1 Kontext della generazione precedente.

Fonte: Text to Image Leaderboard | Artificial Analysis

Eseguire FLUX.2 in locale: guida passo passo

Nei passaggi seguenti, ti spiegherò tutto ciò che serve per eseguire FLUX.2 in locale usando una GPU RTX 3090. 

1. Requisiti di sistema e prerequisiti

Prima di eseguire FLUX.2 in locale, assicurati che il sistema sia configurato correttamente per l’inferenza su GPU.

Hardware

• GPU NVIDIA (consigliata RTX 3090)
• 24 GB di VRAM
• 64 GB di RAM di sistema consigliati

Driver NVIDIA e CUDA Toolkit

• Installa i driver NVIDIA: assicurati di avere installati i driver GPU NVIDIA più recenti con supporto per versioni CUDA recenti (consigliata CUDA 12.1+).
• Installa il CUDA Toolkit: scarica e installa il CUDA Toolkit dalla pagina ufficiale NVIDIA CUDA Downloads per migliorare la compatibilità con estensioni GPU e kernel personalizzati.

Esegui il seguente comando nel terminale per verificare l’installazione:

nvidia-smiOfferto da

Come possiamo vedere, abbiamo una GPU RTX 3090 con versione CUDA 13. 

Python e Jupyter

• Python 3.10+
• Jupyter Notebook o JupyterLab (consigliati per sperimentazione interattiva e semplice)

pip install jupyterlab notebookOfferto da

Nota: usiamo Jupyter Notebook come ambiente di coding, che rende più facile sperimentare, eseguire l’inferenza passo passo e generare/modificare immagini direttamente nel notebook.

2. Installare PyTorch con supporto CUDA

In questo passaggio installiamo PyTorch con supporto CUDA in modo che l’inferenza giri sulla GPU invece che sulla CPU. Il comando qui sotto installa PyTorch, TorchVision e TorchAudio con binari CUDA precompilati, evitando di dover compilare CUDA dai sorgenti.

!pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu130Offerto da

Dopo l’installazione, PyTorch userà automaticamente la GPU se disponibile e configurata correttamente.

3. Installare FLUX.2 e le dipendenze necessarie

Ora installiamo le librerie principali necessarie per eseguire FLUX.2 in locale. Questi pacchetti gestiscono il caricamento del modello, l’inferenza, l’accelerazione GPU, la quantizzazione e un trasferimento dati efficiente.

!pip install -q diffusers transformers accelerate bitsandbytes huggingface_hub protobuf sentencepiece hf_transferOfferto da

Una volta installato, l’ambiente è pronto per caricare FLUX.2 e iniziare a eseguire inferenza di generazione ed editing di immagini.

4. Verificare supporto GPU e quantizzazione

Prima di caricare FLUX.2, verifichiamo che PyTorch veda la GPU e che la quantizzazione a 4 bit sia supportata. Questo passaggio è importante per garantire che il modello possa girare in modo efficiente entro i limiti di memoria di una RTX 3090.

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.")Offerto da

L’output conferma che PyTorch è installato correttamente con supporto CUDA, che la tua GPU RTX 3090 è rilevata e che bitsandbytes funziona correttamente con la quantizzazione a 4 bit abilitata, quindi il sistema è pronto per un’inferenza GPU efficiente.

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: PASSEDOfferto da

5. Caricare FLUX.2 con quantizzazione a 4 bit

In questo passaggio carichiamo FLUX.2 [dev] usando un checkpoint quantizzato a 4 bit per ridurre l’uso della memoria GPU mantenendo alta la qualità delle immagini. Questo è essenziale per eseguire un modello grande come FLUX.2 su una RTX 3090.

Iniziamo importando le librerie necessarie e definendo alcune impostazioni chiave.

• repo_id punta al checkpoint FLUX.2 dev a 4 bit.
• device seleziona la tua GPU (primo device CUDA).
• torch_dtype imposta la precisione di calcolo usata in inferenza. bfloat16 è spesso usata perché riduce la memoria e può migliorare la velocità mantenendo stabili gli output.

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.bfloat16Offerto da

Quindi carichiamo il backbone transformer di immagini di FLUX.2 (il componente principale responsabile della generazione dei latenti immagine) prima sulla CPU. Questo evita di saturare la VRAM durante il caricamento iniziale e dà maggiore flessibilità alla pipeline per spostare i moduli sulla GPU solo quando necessario.

transformer = Flux2Transformer2DModel.from_pretrained(
  repo_id, subfolder="transformer", torch_dtype=torch_dtype, device_map="cpu"
)Offerto da

Poi carichiamo anche il text encoder sulla CPU. Il text encoder converte il tuo prompt in embedding che guidano la generazione dell’immagine. Tenerlo sulla CPU durante il setup aiuta a lasciare libera memoria GPU per le parti più pesanti del processo di generazione.

text_encoder = Mistral3ForConditionalGeneration.from_pretrained(
  repo_id, subfolder="text_encoder", dtype=torch_dtype, device_map="cpu"
)Offerto da

Infine, assembliamo la pipeline di Diffusers iniettando il transformer e il text encoder caricati. 

La riga chiave qui è enable_model_cpu_offload(): abilita l’offload automatico CPU ↔ GPU, cioè la pipeline sposta parti del modello sulla GPU solo quando servono attivamente, per poi riportarle sulla CPU. È uno dei modi più semplici per eseguire modelli grandi su GPU consumer senza gestire manualmente il posizionamento sui device.

pipe = Flux2Pipeline.from_pretrained(
  repo_id, transformer=transformer, text_encoder=text_encoder, torch_dtype=torch_dtype
)
pipe.enable_model_cpu_offload()Offerto da

6. Prima generazione testo-immagine

Ora siamo pronti a generare la nostra prima immagine con FLUX.2. Per semplicità, partiamo con un singolo prompt testuale che descrive una fotografia macro iperrealistica di una coccinella.

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."
)
Offerto da

Poi passiamo il prompt alla pipeline ed eseguiamo l’inferenza.

• Usiamo 28 step di inferenza per bilanciare velocità e qualità dell’immagine.
• Una guidance scale pari a 4 mantiene il risultato naturale senza forzare troppo il prompt.
• Un seed casuale fisso garantisce risultati riproducibili.

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

Per monitorare quanta memoria GPU viene usata durante l’inferenza, apri un terminale ed esegui:

nvidia-smiOfferto da

Dovresti vedere quasi 21 GB di VRAM occupata con alta utilizzazione della GPU, segno che il modello sta usando in modo efficiente le risorse disponibili e gira alla massima performance sulla RTX 3090.

Una volta completata l’inferenza, puoi visualizzare l’immagine generata direttamente nel Jupyter Notebook semplicemente mostrando l’oggetto immagine:

imageOfferto da

Il risultato è molto dettagliato e realistico. Il modello segue da vicino il prompt aggiungendo anche dettagli sottili, come illuminazione e texture, non specificati esplicitamente.

Infine, salviamo in locale l’immagine generata:

output_path = "flux2_local_full.png"
image.save(output_path)
print(f"Image saved to {output_path}")Offerto da

Output:

Image saved to flux2_local_full.pngOfferto da

7. Prompt avanzati con JSON strutturato

FLUX.2 supporta tecniche di prompting avanzate che vanno oltre il semplice testo, consentendo un controllo molto più fine sull’immagine finale. Con prompt JSON strutturati, puoi definire esplicitamente layout della scena, soggetti, illuminazione, impostazioni della fotocamera, mood e persino palette di colori usando precisi codici esadecimali.

In questa sezione usiamo un prompt JSON strutturato per descrivere la scena in dettaglio. Invece di una singola frase, definiamo ambiente, soggetti, stile, colori, illuminazione, proprietà della fotocamera e vincoli negativi in un formato chiaro e organizzato. 

Questo aiuta FLUX.2 a comprendere meglio istruzioni complesse e a produrre risultati più prevedibili e di alta qualità.

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"
  ]
}
"""Offerto da

Quindi eseguiamo l’inferenza con un numero maggiore di step per catturare più dettagli, mantenendo la guidance scale moderata per un look naturale.

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

Per mostrare l’immagine generata nel Jupyter Notebook:

image_2Offerto da

L’immagine risultante segue da vicino il prompt strutturato, catturando scena, mood, illuminazione e composizione esattamente come specificato. 

8. Editing di immagini con FLUX.2 (image to image)

FLUX.2 supporta anche l’editing di immagini, in cui un’immagine di riferimento viene usata come base e il modello applica modifiche guidate da un prompt testuale. Questo è particolarmente utile quando vuoi preservare identità, tratti del viso e tono della pelle, cambiando però scena, mood o ambiente attorno al soggetto.

Per questo esempio, usiamo come immagine di riferimento una foto di una donna indiana tratta da Pexels.com:

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

Progettiamo con cura il prompt per istruire il modello a mantenere intatti il viso della donna e i toni naturali della pelle, cambiando invece ambientazione, illuminazione ed espressione emotiva. L’obiettivo è modificare l’immagine senza alterarne l’identità.

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."
)Offerto da

Successivamente, carichiamo l’immagine di riferimento e la passiamo alla pipeline. FLUX.2 supporta più immagini di riferimento, ma qui ne usiamo una sola per guidare l’editing.

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]Offerto da

Per visualizzare il risultato modificato nel Jupyter Notebook:

image_3Offerto da

L’output è altamente realistico. Il modello preserva la struttura del viso e il tono della pelle della donna, posizionandola in modo naturale in una nuova scena con illuminazione, mood e sfondo diversi. 

Il risultato sembra meno un editing AI e più una fotografia scattata da un professionista in un luogo e momento diversi.

Consigli per l’ottimizzazione della memoria con FLUX.2

Per esperienza, l’esecuzione in locale di FLUX.2 è diventata affidabile solo dopo il passaggio al modello quantizzato a 4 bit e a un setup code-first con Transformers e Diffusers. 

In precedenza, incappavo spesso in errori di memoria esaurita su una RTX 3090 da 24 GB quando provavo a caricare troppo direttamente su CUDA. 

Strumenti UI come Stable Diffusion WebUI e ComfyUI possono andare più facilmente in esaurimento memoria perché spesso mantengono in memoria buffer intermedi aggiuntivi, anteprime e stato del workflow, a meno di regolare con attenzione le loro opzioni low-VRAM.

Consigli per ottimizzare la VRAM (quello che mi ha davvero aiutato):

• Usa il checkpoint a 4 bit (bitsandbytes) invece di pesi a piena precisione.
• Carica prima i componenti su CPU (device_map="cpu") ed evita di spingere tutto su CUDA subito.
• Abilita l’offload CPU–GPU (pipe.enable_model_cpu_offload()) così solo le parti attive risiedono sulla GPU.
• Mantieni ragionevoli gli step di inferenza (ad esempio, 28–35 step per esecuzioni rapide; aumenta solo se serve).
• Tieni la guidance scale moderata (intorno a 3–5) per evitare calcolo superfluo e instabilità.
• Monitora la VRAM in tempo reale con nvidia-smi e chiudi altre applicazioni pesanti sulla GPU.
• Se vai ancora in OOM, riavvia il kernel del notebook per svuotare completamente la memoria GPU prima di riprovare.

Se riscontri ancora problemi di memoria esaurita dopo questi passaggi, consulta questo notebook DataLab per ulteriore troubleshooting ed esempi di ottimizzazione della memoria.

Considerazioni finali

Sono sinceramente colpito dai progressi dei modelli open source per la generazione di immagini. 

Modelli come FLUX.2 sono ormai chiaramente competitivi con i sistemi proprietari, sia in termini di qualità visiva sia di comprensione dei prompt. Con la giusta configurazione, un po’ di sperimentazione e qualche accorgimento sulla memoria, è possibile generare immagini realistiche e di alta qualità in locale e gratis, anche su GPU consumer.

Ciò che colpisce di più è il livello di controllo. Prompt avanzati, JSON strutturato, editing multi-riferimento e flussi image-to-image permettono di andare oltre le semplici generazioni. 

Puoi creare scene cinematografiche, far evolvere immagini per lo storytelling, effettuare editing di livello professionale e iterare rapidamente senza dipendere da piattaforme chiuse. 

Per creator, ricercatori e sviluppatori, questo apre molta libertà creativa e rende la generazione di immagini di alto livello più accessibile che mai.