> 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 les modèles de cohérence latente (LCM) 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 SDXL Turbo / LCM ?

* **Vitesse en temps réel** - Générer des images en 1 à 4 étapes au lieu de 30 à 50
* **Même qualité** - Comparable au SDXL complet avec 10x moins d'étapes
* **Interactif** - Assez rapide pour des applications en temps réel
* **Faible VRAM** - Utilisation efficace de la mémoire
* **Compatible LoRA** - À utiliser avec les LoRA SDXL existants

## Variantes de modèle

| Modèle          | Pas | 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         | Excellent | 10Go |
| SD Turbo (1.5)  | 1-4 | Le plus rapide | Bon       | 4 Go |

## Déploiement rapide sur CLORE.AI

**Image Docker :**

```
pytorch/pytorch:2.5.1-cuda12.4-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='Prompt'),
        gr.Slider(1, 4, value=1, step=1, label='Steps'),
        gr.Number(value=-1, label='Seed')
    ],
    outputs=gr.Image(),
    title='SDXL Turbo - Real-time Generation'
).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. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

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

## Exigences matérielles

| Modèle         | GPU minimum   | Recommandé |
| -------------- | ------------- | ---------- |
| SD Turbo       | RTX 3060 8GB  | RTX 3070   |
| SDXL Turbo     | RTX 3070 8GB  | RTX 3080   |
| SDXL Lightning | RTX 3070 8GB  | RTX 3090   |
| LCM-SDXL       | RTX 3080 10Go | 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érer 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 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 le unet lightning
pipe.unet.load_state_dict(
    torch.load(hf_hub_download(repo, ckpt), map_location="cuda")
)

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

# Générer en 2 étapes
image = pipe(
    "Une fille souriante 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

À utiliser 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 scheduler LCM
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

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

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

### Avec des LoRA personnalisés

```python
# Charger la 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 adapteurs
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 de VRAM plus faibles :

```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="sorcier chat, gandalf, 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 lot

```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 des montagnes",
    "Une ville futuriste la nuit",
    "Un robot mignon dans un jardin",
    "Un temple ancien dans le brouillard"
]

# Génération 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="Prompt"),
    outputs=gr.Image(label="Generated"),
    live=True,  # Mise à jour au fur et à mesure de la saisie
    title="Real-time SDXL Turbo"
)

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

## Comparaison des performances

| Modèle         | Pas | Résolution | RTX 3090 | RTX 4090 | A100  |
| -------------- | --- | ---------- | -------- | -------- | ----- |
| SDXL (base)    | 30  | 1024x1024  | 8s       | 5s       | 4s    |
| SDXL Turbo     | 1   | 512x512    | 0,3 s    | 0.2s     | 0.15s |
| SDXL Turbo     | 4   | 512x512    | 0,8 s    | 0,5 s    | 0.4s  |
| SDXL Lightning | 2   | 1024x1024  | 0,8 s    | 0,5 s    | 0.4s  |
| SDXL Lightning | 4   | 1024x1024  | 1,2 s    | 0,8 s    | 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           | Excellent      | Bon            | Excellent          |
| Rendu du texte    | Bon            | Faible         | Faible             |
| Visages           | Excellent      | Bon            | Bon                |
| Cohérence         | Excellent      | Bon            | Excellent          |
| Variété de styles | Excellent      | Bon            | Excellent          |

## Quand utiliser quoi

| Cas d'utilisation           | Recommandé     | Pas |
| --------------------------- | -------------- | --- |
| 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és | LCM-LoRA       | 4-8 |
| Qualité maximale            | SDXL Lightning | 8   |
| Faible VRAM                 | SD Turbo       | 1-2 |

## Estimation des coûts

Tarifs typiques du marketplace CLORE.AI :

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

*Les prix varient. Vérifiez* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *pour les tarifs actuels.*

## Dépannage

### Résultats flous

* SDXL Turbo produit nativement du 512x512
* Utilisez SDXL Lightning pour du 1024x1024
* Ajouter 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]
```

### 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
# Enable memory optimizations
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

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

## Prochaines étapes

* [FLUX.1](/guides/guides_v2-fr/generation-dimages/flux.md) - Génération de la plus haute qualité
* [Stable Diffusion WebUI](/guides/guides_v2-fr/generation-dimages/stable-diffusion-webui.md) - Interface complète
* [ComfyUI](/guides/guides_v2-fr/generation-dimages/comfyui.md) - Flux de travail basé sur des nœuds
* [Real-ESRGAN](/guides/guides_v2-fr/traitement-dimages/real-esrgan-upscaling.md) - Amplifier 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:

```
GET https://docs.clore.ai/guides/guides_v2-fr/generation-dimages/sdxl-turbo.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.