使用 Kaggle 进行模型训练

前言

接触 AI 绘画后，想自己训练一个 LoRA 模型来实现自己想要的效果，但自己的显卡训练模型非常慢，或者显存太小无法训练，此时就可以通过云端进行模型训练。

使用工具

这里我使用 SD-Trainer 提供的打标器对图片进行打标，使用 SD-Trainer Installer 进行安装。

云端训练使用的是 Kaggle 平台，使用邮箱注册并且绑定手机号。

云端训练脚本使用的是 SD Scripts Kaggle Jupyter NoteBook，该脚本将会部署 sd-scripts 进行 Stable Diffusion 模型训练。

为了方便存储模型和训练集，使用 HuggingFace 和 ModelScope 平台，这 2 个平台的使用教程可以阅读《使用 HuggingFace / ModelScope 保存和下载文件》这篇文章。

准备训练集

一般想训练出比较好效果的 LoRA，训练集最好准备 50 张以上的图片，为了方便演示，所以只准备了 3 张图片，下面是训练集的结构。

character_aaaki 为训练集的名称，填写训练集路径时，只能填到 character_aaaki 这一层路径，不能继续将路径深入。

在 character_aaaki 这个文件夹下是不同子文件夹，并且按照{重复次数}_{子训练集名称}这个格式进行命名，则 1_aaaki 这个子训练集在每轮训练时，里面的图片只会被训练 1 次，而 2_aaaki 这个子训练集中的图片会被训练 2 次。

子训练集的数量和子训练集设置的重复次数根据自己的训练素材来设置。

在子训练集中存放的则是图片，模型在训练时将会学习图片中的特征，但这些图片缺少标注，所以使用打标器对图片进行内容标注。

图片标注

这里需要对 1_aaaki 和 2_aaaki 这 2 个子训练集进行打标，使用 SD-Trainer 中的打标工具。

打开 SD-Trainer 后，进入 WD 标签器，在图片文件夹路径填写子训练集的路径，Tagger 模型选择 wd-eva02-large-tagger-v3（这个打标模型的标注比较详细，不过选择其他 Tagger 模型也可以）。

因为我训练的是人物 LoRA，需要为人物 LoRA 设置触发词，所以在附加提示词 (逗号分隔)中填写了触发词，如果训练的是画风 LoRA，则一般不需要设置触发词。

这里将将结果中的括号进行转义处理取消勾选，因为训练脚本所使用的 sd-scripts 不需要对标注文本中的括号进行转义处理。

配置完成后点击右边的启动按钮对子训练集中的图片进行标注，将子训练集分别进行打标处理后，训练集结构如下。

配置 Kaggle 训练脚本

处理完训练集后，现在对云端的训练脚本进行配置，进入 sd-webui-all-in-one 项目地址，找到 SD Scripts Kaggle Jupyter NoteBook 后，点击 sd_scripts_kaggle.ipynb 下载该训练脚本。

进入 Kaggle 官网，点击左侧的 Code（代码），在 Code（代码）界面点击 Your Work（个人工作），在该界面可以看到自己创建的 Notebooks（基于 Jupyter 的笔记本）。点击上方的 Create（创建）-> New Notebook（新建笔记本），此时将新建一个新的笔记本并打开编辑界面。

在编辑界面的顶部点击 File（文件）-> Import Notebook（导入笔记本），在右侧的导入界面选择刚刚下载下来的 sd_scripts_kaggle.ipynb，再点击下方的 Import（导入）将训练脚本导入 Kaggle。

将 sd_scripts_kaggle.ipynb 导入后，如果右侧没有看到 Kaggle Notebook 的配置界面，可以点击右下角的小三角箭头打开，然后在右侧 Notebook（笔记本）-> Session options（会话选项）-> ACCELERATOR（加速器）选项选择 GPU T4 x 2，此时训练脚本基本配置完成。

配置训练脚本参数

该训练脚本主要分为 6 大部分，第 1 部分是训练脚本的简单说明，第 2 部分则是该训练脚本的功能初始化单元，该部分包含大量处理训练环境的函数，如果对训练脚本功能的具体代码实现感兴趣，可以阅读该部分的代码，否则直接忽略该部分。

在每个大标题的下方包含下一个单元和上一个单元按钮，点击按钮可以快速跳转笔记本不同的单元。

下一个单元是参数配置单元，这里设置了在 Kaggle 部署训练环境的不同参数。

环境设置中的内容通常不需要修改，保持默认即可。

sd-scripts 版本设置设置了使用 sd-scripts 的分支和版本，这里可以看 sd-scripts 在 Github 的项目。

在该项目的左上角为项目的分支，不同的分支功能会有些差异，稳定性不同，通常使用 dev 分支即可，右上角为 Commits（提交记录），该项目没更新一次时将生成一个新的 Commit（提交记录）对应的哈希值，可以通过该哈希值切换版本。

sd-scripts 版本设置通常不需要修改。

模型上传设置设置训练结束后将模型上传到 HuggingFace / ModelScope。如果没有设置该选项，在训练结束后，只能从 Kaggle Output 中下载训练好的模型。这里推荐启用该选项，则将USE_HF_TO_SAVE_MODEL和USE_MS_TO_SAVE_MODEL的值从False设置为True。

设置后，需要分别获取 HuggingFace Token 和 ModelScope Token。

进入 HuggingFace 官网后，点击右上角头像打开菜单，选择 Access Tokens -> Create new token，在 Token name（密钥名字）随便填写一个名字，然后在 Repositories（仓库）选项将下方的 3 个选项勾选，再点击下方的 Create token（创建密钥），此时将获得 HuggingFace Token，复制下来并保管好，比如获取到的 HuggingFace Token 为hf_abcdef。

