> 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/sdxl-turbo.md).

# SDXL Turbo & LCM

Générez des images en 1 à 4 étapes avec SDXL Turbo et LCM sur Clore.ai

Générez des images en 1 à 4 étapes avec SDXL Turbo et les modèles de cohérence latente sur les GPU CLORE.AI.

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

## Pourquoi SDXL Turbo / LCM ?

* **Vitesse en temps réel** - Générez des images en 1 à 4 étapes contre 30 à 50
* **Qualité identique** - Comparable à SDXL complet avec 10 fois moins d’étapes
* **Interactif** - Assez rapide pour des applications en temps réel
* **Faible VRAM** - Utilisation efficace de la mémoire
* **Compatible LoRA** - Utilisez avec des LoRA SDXL existantes

## Variantes de modèle

| Modèle          | Étapes | Vitesse        | Qualité    | VRAM |
| --------------- | ------ | -------------- | ---------- | ---- |
| SDXL Turbo      | 1-4    | Le plus rapide | Bon        | 8 Go |
| SDXL Lightning  | 2-8    | Très rapide    | Excellent  | 8 Go |
| LCM-SDXL        | 4-8    | Rapide         | Excellent  | 8 Go |
| LCM-LoRA + SDXL | 4-8    | Rapide         | Excellente | 10GB |
| SD Turbo (1.5)  | 1-4    | Le plus rapide | Bon        | 4 Go |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Ports :**

```
22/tcp
7860/http
```

**Commande :**

```bash
pip install diffusers transformers accelerate gradio && \
python -c "
import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    'stabilityai/sdxl-turbo',
    torch_dtype=torch.float16,
    variant='fp16'
).to('cuda')

def generate(prompt, steps, seed):
    generator = torch.Generator('cuda').manual_seed(seed) if seed > 0 else None
    image = pipe(prompt, num_inference_steps=steps, guidance_scale=0.0, generator=generator).images[0]
    return image

gr.Interface(
    fn=generate,
    inputs=[
        gr.Textbox(label='Instruction'),
        gr.Slider(1, 4, value=1, step=1, label='Étapes'),
        gr.Number(value=-1, label='Graine')
    ],
    outputs=gr.Image(),
    title='SDXL Turbo - Génération en temps réel'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Accédez à **Mes commandes** la page
2. Cliquez sur votre commande
3. Trouvez le `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://YOUR_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Configuration matérielle requise

| Modèle         | GPU minimum    | Recommandé |
| -------------- | -------------- | ---------- |
| SD Turbo       | RTX 3060 8GB   | RTX 3070   |
| SDXL Turbo     | RTX 3070 8 Go  | RTX 3080   |
| SDXL Lightning | RTX 3070 8 Go  | RTX 3090   |
| LCM-SDXL       | RTX 3080 10 Go | RTX 4090   |

## Installation

```bash
pip install diffusers transformers accelerate torch
```

## SDXL Turbo

### Utilisation de base

```python
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/sdxl-turbo",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Générez en 1 étape !
image = pipe(
    prompt="Un plan cinématographique d’un bébé raton laveur portant une robe de prêtre italienne complexe",
    num_inference_steps=1,
    guidance_scale=0.0  # Turbo n'utilise pas le CFG
).images[0]

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

### Meilleurs réglages

```python
# 1 étape - le plus rapide, bonne qualité
image = pipe(prompt, num_inference_steps=1, guidance_scale=0.0).images[0]

# 2 étapes - meilleurs détails
image = pipe(prompt, num_inference_steps=2, guidance_scale=0.0).images[0]

# 4 étapes - meilleure qualité pour Turbo
image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0]
```

## SDXL Lightning

### Génération en 2 étapes

```python
import torch
from diffusers import StableDiffusionXLPipeline, EulerDiscreteScheduler
from huggingface_hub import hf_hub_download

base = "stabilityai/stable-diffusion-xl-base-1.0"
repo = "ByteDance/SDXL-Lightning"
ckpt = "sdxl_lightning_2step_unet.safetensors"

