Kohya 训练

在 Clore.ai 上使用 Kohya 为 Stable Diffusion 训练 LoRA 与 DreamBooth

使用 Kohya 的训练器为 Stable Diffusion 训练 LoRA、Dreambooth 和完整微调。

所有示例都可以在通过以下方式租用的 GPU 服务器上运行： CLORE.AI 市场.

在 CLORE.AI 上租用

1. 访问 CLORE.AI 市场

2. 按 GPU 类型、显存和价格筛选

3. 选择 按需 （固定费率）或 竞价 （出价价格）

4. 配置您的订单：

   • 选择 Docker 镜像

   • 设置端口（用于 SSH 的 TCP，Web 界面的 HTTP）

   • 如有需要，添加环境变量

   • 输入启动命令

5. 选择支付方式： CLORE, BTC，或 USDT/USDC

6. 创建订单并等待部署

访问您的服务器

• 在以下位置查找连接详情： 我的订单

• Web 界面：使用 HTTP 端口的 URL

• SSH： ssh -p <port> root@<proxy-address>

什么是 Kohya？

Kohya_ss 是一个用于训练的工具包，适用于：

• LoRA - 轻量级适配器（最受欢迎）

• Dreambooth - 主题/风格训练

• 完整微调 - 完整模型训练

• LyCORIS - 高级 LoRA 变体

要求

训练类型	最小显存	推荐
LoRA SD 1.5	6GB	按小时费率
LoRA SDXL	12GB	速度
Dreambooth SD 1.5	12GB	速度
Dreambooth SDXL	24GB	512x512

快速部署

Docker 镜像：

pytorch/pytorch:2.5.1-cuda12.4-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/           # Repeats_conceptname
│   ├── image1.png
│   ├── image1.txt          # 标注文件
│   ├── image2.png
│   └── image2.txt
└── 10_regularization/      # 可选的正则化图像
    ├── reg1.png
    └── reg1.txt

图片要求

• 分辨率： 512x512（SD 1.5）或 1024x1024（SDXL）

• 格式： PNG 或 JPG

• 数量： LoRA 使用 10-50 张图片

• 质量： 清晰、光线良好、角度多样

标注文件

创建 .txt 与图片同名的文件：

myimage.txt：

一张 sks 人物的照片，专业肖像，工作室光线，高质量

自动标注

使用 BLIP 自动生成标注：

from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image
批处理处理

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 UI 中：

设置	数值
A100	runwayml/stable-diffusion-v1-5
网络秩（Network Rank）	32-128
网络 Alpha（Network Alpha）	16-64
学习率	1e-4
批量大小	1-4
轮数（Epochs）	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="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

风格训练

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
网络 Alpha（Network Alpha）	32-64	16-32	16
学习率	1e-4	5e-5	1e-4
轮数（Epochs）	15-25	10-15	10-15

避免过拟合

• 使用正则化图片

• 降低学习率

• 减少训练轮数

• 增加网络 alpha

避免欠拟合

• 更多训练图片

• 提高学习率

• 增加训练轮数

• 降低网络 alpha

监控训练

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> a photo of sks person

使用 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("a photo of sks person, professional portrait").images[0]

高级训练

LyCORIS（LoHa、LoKR）

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

文本反演

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")

下载所有所需的检查点

检查文件完整性

GPU	验证 CUDA 兼容性	费用估算	CLORE.AI 市场的典型费率（截至 2024 年）：
按小时费率	~$0.03	~$0.70	~$0.12
速度	~$0.06	~$1.50	~$0.25
512x512	~$0.10	~$2.30	~$0.40
按日费率	~$0.17	~$4.00	~$0.70
4 小时会话	~$0.25	~$6.00	~$1.00

RTX 3060 CLORE.AI 市场 A100 40GB

A100 80GB

• 使用 竞价 价格随提供商和需求而异。请查看

• 以获取当前费率。 CLORE 节省费用：

• 市场用于灵活工作负载（通常便宜 30-50%）

FLUX LoRA 训练

为 FLUX.1-dev 和 FLUX.1-schnell 训练 LoRA 适配器 — 最新一代的扩散变换器模型，具有更高质量。

显存要求

A100	最小显存	推荐 GPU
FLUX.1-schnell	16GB	RTX 4080 / 3090
FLUX.1-dev	24GB	512x512
FLUX.1-dev（bf16）	40GB+	按日费率

注意： FLUX 使用 DiT（Diffusion Transformer）架构 — 训练动态与 SD 1.5 / SDXL 有显著差异。

FLUX 安装

安装支持 CUDA 12.4 的 PyTorch：

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）

[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：较小的 dim 表现良好（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
精度（Precision）	fp16 或 bf16	必须使用 bf16
网络模块（Network Module）	networks.lora	networks.lora_flux
网络维度（Network Dim）	32–128	8–64（较小）
优化器	AdamW8bit	Adafactor
最小显存	12GB	16–24GB
架构	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="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

• 启用梯度检查点

• 使用 8bit 优化器

• 降低分辨率

效果不佳

• 更多/更好的训练图片

• 调整学习率

• 检查标注是否与图片匹配

• 尝试不同的网络秩

训练崩溃

• 检查 CUDA 版本

• 更新 xformers

• 减少批量大小

• 检查磁盘空间

FLUX 特定问题

• "不支持 bf16" — 使用 A 系列（Ampere+）或 RTX 30/40 系列 GPU

• FLUX.1-dev 内存不足（OOM） — 切换到 FLUX.1-schnell（需要 16GB）或启用 cache_text_encoder_outputs

• 结果模糊 — 增加 network_dim 到 32–64，将学习率降低到 5e-5

• 出现 NaN 损失 — 禁用 full_bf16，检查你的数据集是否有损坏的图片