FLUX.1

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

Alternative plus rapide ! FLUX.2 Klein génère des images en < 0,5 seconde (vs 10–30s 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 développé par 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 du texte - Texte réellement lisible dans les images

• Respect des instructions - Excellente adhérence aux instructions

• Variantes 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)	Excellent	12 Go+	Apache 2.0
FLUX.1-dev	Moyen (20 étapes)	Excellent	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 le plus simple, utilisez ComfyUI avec des 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 un scaphandre sur Mars",
    num_inference_steps=4,
    guidance_scale=0.0,
).images[0]

image.save("flux_output.png")
PYEOF

Méthode 3 : Fooocus

Fooocus prend en charge FLUX nativement :

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

Flux de travail 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 → steps : 4, cfg : 1.0

6. VAE Decode → ae.safetensors

7. Sauvegarder l'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 basique

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 jardin japonais serein 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 ~10GB 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 lot

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: "Un panneau néon indiquant 'OPEN 24/7'"

• 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

# Photorealiste
Une photographie professionnelle d'un chiot golden retriever jouant dans des feuilles d'automne, 
profondeur de champ réduite, lumière chaude d'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 du texte
Une affiche de film vintage avec le titre "COSMIC VOYAGE" en lettres rétro en gras,
esthétique sci-fi des années 1960, illustration d'astronaute

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

Optimisation de la mémoire

Pour 12GB 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 inférieure
image = pipe(prompt, height=768, width=768, num_inference_steps=4).images[0]

Pour 8 Go de VRAM

Utiliser la version quantifiée ou ComfyUI avec GGUF :

# Dans ComfyUI, installer 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	Pas	Temps (4090)	Qualité
FLUX.1-schnell	4	~3 sec	Excellent
FLUX.1-dev	20	~12 s	Excellent
FLUX.1-dev	50	~30 s	Meilleur
SDXL	30	~8 s	Bon

Exigences GPU

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

Préréglages GPU

RTX 3060 12GB (Budget)

# Utiliser un 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()

# Réglages :
# - uniquement schnell (dev peut OOM)
# - 512x512 à 768x768
# - 4 étapes
# - Taille de batch 1

RTX 3090 24GB (Optimal)

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

# Réglages :
# - schnell : 1024x1024, batch 2
# - dev : 1024x1024, batch 1
# - 20-30 étapes pour dev
# - Activer le tiling VAE pour haute résolution

RTX 4090 24GB (Performance)

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

# Réglages :
# - schnell : 1024x1024, batch 4
# - dev : 1024x1024, batch 2
# - 30-50 étapes pour la meilleure qualité
# - Peut faire 1536x1536 avec tiling

A100 40GB/80GB (Production)

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

# Réglages :
# - schnell : 1024x1024, batch 8+
# - dev : 1024x1024, batch 4
# - 50 étapes pour qualité maximale
# - 2048x2048 possible

Estimation des coûts

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

Dépannage

Mémoire insuffisante

# Utiliser l'offload CPU
pipe.enable_model_cpu_offload()

# Ou offload 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

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

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

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

Mauvaise qualité

• Utiliser plus d'étapes (FLUX-dev : 30-50)

• Augmenter guidance_scale (3.0-4.0 pour dev)

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

---

FLUX LoRA

Les poids LoRA (Low-Rank Adaptation) 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 communautaires sont disponibles sur HuggingFace et CivitAI.

Installation

pip install diffusers transformers accelerate peft

Chargement d'un seul 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 depuis 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 le LoRA directement depuis le repo HuggingFace
pipe.load_lora_weights(
    "username/my-flux-lora",          # ID du repo HF
    weight_name="my_lora.safetensors" # nom de fichier dans le repo
)

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

Échelle LoRA (Force)

# Contrôler l'influence du 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 total
).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 le premier LoRA
pipe.load_lora_weights(
    "path/to/style_lora.safetensors",
    adapter_name="style"
)

# Charger le second 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 du LoRA

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

Entraîner votre propre LoRA FLUX

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

# Préparer le jeu de données : 10-30 images avec légendes
# Éditer le YAML de config, puis :
python run.py config/flux_lora_train.yaml

Sources recommandées de LoRA

Source	URL	Remarques
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 des contours Canny, des cartes de profondeur et des 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 l'aide de ControlNet
image = pipe(
    prompt="Un paysage urbain futuriste avec 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 ControlNets
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	Repo	Cas d'utilisation
Canny	XLabs-AI/flux-controlnet-canny-diffusers	Génération guidée par contours
Profondeur	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 pour FLUX (trop haut réduit la créativité)

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

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

• Des étapes plus faibles (20–25) suffisent généralement avec ControlNet

---

FLUX.1-schnell : Mode 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 (vs 20–50 pour FLUX.1-dev), ce qui le rend idéal pour le prototypage rapide et les workflows à haut débit.

Principales différences vs FLUX.1-dev

Fonction	FLUX.1-schnell	FLUX.1-dev
Pas	4	20–50
Vitesse (4090)	~3 sec	~12–30 sec
Licence	Apache 2.0 (commercial gratuit)	Non commercial
guidance_scale	0.0 (pas de CFG)	3.5
Qualité	Excellent	Excellent
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 à l'heure dorée, 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 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 lac de montagne serein à l'aube, atmosphère brumeuse",
    "Un marché de rue animé à Tokyo la nuit, reflets néon",
    "Une photo macro d'une toile d'araignée couverte de rosée",
    "Une bibliothèque ancienne avec des livres flottants et une lumière magique",
    "Une ville sous-marine futuriste avec une vie marine bioluminescente",
]

# Génération par lot
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 rapports d'aspect 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 rapports d'aspect 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 la 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 12GB VRAM (RTX 3060/3080)
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-schnell",
    torch_dtype=torch.float16  # fp16 économise de la mémoire sur les GPU plus anciens
)
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()
pipe.enable_vae_tiling()

image = pipe(
    prompt="Une cabane douillette 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")

Benchmarks de performance (schnell)

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

Quand utiliser schnell vs dev

Utiliser FLUX.1-schnell lorsque :

• Prototypage rapide / tester des prompts

• Génération par lots à haut volume

• Projets commerciaux (Apache 2.0)

• Budget GPU limité

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

Utiliser FLUX.1-dev lorsque :

• La qualité d'image maximale est prioritaire

• Détails fins et scènes complexes

• Travail de recherche / artistique

• Combinaison avec LoRA/ControlNet (dev a tendance à mieux répondre)

---

Prochaines étapes

• ComfyUI - Meilleure interface pour FLUX

• Fooocus - Alternative simple

• ControlNet - Génération guidée

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