进入 ModelScope 官网后，点击首页 -> 访问令牌 -> SDK 令牌 -> 新建 SDK 令牌，输入名称后点击新建令牌，再将 SDK 令牌复制下来并保管好，比如刚刚获取到的 ModelScope SDK 令牌（ModelScope Token）为ms_fedcba。

获取到 HuggingFace Token 和 ModelScope SDK 令牌后，将训练脚本的HF_TOKEN值修改为hf_abcdef，即HF_TOKEN = "hf_abcdef"。将MS_TOKEN的值修改为ms_fedcba，即MS_TOKEN = "ms_fedcba"。

接下来在 HuggingFace 和 ModelScope 分别创建一个模型仓库。

此时在 HuggingFace 上创建的模型仓库 ID 为licyk/sd_training_model，在 ModelScope 上创建的模型仓库 ID 为licyks/sd_training_model。

得到 HuggingFace 仓库 ID 后，将HF_REPO_ID的值设置为 HuggingFace 上创建的模型仓库 ID，即licyk/sd_training_model，将HF_REPO_TYPE的值修改为model。

得到 ModelScope 仓库 ID 后，将MS_REPO_ID的值设置为 ModelScope 上创建的模型仓库 ID，即licyks/sd_training_model，将MS_REPO_TYPE的值修改为model。

因为使用 ModelScope 上传模型的功能基于 Git，所以需要配置 Git 的个人信息，但通常使用默认值即可。

路径设置配置了一些预设路径，通常不需要修改。

训练模型设置提供了一部分常用的大模型和 VAE 模型，可以根据自己训练的要求进行选择。

在模型列表中，前面部分的为模型下载链接，后面为数字，当数字设置为 1 时，模型将会被下载。设置为其他数字时，模型将不会被下载。

例如["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/v1-5-pruned-emaonly.safetensors", 0],和["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/animefull-final-pruned.safetensors", 1],，当在进行环境安装时，前面的模型不会被下载，后面的模型将被下载，并且模型的名称为animefull-final-pruned.safetensors。

模型将会下载到{SD_MODEL_PATH}，即/kaggle/sd-models。

下面是配置好的训练脚本参数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
# 环境设置
WORKSPACE = "/kaggle" # 工作路径, 通常不需要修改
WORKFOLDER = "sd-scripts" # 工作路径中文件夹名称, 通常不需要修改
SD_SCRIPTS_PATH = "/kaggle/sd-scripts" # sd-scripts 的路径
TORCH_VER = "torch==2.5.0+cu121 torchvision==0.20.0+cu121 torchaudio==2.5.0+cu121" # PyTorch 版本
XFORMERS_VER = "xformers==0.0.28.post2" # xFormers 版本
USE_UV = True # 使用 uv 加速 Python 软件包安装, 修改为 True 为启用, False 为禁用

##############################################################################

# sd-scripts 版本设置
SD_SCRIPTS_BRANCH = "dev" # sd-scripts 分支, 可切换成 main / dev 或者其它分支, 留空则不进行切换
SD_SCRIPTS_COMMIT = "" # 切换 sd-scripts 的版本到某个 Git 提交记录上, 留空则不进行切换

##############################################################################

# 模型上传设置, 使用 HuggingFace / ModelScope 上传训练好的模型
# HuggingFace: https://huggingface.co
# ModelScope: https://modelscope.cn
USE_HF_TO_SAVE_MODEL = True # 使用 HuggingFace 保存训练好的模型, 修改为 True 为启用, False 为禁用
USE_MS_TO_SAVE_MODEL = True # 使用 ModelScope 保存训练好的模型, 修改为 True 为启用, False 为禁用

# 设置使用 ModelScope 上传文件时使用的文件上传方式, 使用旧版方式上传速度更快, 通常保持默认即可
USE_NEW_MS_UPLOADER = False # 修改为 True 设置为新版, False 为旧版
# 旧版上传方式基于 Git, 新版上传方式基于 ModelScope API
# 旧版方式在 Kaggle 的网络环境中速度更快

# HuggingFace Token 在 Account -> Settings -> Access Tokens 中获取
HF_TOKEN = "hf_abcdef" # HuggingFace Token
# ModelScope Token 在 首页 -> 访问令牌 -> SDK 令牌 中获取
MS_TOKEN = "ms_fedcba" # ModelScope Token

# HuggingFace 模型仓库的 ID, 当仓库不存在时则尝试新建一个
HF_REPO_ID = "licyk/sd_training_model" # HuggingFace 仓库的 ID (格式: "用户名/仓库名")
HF_REPO_TYPE = "model" # HuggingFace 仓库的种类 (可选的类型为: model / dataset / space), 如果在 HuggingFace 新建的仓库为模型仓库则不需要修改
# HuggingFace 仓库类型和对应名称:
# model: 模型仓库
# dataset: 数据集仓库
# space: 在线运行空间仓库

# ModelScope 模型仓库的 ID, 当仓库不存在时则尝试新建一个
MS_REPO_ID = "licyks/sd_training_model" # ModelScope 仓库的 ID (格式: "用户名/仓库名")
MS_REPO_TYPE = "model" # ModelScope 仓库的种类 (model / dataset / space), 如果在 ModelScope 新建的仓库为模型仓库则不需要修改
# ModelScope 仓库类型和对应名称:
# model: 模型仓库
# dataset: 数据集仓库
# space: 创空间仓库

# 设置自动创建仓库时仓库的可见性, False 为私有仓库(不可见), True 为公有仓库(可见), 通常保持默认即可
HF_REPO_VISIBILITY = False # 设置新建的 HuggingFace 仓库可见性
MS_REPO_VISIBILITY = False # 设置新建的 ModelScope 仓库可见性

