# 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) - Увеличение разрешения результата


---

# Agent Instructions: 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-ru/generaciya-izobrazhenii/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.