FLUX.1

Exécutez la génération d'images FLUX.1 de Black Forest Labs sur Clore.ai

Alternative plus rapide ! FLUX.2 Klein génère des images en < 0,5 seconde (contre 10 à 30 s pour FLUX.1) avec une qualité comparable. Ce guide reste pertinent pour l’entraînement LoRA et les workflows ControlNet.

Modèle de génération d’images à la pointe de la technologie de Black Forest Labs sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Pourquoi FLUX.1 ?

• Meilleure qualité - Supérieur à SDXL et Midjourney v5

• Rendu de texte - Texte réellement lisible dans les images

• Respect des prompts - Excellente adhérence aux instructions

• Versions rapides - FLUX.1-schnell pour une génération rapide

Variantes de modèle

Modèle	Vitesse	Qualité	VRAM	Licence
FLUX.1-schnell	Rapide (4 étapes)	Très bonne	12 Go+	Apache 2.0
FLUX.1-dev	Moyenne (20 étapes)	Excellente	16 Go+	Non commercial
FLUX.1-pro	API uniquement	Meilleur	-	Commercial

Déploiement rapide sur CLORE.AI

Image Docker :

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

Ports :

22/tcp
7860/http

Pour un déploiement plus simple, utilisez ComfyUI avec les nœuds FLUX.

Méthodes d’installation

Méthode 1 : ComfyUI (recommandé)

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

# Télécharger les modèles FLUX
cd models/unet
wget https://huggingface.co/black-forest-labs/FLUX.1-schnell/resolve/main/flux1-schnell.safetensors

# Télécharger les composants requis
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

# Lancer ComfyUI
python main.py --listen 0.0.0.0

Méthode 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(
    "Un chat portant une combinaison spatiale sur Mars",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

Méthode 3 : Fooocus

Fooocus dispose d’une prise en charge FLUX intégrée :

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

# Télécharger le modèle FLUX dans models/checkpoints/
python launch.py --listen

Workflow ComfyUI

FLUX.1-schnell (rapide)

Nœuds nécessaires :

1. Load Diffusion Model → flux1-schnell.safetensors

2. DualCLIPLoader → clip_l.safetensors + t5xxl_fp16.safetensors

3. CLIP Text Encode → votre prompt

4. Empty SD3 Latent Image → définir les dimensions

5. KSampler → étapes : 4, cfg : 1.0

6. VAE Decode → ae.safetensors

7. Save Image

FLUX.1-dev (qualité)

Même workflow, mais :

• Étapes : 20-50

• CFG : 3.5

• Utiliser guidance_scale dans le prompt

API Python

Génération de base

import torch
from diffusers import FluxPipeline

# Charger le modèle
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.bfloat16
)
pipe.to("cuda")

# Générer
image = pipe(
    prompt="Un paisible jardin japonais avec des cerisiers en fleurs",
    height=1024,
    width=1024,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("output.png")

Avec optimisation de la mémoire

from diffusers import FluxPipeline
import torch

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

# Activer les optimisations
pipe.enable_model_cpu_offload()  # Économise ~10 Go de VRAM
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    "Portrait d’un samouraï cyberpunk",
    height=1024,
    width=1024,
    num_inference_steps=4,
).images[0]

Génération par lots

prompts = [
    "Un coucher de soleil sur des montagnes",
    "Une ville futuriste la nuit",
    "Un récif corallien sous-marin",
]

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 (qualité supérieure)

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="Portrait hyperréaliste d’un vieux pêcheur",
    height=1024,
    width=1024,
    num_inference_steps=50,
    guidance_scale=3.5,
).images[0]

Conseils pour les prompts

FLUX excelle dans :

• Texte dans les images: "Une enseigne au néon indiquant 'OUVERT 24H/24'"

• Scènes complexes: "Une rue animée de Tokyo la nuit avec des reflets"

• Styles spécifiques: "Peinture à l’huile dans le style de Monet"

• Descriptions détaillées: Les prompts longs et détaillés fonctionnent bien

Exemples de prompts

# Photoréaliste
Une photo professionnelle d’un chiot golden retriever jouant dans des feuilles d’automne, 
faible profondeur de champ, lumière chaude de l’après-midi, Canon EOS R5

# Artistique
Une peinture impressionniste d’un café parisien sous la pluie, 
huile sur toile, coups de pinceau visibles, couleurs chaudes