# Git 信息设置, 用于上传模型至 ModelScope 时使用, 可以使用默认值
GIT_USER_EMAIL = "username@example.com" # Git 的邮箱
GIT_USER_NAME = "username" # Git 的用户名

##############################################################################

# 训练日志设置, 可使用 tensorboard / wandb 记录训练日志, 使用 wandb 可远程查看实时训练日志
# 使用 wandb 需要填写 WANDB_TOKEN
LOG_MODULE = "tensorboard" # 使用的日志记录工具 (tensorboard / wandb)

# wandb Token 设置
# wandb Token 可在 https://wandb.ai/authorize 中获取
WANDB_TOKEN = "" # wandb Token

##############################################################################

# 路径设置, 通常保持默认即可
INPUT_DATASET_PATH = "/kaggle/dataset" # 训练集保存的路径
OUTPUT_PATH = "/kaggle/working/model" # 训练时模型保存的路径
SD_MODEL_PATH = "/kaggle/sd-models" # 模型下载到的路径
KAGGLE_INPUT_PATH = "/kaggle/input" # Kaggle Input 的路径

##############################################################################

# 训练模型设置, 在安装时将会下载选择的模型
# 下面举个例子:
# SD_MODEL = [
#     ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/v1-5-pruned-emaonly.safetensors", 0],
#     ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/animefull-final-pruned.safetensors", 1],
#     ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/Counterfeit-V3.0_fp16.safetensors", 0],
#     ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/Illustrious-XL-v0.1.safetensors", 1, "Illustrious.safetensors"]
# ]
# 
# 在这个例子中, 第一个参数指定了模型的下载链接, 第二个参数设置了是否要下载这个模型, 当这个值为 1 时则下载该模型
# 第三个参数是可选参数, 用于指定下载到本地后的文件名称
# 
# 则上面的例子中
# https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/animefull-final-pruned.safetensors 和 
# https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/Illustrious-XL-v0.1.safetensors 下载链接所指的文件将被下载
# https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/animefull-final-pruned.safetensors 的文件下载到本地后名称为 animefull-final-pruned.safetensors
# 并且 https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/Illustrious-XL-v0.1.safetensors 所指的文件将被重命名为 Illustrious.safetensors

SD_MODEL = [
    # Stable Diffusion 模型
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/v1-5-pruned-emaonly.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/animefull-final-pruned.safetensors", 1],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/Counterfeit-V3.0_fp16.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/cetusMix_Whalefall2.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/cuteyukimixAdorable_neochapter3.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/ekmix-pastel-fp16-no-ema.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/ex2K_sse2.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/kohakuV5_rev2.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/meinamix_meinaV11.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/oukaStar_10.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/pastelMixStylizedAnime_pastelMixPrunedFP16.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/rabbit_v6.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/sweetSugarSyndrome_rev15.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/AnythingV5Ink_ink.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/bartstyledbBlueArchiveArtStyleFineTunedModel_v10.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/meinapastel_v6Pastel.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/qteamixQ_omegaFp16.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sd_1.5/tmndMix_tmndMixSPRAINBOW.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/sd_xl_base_1.0_0.9vae.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/animagine-xl-3.0.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/AnythingXL_xl.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/abyssorangeXLElse_v10.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/animaPencilXL_v200.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/animagine-xl-3.1.safetensors", 1],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/heartOfAppleXL_v20.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/baxlBartstylexlBlueArchiveFlatCelluloid_xlv1.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/kohaku-xl-delta-rev1.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/kohakuXLEpsilon_rev1.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/kohaku-xl-epsilon-rev3.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/kohaku-xl-zeta.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/nekorayxl_v06W3.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/CounterfeitXL-V1.0.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/ponyDiffusionV6XL_v6StartWithThisOne.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/Illustrious-XL-v0.1.safetensors", 1],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_earlyAccessVersion.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_epsilonPred05Version.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_epsilonPred075.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_epsilonPred077.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_epsilonPred10Version.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_epsilonPred11Version.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPredTestVersion.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred05Version.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred06Version.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred065SVersion.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred075SVersion.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred09RVersion.safetensors", 0],
    ["https://huggingface.co/licyk/sd-model/resolve/main/sdxl_1.0/noobaiXLNAIXL_vPred10Version.safetensors", 0],

    # VAE 模型
    ["https://huggingface.co/licyk/sd-vae/resolve/main/sd_1.5/vae-ft-ema-560000-ema-pruned.safetensors", 0],
    ["https://huggingface.co/licyk/sd-vae/resolve/main/sd_1.5/vae-ft-mse-840000-ema-pruned.safetensors", 1],
    ["https://huggingface.co/licyk/sd-vae/resolve/main/sdxl_1.0/sdxl_fp16_fix_vae.safetensors", 1],
]

##############################################################################
echo("参数设置完成")

自定义模型上传

训练脚本提供的模型可能不适合自己的训练要求，此时可以上传自己所需的模型。比如我需要上传ill-xl.safetensors这个模型，下面提供了 3 种方式进行模型上传。

1. 使用 Kaggle Input 上传模型

在右侧的 Kaggle Input（Kaggle 导入工具）支持上传自己的模型到 Kaggle 中，在 Notebook（笔记本）-> Input（导入）-> Upload（上传）-> New Model（新建模型），在模型上传界面选择要上传的模型，此时将弹出模型信息设置界面。MODEL NAME（模型名称）填写模型的名称，这将决定模型所在的文件夹名称，这里我设置成ill-xl-01，FRAMEWORK（框架）选择 Other，LICENSE（许可证）选择 Unknown，如果还有其他需要上传的模型，可以在下方继续选择模型，配置完成后点击 Create（创建）上传模型。

