# Modified from: # fast-DiT: https://github.com/chuanyangjin/fast-DiT # nanoGPT: https://github.com/karpathy/nanoGPT from PIL import PngImagePlugin MaximumDecompressedSize = 1024 MegaByte = 2**20 PngImagePlugin.MAX_TEXT_CHUNK = MaximumDecompressedSize * MegaByte import torch torch.backends.cuda.matmul.allow_tf32 = True torch.backends.cudnn.allow_tf32 = True import torch.distributed as dist from torch.nn.parallel import DistributedDataParallel as DDP from torch.utils.data import DataLoader from torch.utils.data.distributed import DistributedSampler from torchvision import transforms from glob import glob import time import argparse import os import sys current_directory = os.getcwd() sys.path.append(current_directory) from utils.distributed import init_distributed_mode from utils.logger import create_logger from dataset.build import build_dataset from dataset.augmentation import center_crop_arr from autoregressive.train.train_c2i import creat_optimizer from torch.optim.lr_scheduler import StepLR from autoregressive.models.gpt_t2i import GPT_models from tokenizer.tokenizer_image.vq_model import VQ_models from accelerate.utils import ProjectConfiguration, set_seed from pathlib import Path from accelerate import Accelerator from language.t5 import T5Embedder from dataset.t2i_control import build_t2i_control_code import torch._dynamo torch._dynamo.config.suppress_errors = True def main(args): assert torch.cuda.is_available(), "Training currently requires at least one GPU." # Setup DDP: init_distributed_mode(args) assert args.global_batch_size % dist.get_world_size() == 0, f"Batch size must be divisible by world size." rank = dist.get_rank() device = rank % torch.cuda.device_count() seed = args.global_seed * dist.get_world_size() + rank torch.manual_seed(seed) torch.cuda.set_device(device) # Setup an experiment folder: if rank == 0: os.makedirs(args.results_dir, exist_ok=True) # Make results folder (holds all experiment subfolders) experiment_index = len(glob(f"{args.results_dir}/*")) model_string_name = args.gpt_model.replace("/", "-") experiment_dir = f"{args.results_dir}/{experiment_index:03d}-{model_string_name}" checkpoint_dir = f"{experiment_dir}/checkpoints" os.makedirs(checkpoint_dir, exist_ok=True) logger = create_logger(experiment_dir) logger.info(f"Experiment directory created at {experiment_dir}") time_record = time.strftime("%Y-%m-%d-%H-%M-%S", time.localtime()) cloud_results_dir = f"{args.cloud_save_path}/{time_record}" cloud_checkpoint_dir = f"{cloud_results_dir}/{experiment_index:03d}-{model_string_name}/checkpoints" os.makedirs(cloud_checkpoint_dir, exist_ok=True) logger.info(f"Experiment directory created in cloud at {cloud_checkpoint_dir}") else: logger = create_logger(None) # training args logger.info(f"{args}") # training env logger.info(f"Starting rank={rank}, seed={seed}, world_size={dist.get_world_size()}.") # Setup model latent_size = args.image_size // args.downsample_size model = GPT_models[args.gpt_model]( vocab_size=args.vocab_size, block_size=latent_size ** 2, num_classes=args.num_classes, cls_token_num=args.cls_token_num, model_type=args.gpt_type, resid_dropout_p=args.dropout_p, ffn_dropout_p=args.dropout_p, token_dropout_p=args.token_dropout_p, adapter_size=args.adapter_size, condition_type=args.condition_type, ).to(device) logger.info(f"GPT Parameters: {sum(p.numel() for p in model.parameters()):,}") # Setup optimizer optimizer = creat_optimizer(model, args.weight_decay, args.lr, (args.beta1, args.beta2), logger) lr_scheduler = StepLR(optimizer, step_size=1, gamma=0.9) # 每10个epoch后，学习率乘以0.1 # 加载数据集 train_dataset = build_t2i_control_code(args) sampler = DistributedSampler( train_dataset, num_replicas=dist.get_world_size(), rank=rank, shuffle=True, seed=args.global_seed ) loader = torch.utils.data.DataLoader( train_dataset, shuffle=False, collate_fn=train_dataset.collate_fn, batch_size=int(args.global_batch_size // dist.get_world_size()), num_workers=args.num_workers, pin_memory=True, sampler=sampler, drop_last=True ) logger.info(f"Dataset contains {len(train_dataset):,} images") # Prepare models for training: if args.gpt_ckpt: checkpoint = torch.load(args.gpt_ckpt, map_location="cpu") model.load_state_dict(checkpoint["model"], strict=False) # optimizer.load_state_dict(checkpoint["optimizer"]) train_steps = 0#checkpoint["steps"] if "steps" in checkpoint else int(args.gpt_ckpt.split('/')[-1].split('.')[0]) start_epoch = 0#int(train_steps / int(len(dataset) / args.global_batch_size)) train_steps = 0#int(start_epoch * int(len(dataset) / args.global_batch_size)) del checkpoint logger.info(f"Resume training from checkpoint: {args.gpt_ckpt}") logger.info(f"Initial state: steps={train_steps}, epochs={start_epoch}") else: train_steps = 0 start_epoch = 0 if not args.no_compile: logger.info("compiling the model... (may take several minutes)") model = torch.compile(model) # requires PyTorch 2.0 model = DDP(model.to(device), device_ids=[args.gpu], find_unused_parameters=True) model.train() # important! This enables embedding dropout for classifier-free guidance ptdtype = {'none': torch.float32, 'bf16': torch.bfloat16, 'fp16': torch.float16}[args.mixed_precision] # initialize a GradScaler. If enabled=False scaler is a no-op scaler = torch.cuda.amp.GradScaler(enabled=(args.mixed_precision =='fp16')) # Variables for monitoring/logging purposes: log_steps = 0 running_loss = 0 start_time = time.time() logger.info(f"Training for {args.epochs} epochs...") for epoch in range(start_epoch, args.epochs): sampler.set_epoch(epoch)# 设定采样器的 epoch logger.info(f"Beginning epoch {epoch}...") # 载入数据 for batch in loader: x = batch['code']# 生成的图像的 VQ 代码 caption_emb = batch['caption_emb']# 文本 T5 Embedding condition_img = batch['control'] # 条件图像（如 Canny Edge） attn_mask = batch['attn_mask']# 注意力掩码 valid = batch['valid'] # 有效性标记 y = caption_emb # `y` 作为 `GPT` 的 condition #将数据移到GPU x = x.to(device, non_blocking=True) y = y.to(device, non_blocking=True) condition_img = condition_img.to(device, non_blocking=True) # 调整数据形状 展平 z_indices = x.reshape(x.shape[0], -1) c_indices = y.reshape(y.shape[0], y.shape[-2], y.shape[-1]) assert z_indices.shape[0] == c_indices.shape[0] attn_mask = attn_mask.reshape(attn_mask.shape[0], 1, attn_mask.shape[-2], attn_mask.shape[-1]) # (bs, n_head, seq_len, seq_len) # 前向传播 with torch.cuda.amp.autocast(dtype=ptdtype): _, loss = model(cond_idx=c_indices, idx=z_indices[:,:-1], targets=z_indices, mask=attn_mask[:, :, :-1,:-1], valid=valid, condition=condition_img.to(ptdtype)) # 反向传播 backward pass, with gradient scaling if training in fp16 scaler.scale(loss).backward() # 计算梯度 if args.max_grad_norm != 0.0: scaler.unscale_(optimizer) torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm) # 更新模型参数 step the optimizer and scaler if training in fp16 scaler.step(optimizer) scaler.update() # flush the gradients as soon as we can, no need for this memory anymore optimizer.zero_grad(set_to_none=True) # 记录训练损失 Log loss values: running_loss += loss.item() log_steps += 1 train_steps += 1 if train_steps % args.log_every == 0: # Measure training speed: torch.cuda.synchronize() end_time = time.time() steps_per_sec = log_steps / (end_time - start_time) # Reduce loss history over all processes: avg_loss = torch.tensor(running_loss / log_steps, device=device) dist.all_reduce(avg_loss, op=dist.ReduceOp.SUM) avg_loss = avg_loss.item() / dist.get_world_size() logger.info(f"(step={train_steps:07d}) Train Loss: {avg_loss:.4f}, Train Steps/Sec: {steps_per_sec:.2f}") # Reset monitoring variables: running_loss = 0 log_steps = 0 start_time = time.time() # Save checkpoint: if train_steps % args.ckpt_every == 0 and train_steps > 0: if rank == 0: if not args.no_compile: model_weight = model.module._orig_mod.state_dict() else: model_weight = model.module.state_dict() checkpoint = { "model": model_weight, "steps": train_steps, "args": args } if not args.no_local_save: checkpoint_path = f"{checkpoint_dir}/{train_steps:07d}.pt" torch.save(checkpoint, checkpoint_path) logger.info(f"Saved checkpoint to {checkpoint_path}") cloud_checkpoint_path = f"{cloud_checkpoint_dir}/{train_steps:07d}.pt" torch.save(checkpoint, cloud_checkpoint_path) logger.info(f"Saved checkpoint in cloud to {cloud_checkpoint_path}") dist.barrier() lr_scheduler.step() for param_group in optimizer.param_groups: print(f"Epoch {epoch + 1}, LR: {param_group['lr']}") model.eval() # important! This disables randomized embedding dropout # do any sampling/FID calculation/etc. with ema (or model) in eval mode ... logger.info("Done!") dist.destroy_process_group() if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("--data-path", type=str, required=False) parser.add_argument("--t5-feat-path", type=str, required=False) parser.add_argument("--short-t5-feat-path", type=str, default=None, help="short caption of t5_feat_path") parser.add_argument("--cloud-save-path", type=str, required=False, help='please specify a cloud disk path, if not, local path') parser.add_argument("--no-local-save", action='store_true', help='no save checkpoints to local path for limited disk volume') parser.add_argument("--vq-model", type=str, choices=list(VQ_models.keys()), default="VQ-16") parser.add_argument("--vq-ckpt", type=str, default=None, help="ckpt path for vq model") parser.add_argument("--codebook-size", type=int, default=16384, help="codebook size for vector quantization") parser.add_argument("--codebook-embed-dim", type=int, default=8, help="codebook dimension for vector quantization") parser.add_argument("--gpt-model", type=str, choices=list(GPT_models.keys()), default="GPT-XL") parser.add_argument("--gpt-ckpt", type=str, default=None, help="ckpt path for resume training") parser.add_argument("--gpt-type", type=str, choices=['c2i', 't2i'], default="t2i") parser.add_argument("--vocab-size", type=int, default=16384, help="vocabulary size of visual tokenizer") parser.add_argument("--cls-token-num", type=int, default=120, help="max token number of condition input") parser.add_argument("--dropout-p", type=float, default=0.1, help="dropout_p of resid_dropout_p and ffn_dropout_p") parser.add_argument("--token-dropout-p", type=float, default=0.1, help="dropout_p of token_dropout_p") parser.add_argument("--drop-path", type=float, default=0.0, help="drop_path_rate of attention and ffn") parser.add_argument("--no-compile", action='store_true') parser.add_argument("--results-dir", type=str, default="results") parser.add_argument("--dataset", type=str, default='t2i_control') parser.add_argument("--image-size", type=int, choices=[256, 384, 512], default=512) parser.add_argument("--downsample-size", type=int, choices=[8, 16], default=16) parser.add_argument("--num-classes", type=int, default=1000) parser.add_argument("--epochs", type=int, default=20) parser.add_argument("--lr", type=float, default=5e-5) parser.add_argument("--weight-decay", type=float, default=5e-2, help="Weight decay to use.") parser.add_argument("--beta1", type=float, default=0.9, help="The beta1 parameter for the Adam optimizer.") parser.add_argument("--beta2", type=float, default=0.95, help="The beta2 parameter for the Adam optimizer.") parser.add_argument("--max-grad-norm", default=1.0, type=float, help="Max gradient norm.") parser.add_argument("--global-batch-size", type=int, default=96) parser.add_argument("--global-seed", type=int, default=0) parser.add_argument("--num-workers", type=int, default=24) parser.add_argument("--log-every", type=int, default=100) parser.add_argument("--ckpt-every", type=int, default=1443) parser.add_argument("--gradient-accumulation-steps", type=int, default=1) parser.add_argument("--mixed-precision", type=str, default='bf16', choices=["none", "fp16", "bf16"]) parser.add_argument("--condition-type", type=str, choices=['segmentation', 'canny', 'hed', 'lineart', 'depth'], default="segmentation") parser.add_argument("--code-path", type=str, required=True) parser.add_argument("--code-path2", type=str, default=None) parser.add_argument("--adapter-size", type=str, default='small') parser.add_argument("--get-image", type=bool, default=False) parser.add_argument("--get-prompt", type=bool, default=False) parser.add_argument("--get-label", type=bool, default=False) parser.add_argument("--t5-path", type=str, default='checkpoints/t5-ckpt') parser.add_argument("--t5-model-type", type=str, default='flan-t5-xl') parser.add_argument("--t5-feature-max-len", type=int, default=120) parser.add_argument("--t5-feature-dim", type=int, default=2048) args = parser.parse_args() main(args)