blockdiffusion-api / train_oneclick.py
wkea's picture
Deploy Space
c388140 verified
Raw History Blame Contribute Delete
11.7 kB
from __future__ import annotations
"""
一键训练脚本(无命令行参数):
- 直接修改本文件顶部常量即可
- 数据目录:DATA_DIR
- 提示词来自文件名(HASH-xxx_yyy.png => "xxx yyy")
运行方式(推荐 Python 3.10):
- py -3.10 train_oneclick.py
"""
import dataclasses
import os
import torch
from torch.utils.data import DataLoader
from blockdiffusion.data.filename_captions import build_caption_items_from_filenames
from blockdiffusion.data.texture_caption_dataset import TextureCaptionDataset
from blockdiffusion.diffusion.gaussian_diffusion import GaussianDiffusion
from blockdiffusion.diffusion.schedules import get_beta_schedule
from blockdiffusion.models.text_unet16 import TextCondConfig, TextCondUNet16
from blockdiffusion.models.unet16 import UNet16Config
from blockdiffusion.text.simple_tokenizer import SimpleVocab, VocabConfig
from blockdiffusion.train.trainer import Trainer, TrainerConfig
from blockdiffusion.utils.checkpoint import load_checkpoint
from blockdiffusion.utils.seed import get_device, seed_everything
# =========================
# 可修改常量(按需改这里)
# =========================
# 数据目录(你提供的路径)
DATA_DIR = r"G:\PycharmProjects\modrinth_downloads\Training_v2"
# 纹理尺寸(本项目目标 16)
IMAGE_SIZE = 16
# 通道数:3=RGB,4=RGBA(需要保留透明就用 4)
CHANNELS = 4
# 扩散步数与调度
TIMESTEPS = 1000
BETA_SCHEDULE = "cosine" # "linear" / "cosine"
# UNet 规模(16×16 不要太深)
BASE_CHANNELS = 64
NUM_RES_BLOCKS = 2
DROPOUT = 0.0
# 文本(提示词)配置
MAX_TEXT_LEN = 32
VOCAB_MAX = 8000
COND_DROP_PROB = 0.1 # CFG 训练丢条件概率(0~1)
PRETOKENIZE = False # 大数据集建议 False:启动更快、占用更小
# 透明度提示词(可选):
# - 仅在 CHANNELS=4 且“新训练(非续训)”时建议开启
# - 作用:自动根据图片 alpha 是否含透明像素,为文本追加 "transparent"/"opaque"
# 这样模型才能学到“透明度与提示词相关”的监督信号
APPEND_ALPHA_TAG = False
ALPHA_TAG_TRANSPARENT = "transparent"
ALPHA_TAG_OPAQUE = "opaque"
# 训练配置(4070Ti 12G:RGBA 建议先从 128/256 试起)
BATCH_SIZE = 128
# 数据加载并行:Windows 若不稳定可改回 0;稳定时建议 4~8
NUM_WORKERS = 4
PREFETCH_FACTOR = 4 # NUM_WORKERS>0 时生效
PERSISTENT_WORKERS = True # NUM_WORKERS>0 时生效
LR = 2e-4
WEIGHT_DECAY = 1e-4
TOTAL_STEPS = 700_000
GRAD_CLIP = 1.0
AMP = True
EMA_DECAY = 0.9999
GRAD_ACCUM_STEPS = 1 # 不想OOM但想更大有效batch:例如设为 2/4
LR_WARMUP_STEPS = 2000
LR_MIN_RATIO = 0.1
SNR_GAMMA = 5.0 # <=0 关闭;5 通常比较稳
CHANNELS_LAST = True
LOG_EVERY = 10
SAVE_EVERY = 5000
SAMPLE_EVERY = 5000
# 输出
OUT_DIR = "outputs"
RUN_NAME = "oneclick_filename_caption"
# 断点续训:
# - 若你明确指定某个 checkpoint,就填 RESUME_PATH
# - 若 RESUME_PATH=None 且 AUTO_RESUME=True,会自动扫描 outputs/<RUN_NAME>/checkpoints 下最新 step_*.pt 继续训练
RESUME_PATH = None # 例如 r"outputs/oneclick_filename_caption/checkpoints/step_5000.pt"
AUTO_RESUME = True
# 训练中采样(可选):用这个提示词做固定可视化
SAMPLE_PROMPT = "block" # 改成你想看的关键词;不想要可设为 None
SAMPLE_CFG_SCALE = 3.0
# 随机种子
SEED = 42
DEVICE = None # 例如 "cuda:0";None 表示自动
def main() -> None:
seed_everything(SEED, deterministic=False)
device = get_device(DEVICE)
print(f"[init] device={device} channels={CHANNELS} image_size={IMAGE_SIZE}")
# RTX 40 系列性能优化(不影响数值正确性)
if hasattr(torch, "set_float32_matmul_precision"):
torch.set_float32_matmul_precision("high")
if device.type == "cuda":
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
# =====
# 续训注意:
# - 如果设置了 RESUME_PATH,为保证词表/模型结构不变,本脚本会优先从 checkpoint 读取并复用配置;
# - 新增数据会自动被扫描并参与训练;新出现的词如果不在旧词表里,会被编码为 <unk>(可继续训练,但不会学到新词语义)。
# =====
def _auto_find_latest_ckpt() -> str | None:
ckpt_dir = os.path.join(OUT_DIR, RUN_NAME, "checkpoints")
if not os.path.isdir(ckpt_dir):
return None
best_step = -1
best_path = None
for fn in os.listdir(ckpt_dir):
if not (fn.startswith("step_") and fn.endswith(".pt")):
continue
# 形如 step_5000.pt
core = fn[len("step_") : -len(".pt")]
try:
step = int(core)
except Exception:
continue
if step > best_step:
best_step = step
best_path = os.path.join(ckpt_dir, fn)
return best_path
effective_resume_path = RESUME_PATH
if (effective_resume_path is None) and AUTO_RESUME:
effective_resume_path = _auto_find_latest_ckpt()
resume_meta = None
if effective_resume_path:
print(f"[resume] 使用 checkpoint: {effective_resume_path}")
ckpt = load_checkpoint(effective_resume_path, map_location="cpu")
resume_meta = ckpt.get("meta", {}) or {}
# 从 checkpoint 复用关键配置(避免“重建词表”导致继续训练变差/不可用)
if resume_meta:
data_meta = resume_meta.get("data", {}) or {}
diff_meta = resume_meta.get("diffusion", {}) or {}
unet_cfg_dict = resume_meta.get("unet_cfg", None)
text_cfg_dict = resume_meta.get("text_cfg", None)
tok_dict = resume_meta.get("tokenizer", None)
cfg_image_size = int(data_meta.get("image_size", IMAGE_SIZE))
cfg_channels = int(data_meta.get("channels", CHANNELS))
cfg_timesteps = int(diff_meta.get("timesteps", TIMESTEPS))
cfg_beta_schedule = str(diff_meta.get("beta_schedule", BETA_SCHEDULE))
if unet_cfg_dict is None or text_cfg_dict is None or tok_dict is None:
raise ValueError("RESUME_PATH 指向的 checkpoint 缺少 tokenizer/text_cfg/unet_cfg,无法安全续训")
vocab = SimpleVocab.from_dict(tok_dict)
text_cfg = TextCondConfig(**text_cfg_dict)
unet_cfg = UNet16Config(**unet_cfg_dict)
else:
cfg_image_size = IMAGE_SIZE
cfg_channels = CHANNELS
cfg_timesteps = TIMESTEPS
cfg_beta_schedule = BETA_SCHEDULE
text_cfg = TextCondConfig(max_text_len=MAX_TEXT_LEN, emb_dim=128, dropout=0.0)
unet_cfg = UNet16Config(
in_channels=cfg_channels,
out_channels=cfg_channels,
base_channels=BASE_CHANNELS,
channel_mults=(1, 2, 2), # 16->8->4
num_res_blocks=NUM_RES_BLOCKS,
attn_resolutions=(8, 4),
dropout=DROPOUT,
time_emb_dim=256,
cond_dim=256,
)
# 非续训:词表会基于当前数据构建
vocab = None
# 扫描目录(只扫描一次):用于训练集;非续训时也用于构建词表
print("[data] 扫描图片并从文件名提取提示词...")
cap_items = build_caption_items_from_filenames(DATA_DIR, verbose=True)
if vocab is None:
# 新训练:可强制加入额外 token,避免采样时提示词变成 <unk> 而“看起来不遵从”
extra_tokens = None
append_alpha_tag = bool(APPEND_ALPHA_TAG and (cfg_channels == 4))
if append_alpha_tag:
extra_tokens = [ALPHA_TAG_TRANSPARENT, ALPHA_TAG_OPAQUE]
vocab = SimpleVocab.build(
(it.text for it in cap_items),
VocabConfig(max_vocab=VOCAB_MAX, min_freq=1),
extra_tokens=extra_tokens,
)
else:
# 续训:vocab 固定,不能改变;否则 embedding 尺寸不匹配
append_alpha_tag = False
dataset = TextureCaptionDataset(
items=cap_items,
vocab=vocab,
image_size=cfg_image_size,
channels=cfg_channels,
max_text_len=text_cfg.max_text_len,
random_flip=True,
pretokenize=PRETOKENIZE,
append_alpha_tag=append_alpha_tag,
alpha_tag_transparent=ALPHA_TAG_TRANSPARENT,
alpha_tag_opaque=ALPHA_TAG_OPAQUE,
verbose=True,
)
print(f"[data] dataset_size={len(dataset)} vocab_size={vocab.size} pretokenize={PRETOKENIZE}")
dl_kwargs = dict(
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=NUM_WORKERS,
pin_memory=(device.type == "cuda"),
drop_last=True,
)
if NUM_WORKERS > 0:
dl_kwargs["prefetch_factor"] = int(PREFETCH_FACTOR)
dl_kwargs["persistent_workers"] = bool(PERSISTENT_WORKERS)
dataloader = DataLoader(dataset, **dl_kwargs)
print(f"[data] dataloader_workers={NUM_WORKERS}")
# 2) 模型(文本条件)
model = TextCondUNet16(unet_cfg=unet_cfg, vocab=vocab, text_cfg=text_cfg)
# 3) Diffusion
betas = get_beta_schedule(cfg_beta_schedule, cfg_timesteps).to(device)
diffusion = GaussianDiffusion(betas)
# 4) 训练配置
trainer_cfg = TrainerConfig(
image_size=cfg_image_size,
channels=cfg_channels,
batch_size=BATCH_SIZE,
num_workers=NUM_WORKERS,
lr=LR,
weight_decay=WEIGHT_DECAY,
total_steps=TOTAL_STEPS,
grad_clip=GRAD_CLIP,
amp=AMP,
ema_decay=EMA_DECAY,
cond_drop_prob=COND_DROP_PROB,
grad_accum_steps=GRAD_ACCUM_STEPS,
lr_warmup_steps=LR_WARMUP_STEPS,
lr_min_ratio=LR_MIN_RATIO,
snr_gamma=SNR_GAMMA,
channels_last=CHANNELS_LAST,
log_every=LOG_EVERY,
save_every=SAVE_EVERY,
sample_every=SAMPLE_EVERY,
sample_cfg_scale=SAMPLE_CFG_SCALE,
out_dir=OUT_DIR,
run_name=RUN_NAME,
resume_path=effective_resume_path,
)
# 训练中采样 CFG(可选)
sample_model_kwargs = None
sample_uncond_model_kwargs = None
if SAMPLE_PROMPT:
tok = torch.tensor([vocab.encode(SAMPLE_PROMPT, max_len=text_cfg.max_text_len)], dtype=torch.long)
m = (tok != vocab.pad_id)
sample_model_kwargs = {"tokens": tok.to(device), "mask": m.to(device)}
un_tok = torch.full_like(tok, fill_value=vocab.pad_id)
un_m = torch.zeros_like(m)
sample_uncond_model_kwargs = {"tokens": un_tok.to(device), "mask": un_m.to(device)}
meta = {
"model_type": "text_cond",
"unet_cfg": dataclasses.asdict(unet_cfg),
"diffusion": {"timesteps": cfg_timesteps, "beta_schedule": cfg_beta_schedule},
"data": {"image_size": cfg_image_size, "channels": cfg_channels},
"tokenizer": vocab.to_dict(),
"text_cfg": dataclasses.asdict(text_cfg),
# 额外信息:方便回溯
"data_dir": os.path.abspath(DATA_DIR),
"caption_source": "filename",
}
trainer = Trainer(
model=model,
diffusion=diffusion,
dataloader=dataloader,
device=device,
cfg=trainer_cfg,
meta=meta,
sample_model_kwargs=sample_model_kwargs,
sample_uncond_model_kwargs=sample_uncond_model_kwargs,
)
print("[train] start...")
trainer.train()
if __name__ == "__main__":
main()