# Charger le modèle de base
pipe = StableDiffusionXLPipeline.from_pretrained(
    base,
    torch_dtype=torch.float16,
    variant="fp16"
).to("cuda")

# Charger l'UNet Lightning
pipe.unet.load_state_dict(
    torch.load(hf_hub_download(repo, ckpt), map_location="cuda")
)

# Configurer le planificateur
pipe.scheduler = EulerDiscreteScheduler.from_config(
    pipe.scheduler.config,
    timestep_spacing="trailing"
)

# Générer en 2 étapes
image = pipe(
    "Une fille souriant dans un jardin",
    num_inference_steps=2,
    guidance_scale=0.0
).images[0]

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

### 4 étapes (qualité supérieure)

```python
ckpt = "sdxl_lightning_4step_unet.safetensors"
# ... même configuration ...

image = pipe(
    prompt,
    num_inference_steps=4,
    guidance_scale=0.0
).images[0]
```

## LCM-LoRA

Utilisez avec n'importe quel modèle SDXL pour une génération rapide :

```python
import torch
from diffusers import DiffusionPipeline, LCMScheduler

pipe = DiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

# Charger LCM-LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

# Définir le planificateur LCM
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

# Générer en 4 étapes
image = pipe(
    "Astronaute dans une jungle, palette de couleurs froides, couleurs atténuées, détaillé, 8k",
    num_inference_steps=4,
    guidance_scale=1.0  # LCM utilise un CFG faible
).images[0]

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

### Avec des LoRA personnalisées

```python
# Charger le modèle de base + LCM-LoRA + LoRA de style
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
pipe.load_lora_weights("your-style-lora", adapter_name="style")

# Combiner les adaptateurs
pipe.set_adapters(["lcm", "style"], adapter_weights=[1.0, 0.8])

image = pipe(prompt, num_inference_steps=4, guidance_scale=1.5).images[0]
```

## SD Turbo (SD 1.5)

Pour des besoins plus faibles en VRAM :

```python
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/sd-turbo",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

image = pipe(
    "Une photo d'un chat",
    num_inference_steps=1,
    guidance_scale=0.0
).images[0]
```

## Image à image

### SDXL Turbo Img2Img

```python
from diffusers import AutoPipelineForImage2Image
from diffusers.utils import load_image

pipe = AutoPipelineForImage2Image.from_pretrained(
    "stabilityai/sdxl-turbo",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe.to("cuda")

init_image = load_image("input.jpg").resize((512, 512))

image = pipe(
    prompt="chat magicien, Gandalf, Le Seigneur des anneaux, détaillé, fantasy",
    image=init_image,
    num_inference_steps=2,
    strength=0.5,
    guidance_scale=0.0
).images[0]
```

## Génération par lots

```python
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/sdxl-turbo",
    torch_dtype=torch.float16
).to("cuda")

prompts = [
    "Un coucher de soleil sur les montagnes",
    "Une ville futuriste la nuit",
    "Un robot mignon dans un jardin",
    "Un temple ancien dans le brouillard"
]

# Générer par lot
images = pipe(
    prompts,
    num_inference_steps=1,
    guidance_scale=0.0
).images

for i, img in enumerate(images):
    img.save(f"batch_{i}.png")
```

## Streaming en temps réel

```python
import gradio as gr
import torch
from diffusers import AutoPipelineForText2Image

pipe = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/sdxl-turbo",
    torch_dtype=torch.float16
).to("cuda")

def generate_realtime(prompt):
    if not prompt:
        return None
    image = pipe(
        prompt,
        num_inference_steps=1,
        guidance_scale=0.0,
        width=512,
        height=512
    ).images[0]
    return image

demo = gr.Interface(
    fn=generate_realtime,
    inputs=gr.Textbox(label="Consigne"),
    outputs=gr.Image(label="Généré"),
    live=True,  # Met à jour au fil de la saisie
    title="SDXL Turbo en temps réel"
)

