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.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

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 :

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

pip install diffusers transformers accelerate torch

SDXL Turbo

Utilisation de base

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

# 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

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)

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 :

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

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

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

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

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

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

# 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

# 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

# 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 - Génération de la plus haute qualité

• Interface web Stable Diffusion - Interface utilisateur complète

• ComfyUI - Flux de travail basés sur des nœuds

• Real-ESRGAN - Agrandir les résultats