根据刚刚设置的 MODEL NAME（模型名称），上传的ill-xl.safetensors模型将会在{INPUT_DATASET_PATH}/ill-xl-01/ill-xl.safetensors，即/kaggle/dataset/ill-xl-01/ill-xl.safetensors。

2. 使用模型下载链接上传模型

除了可以使用 Kaggle Input（Kaggle 导入工具）上传模型，还可以将模型上传到模型托管平台，获取模型下载链接后使用下载链接将模型下载到 Kaggle 中。

刚刚在 ModelScope 上创建了一个模型仓库，并将ill-xl.safetensors上传到该仓库中。

右键下载按钮后获取到下载链接，比如https://modelscope.cn/models/licyks/sd_training_model/resolve/master/ill-xl.safetensors。

得到模型下载链接后，可以通过sd_scripts.get_model()函数将模型下载到 Kaggle 中。在安装单元中有注释说明了该函数的用法，根据注释的说明进行修改。

1
2
3
4
5
sd_scripts.get_model(
    url="https://modelscope.cn/models/licyks/sd_training_model/resolve/master/ill-xl.safetensors",
    path=SD_MODEL_PATH,
    filename="ill-xl.safetensors"
)

该模型下载到{SD_MODEL_PATH}/ill-xl.safetensors，即/kaggle/sd-models/ill-xl.safetensors。

3. 使用 HuggingFace 上传模型

如果将文件保存到 HuggingFace，比如将ill-xl.safetensors上传到刚刚在 HuggingFace 上创建的模型仓库。

在 HuggingFace 上可以获取文件的下载链接，使用上面的方法将模型下载到 Kaggle 中，也可以使用sd_scripts.dataset.get_single_file_from_hf()函数下载到 kaggle 中。在安装单元中有注释说明了该函数的用法，根据注释的说明进行修改。

1
2
3
4
5
6
sd_scripts.dataset.get_single_file_from_hf(
    repo_id="licyk/sd_training_model",
    repo_type="model",
    filename="ill-xl.safetensors",
    local_dir=SD_MODEL_PATH,
)

如果刚刚的模型仓库为私有仓库，则需要 HuggingFace Token 进行访问，此时需要添加token参数传入 HuggingFace Token。

1
2
3
4
5
6
7
sd_scripts.dataset.get_single_file_from_hf(
    repo_id="licyk/sd_training_model",
    repo_type="model",
    filename="ill-xl.safetensors",
    local_dir=SD_MODEL_PATH,
    token=HF_TOKEN,
)

模型将会下载到{SD_MODEL_PATH}/ill-xl.safetensors，即/kaggle/sd-models/ill-xl.safetensors。

4. 使用 ModelScope 上传模型

如果将文件保存到 ModelScope，比如将ill-xl.safetensors上传到刚刚在 ModelScope 上创建的模型仓库，可以使用sd_scripts.dataset.get_single_file_from_ms()函数进行下载。

1
2
3
4
5
6
7
sd_scripts.dataset.get_single_file_from_ms(
    repo_id="licyk/sd_training_model",
    repo_type="model",
    filename="ill-xl.safetensors",
    local_dir=SD_MODEL_PATH,
    token=MS_TOKEN,
)

sd_scripts.dataset.get_single_file_from_ms()函数的使用方法和sd_scripts.dataset.get_single_file_from_hf()函数基本一致，可参考使用 HuggingFace 上传模型中的说明进行使用。

训练集上传

有了训练所需的模型之后，还需要上传训练集作为训练素材，下面提供 3 种方式上传训练集。

1. 使用 Kaggle Input 上传训练集

在右侧的 Kaggle Input（Kaggle 导入工具）支持上传自己的训练集到 Kaggle 中，在 Notebook（笔记本）-> Input（导入）-> Upload（上传）-> New Dataset（新建数据集），在训练集上传界面选择自己的训练集文件夹，比如前面创建的character_aaaki文件夹，在 DATASET TITLE（数据集名称）填写训练集的名字，这里我填的是ch-aaaki，再点击 Create（创建）上传训练集。

如果为了加快上传速度，可以将训练集文件夹压缩成 ZIP 文件再上传。

根据刚刚设置的 DATASET TITLE（数据集名称），训练集将上传到{INPUT_DATASET_PATH}/ch-aaaki/character_aaaki，即/kaggle/dataset/ch-aaaki/character_aaaki。

2. 使用训练集下载链接上传训练集

除了可以使用 Kaggle Input（Kaggle 导入工具）上传训练集，还可以将训练集进行压缩，上传训练集压缩包到模型托管平台，获取训练集下载链接后使用下载链接将训练集下载到 Kaggle 中。

将训练集使用 ZIP / 7Z / TAR 格式进行压缩后，利用之前在 ModelScope 上创建的仓库上传训练集压缩包。

右键下载按钮后获取到下载链接，比如https://modelscope.cn/models/licyks/sd_training_model/resolve/master/character_aaaki.zip。

得到模型下载链接后，可以通过sd_scripts.dataset.get_dataset()函数将模型下载到 Kaggle 中。在安装单元中有注释说明了该函数的用法，根据注释的说明进行修改。

1
2
3
4
5
sd_scripts.dataset.get_dataset(
    dataset_path=INPUT_DATASET_PATH,
    url="https://modelscope.cn/models/licyks/sd_training_model/resolve/master/character_aaaki.zip",
    name="character_aaaki.zip",
)

该训练集将会下载并解压到{INPUT_DATASET_PATH}中，即/kaggle/dataset，解压出来的文件夹名称为character_aaaki（和压缩character_aaaki这个文件夹时处理方式有关），则该训练集的完整路径为/kaggle/dataset/character_aaaki。

