# FLUX.1

{% hint style="info" %}
**Alternative plus rapide !** [**FLUX.2 Klein**](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/flux2-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.
{% endhint %}

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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é)

```bash
# 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

```bash
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 :

```bash
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

```python
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

```python
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

```python
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)

```python
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)

```python
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 :

```bash
# 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)

```python
# 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)

```python
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)

```python
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)

```python
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

```python
# 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

```bash
pip install diffusers transformers accelerate peft
```

### Chargement d'un seul LoRA

```python
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

```python
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)

```python
# 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

```python
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

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

### Entraîner votre propre LoRA FLUX

```bash
# 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

```bash
pip install diffusers transformers accelerate controlnet-aux pillow
```

### FLUX ControlNet Canny (XLabs-AI)

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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

```python
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](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/comfyui) - Meilleure interface pour FLUX
* [Fooocus](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/fooocus-simple-sd) - Alternative simple
* [ControlNet](https://docs.clore.ai/guides/guides_v2-fr/traitement-dimages/controlnet-advanced) - Génération guidée
* [Entraînement Kohya](https://docs.clore.ai/guides/guides_v2-fr/entrainement/kohya-training) - Entraîner des LoRAs FLUX