> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/controlnet-advanced.md).

# ControlNet

Точный контроль над генерацией AI-изображений с ControlNet

Освойте ControlNet для точного управления генерацией изображений ИИ.

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

## Аренда на CLORE.AI

1. Перейдите на [маркетплейс CLORE.AI](https://clore.ai/marketplace)
2. Отфильтруйте по типу GPU, объёму VRAM и цене
3. Выберите **On-Demand** (фиксированная ставка) или **Spot** (цена ставки)
4. Настройте свой заказ:
   * Выберите Docker-образ
   * Установите порты (TCP для SSH, HTTP для веб-интерфейсов)
   * При необходимости добавьте переменные окружения
   * Введите команду запуска
5. Выберите способ оплаты: **CLORE**, **BTC**, или **USDT/USDC**
6. Создайте заказ и дождитесь развертывания

### Получите доступ к своему серверу

* Найдите данные для подключения в **Мои заказы**
* Веб-интерфейсы: используйте URL HTTP-порта
* SSH: `ssh -p <port> root@<proxy-address>`

## Что такое ControlNet?

ControlNet добавляет условное управление в Stable Diffusion:

* **Canny** - Обнаружение краёв
* **Глубина** - Карты глубины 3D
* **Поза** - Позы человека
* **Скетч** - Наброски от руки
* **Сегментация** - Семантические маски
* **Лайн-арт** - Чистые линии
* **IP-Adapter** - Перенос стиля

## Требования

| Тип контроля         | Мин. VRAM | Рекомендуется |
| -------------------- | --------- | ------------- |
| Один ControlNet      | 8 ГБ      | RTX 3070      |
| Несколько ControlNet | 12GB      | RTX 3090      |
| ControlNet для SDXL  | 16GB      | RTX 4090      |

## Быстрое развёртывание с A1111

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

```bash
cd /workspace/stable-diffusion-webui && \\
cd extensions && \\
git clone https://github.com/Mikubill/sd-webui-controlnet && \\
cd .. && \\
python launch.py --listen --enable-insecure-extension-access
```

### Скачать модели

```bash
cd /workspace/stable-diffusion-webui/extensions/sd-webui-controlnet/models

# ControlNet для SD 1.5
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_canny.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11f1p_sd15_depth.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_openpose.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_scribble.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_lineart.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_softedge.pth
wget https://huggingface.co/lllyasviel/ControlNet-v1-1/resolve/main/control_v11p_sd15_seg.pth

# ControlNet для SDXL
wget https://huggingface.co/diffusers/controlnet-canny-sdxl-1.0/resolve/main/diffusion_pytorch_model.safetensors -O controlnet-canny-sdxl.safetensors
```

## Python с Diffusers

### Управление по Canny-краям

```python
import torch
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from diffusers.utils import load_image
from controlnet_aux import CannyDetector
import cv2
import numpy as np

# Загрузить ControlNet
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

# Загрузить пайплайн
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()

# Подготовить контрольное изображение
image = load_image("input.jpg")
canny = CannyDetector()
control_image = canny(image)

# Генерировать
output = pipe(
    prompt="красивая женщина в саду, высокое качество",
    negative_prompt="уродливо, размыто",
    image=control_image,
    num_inference_steps=30,
    controlnet_conditioning_scale=1.0
).images[0]

output.save("canny_output.png")
```

### Управление глубиной

```python
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from controlnet_aux import MidasDetector
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11f1p_sd15_depth",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# Получить карту глубины
depth_estimator = MidasDetector.from_pretrained("lllyasviel/Annotators")
depth_image = depth_estimator(image)

# Генерировать с глубиной
output = pipe(
    prompt="футуристический город, научная фантастика, детализированный",
    image=depth_image,
    num_inference_steps=30
).images[0]
```

### OpenPose (Позы человека)

```python
from controlnet_aux import OpenposeDetector

# Получить позу
pose_detector = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
pose_image = pose_detector(image)

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_openpose",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="танцующая балерина, элегантная, студийное освещение",
    image=pose_image,
    num_inference_steps=30
).images[0]
```

### Скриббл/Скетч

```python
from controlnet_aux import HEDdetector

# Обнаружить края как скетч
hed = HEDdetector.from_pretrained("lllyasviel/Annotators")
scribble_image = hed(image, scribble=True)

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_scribble",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="детализированная живописная картина пейзажа",
    image=scribble_image,
    num_inference_steps=30
).images[0]
```

## Multi-ControlNet

Объедините несколько типов контроля:

```python
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
import torch

# Загрузить несколько ControlNet
controlnet_canny = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

controlnet_depth = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11f1p_sd15_depth",
    torch_dtype=torch.float16
)

# Создать pipeline с несколькими ControlNet
pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=[controlnet_canny, controlnet_depth],
    torch_dtype=torch.float16
).to("cuda")

# Генерировать с несколькими типами контроля
output = pipe(
    prompt="красивый портрет",
    image=[canny_image, depth_image],
    controlnet_conditioning_scale=[1.0, 0.8],  # Настроить веса
    num_inference_steps=30
).images[0]
```

## ControlNet для SDXL

```python
from diffusers import StableDiffusionXLControlNetPipeline, ControlNetModel
from controlnet_aux import CannyDetector
import torch

# Загрузить SDXL ControlNet
controlnet = ControlNetModel.from_pretrained(
    "diffusers/controlnet-canny-sdxl-1.0",
    torch_dtype=torch.float16
)

pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

# Подготовить изображение Canny
canny = CannyDetector()
control_image = canny(image, low_threshold=100, high_threshold=200)

output = pipe(
    prompt="профессиональная фотография, детализированная, 8k",
    image=control_image,
    controlnet_conditioning_scale=0.5,
    num_inference_steps=30
).images[0]
```

## IP-Adapter (Перенос стиля)

```python
from diffusers import StableDiffusionPipeline
from transformers import CLIPVisionModelWithProjection
import torch

# Загрузить IP-Adapter
pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")

pipe.load_ip_adapter(
    "h94/IP-Adapter",
    subfolder="models",
    weight_name="ip-adapter_sd15.bin"
)

pipe.set_ip_adapter_scale(0.6)

# Изображение-референс стиля
style_image = load_image("style_reference.jpg")

output = pipe(
    prompt="кот, сидящий на стуле",
    ip_adapter_image=style_image,
    num_inference_steps=30
).images[0]
```

## Препроцессоры

Все доступные препроцессоры:

```python
from controlnet_aux import (
    CannyDetector,           # Обнаружение краёв
    HEDdetector,             # Мягкий край/скетч
    MidasDetector,           # Оценка глубины
    OpenposeDetector,        # Позы человека
    MLSDdetector,            # Обнаружение линий
    LineartDetector,         # Лайн-арт
    LineartAnimeDetector,    # Аниме-лайн-арт
    NormalBaeDetector,       # Карты нормалей
    ContentShuffleDetector,  # Перемешивание содержимого
    ZoeDetector,             # Лучшая оценка глубины
    MediapipeFaceDetector,   # Сетка лица
)

# Пример использования
canny = CannyDetector()
canny_image = canny(image, low_threshold=100, high_threshold=200)

depth = MidasDetector.from_pretrained("lllyasviel/Annotators")
depth_image = depth(image)

pose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
pose_image = pose(image, hand_and_face=True)
```

## Вес контроля

Настройте влияние для каждого ControlNet:

```python

# Полный контроль
output = pipe(..., controlnet_conditioning_scale=1.0)

# Частичный контроль (больше свободы для творчества)
output = pipe(..., controlnet_conditioning_scale=0.5)

# Очень лёгкое руководство
output = pipe(..., controlnet_conditioning_scale=0.3)
```

### Пошаговый контроль

```python

# Контролировать только на определённых шагах
output = pipe(
    prompt="...",
    image=control_image,
    controlnet_conditioning_scale=1.0,
    control_guidance_start=0.0,  # Начать с самого начала
    control_guidance_end=0.5,    # Остановить на 50% шагов
    num_inference_steps=30
).images[0]
```

## Инпейнт с ControlNet

```python
from diffusers import StableDiffusionControlNetInpaintPipeline, ControlNetModel
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetInpaintPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

output = pipe(
    prompt="красный спортивный автомобиль",
    image=init_image,
    mask_image=mask,
    control_image=canny_image,
    num_inference_steps=30
).images[0]
```

## Пакетная обработка

```python
import os
from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
from controlnet_aux import CannyDetector
from PIL import Image
import torch

controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
).to("cuda")

canny = CannyDetector()

input_dir = "./inputs"
output_dir = "./outputs"
os.makedirs(output_dir, exist_ok=True)

prompt = "красивая пейзажная картина, детализированная, художественная"

for filename in os.listdir(input_dir):
    if filename.lower().endswith(('.png', '.jpg', '.jpeg')):
        image = Image.open(os.path.join(input_dir, filename))
        control_image = canny(image)

        output = pipe(
            prompt=prompt,
            image=control_image,
            num_inference_steps=30
        ).images[0]

        output.save(os.path.join(output_dir, f"cn_{filename}"))
```

## Руководство по типам контроля

| Контроль | Лучше всего для       | Сильная сторона |
| -------- | --------------------- | --------------- |
| Canny    | Архитектура, объекты  | 0.8-1.0         |
| Глубина  | 3D-сцены, перспектива | 0.6-0.8         |
| Поза     | Люди, персонажи       | 0.8-1.0         |
| Скетч    | Скетчи, концепты      | 0.6-0.8         |
| Лайн-арт | Иллюстрации           | 0.7-0.9         |
| Softedge | Общее руководство     | 0.5-0.7         |
| Seg      | Композиция сцены      | 0.6-0.8         |

## Производительность

| Конфигурация       | GPU      | Разрешение | Время |
| ------------------ | -------- | ---------- | ----- |
| Один CN SD1.5      | RTX 3090 | 512x512    | \~3 с |
| Несколько CN SD1.5 | RTX 3090 | 512x512    | \~5 с |
| Один CN SDXL       | RTX 4090 | 1024x1024  | \~8 с |

## Оптимизация памяти

```python

# Включить экономичное по памяти внимание
pipe.enable_xformers_memory_efficient_attention()

# Выгрузка на CPU
pipe.enable_model_cpu_offload()

# Разбиение внимания
pipe.enable_attention_slicing()
```

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

### Слабый эффект контроля

* Увеличьте `controlnet_conditioning_scale`
* Проверьте качество вывода препроцессора
* Используйте контрольное изображение более высокого разрешения

### Артефакты

* Уменьшите масштаб контроля
* Используйте более мягкий препроцессор (softedge вместо canny)
* Добавьте негативный промпт для артефактов

### Проблемы с VRAM

* Используйте выгрузку на CPU
* Уменьшите разрешение
* Используйте один ControlNet за раз

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

Типичные цены на маркетплейсе CLORE.AI (по состоянию на 2024 год):

| GPU        | Почасовая ставка | Дневная ставка | 4-часовая сессия |
| ---------- | ---------------- | -------------- | ---------------- |
| RTX 3060   | \~$0.03          | \~$0.70        | \~$0.12          |
| RTX 3090   | \~$0.06          | \~$1.50        | \~$0.25          |
| RTX 4090   | \~$0.10          | \~$2.30        | \~$0.40          |
| A100 40 ГБ | \~$0.17          | \~$4.00        | \~$0.70          |
| A100 80 ГБ | \~$0.25          | \~$6.00        | \~$1.00          |

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

**Сэкономьте деньги:**

* Используйте **Spot** рынок для прерываемых задач — примерно треть серверов оценивает spot-цены ниже on-demand (медиана \~13% скидки), остальные совпадают с ними
* Платите **CLORE** токенами
* Сравните цены у разных провайдеров

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

* Веб-интерфейс Stable Diffusion
* Рабочие процессы ComfyUI
* [Обучение Kohya](/guides/guides_v2-ru/obuchenie/kohya-training.md)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-ru/obrabotka-izobrazhenii/controlnet-advanced.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.