3. 使用 HuggingFace 上传训练集

如果将训练集保存到 HuggingFace，比如在 HuggingFace 上创建一个训练集仓库，将character_aaaki这个文件夹上传到刚创建的训练集仓库。

再使用sd_scripts.dataset.get_dataset_from_hf()函数将训练集下载到 Kaggle 中。在安装单元中有注释说明了该函数的用法，根据注释的说明进行修改。

1
2
3
4
5
6
sd_scripts.dataset.get_dataset_from_hf(
    local_path=INPUT_DATASET_PATH,
    repo_id="licyk/sd_training_dataset",
    repo_type="dataset",
    folder="character_aaaki",
)

如果刚刚的训练集仓库为私有仓库，则需要 HuggingFace Token 进行访问，此时需要添加hf_token参数传入 HuggingFace Token。

1
2
3
4
5
6
7
sd_scripts.dataset.get_dataset_from_hf(
    local_path=INPUT_DATASET_PATH,
    repo_id="licyk/sd_training_dataset",
    repo_type="dataset",
    folder="character_aaaki",
    hf_token=HF_TOKEN,
)

训练集将会下载并解压到{INPUT_DATASET_PATH}中，即/kaggle/dataset，文件夹名称为character_aaaki（下载训练集的时候会保持和在 HuggingFace 中一样的目录结构），则该训练集的完整路径为/kaggle/dataset/character_aaaki。

小技巧

前面的 character_aaaki 训练集上传到 HuggingFace 上时结构如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
HuggingFace_Repo (licyk/sd_training_dataset)
├── character_aaaki
│   ├── 1_aaaki
│   │   ├── 1.png
│   │   ├── 1.txt
│   │   ├── 3.png
│   │   └── 3.txt
│   └── 2_aaaki
│       ├── 4.png
│       └── 4.txt
├── character_robin
│   └── 1_xxx
│       ├── 11.png
│       └── 11.txt
└── style_pvc
    └── 5_aaa
        ├── test.png
        └── test.txt

可能有时候不想为训练集中每个子训练集设置不同的重复次数，又不想上传的时候再多套一层文件夹，就把训练集结构调整成了下面的（我自己经常这样做）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
HuggingFace_Repo (licyk/sd_training_dataset)
├── character_aaaki
│   ├── 1.png
│   ├── 1.txt
│   ├── 3.png
│   ├── 3.txt
│   ├── 4.png
│   └── 4.txt
├── character_robin
│   └── 1_xxx
│       ├── 11.png
│       └── 11.txt
└── style_pvc
    └── 5_aaa
        ├── test.png
        └── test.txt

此时这个状态的训练集是缺少子训练集和重复次数的，如果直接使用sd_scripts.dataset.get_dataset_from_hf()去下载训练集并用于训练将会导致报错。不过没关系，可以自己再编写一个函数对sd_scripts.dataset.get_dataset_from_hf()函数再次封装，自动加上子训练集并设置重复次数。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def make_dataset(
    local_path: Union[str, Path],
    repo_id: str,
    repo_type: str,
    repeat: int,
    folder: str,
    hf_token: Optional[str] = None
) -> None:
    import os
    import shutil

    origin_dataset_path = os.path.join(local_path, folder)
    tmp_dataset_path = os.path.join(local_path, f"{repeat}_{folder}")
    new_dataset_path = os.path.join(origin_dataset_path, f"{repeat}_{folder}")
    sd_scripts.dataset.get_dataset_from_hf(
        local_path=local_path,
        repo_id=repo_id,
        repo_type=repo_type,
        folder=folder,
        hf_token=hf_token
    )
    if os.path.exists(origin_dataset_path):
        echo(f"设置 {folder} 训练集的重复次数为 {repeat}")
        shutil.move(origin_dataset_path, tmp_dataset_path)
        shutil.move(tmp_dataset_path, new_dataset_path)
    else:
        echo(f"从 {repo_id} 下载 {folder} 失败")

编写好后，可以去调用这个函数了。

1
2
3
4
5
6
7
8
make_dataset(
    local_path=INPUT_DATASET_PATH,
    repo_id="licyk/sd_training_dataset",
    repo_type="dataset",
    repeat=3,
    folder="character_aaaki",
    hf_token=HF_TOKEN,
)

该函数将会把character_aaaki训练集下载到{INPUT_DATASET_PATH}中，即/kaggle/dataset，文件夹名称为character_aaaki，并且character_aaaki文件夹内继续创建了一个子文件夹作为子训练集，根据repeat=3将子训练集的重复次数设置为 3。

4. 使用 ModelScope 上传训练集

如果将训练集保存到 HuggingFace，比如在 HuggingFace 上创建一个训练集仓库，将character_aaaki这个文件夹上传到刚创建的训练集仓库。

再使用sd_scripts.dataset.get_dataset_from_ms()函数将训练集下载到 Kaggle 中。在安装单元中有注释说明了该函数的用法，根据注释的说明进行修改。

1
2
3
4
5
6
7
sd_scripts.dataset.get_dataset_from_ms(
    local_path=INPUT_DATASET_PATH,
    repo_id="licyk/sd_training_dataset",
    repo_type="dataset",
    folder="character_aaaki",
    ms_token=MS_TOKEN,
)

sd_scripts.dataset.get_dataset_from_ms()函数的用法和sd_scripts.dataset.get_dataset_from_hf()函数基本一致，可参考使用 HuggingFace 上传训练集中的说明进行使用。

编写训练参数

有了模型和训练集，此时就可以编写模型训练参数进行模型训练了，在模型训练单元中编写训练训练命令。

