> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/flux2-klein.md).

# FLUX.2 Klein

FLUX.2 Klein — génération d'images en moins d'une seconde sur les GPU Clore.ai

FLUX.2 Klein de Black Forest Labs est le successeur de FLUX.1, offrant la même qualité d’image à **20–60× plus rapide**. Là où FLUX.1 prenait 10 à 30 secondes par image, FLUX.2 Klein génère en **moins de 0,5 seconde** sur une RTX 4090. C’est un modèle Diffusion Transformer (DiT) de 32B avec une licence Apache 2.0, et, depuis janvier 2026, il est même pris en charge à titre expérimental dans Ollama.

## Caractéristiques clés

* **génération en moins de 0,5 seconde**: 20–60× plus rapide que FLUX.1
* **architecture DiT de 32B**: Même qualité que FLUX.1 dev
* **Licence Apache 2.0**: Utilisation commerciale complète
* **Prise en charge d’Ollama**: Génération d’images expérimentale via Ollama (janv. 2026)
* **Compatible avec ComfyUI**: Remplacement direct pour les workflows FLUX.1
* **LoRA + ControlNet**: Adaptateurs communautaires disponibles

## Exigences

| Composant | Minimum                   | Recommandé     |
| --------- | ------------------------- | -------------- |
| GPU       | RTX 3090 24 Go            | RTX 4090 24 Go |
| VRAM      | 16 Go (avec déchargement) | 24GB           |
| RAM       | 32 Go                     | 64 Go          |
| Disque    | 40 Go                     | 60 Go          |
| CUDA      | 12.8+                     | 12.8+          |

**GPU Clore.ai recommandé**: RTX 4090 24 Go (0,14–0,42 $/h) — génération en moins d’une seconde

### Comparaison de vitesse : FLUX.1 vs FLUX.2 Klein

| GPU      | FLUX.1 dev (20 étapes) | FLUX.2 Klein | Accélération |
| -------- | ---------------------- | ------------ | ------------ |
| RTX 3090 | \~25 s                 | \~1,2 s      | 20×          |
| RTX 4090 | \~12 s                 | \~0,4 s      | 30×          |
| RTX 5090 | \~8 s                  | \~0,25 s     | 32×          |
| H100     | \~5 s                  | \~0,15 s     | 33×          |

## Démarrage rapide avec diffusers

```python
import torch
from diffusers import FluxPipeline

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

# Générer une image en < 0,5 seconde !
image = pipe(
    prompt="une plateforme de minage GPU cyberpunk dans une salle serveur éclairée au néon, photoréaliste",
    height=1024,
    width=1024,
    num_inference_steps=4,  # Klein n’a besoin que de 4 étapes !
    guidance_scale=3.5,
).images[0]

image.save("output.png")
```

### Mode économe en mémoire (GPU 16 Go)

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein",
    torch_dtype=torch.bfloat16
)
pipe.enable_model_cpu_offload()  # Tient sur 16 Go
pipe.vae.enable_tiling()         # Économise ~2 Go

image = pipe("un paysage de montagne au coucher du soleil", num_inference_steps=4).images[0]
```

## Flux de travail ComfyUI

FLUX.2 Klein fonctionne comme un remplacement direct dans les workflows ComfyUI FLUX.1 existants :

1. Téléchargez le checkpoint FLUX.2 Klein dans `ComfyUI/models/diffusion_models/`
2. Dans votre workflow, modifiez le nœud de checkpoint pour qu’il pointe vers FLUX.2 Klein
3. Réduisez les étapes à 4 (au lieu de 20 à 50 pour FLUX.1)
4. Définissez la guidance scale entre 3,0 et 4,0

```bash
# Télécharger le modèle pour ComfyUI
cd ComfyUI/models/diffusion_models/
wget https://huggingface.co/black-forest-labs/FLUX.2-klein/resolve/main/flux2-klein.safetensors
```

## Génération par lots

Avec une génération en moins d’une seconde, FLUX.2 Klein permet un traitement par lots massif :

```python
import torch
from diffusers import FluxPipeline

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

prompts = [
    "une voiture de sport rouge sur une route de montagne, cinématographique",
    "l’intérieur d’un café chaleureux, éclairage doux",
    "un astronaute flottant au-dessus de la Terre, hyperréaliste",
    "un château médiéval en automne, art fantastique",
    # ... ajoutez-en des centaines d’autres
]

for i, prompt in enumerate(prompts):
    image = pipe(prompt, num_inference_steps=4, guidance_scale=3.5).images[0]
    image.save(f"batch_{i:04d}.png")
    print(f"Généré {i+1}/{len(prompts)}")

# Sur RTX 4090 : ~100 images en moins d’une minute !
```

## Prise en charge de LoRA

```python
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.2-klein", torch_dtype=torch.bfloat16
).to("cuda")

# Charger une LoRA entraînée sur l’architecture FLUX
pipe.load_lora_weights("your-lora/flux2-style-lora", weight_name="lora.safetensors")
pipe.fuse_lora(lora_scale=0.8)

image = pipe("un portrait dans le style entraîné", num_inference_steps=4).images[0]
```

## Conseils pour les utilisateurs de Clore.ai

* **Le roi du traitement par lots**: À 0,4 s/image, vous pouvez générer plus de 10 000 images par heure sur RTX 4090
* **4 étapes seulement**: N’en utilisez pas plus — Klein est optimisé pour 4 étapes (davantage n’améliore pas la qualité)
* **Les mêmes LoRA que FLUX.1**: La plupart des LoRA FLUX.1 sont compatibles avec Klein
* **Remplacement direct dans ComfyUI**: Il suffit de remplacer le checkpoint et de régler les étapes à 4
* **La RTX 3090 est viable**: 1,2 s/image reste excellent à 0,07–0,21 $/h

## Dépannage

| Problème                     | Solution                                                                                      |
| ---------------------------- | --------------------------------------------------------------------------------------------- |
| OOM sur 24 Go                | Utilisez `enable_model_cpu_offload()` + `vae.enable_tiling()`                                 |
| Images floues                | Assurez-vous que `num_inference_steps=4`, pas moins. Vérifiez guidance\_scale 3,0–4,0         |
| Première génération lente    | Normal — le modèle se charge au premier appel (\~30 s). Les suivants : en moins d’une seconde |
| Erreur de checkpoint ComfyUI | Assurez-vous d’avoir le `.safetensors` fichier, et non le format diffusers                    |

## Pour aller plus loin

* [Guide FLUX.1](/guides/guides_v2-fr/generation-dimages/flux.md) — guide FLUX original avec des détails sur LoRA et ControlNet
* [Guide ComfyUI](/guides/guides_v2-fr/generation-dimages/comfyui.md) — configuration et workflows ComfyUI
* [Blog de Black Forest Labs](https://blackforestlabs.ai/)
* [Modèle Hugging Face](https://huggingface.co/black-forest-labs/FLUX.2-klein)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/flux2-klein.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.