# Rendu de texte
Une affiche de film vintage avec le titre "COSMIC VOYAGE" en lettres rétro audacieuses,
esthétique de science-fiction des années 1960, illustration d’astronaute

# Scène complexe
Un intérieur de bibliothèque chaleureux avec des étagères du sol au plafond, 
un fauteuil en cuir près d’une cheminée, la pluie visible à travers une fenêtre,
lumière chaude d’une lampe, photoréaliste

Optimisation de la mémoire

Pour 12 Go de VRAM (RTX 3060)

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # Utiliser fp16 au lieu de bf16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

# Générer à une résolution plus faible
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]

Pour 8 Go de VRAM

Utilisez la version quantifiée ou ComfyUI avec GGUF :

# Dans ComfyUI, installez les nœuds GGUF
cd custom_nodes
git clone https://github.com/city96/ComfyUI-GGUF

# Télécharger le modèle quantifié
wget https://huggingface.co/city96/FLUX.1-schnell-gguf/resolve/main/flux1-schnell-Q4_K_S.gguf

Comparaison des performances

Modèle	Étapes	Temps (4090)	Qualité
FLUX.1-schnell	4	~3 s	Très bonne
FLUX.1-dev	20	~12 s	Excellente
FLUX.1-dev	50	~30 s	Meilleur
SDXL	30	~8 s	Bon

Exigences GPU

Configuration	Minimum	Recommandé
FLUX.1-schnell	12 Go	16 Go+
FLUX.1-dev	16 Go	24 Go+
Avec déchargement CPU	8 Go	12 Go+
Quantifié (GGUF)	6 Go	8 Go+

Préréglages GPU

RTX 3060 12 Go (Budget)

# Utiliser le modèle quantifié
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_tiling()

# Paramètres :
# - schnell uniquement (dev peut manquer de mémoire)
# - 512x512 à 768x768
# - 4 étapes
# - Taille de lot 1

RTX 3090 24 Go (Optimal)

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

# Paramètres :
# - schnell : 1024x1024, lot 2
# - dev : 1024x1024, lot 1
# - 20-30 étapes pour dev
# - Activer le découpage VAE pour la haute résolution

RTX 4090 24 Go (Performances)

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

# Paramètres :
# - schnell : 1024x1024, lot 4
# - dev : 1024x1024, lot 2
# - 30-50 étapes pour la meilleure qualité
# - Peut faire du 1536x1536 avec découpage

A100 40 Go/80 Go (Production)

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

# Paramètres :
# - schnell : 1024x1024, lot 8+
# - dev : 1024x1024, lot 4
# - 50 étapes pour une qualité maximale
# - 2048x2048 possible

Estimation des coûts

GPU	Par heure	Images/heure
RTX 3060 12 Go	~$0.03	~200 (schnell)
RTX 3090 24 Go	~$0.06	~600 (schnell)
RTX 4090 24 Go	~$0.10	~1000 (schnell)
A100 40 Go	~$0.17	~1500 (schnell)

Dépannage

Mémoire insuffisante

# Utiliser le déchargement CPU
pipe.enable_model_cpu_offload()

# Ou le déchargement CPU séquentiel (plus lent mais moins de VRAM)
pipe.enable_sequential_cpu_offload()

# Réduire la résolution
height=768, width=768

Génération lente

• Utilisez FLUX.1-schnell (4 étapes)

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

• Utilisez fp16 au lieu de bf16 sur les GPU plus anciens

Mauvaise qualité

• Utilisez plus d’étapes (FLUX-dev : 30-50)

• Augmentez guidance_scale (3.0-4.0 pour dev)

• Rédigez des prompts plus détaillés

---

LoRA FLUX

Les poids LoRA (adaptation de faible rang) vous permettent d’affiner FLUX pour des styles, personnages ou concepts spécifiques sans réentraîner le modèle complet. Des centaines de LoRA de la communauté sont disponibles sur HuggingFace et CivitAI.

Installation

pip install diffusers transformers accelerate peft

Chargement d’une seule LoRA

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()

# Charger les poids LoRA à partir d’un fichier local
pipe.load_lora_weights("path/to/lora.safetensors")

image = pipe(
    "Un portrait dans le style de Van Gogh, coups de pinceau tourbillonnants",
    num_inference_steps=20,
    guidance_scale=3.5,
    generator=torch.Generator(device="cuda").manual_seed(42),
).images[0]
image.save("flux_lora_output.png")

