Обучение с Kohya

Обучайте LoRA и DreamBooth для Stable Diffusion с Kohya на Clore.ai

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

Все примеры можно запускать на GPU-серверах, арендованных через маркетплейс CLORE.AI.

Аренда на CLORE.AI

1. Перейдите на маркетплейс CLORE.AI

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

Команда:

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 для автоматических подписей:

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

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

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)

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

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

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

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

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

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

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)

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

Textual Inversion

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

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

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

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

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

# 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 актуальные тарифы.

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

• Используйте 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:

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)

[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

# Одна 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

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

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

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

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

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

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, проверьте набор данных на наличие повреждённых изображений