因为篇幅问题，这里就不涉及大量的训练参数说明，直接使用已有训练参数模板，在已有的训练参数上进行修改。

下面是我比较常用的训练参数，可以自行在这些模板中寻找。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# 使用 lokr 算法训练 XL 画风 LoRA, 使用多卡进行训练
# 该参数也可以用于人物 LoRA 训练
# 
# 在训练多画风 LoRA 或者人物 LoRA 时, 通常会打上触发词
# 当使用了 --network_train_unet_only 后, Text Encoder 虽然不会训练, 但并不影响将触发词训练进 LoRA 模型中
# 并且不训练 Text Encoder 避免 Text Encoder 被炼烂(Text Encoder 比较容易被炼烂)
# 
# 学习率调度器从 cosine_with_restarts 换成 constant_with_warmup, 此时学习率靠优化器(Lion8bit)进行调度
# 拟合速度会更快
# constant_with_warmup 用在大规模的训练上比较好, 但用在小规模训练也有不错的效果
# 如果训练集的图比较少, 重复的图较多, 重复次数较高, 可能容易造成过拟合
# 
# 在 --network_args 设置了 preset, 可以调整训练网络的大小
# 该值默认为 full, 如果使用 attn-mlp 可以得到更小的 LoRA, 但对于难学的概念使用 full 效果会更好
# 
# 可用的预设可阅读文档: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/docs/Preset.md
# 该预设也可以自行编写并指定, 编写例子可查看: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/example_configs/preset_configs/example.toml
# 
# 使用 --optimizer_args 设置 weight_decay 和 betas, 更高的 weight_decay 可以降低拟合程度, 减少过拟合
# 如果拟合程度不够高, 可以提高 --max_train_epochs 的值, 或者适当降低 weight_decay 的值, 可自行测试
# 较小的训练集适合使用较小的值, 如 0.05, 较大的训练集适合用 0.1
# 大概 34 Epoch 会有比较好的效果吧, 不过不好说, 看训练集
# 自己测的时候大概在 26~40 Epoch 之间会出现好结果, 测试了很多炉基本都在这个区间里, 但也不排除意外情况 (训练参数这东西好麻烦啊, 苦い)
# 
# 测试的时候发现 --debiased_estimation_loss 对于训练效果的有些改善
# 这里有个对比: https://licyk.netlify.app/2025/02/10/debiased_estimation_loss_in_stable_diffusion_model_training
# 启用后能提高拟合速度和颜色表现吧, 画风的学习能学得更好
# debiased estimation loss 有个相关的论文可以看看: https://arxiv.org/abs/2310.08442
# 
# !python -m accelerate.commands.launch \
#     --num_cpu_threads_per_process=1 \
#     --multi_gpu \
#     --num_processes=2 \
#     "{SD_SCRIPTS_PATH}/sdxl_train_network.py" \
#     --pretrained_model_name_or_path="{SD_MODEL_PATH}/Illustrious-XL-v0.1.safetensors" \
#     --vae="{SD_MODEL_PATH}/sdxl_fp16_fix_vae.safetensors" \
#     --train_data_dir="{INPUT_DATASET_PATH}/Nachoneko" \
#     --output_name="Nachoneko_2" \
#     --output_dir="{OUTPUT_PATH}/Nachoneko" \
#     --log_tracker_name="lora-Nachoneko" \
#     --prior_loss_weight=1 \
#     --resolution="1024,1024" \
#     --enable_bucket \
#     --min_bucket_reso=256 \
#     --max_bucket_reso=4096 \
#     --bucket_reso_steps=64 \
#     --save_model_as="safetensors" \
#     --save_precision="fp16" \
#     --save_every_n_epochs=2 \
#     --max_train_epochs=40 \
#     --train_batch_size=6 \
#     --gradient_checkpointing \
#     --network_train_unet_only \
#     --learning_rate=0.0001 \
#     --unet_lr=0.0001 \
#     --text_encoder_lr=0.00001 \
#     --lr_scheduler="constant_with_warmup" \
#     --lr_warmup_steps=100 \
#     --optimizer_type="Lion8bit" \
#     --network_module="lycoris.kohya" \
#     --network_dim=100000 \
#     --network_alpha=100000 \
#     --network_args \
#         conv_dim=100000 \
#         conv_alpha=100000 \
#         algo=lokr \
#         dropout=0 \
#         factor=8 \
#         train_norm=True \
#         preset="full" \
#     --optimizer_args \
#         weight_decay=0.05 \
#         betas="0.9,0.95" \
#     --log_with="{LOG_MODULE}" \
#     --logging_dir="{OUTPUT_PATH}/logs" \
#     --caption_extension=".txt" \
#     --shuffle_caption \
#     --keep_tokens=0 \
#     --max_token_length=225 \
#     --seed=1337 \
#     --mixed_precision="fp16" \
#     --xformers \
#     --cache_latents \
#     --cache_latents_to_disk \
#     --persistent_data_loader_workers \
#     --debiased_estimation_loss \
#     --full_fp16

在该训练命令中，前面使用了#进行注释，此时需要将这些注释取消掉使其能够被执行，使用鼠标选中这些命令。

