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