# FLUX.1

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

Modèle de génération d’images à la pointe de la technologie de 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 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é)

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

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

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

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

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

```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**: "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)

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

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

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

```python
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](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=flux) (Performances)

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

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

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

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

### Chargement d’une seule 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 à 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

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

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

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

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

### Entraîner votre propre LoRA FLUX

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

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

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

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

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

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

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


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/flux.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.