Chargement depuis HuggingFace Hub

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()

# Charger la LoRA directement depuis le dépôt HuggingFace
pipe.load_lora_weights(
    "username/my-flux-lora",          # ID du dépôt HF
    weight_name="my_lora.safetensors" # nom de fichier dans le dépôt
)

image = pipe(
    "trigger_word un magnifique paysage",
    num_inference_steps=20,
    guidance_scale=3.5,
).images[0]
image.save("output.png")

Échelle LoRA (intensité)

# Contrôler l’influence de la LoRA avec cross_attention_kwargs
image = pipe(
    "Un personnage cyberpunk, lumières néon",
    num_inference_steps=20,
    guidance_scale=3.5,
    cross_attention_kwargs={"scale": 0.8},  # 0.0 = aucun effet, 1.0 = effet complet
).images[0]

Combiner plusieurs LoRA

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()

# Charger la première LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Charger la deuxième LoRA
pipe.load_lora_weights(
    "path/to/character_lora.safetensors",
    adapter_name="character"
)

# Combiner avec des poids
pipe.set_adapters(["style", "character"], adapter_weights=[0.7, 0.9])

image = pipe(
    "character_trigger portant un costume élaboré, artistic_trigger style",
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]
image.save("combined_lora.png")

Déchargement de LoRA

# Supprimer les poids LoRA pour restaurer le modèle de base
pipe.unload_lora_weights()

Entraîner votre propre LoRA FLUX

# Utilisez kohya-ss ou ai-toolkit pour l’entraînement LoRA FLUX
git clone https://github.com/ostris/ai-toolkit
cd ai-toolkit
pip install -r requirements.txt

# Préparez le jeu de données : 10 à 30 images avec légendes
# Modifiez le YAML de configuration, puis :
python run.py config/flux_lora_train.yaml

Sources LoRA recommandées

Source	URL	Notes
CivitAI	civitai.com	Grande bibliothèque communautaire
HuggingFace	huggingface.co/models	Filtrer par FLUX
Replicate	replicate.com	Parcourir les modèles entraînés

---

ControlNet pour FLUX

ControlNet permet de guider la génération FLUX avec des entrées structurelles comme les contours canny, les cartes de profondeur et les squelettes de pose. XLabs-AI a publié les premiers modèles ControlNet spécifiquement pour FLUX.1.

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

# Charger le modèle FLUX ControlNet (variante Canny)
controlnet = FluxControlNetModel.from_pretrained(
    "XLabs-AI/flux-controlnet-canny-diffusers",
    torch_dtype=torch.bfloat16
)

# Charger le pipeline avec ControlNet
pipe = FluxControlNetPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    controlnet=controlnet,
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()

# Préparer l’image de contrôle (contours canny)
input_image = load_image("your_input.jpg").resize((1024, 1024))
canny = CannyDetector()
control_image = canny(input_image, low_threshold=50, high_threshold=200)

# Générer avec le guidage ControlNet
image = pipe(
    prompt="Un paysage urbain futuriste avec des enseignes néon, photoréaliste, 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

# Charger l’estimateur de profondeur
depth_estimator = hf_pipeline("depth-estimation", model="LiheYoung/depth-anything-small-hf")

# Préparer la carte de profondeur
input_image = load_image("portrait.jpg").resize((1024, 1024))
depth_result = depth_estimator(input_image)["depth"]
depth_image = depth_result.convert("RGB")

# Charger ControlNet Depth
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="Une statue en marbre d’un guerrier, éclairage dramatique, photo de musée",
    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 pour FLUX

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

# Charger plusieurs ControlNet
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
)

# Combiner en MultiControlNet
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="Un chevalier en armure debout dans une forêt, éclairage dramatique",
    control_image=[canny_image, depth_image],
    controlnet_conditioning_scale=[0.7, 0.5],
    num_inference_steps=25,
    guidance_scale=3.5,
).images[0]

Modèles FLUX ControlNet disponibles

Modèle	Dépôt	Cas d’utilisation
Canny	XLabs-AI/flux-controlnet-canny-diffusers	Génération guidée par les contours
Depth	XLabs-AI/flux-controlnet-depth-diffusers	Génération guidée par la profondeur
HED/Soft Edge	XLabs-AI/flux-controlnet-hed-diffusers	Contrôle structurel doux
Pose	XLabs-AI/flux-controlnet-openpose-diffusers	Portraits guidés par la pose

