# SDXL Turbo & LCM

Генерируйте изображения за 1–4 шага с SDXL Turbo и моделями латентной согласованности (Latent Consistency Models) на GPU CLORE.AI.

{% hint style="success" %}
Все примеры можно запускать на GPU-серверах, арендуемых через [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Почему SDXL Turbo / LCM?

* **Скорость в реальном времени** - Генерация изображений за 1–4 шага вместо 30–50
* **Та же качество** - Сравнимо с полным SDXL при в 10 раз меньшем количестве шагов
* **Интерактивность** - Достаточно быстро для приложений в реальном времени
* **Низкое использование VRAM** - Эффективное использование памяти
* **Совместимость с LoRA** - Используйте с существующими SDXL LoRA

## Варианты моделей

| Модель          | Шаги | Скорость      | Качество | VRAM |
| --------------- | ---- | ------------- | -------- | ---- |
| SDXL Turbo      | 1-4  | Самая быстрая | Хорошо   | 8GB  |
| SDXL Lightning  | 2-8  | Очень быстро  | Отлично  | 8GB  |
| LCM-SDXL        | 4-8  | Быстро        | Отлично  | 8GB  |
| LCM-LoRA + SDXL | 4-8  | Быстро        | Отлично  | 10GB |
| SD Turbo (1.5)  | 1-4  | Самая быстрая | Хорошо   | 4 ГБ |

## Быстрое развертывание на CLORE.AI

**Docker-образ:**

```
pytorch/pytorch:2.5.1-cuda12.4-cudnn9-devel
```

**Порты:**

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

**Команда:**

```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 - генерация в реальном времени'
).launch(server_name='0.0.0.0', server_port=7860)
"
```

## Доступ к вашему сервису

После развертывания найдите ваш `http_pub` URL в **Моих заказах**:

1. Перейдите на **Моих заказах** страницу
2. Нажмите на ваш заказ
3. Найдите `http_pub` URL (например, `abc123.clorecloud.net`)

Используйте `https://YOUR_HTTP_PUB_URL` вместо `localhost` в примерах ниже.

## Требования к аппаратному обеспечению

| Модель         | Минимальная GPU | Рекомендуется |
| -------------- | --------------- | ------------- |
| 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 10GB   | RTX 4090      |

## Установка

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

## SDXL Turbo

### Базовое использование

```python
import torch
from diffusers import AutoPipelineForText2Image

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

# Генерировать за 1 шаг!
image = pipe(
    prompt="Кинематографический кадр с маленьким енотом в сложной итальянской священнической рясе",
    num_inference_steps=1,
    guidance_scale=0.0  # Turbo не использует CFG
).images[0]

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

### Лучшие настройки

```python
# 1 шаг — быстрее всего, хорошее качество
image = pipe(prompt, num_inference_steps=1, guidance_scale=0.0).images[0]

# 2 шага — лучше детали
image = pipe(prompt, num_inference_steps=2, guidance_scale=0.0).images[0]

# 4 шага — лучшее качество для turbo
image = pipe(prompt, num_inference_steps=4, guidance_scale=0.0).images[0]
```

## SDXL Lightning

### Генерация в 2 шага

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

# Загрузить базовую модель
pipe = StableDiffusionXLPipeline.from_pretrained(
    base,
    torch_dtype=torch.float16,
    variant="fp16"
).to("cuda")

# Загрузить lightning unet
pipe.unet.load_state_dict(
    torch.load(hf_hub_download(repo, ckpt), map_location="cuda")
)

# Настроить планировщик (scheduler)
pipe.scheduler = EulerDiscreteScheduler.from_config(
    pipe.scheduler.config,
    timestep_spacing="trailing"
)

# Генерировать за 2 шага
image = pipe(
    "Девочка улыбается в саду",
    num_inference_steps=2,
    guidance_scale=0.0
).images[0]

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

### 4 шага (большее качество)

```python
ckpt = "sdxl_lightning_4step_unet.safetensors"
# ... та же настройка ...

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

## LCM-LoRA

Используйте с любой моделью SDXL для быстрой генерации:

```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")

# Загрузить LCM-LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl")

# Установить LCМ-планировщик
pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)

# Генерировать за 4 шага
image = pipe(
    "Астронавт в джунглях, холодная палитра, приглушенные цвета, детализированно, 8k",
    num_inference_steps=4,
    guidance_scale=1.0  # LCM использует низкий CFG
).images[0]

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

### С пользовательскими LoRA

```python
# Загрузить базу + LCM-LoRA + стильный LoRA
pipe.load_lora_weights("latent-consistency/lcm-lora-sdxl", adapter_name="lcm")
pipe.load_lora_weights("your-style-lora", adapter_name="style")

# Объединить адаптеры
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)

