From 5ef5ff5aece1a29995f11943c3ca1d6fe2fabbfa Mon Sep 17 00:00:00 2001 From: Volpeon Date: Wed, 19 Oct 2022 17:45:56 +0200 Subject: Dreambooth: Added option to insert a new input token; removed Dreambooth Plus --- dreambooth_plus.py | 1023 ---------------------------------------------------- 1 file changed, 1023 deletions(-) delete mode 100644 dreambooth_plus.py (limited to 'dreambooth_plus.py') diff --git a/dreambooth_plus.py b/dreambooth_plus.py deleted file mode 100644 index 413abe3..0000000 --- a/dreambooth_plus.py +++ /dev/null @@ -1,1023 +0,0 @@ -import argparse -import itertools -import math -import os -import datetime -import logging -import json -from pathlib import Path - -import numpy as np -import torch -import torch.nn.functional as F -import torch.utils.checkpoint - -from accelerate import Accelerator -from accelerate.logging import get_logger -from accelerate.utils import LoggerType, set_seed -from diffusers import AutoencoderKL, DDPMScheduler, PNDMScheduler, UNet2DConditionModel -from diffusers.optimization import get_scheduler, get_cosine_with_hard_restarts_schedule_with_warmup -from diffusers.training_utils import EMAModel -from PIL import Image -from tqdm.auto import tqdm -from transformers import CLIPTextModel, CLIPTokenizer -from slugify import slugify - -from schedulers.scheduling_euler_a import EulerAScheduler -from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion -from data.csv import CSVDataModule -from models.clip.prompt import PromptProcessor - -logger = get_logger(__name__) - - -torch.backends.cuda.matmul.allow_tf32 = True - - -def parse_args(): - parser = argparse.ArgumentParser( - description="Simple example of a training script." - ) - parser.add_argument( - "--pretrained_model_name_or_path", - type=str, - default=None, - help="Path to pretrained model or model identifier from huggingface.co/models.", - ) - parser.add_argument( - "--tokenizer_name", - type=str, - default=None, - help="Pretrained tokenizer name or path if not the same as model_name", - ) - parser.add_argument( - "--train_data_file", - type=str, - default=None, - help="A CSV file containing the training data." - ) - parser.add_argument( - "--instance_identifier", - type=str, - default=None, - help="A token to use as a placeholder for the concept.", - ) - parser.add_argument( - "--class_identifier", - type=str, - default=None, - help="A token to use as a placeholder for the concept.", - ) - parser.add_argument( - "--placeholder_token", - type=str, - default="<*>", - help="A token to use as a placeholder for the concept.", - ) - parser.add_argument( - "--initializer_token", - type=str, - default=None, - help="A token to use as initializer word." - ) - parser.add_argument( - "--num_class_images", - type=int, - default=400, - help="How many class images to generate." - ) - parser.add_argument( - "--repeats", - type=int, - default=1, - help="How many times to repeat the training data." - ) - parser.add_argument( - "--output_dir", - type=str, - default="output/dreambooth-plus", - help="The output directory where the model predictions and checkpoints will be written.", - ) - parser.add_argument( - "--seed", - type=int, - default=None, - help="A seed for reproducible training.") - parser.add_argument( - "--resolution", - type=int, - default=512, - help=( - "The resolution for input images, all the images in the train/validation dataset will be resized to this" - " resolution" - ), - ) - parser.add_argument( - "--center_crop", - action="store_true", - help="Whether to center crop images before resizing to resolution" - ) - parser.add_argument( - "--num_train_epochs", - type=int, - default=100 - ) - parser.add_argument( - "--max_train_steps", - type=int, - default=4700, - help="Total number of training steps to perform. If provided, overrides num_train_epochs.", - ) - parser.add_argument( - "--gradient_accumulation_steps", - type=int, - default=1, - help="Number of updates steps to accumulate before performing a backward/update pass.", - ) - parser.add_argument( - "--gradient_checkpointing", - action="store_true", - help="Whether or not to use gradient checkpointing to save memory at the expense of slower backward pass.", - ) - parser.add_argument( - "--learning_rate_unet", - type=float, - default=2e-6, - help="Initial learning rate (after the potential warmup period) to use.", - ) - parser.add_argument( - "--learning_rate_text", - type=float, - default=2e-6, - help="Initial learning rate (after the potential warmup period) to use.", - ) - parser.add_argument( - "--scale_lr", - action="store_true", - default=True, - help="Scale the learning rate by the number of GPUs, gradient accumulation steps, and batch size.", - ) - parser.add_argument( - "--lr_scheduler", - type=str, - default="cosine_with_restarts", - help=( - 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' - ' "constant", "constant_with_warmup"]' - ), - ) - parser.add_argument( - "--lr_warmup_steps", - type=int, - default=300, - help="Number of steps for the warmup in the lr scheduler." - ) - parser.add_argument( - "--lr_cycles", - type=int, - default=None, - help="Number of restart cycles in the lr scheduler." - ) - parser.add_argument( - "--use_ema", - action="store_true", - default=True, - help="Whether to use EMA model." - ) - parser.add_argument( - "--ema_inv_gamma", - type=float, - default=1.0 - ) - parser.add_argument( - "--ema_power", - type=float, - default=9 / 10 - ) - parser.add_argument( - "--ema_max_decay", - type=float, - default=0.9999 - ) - parser.add_argument( - "--use_8bit_adam", - action="store_true", - default=True, - help="Whether or not to use 8-bit Adam from bitsandbytes." - ) - parser.add_argument( - "--adam_beta1", - type=float, - default=0.9, - help="The beta1 parameter for the Adam optimizer." - ) - parser.add_argument( - "--adam_beta2", - type=float, - default=0.999, - help="The beta2 parameter for the Adam optimizer." - ) - parser.add_argument( - "--adam_weight_decay", - type=float, - default=1e-2, - help="Weight decay to use." - ) - parser.add_argument( - "--adam_epsilon", - type=float, - default=1e-08, - help="Epsilon value for the Adam optimizer" - ) - parser.add_argument( - "--mixed_precision", - type=str, - default="no", - choices=["no", "fp16", "bf16"], - help=( - "Whether to use mixed precision. Choose" - "between fp16 and bf16 (bfloat16). Bf16 requires PyTorch >= 1.10." - "and an Nvidia Ampere GPU." - ), - ) - parser.add_argument( - "--checkpoint_frequency", - type=int, - default=500, - help="How often to save a checkpoint and sample image", - ) - parser.add_argument( - "--sample_frequency", - type=int, - default=100, - help="How often to save a checkpoint and sample image", - ) - parser.add_argument( - "--sample_image_size", - type=int, - default=512, - help="Size of sample images", - ) - parser.add_argument( - "--sample_batches", - type=int, - default=1, - help="Number of sample batches to generate per checkpoint", - ) - parser.add_argument( - "--sample_batch_size", - type=int, - default=1, - help="Number of samples to generate per batch", - ) - parser.add_argument( - "--train_batch_size", - type=int, - default=1, - help="Batch size (per device) for the training dataloader." - ) - parser.add_argument( - "--sample_steps", - type=int, - default=30, - help="Number of steps for sample generation. Higher values will result in more detailed samples, but longer runtimes.", - ) - parser.add_argument( - "--prior_loss_weight", - type=float, - default=1.0, - help="The weight of prior preservation loss." - ) - parser.add_argument( - "--max_grad_norm", - default=1.0, - type=float, - help="Max gradient norm." - ) - parser.add_argument( - "--noise_timesteps", - type=int, - default=1000, - ) - parser.add_argument( - "--config", - type=str, - default=None, - help="Path to a JSON configuration file containing arguments for invoking this script." - ) - - args = parser.parse_args() - if args.config is not None: - with open(args.config, 'rt') as f: - args = parser.parse_args( - namespace=argparse.Namespace(**json.load(f)["args"])) - - if args.train_data_file is None: - raise ValueError("You must specify --train_data_file") - - if args.pretrained_model_name_or_path is None: - raise ValueError("You must specify --pretrained_model_name_or_path") - - if args.placeholder_token is None: - raise ValueError("You must specify --placeholder_token") - - if args.initializer_token is None: - raise ValueError("You must specify --initializer_token") - - if args.output_dir is None: - raise ValueError("You must specify --output_dir") - - return args - - -def save_args(basepath: Path, args, extra={}): - info = {"args": vars(args)} - info["args"].update(extra) - with open(basepath.joinpath("args.json"), "w") as f: - json.dump(info, f, indent=4) - - -def freeze_params(params): - for param in params: - param.requires_grad = False - - -def make_grid(images, rows, cols): - w, h = images[0].size - grid = Image.new('RGB', size=(cols*w, rows*h)) - for i, image in enumerate(images): - grid.paste(image, box=(i % cols*w, i//cols*h)) - return grid - - -class Checkpointer: - def __init__( - self, - datamodule, - accelerator, - vae, - unet, - ema_unet, - tokenizer, - text_encoder, - instance_identifier, - placeholder_token, - placeholder_token_id, - output_dir: Path, - sample_image_size, - sample_batches, - sample_batch_size, - seed - ): - self.datamodule = datamodule - self.accelerator = accelerator - self.vae = vae - self.unet = unet - self.ema_unet = ema_unet - self.tokenizer = tokenizer - self.text_encoder = text_encoder - self.instance_identifier = instance_identifier - self.placeholder_token = placeholder_token - self.placeholder_token_id = placeholder_token_id - self.output_dir = output_dir - self.sample_image_size = sample_image_size - self.seed = seed or torch.random.seed() - self.sample_batches = sample_batches - self.sample_batch_size = sample_batch_size - - @torch.no_grad() - def checkpoint(self, step, postfix): - print("Saving checkpoint for step %d..." % step) - - checkpoints_path = self.output_dir.joinpath("checkpoints") - checkpoints_path.mkdir(parents=True, exist_ok=True) - - unwrapped = self.accelerator.unwrap_model(self.text_encoder) - - # Save a checkpoint - learned_embeds = unwrapped.get_input_embeddings().weight[self.placeholder_token_id] - learned_embeds_dict = {self.placeholder_token: learned_embeds.detach().cpu()} - - filename = f"%s_%d_%s.bin" % (slugify(self.placeholder_token), step, postfix) - torch.save(learned_embeds_dict, checkpoints_path.joinpath(filename)) - - del unwrapped - del learned_embeds - - @torch.no_grad() - def save_model(self): - print("Saving model...") - - unwrapped_unet = self.accelerator.unwrap_model( - self.ema_unet.averaged_model if self.ema_unet is not None else self.unet) - unwrapped_text_encoder = self.accelerator.unwrap_model(self.text_encoder) - pipeline = VlpnStableDiffusion( - text_encoder=unwrapped_text_encoder, - vae=self.vae, - unet=unwrapped_unet, - tokenizer=self.tokenizer, - scheduler=PNDMScheduler( - beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", skip_prk_steps=True - ), - ) - pipeline.save_pretrained(self.output_dir.joinpath("model")) - - del unwrapped_unet - del unwrapped_text_encoder - del pipeline - - if torch.cuda.is_available(): - torch.cuda.empty_cache() - - @torch.no_grad() - def save_samples(self, step, height, width, guidance_scale, eta, num_inference_steps): - samples_path = Path(self.output_dir).joinpath("samples") - - unwrapped_unet = self.accelerator.unwrap_model( - self.ema_unet.averaged_model if self.ema_unet is not None else self.unet) - unwrapped_text_encoder = self.accelerator.unwrap_model(self.text_encoder) - scheduler = EulerAScheduler( - beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear" - ) - - # Save a sample image - pipeline = VlpnStableDiffusion( - text_encoder=unwrapped_text_encoder, - vae=self.vae, - unet=unwrapped_unet, - tokenizer=self.tokenizer, - scheduler=scheduler, - ).to(self.accelerator.device) - pipeline.set_progress_bar_config(dynamic_ncols=True) - - train_data = self.datamodule.train_dataloader() - val_data = self.datamodule.val_dataloader() - - generator = torch.Generator(device=pipeline.device).manual_seed(self.seed) - stable_latents = torch.randn( - (self.sample_batch_size, pipeline.unet.in_channels, height // 8, width // 8), - device=pipeline.device, - generator=generator, - ) - - with torch.inference_mode(): - for pool, data, latents in [("stable", val_data, stable_latents), ("val", val_data, None), ("train", train_data, None)]: - all_samples = [] - file_path = samples_path.joinpath(pool, f"step_{step}.png") - file_path.parent.mkdir(parents=True, exist_ok=True) - - data_enum = enumerate(data) - - for i in range(self.sample_batches): - batches = [batch for j, batch in data_enum if j * data.batch_size < self.sample_batch_size] - prompt = [ - prompt.format(self.instance_identifier) - for batch in batches - for prompt in batch["prompts"] - ][:self.sample_batch_size] - nprompt = [ - prompt - for batch in batches - for prompt in batch["nprompts"] - ][:self.sample_batch_size] - - samples = pipeline( - prompt=prompt, - negative_prompt=nprompt, - height=self.sample_image_size, - width=self.sample_image_size, - latents=latents[:len(prompt)] if latents is not None else None, - generator=generator if latents is not None else None, - guidance_scale=guidance_scale, - eta=eta, - num_inference_steps=num_inference_steps, - output_type='pil' - ).images - - all_samples += samples - - del samples - - image_grid = make_grid(all_samples, self.sample_batches, self.sample_batch_size) - image_grid.save(file_path) - - del all_samples - del image_grid - - del unwrapped_unet - del unwrapped_text_encoder - del scheduler - del pipeline - del generator - del stable_latents - - if torch.cuda.is_available(): - torch.cuda.empty_cache() - - -def main(): - args = parse_args() - - global_step_offset = 0 - now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S") - basepath = Path(args.output_dir).joinpath(slugify(args.placeholder_token), now) - basepath.mkdir(parents=True, exist_ok=True) - - accelerator = Accelerator( - log_with=LoggerType.TENSORBOARD, - logging_dir=f"{basepath}", - gradient_accumulation_steps=args.gradient_accumulation_steps, - mixed_precision=args.mixed_precision - ) - - logging.basicConfig(filename=basepath.joinpath("log.txt"), level=logging.DEBUG) - - save_args(basepath, args) - - # If passed along, set the training seed now. - if args.seed is not None: - set_seed(args.seed) - - args.instance_identifier = args.instance_identifier.format(args.placeholder_token) - - # Load the tokenizer and add the placeholder token as a additional special token - if args.tokenizer_name: - tokenizer = CLIPTokenizer.from_pretrained(args.tokenizer_name) - elif args.pretrained_model_name_or_path: - tokenizer = CLIPTokenizer.from_pretrained(args.pretrained_model_name_or_path, subfolder='tokenizer') - - # Convert the initializer_token, placeholder_token to ids - initializer_token_ids = tokenizer.encode(args.initializer_token, add_special_tokens=False) - print(f"Initializer token maps to {len(initializer_token_ids)} embeddings.") - initializer_token_ids = torch.tensor(initializer_token_ids[:1]) - - # Add the placeholder token in tokenizer - num_added_tokens = tokenizer.add_tokens(args.placeholder_token) - if num_added_tokens == 0: - print(f"Re-using existing token {args.placeholder_token}.") - else: - print(f"Training new token {args.placeholder_token}.") - - placeholder_token_id = tokenizer.convert_tokens_to_ids(args.placeholder_token) - - # Load models and create wrapper for stable diffusion - text_encoder = CLIPTextModel.from_pretrained(args.pretrained_model_name_or_path, subfolder='text_encoder') - vae = AutoencoderKL.from_pretrained(args.pretrained_model_name_or_path, subfolder='vae') - unet = UNet2DConditionModel.from_pretrained( - args.pretrained_model_name_or_path, subfolder='unet') - - ema_unet = EMAModel( - unet, - inv_gamma=args.ema_inv_gamma, - power=args.ema_power, - max_value=args.ema_max_decay, - device=accelerator.device - ) if args.use_ema else None - - prompt_processor = PromptProcessor(tokenizer, text_encoder) - - if args.gradient_checkpointing: - unet.enable_gradient_checkpointing() - text_encoder.gradient_checkpointing_enable() - - # slice_size = unet.config.attention_head_dim // 2 - # unet.set_attention_slice(slice_size) - - # Resize the token embeddings as we are adding new special tokens to the tokenizer - text_encoder.resize_token_embeddings(len(tokenizer)) - - # Initialise the newly added placeholder token with the embeddings of the initializer token - token_embeds = text_encoder.get_input_embeddings().weight.data - original_token_embeds = token_embeds.detach().clone().to(accelerator.device) - initializer_token_embeddings = text_encoder.get_input_embeddings()(initializer_token_ids) - token_embeds[placeholder_token_id] = initializer_token_embeddings - - # Freeze vae and unet - freeze_params(vae.parameters()) - # Freeze all parameters except for the token embeddings in text encoder - params_to_freeze = itertools.chain( - text_encoder.text_model.encoder.parameters(), - text_encoder.text_model.final_layer_norm.parameters(), - text_encoder.text_model.embeddings.position_embedding.parameters(), - ) - freeze_params(params_to_freeze) - - if args.scale_lr: - args.learning_rate_unet = ( - args.learning_rate_unet * args.gradient_accumulation_steps * - args.train_batch_size * accelerator.num_processes - ) - args.learning_rate_text = ( - args.learning_rate_text * args.gradient_accumulation_steps * - args.train_batch_size * accelerator.num_processes - ) - - # Use 8-bit Adam for lower memory usage or to fine-tune the model in 16GB GPUs - if args.use_8bit_adam: - try: - import bitsandbytes as bnb - except ImportError: - raise ImportError("To use 8-bit Adam, please install the bitsandbytes library: `pip install bitsandbytes`.") - - optimizer_class = bnb.optim.AdamW8bit - else: - optimizer_class = torch.optim.AdamW - - # Initialize the optimizer - optimizer = optimizer_class( - [ - { - 'params': unet.parameters(), - 'lr': args.learning_rate_unet, - }, - { - 'params': text_encoder.get_input_embeddings().parameters(), - 'lr': args.learning_rate_text, - } - ], - betas=(args.adam_beta1, args.adam_beta2), - weight_decay=args.adam_weight_decay, - eps=args.adam_epsilon, - ) - - noise_scheduler = DDPMScheduler( - beta_start=0.00085, - beta_end=0.012, - beta_schedule="scaled_linear", - num_train_timesteps=args.noise_timesteps - ) - - weight_dtype = torch.float32 - if args.mixed_precision == "fp16": - weight_dtype = torch.float16 - elif args.mixed_precision == "bf16": - weight_dtype = torch.bfloat16 - - def collate_fn(examples): - prompts = [example["prompts"] for example in examples] - nprompts = [example["nprompts"] for example in examples] - input_ids = [example["instance_prompt_ids"] for example in examples] - pixel_values = [example["instance_images"] for example in examples] - - # concat class and instance examples for prior preservation - if args.num_class_images != 0 and "class_prompt_ids" in examples[0]: - input_ids += [example["class_prompt_ids"] for example in examples] - pixel_values += [example["class_images"] for example in examples] - - pixel_values = torch.stack(pixel_values) - pixel_values = pixel_values.to(dtype=weight_dtype, memory_format=torch.contiguous_format) - - input_ids = prompt_processor.unify_input_ids(input_ids) - - batch = { - "prompts": prompts, - "nprompts": nprompts, - "input_ids": input_ids, - "pixel_values": pixel_values, - } - return batch - - datamodule = CSVDataModule( - data_file=args.train_data_file, - batch_size=args.train_batch_size, - prompt_processor=prompt_processor, - instance_identifier=args.instance_identifier, - class_identifier=args.class_identifier, - class_subdir="cls", - num_class_images=args.num_class_images, - size=args.resolution, - repeats=args.repeats, - center_crop=args.center_crop, - valid_set_size=args.sample_batch_size*args.sample_batches, - collate_fn=collate_fn - ) - - datamodule.prepare_data() - datamodule.setup() - - if args.num_class_images != 0: - missing_data = [item for item in datamodule.data_train if not item.class_image_path.exists()] - - if len(missing_data) != 0: - batched_data = [ - missing_data[i:i+args.sample_batch_size] - for i in range(0, len(missing_data), args.sample_batch_size) - ] - - scheduler = EulerAScheduler( - beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear" - ) - - pipeline = VlpnStableDiffusion( - text_encoder=text_encoder, - vae=vae, - unet=unet, - tokenizer=tokenizer, - scheduler=scheduler, - ).to(accelerator.device) - pipeline.set_progress_bar_config(dynamic_ncols=True) - - with torch.inference_mode(): - for batch in batched_data: - image_name = [item.class_image_path for item in batch] - prompt = [item.prompt.format(args.class_identifier) for item in batch] - nprompt = [item.nprompt for item in batch] - - images = pipeline( - prompt=prompt, - negative_prompt=nprompt, - num_inference_steps=args.sample_steps - ).images - - for i, image in enumerate(images): - image.save(image_name[i]) - - del pipeline - - if torch.cuda.is_available(): - torch.cuda.empty_cache() - - train_dataloader = datamodule.train_dataloader() - val_dataloader = datamodule.val_dataloader() - - # Scheduler and math around the number of training steps. - overrode_max_train_steps = False - num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) - if args.max_train_steps is None: - args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch - overrode_max_train_steps = True - num_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) - - if args.lr_scheduler == "cosine_with_restarts": - lr_scheduler = get_cosine_with_hard_restarts_schedule_with_warmup( - optimizer=optimizer, - num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, - num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, - num_cycles=args.lr_cycles or math.ceil(math.sqrt( - ((args.max_train_steps - args.lr_warmup_steps) / num_update_steps_per_epoch))), - ) - else: - lr_scheduler = get_scheduler( - args.lr_scheduler, - optimizer=optimizer, - num_warmup_steps=args.lr_warmup_steps * args.gradient_accumulation_steps, - num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, - ) - - text_encoder, unet, optimizer, train_dataloader, val_dataloader, lr_scheduler = accelerator.prepare( - text_encoder, unet, optimizer, train_dataloader, val_dataloader, lr_scheduler - ) - - # Move vae and unet to device - vae.to(accelerator.device, dtype=weight_dtype) - - # Keep vae and unet in eval mode as we don't train these - vae.eval() - - # We need to recalculate our total training steps as the size of the training dataloader may have changed. - num_update_steps_per_epoch = math.ceil(len(train_dataloader) / args.gradient_accumulation_steps) - if overrode_max_train_steps: - args.max_train_steps = args.num_train_epochs * num_update_steps_per_epoch - - num_val_steps_per_epoch = len(val_dataloader) - num_epochs = math.ceil(args.max_train_steps / num_update_steps_per_epoch) - val_steps = num_val_steps_per_epoch * num_epochs - - # We need to initialize the trackers we use, and also store our configuration. - # The trackers initializes automatically on the main process. - if accelerator.is_main_process: - accelerator.init_trackers("dreambooth_plus", config=vars(args)) - - # Train! - total_batch_size = args.train_batch_size * accelerator.num_processes * args.gradient_accumulation_steps - - logger.info("***** Running training *****") - logger.info(f" Num Epochs = {num_epochs}") - logger.info(f" Instantaneous batch size per device = {args.train_batch_size}") - logger.info(f" Total train batch size (w. parallel, distributed & accumulation) = {total_batch_size}") - logger.info(f" Gradient Accumulation steps = {args.gradient_accumulation_steps}") - logger.info(f" Total optimization steps = {args.max_train_steps}") - # Only show the progress bar once on each machine. - - global_step = 0 - min_val_loss = np.inf - - checkpointer = Checkpointer( - datamodule=datamodule, - accelerator=accelerator, - vae=vae, - unet=unet, - ema_unet=ema_unet, - tokenizer=tokenizer, - text_encoder=text_encoder, - instance_identifier=args.instance_identifier, - placeholder_token=args.placeholder_token, - placeholder_token_id=placeholder_token_id, - output_dir=basepath, - sample_image_size=args.sample_image_size, - sample_batch_size=args.sample_batch_size, - sample_batches=args.sample_batches, - seed=args.seed - ) - - if accelerator.is_main_process: - checkpointer.save_samples( - 0, - args.resolution, args.resolution, 7.5, 0.0, args.sample_steps) - - local_progress_bar = tqdm( - range(num_update_steps_per_epoch + num_val_steps_per_epoch), - disable=not accelerator.is_local_main_process, - dynamic_ncols=True - ) - local_progress_bar.set_description("Epoch X / Y") - - global_progress_bar = tqdm( - range(args.max_train_steps + val_steps), - disable=not accelerator.is_local_main_process, - dynamic_ncols=True - ) - global_progress_bar.set_description("Total progress") - - try: - for epoch in range(num_epochs): - local_progress_bar.set_description(f"Epoch {epoch + 1} / {num_epochs}") - local_progress_bar.reset() - - text_encoder.train() - train_loss = 0.0 - - sample_checkpoint = False - - for step, batch in enumerate(train_dataloader): - with accelerator.accumulate(itertools.chain(unet, text_encoder)): - # Convert images to latent space - latents = vae.encode(batch["pixel_values"]).latent_dist.sample() - latents = latents * 0.18215 - - # Sample noise that we'll add to the latents - noise = torch.randn_like(latents) - bsz = latents.shape[0] - # Sample a random timestep for each image - timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, - (bsz,), device=latents.device) - timesteps = timesteps.long() - - # Add noise to the latents according to the noise magnitude at each timestep - # (this is the forward diffusion process) - noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) - - # Get the text embedding for conditioning - encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"]) - - # Predict the noise residual - noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - if args.num_class_images != 0: - # Chunk the noise and noise_pred into two parts and compute the loss on each part separately. - noise_pred, noise_pred_prior = torch.chunk(noise_pred, 2, dim=0) - noise, noise_prior = torch.chunk(noise, 2, dim=0) - - # Compute instance loss - loss = F.mse_loss(noise_pred.float(), noise.float(), reduction="none").mean([1, 2, 3]).mean() - - # Compute prior loss - prior_loss = F.mse_loss(noise_pred_prior.float(), noise_prior.float(), reduction="mean") - - # Add the prior loss to the instance loss. - loss = loss + args.prior_loss_weight * prior_loss - else: - loss = F.mse_loss(noise_pred.float(), noise.float(), reduction="mean") - - accelerator.backward(loss) - - # Keep the token embeddings fixed except the newly added - # embeddings for the concept, as we only want to optimize the concept embeddings - if accelerator.num_processes > 1: - token_embeds = text_encoder.module.get_input_embeddings().weight - else: - token_embeds = text_encoder.get_input_embeddings().weight - - # Get the index for tokens that we want to freeze - index_fixed_tokens = torch.arange(len(tokenizer)) != placeholder_token_id - token_embeds.data[index_fixed_tokens, :] = original_token_embeds[index_fixed_tokens, :] - - if accelerator.sync_gradients: - accelerator.clip_grad_norm_(unet.parameters(), args.max_grad_norm) - - optimizer.step() - if not accelerator.optimizer_step_was_skipped: - lr_scheduler.step() - optimizer.zero_grad(set_to_none=True) - - loss = loss.detach().item() - train_loss += loss - - # Checks if the accelerator has performed an optimization step behind the scenes - if accelerator.sync_gradients: - if args.use_ema: - ema_unet.step(unet) - - local_progress_bar.update(1) - global_progress_bar.update(1) - - global_step += 1 - - if global_step % args.sample_frequency == 0: - sample_checkpoint = True - - if global_step % args.checkpoint_frequency == 0 and global_step > 0 and accelerator.is_main_process: - local_progress_bar.clear() - global_progress_bar.clear() - - checkpointer.checkpoint(global_step + global_step_offset, "training") - - logs = { - "train/loss": loss, - "lr/unet": lr_scheduler.get_last_lr()[0], - "lr/text": lr_scheduler.get_last_lr()[1] - } - if args.use_ema: - logs["ema_decay"] = ema_unet.decay - - accelerator.log(logs, step=global_step) - - local_progress_bar.set_postfix(**logs) - - if global_step >= args.max_train_steps: - break - - train_loss /= len(train_dataloader) - - accelerator.wait_for_everyone() - - text_encoder.eval() - val_loss = 0.0 - - for step, batch in enumerate(val_dataloader): - with torch.no_grad(): - latents = vae.encode(batch["pixel_values"]).latent_dist.sample() - latents = latents * 0.18215 - - noise = torch.randn_like(latents) - bsz = latents.shape[0] - timesteps = torch.randint(0, noise_scheduler.config.num_train_timesteps, - (bsz,), device=latents.device) - timesteps = timesteps.long() - - noisy_latents = noise_scheduler.add_noise(latents, noise, timesteps) - - encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"]) - - noise_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - noise_pred, noise = accelerator.gather_for_metrics((noise_pred, noise)) - - loss = F.mse_loss(noise_pred.float(), noise.float(), reduction="mean") - - loss = loss.detach().item() - val_loss += loss - - if accelerator.sync_gradients: - local_progress_bar.update(1) - global_progress_bar.update(1) - - logs = {"val/loss": loss} - local_progress_bar.set_postfix(**logs) - - val_loss /= len(val_dataloader) - - accelerator.log({"val/loss": val_loss}, step=global_step) - - local_progress_bar.clear() - global_progress_bar.clear() - - if min_val_loss > val_loss: - accelerator.print( - f"Global step {global_step}: Validation loss reached new minimum: {min_val_loss:.2e} -> {val_loss:.2e}") - checkpointer.checkpoint(global_step + global_step_offset, "milestone") - min_val_loss = val_loss - - if sample_checkpoint and accelerator.is_main_process: - checkpointer.save_samples( - global_step + global_step_offset, - args.resolution, args.resolution, 7.5, 0.0, args.sample_steps) - - # Create the pipeline using using the trained modules and save it. - if accelerator.is_main_process: - print("Finished! Saving final checkpoint and resume state.") - checkpointer.checkpoint(global_step + global_step_offset, "end") - checkpointer.save_model() - accelerator.end_training() - - except KeyboardInterrupt: - if accelerator.is_main_process: - print("Interrupted, saving checkpoint and resume state...") - checkpointer.checkpoint(global_step + global_step_offset, "end") - checkpointer.save_model() - accelerator.end_training() - quit() - - -if __name__ == "__main__": - main() -- cgit v1.2.3-54-g00ecf