> 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/obuchenie/kohya-training.md).

# Обучение с Kohya

Обучайте LoRA, Dreambooth и полные дообучения для Stable Diffusion с помощью тренера Kohya.

{% 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>`

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

Kohya\_ss — это набор инструментов для обучения:

* **LoRA** - Лёгкие адаптеры (самые популярные)
* **Dreambooth** - Обучение субъекта/стиля
* **Полное дообучение** - Полное обучение модели
* **LyCORIS** - Продвинутые варианты LoRA

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

| Тип обучения      | Мин. VRAM | Рекомендуется |
| ----------------- | --------- | ------------- |
| LoRA SD 1.5       | 6 ГБ      | RTX 3060      |
| LoRA SDXL         | 12GB      | RTX 3090      |
| Dreambooth SD 1.5 | 12GB      | RTX 3090      |
| Dreambooth SDXL   | 24 ГБ     | RTX 4090      |

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

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

```
pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel
```

**Порты:**

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

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

```bash
apt-get update && apt-get install -y git libgl1 libglib2.0-0 && \
cd /workspace && \
git clone https://github.com/bmaltais/kohya_ss.git && \
cd kohya_ss && \
pip install -r requirements.txt && \
pip install xformers && \
python kohya_gui.py --listen 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` в примерах ниже.

## Использование Web UI

1. Доступ по адресу `http://<proxy>:<port>`
2. Выберите тип обучения (LoRA, Dreambooth и т. д.)
3. Настройте параметры
4. Начните обучение

## Подготовка датасета

### Структура папок

```
/workspace/dataset/
├── 10_mysubject/           # Повторы_имя_концепта
│   ├── image1.png
│   ├── image1.txt          # Файл подписи
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # Необязательные рег. изображения
    ├── reg1.png
    └── reg1.txt
```

### Требования к изображениям

* **Разрешение:** 512x512 (SD 1.5) или 1024x1024 (SDXL)
* **Формат:** PNG или JPG
* **Количество:** 10–50 изображений для LoRA
* **Качество:** Чёткие, хорошо освещённые, с разных ракурсов

### Файлы подписей

Создайте `.txt` файл с тем же именем, что и изображение:

**myimage.txt:**

```
фото человека sks, профессиональный портрет, студийное освещение, высокое качество
```

### Автоматическое создание подписей

Используйте BLIP для автоматических подписей:

```python
from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
import os

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base").to("cuda")

for img_file in os.listdir("./images"):
    if img_file.endswith(('.png', '.jpg')):
        image = Image.open(f"./images/{img_file}")
        inputs = processor(image, return_tensors="pt").to("cuda")
        output = model.generate(**inputs, max_new_tokens=50)
        caption = processor.decode(output[0], skip_special_tokens=True)

        txt_file = img_file.rsplit('.', 1)[0] + '.txt'
        with open(f"./images/{txt_file}", 'w') as f:
            f.write(caption)
```

## Обучение LoRA (SD 1.5)

### Конфигурация

**В интерфейсе Kohya:**

| Параметр          | Значение                       |
| ----------------- | ------------------------------ |
| Модель            | runwayml/stable-diffusion-v1-5 |
| Ранг сети         | 32-128                         |
| Альфа сети        | 16-64                          |
| Скорость обучения | 1e-4                           |
| Размер батча      | 1-4                            |
| Эпохи             | 10-20                          |
| Оптимизатор       | AdamW8bit                      |

### Обучение из командной строки

```bash
accelerate launch --num_cpu_threads_per_process=2 train_network.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_lora" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=fp16 \
    --save_precision=fp16 \
    --optimizer_type=AdamW8bit \
    --lr_scheduler=cosine \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2
```

## Обучение LoRA (SDXL)

```bash
accelerate launch train_network.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --train_data_dir="/workspace/dataset" \
    --output_dir="/workspace/output" \
    --output_name="my_sdxl_lora" \
    --resolution=1024 \
    --train_batch_size=1 \
    --max_train_epochs=10 \
    --learning_rate=1e-4 \
    --network_module=networks.lora \
    --network_dim=32 \
    --network_alpha=16 \
    --mixed_precision=bf16 \
    --save_precision=fp16 \
    --optimizer_type=Adafactor \
    --cache_latents \
    --xformers \
    --save_every_n_epochs=2
```

## Обучение Dreambooth

### Обучение субъекта

```bash
accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/instance" \
    --class_data_dir="/workspace/dataset/class" \
    --output_dir="/workspace/output" \
    --instance_prompt="фото человека sks" \
    --class_prompt="фото человека" \
    --with_prior_preservation \
    --prior_loss_weight=1.0 \
    --num_class_images=200 \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=2e-6 \
    --max_train_steps=1000 \
    --mixed_precision=fp16 \
    --gradient_checkpointing
```

### Обучение стиля

```bash
accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --instance_data_dir="/workspace/dataset/style" \
    --output_dir="/workspace/output" \
    --instance_prompt="картина в стиле xyz" \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=5e-6 \
    --max_train_steps=2000 \
    --mixed_precision=fp16
```

## Советы по обучению

### Оптимальные настройки

| Параметр          | Человек/персонаж | Стиль | Объект |
| ----------------- | ---------------- | ----- | ------ |
| Ранг сети         | 64-128           | 32-64 | 32     |
| Альфа сети        | 32-64            | 16-32 | 16     |
| Скорость обучения | 1e-4             | 5e-5  | 1e-4   |
| Эпохи             | 15-25            | 10-15 | 10-15  |

### Как избежать переобучения

* Используйте регуляризационные изображения
* Более низкая скорость обучения
* Меньше эпох
* Увеличьте альфу сети

### Как избежать недообучения

* Больше обучающих изображений
* Более высокая скорость обучения
* Больше эпох
* Ниже альфа сети

## Мониторинг обучения

### TensorBoard

```bash
tensorboard --logdir /workspace/output/logs --port 6006 --bind_all
```

### Ключевые метрики

* **loss** - Должен снижаться, затем стабилизироваться
* **lr** - График скорости обучения
* **epoch** - Прогресс обучения

## Тестирование вашей LoRA

### С Automatic1111

Скопируйте LoRA в:

```
stable-diffusion-webui/models/Lora/my_lora.safetensors
```

Используйте в промпте:

```
<lora:my_lora:0.8> фото человека sks
```

### С ComfyUI

Загрузите узел LoRA и подключите к модели.

### С Diffusers

```python
from diffusers import StableDiffusionPipeline
import torch

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

pipe.load_lora_weights("/workspace/output/my_lora.safetensors")

image = pipe("фото человека sks, профессиональный портрет").images[0]
```

## Продвинутое обучение

### LyCORIS (LoHa, LoKR)

```bash
accelerate launch train_network.py \
    --network_module=lycoris.kohya \
    --network_args "algo=loha" "conv_dim=4" "conv_alpha=2" \
    ...
```

### Textual Inversion

```bash
accelerate launch train_textual_inversion.py \
    --pretrained_model_name_or_path="runwayml/stable-diffusion-v1-5" \
    --train_data_dir="/workspace/dataset" \
    --learnable_property="style" \
    --placeholder_token="<my-style>" \
    --initializer_token="art" \
    --resolution=512 \
    --train_batch_size=1 \
    --max_train_steps=3000 \
    --learning_rate=5e-4
```

## Сохранение и экспорт

### Скачать обученную модель

```bash
scp -P <port> root@<proxy>:/workspace/output/my_lora.safetensors ./
```

### Конвертация форматов

```python

# SafeTensors в PyTorch
from safetensors.torch import load_file, save_file
import torch

state_dict = load_file("model.safetensors")
torch.save(state_dict, "model.pt")
```

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

Типичные цены на маркетплейсе 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** токенами
* Сравните цены у разных провайдеров

## Обучение FLUX LoRA

Обучайте адаптеры LoRA для FLUX.1-dev и FLUX.1-schnell — новейшего поколения диффузионных трансформерных моделей с превосходным качеством.

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

| Модель            | Мин. VRAM | Рекомендуемый GPU |
| ----------------- | --------- | ----------------- |
| FLUX.1-schnell    | 16GB      | RTX 4080 / 3090   |
| FLUX.1-dev        | 24 ГБ     | RTX 4090          |
| FLUX.1-dev (bf16) | 40 ГБ+    | A100 40 ГБ        |

> **Примечание:** FLUX использует архитектуру DiT (Diffusion Transformer) — динамика обучения существенно отличается от SD 1.5 / SDXL.

### Установка для FLUX

Установите PyTorch с поддержкой CUDA 12.8:

```bash
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu128
pip install xformers --index-url https://download.pytorch.org/whl/cu128
pip install -r requirements.txt
pip install accelerate sentencepiece protobuf
```

### Конфигурация FLUX LoRA (flux\_lora.toml)

```toml
[general]
shuffle_caption = false
caption_extension = ".txt"
keep_tokens = 1

[datasets]
[[datasets.subsets]]
image_dir = "/workspace/dataset/train"
caption_extension = ".txt"
num_repeats = 5
resolution = [512, 512]

[training]
pretrained_model_name_or_path = "black-forest-labs/FLUX.1-dev"
output_dir = "/workspace/output"
output_name = "my_flux_lora"

# Специфично для FLUX: используйте bf16 (НЕ fp16 — FLUX требует bf16)
mixed_precision = "bf16"
save_precision = "bf16"
full_bf16 = true

train_batch_size = 1
max_train_epochs = 20
gradient_checkpointing = true
gradient_accumulation_steps = 4

# Параметры FLUX LoRA — более низкий LR, чем у SDXL!
learning_rate = 1e-4
lr_scheduler = "cosine_with_restarts"
lr_warmup_steps = 100

# Конфигурация сети
network_module = "networks.lora_flux"
network_dim = 16           # Для FLUX хорошо работает меньшая размерность (16–64)
network_alpha = 16         # Установите равным network_dim

# Специфичные для FLUX параметры
t5xxl_max_token_length = 512
apply_t5_attn_mask = true

# Оптимизатор — Adafactor хорошо работает для FLUX
optimizer_type = "adafactor"
optimizer_args = ["scale_parameter=False", "relative_step=False", "warmup_init=False"]

# Экономия памяти
cache_latents = true
cache_latents_to_disk = true
cache_text_encoder_outputs = true
cache_text_encoder_outputs_to_disk = true

# Сэмплирование во время обучения (необязательный предварительный просмотр)
sample_every_n_epochs = 5
sample_prompts = "/workspace/sample_prompts.txt"
```

### Команда обучения FLUX LoRA

```bash
# Одна GPU
accelerate launch train_network.py \
    --config_file flux_lora.toml \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --mixed_precision bf16 \
    --full_bf16

# С явными параметрами (без toml)
accelerate launch train_network.py \
    --pretrained_model_name_or_path "black-forest-labs/FLUX.1-dev" \
    --train_data_dir "/workspace/dataset" \
    --output_dir "/workspace/output" \
    --output_name "my_flux_lora" \
    --network_module networks.lora_flux \
    --network_dim 16 \
    --network_alpha 16 \
    --learning_rate 1e-4 \
    --max_train_epochs 20 \
    --train_batch_size 1 \
    --gradient_accumulation_steps 4 \
    --mixed_precision bf16 \
    --full_bf16 \
    --optimizer_type adafactor \
    --cache_latents \
    --cache_text_encoder_outputs \
    --t5xxl_max_token_length 512 \
    --apply_t5_attn_mask \
    --save_every_n_epochs 5
```

### FLUX против SDXL: ключевые различия

| Параметр          | SDXL          | FLUX.1              |
| ----------------- | ------------- | ------------------- |
| Скорость обучения | 1e-3 до 1e-4  | **1e-4 до 5e-5**    |
| Точность          | fp16 или bf16 | **bf16 ОБЯЗАТЕЛЕН** |
| Модуль сети       | networks.lora | networks.lora\_flux |
| Размерность сети  | 32–128        | 8–64 (меньше)       |
| Оптимизатор       | AdamW8bit     | Adafactor           |
| Мин. VRAM         | 12GB          | 16–24 ГБ            |
| Архитектура       | U-Net         | DiT (Transformer)   |

### Руководство по скорости обучения для FLUX

```toml
# Консервативно (безопаснее, меньше шанс переобучения)
learning_rate = 5e-5

# Стандартно (хорошая отправная точка)
learning_rate = 1e-4

# Агрессивно (более выразительно, риск артефактов)
learning_rate = 2e-4
```

> **Совет:** FLUX более чувствителен к скорости обучения, чем SDXL. Начните с `1e-4` и уменьшите до `5e-5` если заметите проблемы с качеством. Для SDXL, `1e-3` — это обычно; избегайте этого для FLUX.

### Тестирование FLUX LoRA

```python
import torch
from diffusers import FluxPipeline

pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
).to("cuda")

# Загрузите вашу обученную LoRA
pipe.load_lora_weights("/workspace/output/my_flux_lora.safetensors")

image = pipe(
    prompt="фото человека sks, профессиональный портрет, студийное освещение",
    num_inference_steps=28,
    guidance_scale=3.5,
    width=1024,
    height=1024,
).images[0]

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

***

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

### Ошибка нехватки памяти

* Уменьшите размер батча до 1
* Включите gradient checkpointing
* Используйте 8-битный оптимизатор
* Более низкое разрешение

### Плохие результаты

* Больше/лучше обучающих изображений
* Настройте скорость обучения
* Проверьте, соответствуют ли подписи изображениям
* Попробуйте другой ранг сети

### Сбои при обучении

* Проверьте версию CUDA
* Обновите xformers
* Уменьшите размер пакета
* Проверьте свободное место на диске

### Проблемы, специфичные для FLUX

* **"bf16 не поддерживается"** — Используйте GPU серии A (Ampere+) или RTX 30/40
* **OOM в FLUX.1-dev** — Переключитесь на FLUX.1-schnell (требуется 16 ГБ) или включите `cache_text_encoder_outputs`
* **Размытые результаты** — Увеличьте `network_dim` до 32–64, снизьте скорость обучения до `5e-5`
* **NaN в loss** — Отключите `full_bf16`, проверьте набор данных на наличие повреждённых изображений


---

# 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/obuchenie/kohya-training.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.