Conseils ControlNet

• conditioning_scale 0.5–0.8 fonctionne mieux avec FLUX (trop élevé fait perdre la créativité)

• Utiliser 1024×1024 ou des multiples pour une meilleure qualité

• Combiner avec LoRA pour un contrôle style + structure

• Un nombre d’étapes plus faible (20–25) est généralement suffisant avec ControlNet

---

FLUX.1-schnell : mode de génération rapide

FLUX.1-schnell est la variante distillée et optimisée pour la vitesse de FLUX. Il génère des images de haute qualité en seulement 4 étapes (contre 20 à 50 pour FLUX.1-dev), ce qui le rend idéal pour le prototypage rapide et les workflows à haut débit.

Différences clés par rapport à FLUX.1-dev

Fonctionnalité	FLUX.1-schnell	FLUX.1-dev
Étapes	4	20–50
Vitesse (4090)	~3 s	~12–30 s
Licence	Apache 2.0 (commercial gratuit)	Non commercial
guidance_scale	0.0 (pas de CFG)	3.5
Qualité	Très bonne	Excellente
VRAM	12 Go+	16 Go+

Remarque sur la licence : FLUX.1-schnell est sous Apache 2.0 — vous pouvez l’utiliser librement dans des produits commerciaux. FLUX.1-dev nécessite une licence commerciale séparée de Black Forest Labs.

Démarrage rapide

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="Une vue aérienne époustouflante de New York au coucher du soleil doré, photoréaliste",
    height=1024,
    width=1024,
    num_inference_steps=4,   # Seulement 4 étapes nécessaires !
    guidance_scale=0.0,       # CFG désactivé pour schnell
    max_sequence_length=256,
    generator=torch.Generator(device="cpu").manual_seed(0),
).images[0]

image.save("schnell_output.png")
print("Généré en ~3 secondes sur une RTX 4090 !")

Génération par lots à haut débit

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")  # Garder sur le GPU pour la vitesse, ne pas utiliser cpu_offload

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

prompts = [
    "Un paisible lac de montagne à l’aube, atmosphère brumeuse",
    "Un marché de rue animé de Tokyo la nuit, reflets néon",
    "Une macrophotographie d’une toile d’araignée couverte de rosée",
    "Une ancienne bibliothèque avec des livres flottants et une lumière magique",
    "Une ville sous-marine futuriste avec une faune marine bioluminescente",
]

# Génération par lots
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"Généré {i+1}/{len(prompts)} : {prompt[:50]}...")

Plusieurs formats avec 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 prend en charge des formats flexibles
resolutions = {
    "square":    (1024, 1024),
    "portrait":  (768,  1360),
    "landscape": (1360, 768),
    "tall":      (576,  1792),
    "wide":      (1792, 576),
}

prompt = "Un loup majestueux dans une forêt enneigée, photographie professionnelle de faune"

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"Enregistré {name} : {width}x{height}")

schnell avec optimisations mémoire

import torch
from diffusers import FluxPipeline

# Pour 12 Go de VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # le fp16 économise de la mémoire sur les anciens GPU
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="Un chalet douillet dans une forêt d'automne, lumière chaude à travers les fenêtres",
    height=768,
    width=768,
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]
image.save("schnell_low_vram.png")

Références de performance (schnell)

GPU	VRAM	Temps/image (1024 px)	Images/heure
RTX 3060 12 Go	12 Go	~8 s	~450
RTX 3090 24 Go	24 Go	~4 s	~900
RTX 4090 24 Go	24 Go	~3 s	~1200
A100 40 Go	40 Go	~2 s	~1800

Quand utiliser schnell vs dev

Utilisez FLUX.1-schnell lorsque :

• Prototypage rapide / test des prompts

• Génération par lots à grand volume

• Projets commerciaux (Apache 2.0)

• Budget GPU limité

• Applications en temps réel ou quasi temps réel

Utilisez FLUX.1-dev lorsque :

• La qualité maximale de l'image est prioritaire

• Détails fins et scènes complexes

• Travail de recherche / artistique

• Combiner avec LoRA/ControlNet (dev tend à mieux réagir)

---

Étapes suivantes

• ComfyUI - Meilleure interface pour FLUX

• Fooocus - Alternative simple

• ControlNet - Génération guidée

• Entraînement Kohya - Entraîner des LoRA FLUX