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 (LCM) sur les GPU CLORE.AI.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

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 :

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

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

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

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 :

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

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

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

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

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

# 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

# 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

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

• Stable Diffusion WebUI - Interface complète

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

• Real-ESRGAN - Amplifier les résultats