选择后按下Ctrl + /快捷键取消注释，此时训练命令前面的#被清除掉，如果将训练代码加上注释，选择代码后再按下Ctrl + /快捷键即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# 使用 lokr 算法训练 XL 画风 LoRA, 使用多卡进行训练
# 该参数也可以用于人物 LoRA 训练
# 
# 在训练多画风 LoRA 或者人物 LoRA 时, 通常会打上触发词
# 当使用了 --network_train_unet_only 后, Text Encoder 虽然不会训练, 但并不影响将触发词训练进 LoRA 模型中
# 并且不训练 Text Encoder 避免 Text Encoder 被炼烂(Text Encoder 比较容易被炼烂)
# 
# 学习率调度器从 cosine_with_restarts 换成 constant_with_warmup, 此时学习率靠优化器(Lion8bit)进行调度
# 拟合速度会更快
# constant_with_warmup 用在大规模的训练上比较好, 但用在小规模训练也有不错的效果
# 如果训练集的图比较少, 重复的图较多, 重复次数较高, 可能容易造成过拟合
# 
# 在 --network_args 设置了 preset, 可以调整训练网络的大小
# 该值默认为 full, 如果使用 attn-mlp 可以得到更小的 LoRA, 但对于难学的概念使用 full 效果会更好
# 
# 可用的预设可阅读文档: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/docs/Preset.md
# 该预设也可以自行编写并指定, 编写例子可查看: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/example_configs/preset_configs/example.toml
# 
# 使用 --optimizer_args 设置 weight_decay 和 betas, 更高的 weight_decay 可以降低拟合程度, 减少过拟合
# 如果拟合程度不够高, 可以提高 --max_train_epochs 的值, 或者适当降低 weight_decay 的值, 可自行测试
# 较小的训练集适合使用较小的值, 如 0.05, 较大的训练集适合用 0.1
# 大概 34 Epoch 会有比较好的效果吧, 不过不好说, 看训练集
# 自己测的时候大概在 26~40 Epoch 之间会出现好结果, 测试了很多炉基本都在这个区间里, 但也不排除意外情况 (训练参数这东西好麻烦啊, 苦い)
# 
# 测试的时候发现 --debiased_estimation_loss 对于训练效果的有些改善
# 这里有个对比: https://licyk.netlify.app/2025/02/10/debiased_estimation_loss_in_stable_diffusion_model_training
# 启用后能提高拟合速度和颜色表现吧, 画风的学习能学得更好
# debiased estimation loss 有个相关的论文可以看看: https://arxiv.org/abs/2310.08442
# 
!python -m accelerate.commands.launch \
    --num_cpu_threads_per_process=1 \
    --multi_gpu \
    --num_processes=2 \
    "{SD_SCRIPTS_PATH}/sdxl_train_network.py" \
    --pretrained_model_name_or_path="{SD_MODEL_PATH}/Illustrious-XL-v0.1.safetensors" \
    --vae="{SD_MODEL_PATH}/sdxl_fp16_fix_vae.safetensors" \
    --train_data_dir="{INPUT_DATASET_PATH}/Nachoneko" \
    --output_name="Nachoneko_2" \
    --output_dir="{OUTPUT_PATH}/Nachoneko" \
    --log_tracker_name="lora-Nachoneko" \
    --prior_loss_weight=1 \
    --resolution="1024,1024" \
    --enable_bucket \
    --min_bucket_reso=256 \
    --max_bucket_reso=4096 \
    --bucket_reso_steps=64 \
    --save_model_as="safetensors" \
    --save_precision="fp16" \
    --save_every_n_epochs=2 \
    --max_train_epochs=40 \
    --train_batch_size=6 \
    --gradient_checkpointing \
    --network_train_unet_only \
    --learning_rate=0.0001 \
    --unet_lr=0.0001 \
    --text_encoder_lr=0.00001 \
    --lr_scheduler="constant_with_warmup" \
    --lr_warmup_steps=100 \
    --optimizer_type="Lion8bit" \
    --network_module="lycoris.kohya" \
    --network_dim=100000 \
    --network_alpha=100000 \
    --network_args \
        conv_dim=100000 \
        conv_alpha=100000 \
        algo=lokr \
        dropout=0 \
        factor=8 \
        train_norm=True \
        preset="full" \
    --optimizer_args \
        weight_decay=0.05 \
        betas="0.9,0.95" \
    --log_with="{LOG_MODULE}" \
    --logging_dir="{OUTPUT_PATH}/logs" \
    --caption_extension=".txt" \
    --shuffle_caption \
    --keep_tokens=0 \
    --max_token_length=225 \
    --seed=1337 \
    --mixed_precision="fp16" \
    --xformers \
    --cache_latents \
    --cache_latents_to_disk \
    --persistent_data_loader_workers \
    --debiased_estimation_loss \
    --full_fp16

现在修改一下大模型路径和训练集路径，即--pretrained_model_name_or_path和--train_data_dir的值，路径根据前面选择的方法得到的路径来选择。比如大模型路径为SD_MODEL_PATH/ill-xl.safetensors，训练集路径为{INPUT_DATASET_PATH}/character_aaaki，则修改后对应的参数为--pretrained_model_name_or_path="{SD_MODEL_PATH}/ill-xl.safetensors"和--train_data_dir="{INPUT_DATASET_PATH}/character_aaaki"。注意这里的{SD_MODEL_PATH}和{INPUT_DATASET_PATH}为变量，在 Jupyter Notebook 的 Shell 调用方法中需要加上{}符号将变量中的值解析为对应的内容。

这里再修改一下模型保存路径和模型的保存的名称，需要修改--output_dir和--output_name的值。比如我想让训练出来的模型保存在lora-character-aaaki文件夹，模型保存的名称为ill-xl-character-aaaki，则修改后对应的参数为--output_dir="{OUTPUT_PATH}/lora-character-aaaki"和--output_name="ill-xl-character-aaaki"。