Для снижения требований к 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(
    "Фотография кошки",
    num_inference_steps=1,
    guidance_scale=0.0
).images[0]
```

## Изображение в изображение

### 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="кот-волшебник, Гэндальф, Властелин колец, детализированно, фэнтези",
    image=init_image,
    num_inference_steps=2,
    strength=0.5,
    guidance_scale=0.0
).images[0]
```

## Пакетная генерация

```python
import torch
from diffusers import AutoPipelineForText2Image

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

prompts = [
    "Закат над горами",
    "Футуристический город ночью",
    "Милый робот в саду",
    "Древний храм в тумане"
]

# Пакетная генерация
images = pipe(
    prompts,
    num_inference_steps=1,
    guidance_scale=0.0
).images

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

## Поток в реальном времени

```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,  # Обновлять по мере ввода
    title="SDXL Turbo в реальном времени"
)

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

## Сравнение производительности

| Модель         | Шаги | Разрешение | RTX 3090 | RTX 4090 | A100  |
| -------------- | ---- | ---------- | -------- | -------- | ----- |
| SDXL (базовая) | 30   | 1024x1024  | 8s       | 5s       | 4 с   |
| SDXL Turbo     | 1    | 512x512    | 0.3 с    | 0.2s     | 0.15s |
| SDXL Turbo     | 4    | 512x512    | 0.8 с    | 0.5 с    | 0.4s  |
| SDXL Lightning | 2    | 1024x1024  | 0.8 с    | 0.5 с    | 0.4s  |
| SDXL Lightning | 4    | 1024x1024  | 1.2 с    | 0.8 с    | 0.6s  |
| LCM-SDXL       | 4    | 1024x1024  | 1.5s     | 1.0s     | 0.7s  |

## Сравнение качества

| Аспект              | SDXL 30 шагов | Turbo 4 шага | Lightning 4 шага |
| ------------------- | ------------- | ------------ | ---------------- |
| Детали              | Отлично       | Хорошо       | Отлично          |
| Отрисовка текста    | Хорошо        | Плохо        | Плохо            |
| Лица                | Отлично       | Хорошо       | Хорошо           |
| Согласованность     | Отлично       | Хорошо       | Отлично          |
| Разнообразие стилей | Отлично       | Хорошо       | Отлично          |

## Когда что использовать

| Случай использования            | Рекомендуется  | Шаги |
| ------------------------------- | -------------- | ---- |
| Предпросмотр в реальном времени | SDXL Turbo     | 1    |
| Интерактивные приложения        | SDXL Turbo     | 1-2  |
| Быстрые итерации                | SDXL Lightning | 2-4  |
| С пользовательскими LoRA        | LCM-LoRA       | 4-8  |
| Максимальное качество           | SDXL Lightning | 8    |
| Низкое использование VRAM       | SD Turbo       | 1-2  |

## Оценка стоимости

Типичные расценки на маркетплейсе CLORE.AI:

| GPU           | Почасовая ставка | Изображений/час (1 шаг) |
| ------------- | ---------------- | ----------------------- |
| 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                |

*Цены варьируются. Проверьте* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *для текущих тарифов.*

## Устранение неполадок

### Размытые результаты

* SDXL Turbo выводит 512x512 нативно
* Используйте SDXL Lightning для 1024x1024
* Добавьте постобработку для увеличения разрешения

### Ошибка guidance\_scale

```python
# SDXL Turbo: всегда используйте 0.0
image = pipe(prompt, guidance_scale=0.0).images[0]

# LCM: используйте 1.0–2.0
image = pipe(prompt, guidance_scale=1.5).images[0]

# Lightning: используйте 0.0
image = pipe(prompt, guidance_scale=0.0).images[0]
```

### LoRA не работает

```python
# Для LCM-LoRA необходимо использовать LCMScheduler
from diffusers import LCMScheduler

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

### Недостаточно памяти

```python
# Включить оптимизации памяти
pipe.enable_model_cpu_offload()
pipe.enable_vae_slicing()

# Или используйте меньшую модель
# SD Turbo вместо SDXL Turbo
```

## Дальнейшие шаги

* [FLUX.1](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/flux) - Генерация наивысшего качества
* [Stable Diffusion WebUI](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/stable-diffusion-webui) - Полный интерфейс
* [ComfyUI](https://docs.clore.ai/guides/guides_v2-ru/generaciya-izobrazhenii/comfyui) - Работа на основе узлов (node-based)
* [Real-ESRGAN](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/real-esrgan-upscaling) - Увеличение разрешения результата