# Обучение Kohya

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

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

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

1. Посетите [CLORE.AI Marketplace](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.5.1-cuda12.4-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` в примерах ниже.

## Использование веб-интерфейса

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
* **Качество:** Чёткие, хорошо освещённые, разнообразные ракурсы

### Файлы подписей (caption files)

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

**myimage.txt:**

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

### Авто-подписание (Auto-Captioning)

Используйте 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 |
| Ранг сети (Network Rank)          | 32-128                         |
| Альфа сети (Network Alpha)        | 16-64                          |
| Скорость обучения (Learning Rate) | 1e-4                           |
| Размер батча (Batch Size)         | 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

### Обучение предмета (Subject Training)

```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="a photo of sks person" \
    --class_prompt="a photo of person" \
    --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
```

### Обучение стиля (Style Training)

```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="painting in the style of xyz" \
    --resolution=512 \
    --train_batch_size=1 \
    --learning_rate=5e-6 \
    --max_train_steps=2000 \
    --mixed_precision=fp16
```

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

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

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

### Избежание переобучения

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

### Избежание недообучения

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

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

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

Использование в prompt:

```
<lora:my_lora:0.8> a photo of sks person
```

### С 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("a photo of sks person, professional portrait").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 40GB | \~$0.17          | \~$4.00        | \~$0.70       |
| A100 80GB | \~$0.25          | \~$6.00        | \~$1.00       |

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

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

* Используйте **Spot** рынок для гибких рабочих нагрузок (часто на 30–50% дешевле)
* Платите с помощью **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) | 40GB+     | A100 40GB         |

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

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

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

```bash
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
pip install xformers --index-url https://download.pytorch.org/whl/cu124
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 — меньшая скорость обучения, чем для 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 vs SDXL: ключевые различия

| Параметр                          | SDXL          | FLUX.1              |
| --------------------------------- | ------------- | ------------------- |
| Скорость обучения (Learning Rate) | 1e-3 до 1e-4  | **1e-4 до 5e-5**    |
| Точность (Precision)              | fp16 или bf16 | **bf16 ОБЯЗАТЕЛЕН** |
| Модуль сети (Network Module)      | networks.lora | networks.lora\_flux |
| Размерность сети (Network Dim)    | 32–128        | 8–64 (меньше)       |
| Оптимизатор                       | AdamW8bit     | Adafactor           |
| Мин. VRAM                         | 12GB          | 16–24GB             |
| Архитектура                       | 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="a photo of sks person, professional portrait, studio lighting",
    num_inference_steps=28,
    guidance_scale=3.5,
    width=1024,
    height=1024,
).images[0]

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

***

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

### Ошибка OOM

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

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

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

### Крашы во время обучения

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

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

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


---

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