demo.launch(server_name="0.0.0.0", server_port=7860)
```

## Comparaison des performances

| Modèle         | Étapes | Résolution | RTX 3090 | RTX 4090 | A100  |
| -------------- | ------ | ---------- | -------- | -------- | ----- |
| SDXL (base)    | 30     | 1024x1024  | 8 s      | 5 s      | 4 s   |
| SDXL Turbo     | 1      | 512x512    | 0.3s     | 0.2s     | 0.15s |
| SDXL Turbo     | 4      | 512x512    | 0.8s     | 0.5s     | 0.4s  |
| SDXL Lightning | 2      | 1024x1024  | 0.8s     | 0.5s     | 0.4s  |
| SDXL Lightning | 4      | 1024x1024  | 1.2s     | 0.8s     | 0.6s  |
| LCM-SDXL       | 4      | 1024x1024  | 1.5s     | 1.0s     | 0.7s  |

## Comparaison de la qualité

| Aspect           | SDXL 30 étapes | Turbo 4 étapes | Lightning 4 étapes |
| ---------------- | -------------- | -------------- | ------------------ |
| Détails          | Excellente     | Bon            | Excellent          |
| Rendu du texte   | Bon            | Mauvais        | Mauvais            |
| Visages          | Excellent      | Bon            | Bon                |
| Cohérence        | Excellente     | Bon            | Excellent          |
| Variété de style | Excellente     | Bon            | Excellent          |

## Quand utiliser quoi

| Cas d’utilisation            | Recommandé     | Étapes |
| ---------------------------- | -------------- | ------ |
| Aperçu en temps réel         | SDXL Turbo     | 1      |
| Applications interactives    | SDXL Turbo     | 1-2    |
| Itérations rapides           | SDXL Lightning | 2-4    |
| Avec des LoRA personnalisées | LCM-LoRA       | 4-8    |
| Qualité maximale             | SDXL Lightning | 8      |
| Faible VRAM                  | SD Turbo       | 1-2    |

## Estimation des coûts

Tarifs habituels de la place de marché CLORE.AI :

| GPU            | Tarif horaire | Images/heure (1 étape) |
| -------------- | ------------- | ---------------------- |
| RTX 3060 12 Go | \~$0.03       | \~3,000                |
| RTX 3090 24 Go | \~$0.06       | \~8,000                |
| RTX 4090 24 Go | \~$0.10       | \~12,000               |
| A100 40 Go     | \~$0.17       | \~15,000               |

*Les prix varient. Consultez* [*la place de marché CLORE.AI*](https://clore.ai/marketplace) *les tarifs actuels.*

## Dépannage

### Résultats flous

* SDXL Turbo produit nativement du 512x512
* Utilisez SDXL Lightning pour du 1024x1024
* Ajoutez un post-traitement d'upscaling

### Erreur guidance\_scale

```python
# SDXL Turbo : utilisez toujours 0.0
image = pipe(prompt, guidance_scale=0.0).images[0]

# LCM : utilisez 1.0-2.0
image = pipe(prompt, guidance_scale=1.5).images[0]

# Lightning : utilisez 0.0
image = pipe(prompt, guidance_scale=0.0).images[0]
```

### La LoRA ne fonctionne pas

```python
# Pour LCM-LoRA, il faut utiliser LCMScheduler
from diffusers import LCMScheduler

pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")
```

### Mémoire insuffisante

```python
# Activer les optimisations mémoire
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Ou utilisez un modèle plus petit
# SD Turbo au lieu de SDXL Turbo
```

## Étapes suivantes

* [FLUX.1](/guides/guides_v2-fr/generation-dimages/flux.md) - Génération de la plus haute qualité
* [Interface web Stable Diffusion](/guides/guides_v2-fr/generation-dimages/stable-diffusion-webui.md) - Interface utilisateur complète
* [ComfyUI](/guides/guides_v2-fr/generation-dimages/comfyui.md) - Flux de travail basés sur des nœuds
* [Real-ESRGAN](/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling.md) - Agrandir les résultats


---

# 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/sdxl-turbo.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.