其他参数保持默认即可，如果了解这些训练参数中的作用，也可以自行修改。修改后的训练命令如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
# 使用 lokr 算法训练 XL 画风 LoRA, 使用多卡进行训练
# 该参数也可以用于人物 LoRA 训练
# 
# 在训练多画风 LoRA 或者人物 LoRA 时, 通常会打上触发词
# 当使用了 --network_train_unet_only 后, Text Encoder 虽然不会训练, 但并不影响将触发词训练进 LoRA 模型中
# 并且不训练 Text Encoder 避免 Text Encoder 被炼烂(Text Encoder 比较容易被炼烂)
# 
# 学习率调度器从 cosine_with_restarts 换成 constant_with_warmup, 此时学习率靠优化器(Lion8bit)进行调度
# 拟合速度会更快
# constant_with_warmup 用在大规模的训练上比较好, 但用在小规模训练也有不错的效果
# 如果训练集的图比较少, 重复的图较多, 重复次数较高, 可能容易造成过拟合
# 
# 在 --network_args 设置了 preset, 可以调整训练网络的大小
# 该值默认为 full, 如果使用 attn-mlp 可以得到更小的 LoRA, 但对于难学的概念使用 full 效果会更好
# 
# 可用的预设可阅读文档: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/docs/Preset.md
# 该预设也可以自行编写并指定, 编写例子可查看: https://github.com/KohakuBlueleaf/LyCORIS/blob/main/example_configs/preset_configs/example.toml
# 
# 使用 --optimizer_args 设置 weight_decay 和 betas, 更高的 weight_decay 可以降低拟合程度, 减少过拟合
# 如果拟合程度不够高, 可以提高 --max_train_epochs 的值, 或者适当降低 weight_decay 的值, 可自行测试
# 较小的训练集适合使用较小的值, 如 0.05, 较大的训练集适合用 0.1
# 大概 34 Epoch 会有比较好的效果吧, 不过不好说, 看训练集
# 自己测的时候大概在 26~40 Epoch 之间会出现好结果, 测试了很多炉基本都在这个区间里, 但也不排除意外情况 (训练参数这东西好麻烦啊, 苦い)
# 
# 测试的时候发现 --debiased_estimation_loss 对于训练效果的有些改善
# 这里有个对比: https://licyk.netlify.app/2025/02/10/debiased_estimation_loss_in_stable_diffusion_model_training
# 启用后能提高拟合速度和颜色表现吧, 画风的学习能学得更好
# debiased estimation loss 有个相关的论文可以看看: https://arxiv.org/abs/2310.08442
# 
!python -m accelerate.commands.launch \
    --num_cpu_threads_per_process=1 \
    --multi_gpu \
    --num_processes=2 \
    "{SD_SCRIPTS_PATH}/sdxl_train_network.py" \
    --pretrained_model_name_or_path="{SD_MODEL_PATH}/ill-xl.safetensors" \
    --vae="{SD_MODEL_PATH}/sdxl_fp16_fix_vae.safetensors" \
    --train_data_dir="{INPUT_DATASET_PATH}/character_aaaki" \
    --output_name="ill-xl-character-aaaki" \
    --output_dir="{OUTPUT_PATH}/lora-character-aaaki" \
    --log_tracker_name="ill-xl-character-aaaki" \
    --prior_loss_weight=1 \
    --resolution="1024,1024" \
    --enable_bucket \
    --min_bucket_reso=256 \
    --max_bucket_reso=4096 \
    --bucket_reso_steps=64 \
    --save_model_as="safetensors" \
    --save_precision="fp16" \
    --save_every_n_epochs=2 \
    --max_train_epochs=40 \
    --train_batch_size=6 \
    --gradient_checkpointing \
    --network_train_unet_only \
    --learning_rate=0.0001 \
    --unet_lr=0.0001 \
    --text_encoder_lr=0.00001 \
    --lr_scheduler="constant_with_warmup" \
    --lr_warmup_steps=100 \
    --optimizer_type="Lion8bit" \
    --network_module="lycoris.kohya" \
    --network_dim=100000 \
    --network_alpha=100000 \
    --network_args \
        conv_dim=100000 \
        conv_alpha=100000 \
        algo=lokr \
        dropout=0 \
        factor=8 \
        train_norm=True \
        preset="full" \
    --optimizer_args \
        weight_decay=0.05 \
        betas="0.9,0.95" \
    --log_with="{LOG_MODULE}" \
    --logging_dir="{OUTPUT_PATH}/logs" \
    --caption_extension=".txt" \
    --shuffle_caption \
    --keep_tokens=0 \
    --max_token_length=225 \
    --seed=1337 \
    --mixed_precision="fp16" \
    --xformers \
    --cache_latents \
    --cache_latents_to_disk \
    --persistent_data_loader_workers \
    --debiased_estimation_loss \
    --full_fp16

现在模型的训练参数就配置完成了。

启动训练脚本

点击 Kaggle 右上角的 Save Version（保存版本），在 VERSION TYPE（版本种类）选项中选择Save & Run All (Commit)（保存并运行所有单元 (提交记录)），再点击右下角的 Save（保存），此时将依次运行训练脚本中的单元。

运行后点击 Kaggle 左下角的按钮可以打开 Active Event（运行中的实例），可以看到刚刚启动的训练脚本。

点击后可以在 Logs（日志）查看实时的训练日志。

下载训练好的模型

如果训练成功后，可以在 Kaggle Output（Kaggle 输出）中查看训练好的模型，选择其中一个模型后可以下载该模型。

如果在模型上传设置启用了 HuggingFace 和 ModelScope，在 HuggingFace 和 ModelScope 上的仓库中也可以下载模型。

将下载下来的模型导入 Stable Diffusion WebUI，ComfyUI 等软件中即可使用。

教程
#linux #stable diffusion
使用 Kaggle 进行模型训练
http://licyk.github.io/2025/01/16/use-kaggle-to-training-sd-model/
作者
licyk
发布于
2025年1月16日
许可协议