From 6c64f769043c8212b1a5778e857af691a828798d Mon Sep 17 00:00:00 2001 From: Volpeon Date: Thu, 5 Jan 2023 10:19:38 +0100 Subject: Various cleanups --- common.py | 44 --- infer.py | 6 +- models/clip/embeddings.py | 5 + models/clip/tokenizer.py | 9 +- train_dreambooth.py | 86 +---- train_lora.py | 946 ---------------------------------------------- train_ti.py | 86 +---- training/common.py | 75 ++++ util.py | 45 +++ 9 files changed, 172 insertions(+), 1130 deletions(-) delete mode 100644 common.py delete mode 100644 train_lora.py create mode 100644 training/common.py create mode 100644 util.py diff --git a/common.py b/common.py deleted file mode 100644 index 0887197..0000000 --- a/common.py +++ /dev/null @@ -1,44 +0,0 @@ -from pathlib import Path -import json - -from models.clip.embeddings import ManagedCLIPTextEmbeddings -from models.clip.tokenizer import MultiCLIPTokenizer - -from safetensors import safe_open - - -def load_config(filename): - with open(filename, 'rt') as f: - config = json.load(f) - - args = config["args"] - - if "base" in config: - args = load_config(Path(filename).parent.joinpath(config["base"])) | args - - return args - - -def load_embeddings_from_dir(tokenizer: MultiCLIPTokenizer, embeddings: ManagedCLIPTextEmbeddings, embeddings_dir: Path): - if not embeddings_dir.exists() or not embeddings_dir.is_dir(): - return [] - - filenames = [filename for filename in embeddings_dir.iterdir() if filename.is_file()] - - new_tokens = [] - new_embeds = [] - - for filename in filenames: - with safe_open(filename, framework="pt", device="cpu") as file: - embed = file.get_tensor("embed") - - added = tokenizer.add_multi_tokens(filename.stem, embed.shape[0]) - new_tokens.append(added) - new_embeds.append(embed) - - embeddings.resize(len(tokenizer)) - - for (new_token, embeds) in zip(new_tokens, new_embeds): - embeddings.add_embed(new_token.ids, embeds) - - return new_tokens diff --git a/infer.py b/infer.py index b29b136..507d0cf 100644 --- a/infer.py +++ b/infer.py @@ -28,7 +28,7 @@ from transformers import CLIPTextModel from models.clip.embeddings import patch_managed_embeddings from models.clip.tokenizer import MultiCLIPTokenizer from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion -from common import load_config, load_embeddings_from_dir +from util import load_config, load_embeddings_from_dir torch.backends.cuda.matmul.allow_tf32 = True @@ -192,12 +192,12 @@ def save_args(basepath, args, extra={}): def load_embeddings(pipeline, embeddings_dir): - added_tokens = load_embeddings_from_dir( + added_tokens, added_ids = load_embeddings_from_dir( pipeline.tokenizer, pipeline.text_encoder.text_model.embeddings, Path(embeddings_dir) ) - print(f"Added {len(added_tokens)} tokens from embeddings dir: {added_tokens}") + print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}") def create_pipeline(model, dtype): diff --git a/models/clip/embeddings.py b/models/clip/embeddings.py index 1280ebd..fb639f1 100644 --- a/models/clip/embeddings.py +++ b/models/clip/embeddings.py @@ -53,6 +53,8 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings): self.token_embedding = resize_embedding(self.token_embedding, size, self.initializer_factor) def add_embed(self, token_ids: Union[int, list[int]], initializer: Optional[Union[int, list[int], torch.FloatTensor]] = None): + init_ratio = 1.0 + if isinstance(token_ids, int): token_ids = [token_ids] @@ -63,6 +65,7 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings): initializer = [initializer] if isinstance(initializer, list): + init_ratio = len(initializer) / len(token_ids) initializer = (initializer * len(token_ids))[:len(token_ids)] with torch.no_grad(): @@ -76,6 +79,8 @@ class ManagedCLIPTextEmbeddings(CLIPTextEmbeddings): dtype=self.temp_token_embedding.weight.dtype, ) + return init_ratio + def load_embed(self, input_ids: list[int], filename: Path): with safe_open(filename, framework="pt", device="cpu") as file: self.add_embed(input_ids, file.get_tensor("embed")) diff --git a/models/clip/tokenizer.py b/models/clip/tokenizer.py index 4e97ab5..034adf9 100644 --- a/models/clip/tokenizer.py +++ b/models/clip/tokenizer.py @@ -55,11 +55,6 @@ def shuffle_auto(tokens: list[int]): return shuffle_all(tokens) -class MultiCLIPTokenizerItem(NamedTuple): - token: str - ids: list[int] - - class MultiCLIPTokenizer(CLIPTokenizer): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) @@ -96,7 +91,7 @@ class MultiCLIPTokenizer(CLIPTokenizer): self, new_tokens: Union[str, list[str]], num_vectors: Union[int, list[int]] = 1 - ) -> Union[MultiCLIPTokenizerItem, list[MultiCLIPTokenizerItem]]: + ) -> Union[list[int], list[list[int]]]: if isinstance(new_tokens, list): if isinstance(num_vectors, int): num_vectors = [num_vectors] * len(new_tokens) @@ -119,7 +114,7 @@ class MultiCLIPTokenizer(CLIPTokenizer): self.token_map[ids[0]] = ids - return MultiCLIPTokenizerItem(new_tokens, ids) + return ids def expand_id(self, id: int): if id in self.token_map: diff --git a/train_dreambooth.py b/train_dreambooth.py index 2e0696b..c658ad6 100644 --- a/train_dreambooth.py +++ b/train_dreambooth.py @@ -4,9 +4,9 @@ import math import datetime import logging from pathlib import Path +from functools import partial import torch -import torch.nn.functional as F import torch.utils.checkpoint from accelerate import Accelerator @@ -20,9 +20,10 @@ from tqdm.auto import tqdm from transformers import CLIPTextModel from slugify import slugify -from common import load_config, load_embeddings_from_dir +from util import load_config, load_embeddings_from_dir from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion from data.csv import CSVDataModule, CSVDataItem +from training.common import run_model from training.optimization import get_one_cycle_schedule from training.lr import LRFinder from training.util import AverageMeter, CheckpointerBase, save_args @@ -610,8 +611,8 @@ def main(): if not embeddings_dir.exists() or not embeddings_dir.is_dir(): raise ValueError("--embeddings_dir must point to an existing directory") - added_tokens_from_dir = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir) - print(f"Added {len(added_tokens_from_dir)} tokens from embeddings dir: {added_tokens_from_dir}") + added_tokens, added_ids = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir) + print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}") if len(args.placeholder_token) != 0: # Convert the initializer_token, placeholder_token to ids @@ -620,13 +621,15 @@ def main(): for token in args.initializer_token ] - new_tokens = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors) + new_ids = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors) embeddings.resize(len(tokenizer)) - for (new_token, init_ids) in zip(new_tokens, initializer_token_ids): - embeddings.add_embed(new_token.ids, init_ids) + init_ratios = [ + embeddings.add_embed(new_id, init_ids) + for (new_id, init_ids) in zip(new_ids, initializer_token_ids) + ] - print(f"Added {len(new_tokens)} new tokens.") + print(f"Added {len(new_ids)} new tokens: {zip(args.placeholder_token, new_ids, init_ratios)}") else: placeholder_token_id = [] @@ -856,63 +859,16 @@ def main(): def on_eval(): tokenizer.eval() - def loop(step: int, batch, eval: bool = False): - # 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_gen = torch.Generator(device=latents.device).manual_seed(args.seed + step) if eval else None - timesteps = torch.randint( - 0, - noise_scheduler.config.num_train_timesteps, - (bsz,), - generator=timesteps_gen, - 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) - noisy_latents = noisy_latents.to(dtype=unet.dtype) - - # Get the text embedding for conditioning - encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"]) - - # Predict the noise residual - model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - # Get the target for loss depending on the prediction type - if noise_scheduler.config.prediction_type == "epsilon": - target = noise - elif noise_scheduler.config.prediction_type == "v_prediction": - target = noise_scheduler.get_velocity(latents, noise, timesteps) - else: - raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") - - if args.num_class_images != 0: - # Chunk the noise and model_pred into two parts and compute the loss on each part separately. - model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) - target, target_prior = torch.chunk(target, 2, dim=0) - - # Compute instance loss - loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") - - # Compute prior loss - prior_loss = F.mse_loss(model_pred_prior.float(), target_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(model_pred.float(), target.float(), reduction="mean") - - acc = (model_pred == target).float().mean() - - return loss, acc, bsz + loop = partial( + run_model, + vae=vae, + noise_scheduler=noise_scheduler, + unet=unet, + prompt_processor=prompt_processor, + num_class_images=args.num_class_images, + prior_loss_weight=args.prior_loss_weight, + seed=args.seed, + ) # We need to initialize the trackers we use, and also store our configuration. # The trackers initializes automatically on the main process. diff --git a/train_lora.py b/train_lora.py deleted file mode 100644 index de878a4..0000000 --- a/train_lora.py +++ /dev/null @@ -1,946 +0,0 @@ -import argparse -import itertools -import math -import datetime -import logging -import json -from pathlib import Path - -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, DPMSolverMultistepScheduler, UNet2DConditionModel -from diffusers.optimization import get_scheduler, get_cosine_with_hard_restarts_schedule_with_warmup -from diffusers.training_utils import EMAModel -from tqdm.auto import tqdm -from transformers import CLIPTextModel, CLIPTokenizer -from slugify import slugify - -from common import load_text_embeddings, load_config -from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion -from data.csv import CSVDataModule -from training.lora import LoraAttnProcessor -from training.optimization import get_one_cycle_schedule -from training.util import AverageMeter, CheckpointerBase, save_args -from models.clip.prompt import PromptProcessor - -logger = get_logger(__name__) - - -torch.backends.cuda.matmul.allow_tf32 = True -torch.backends.cudnn.benchmark = 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 folder containing the training data." - ) - parser.add_argument( - "--train_data_template", - type=str, - default="template", - ) - 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, - nargs='*', - default=[], - help="A token to use as a placeholder for the concept.", - ) - parser.add_argument( - "--initializer_token", - type=str, - nargs='*', - default=[], - help="A token to use as initializer word." - ) - parser.add_argument( - "--tag_dropout", - type=float, - default=0.1, - help="Tag dropout probability.", - ) - 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/lora", - help="The output directory where the model predictions and checkpoints will be written.", - ) - parser.add_argument( - "--embeddings_dir", - type=str, - default=None, - help="The embeddings directory where Textual Inversion embeddings are stored.", - ) - parser.add_argument( - "--mode", - type=str, - default=None, - help="A mode to filter the dataset.", - ) - parser.add_argument( - "--seed", - type=int, - default=None, - help="A seed for reproducible training." - ) - parser.add_argument( - "--resolution", - type=int, - default=768, - 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( - "--dataloader_num_workers", - type=int, - default=0, - help=( - "The number of subprocesses to use for data loading. 0 means that the data will be loaded in the main" - " process." - ), - ) - parser.add_argument( - "--num_train_epochs", - type=int, - default=100 - ) - parser.add_argument( - "--max_train_steps", - type=int, - default=None, - 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", - 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="one_cycle", - help=( - 'The scheduler type to use. Choose between ["linear", "cosine", "cosine_with_restarts", "polynomial",' - ' "constant", "constant_with_warmup", "one_cycle"]' - ), - ) - parser.add_argument( - "--lr_warmup_epochs", - type=int, - default=10, - 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 (if supported)." - ) - 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( - "--sample_frequency", - type=int, - default=1, - help="How often to save a checkpoint and sample image", - ) - parser.add_argument( - "--sample_image_size", - type=int, - default=768, - 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( - "--valid_set_size", - type=int, - default=None, - help="Number of images in the validation dataset." - ) - 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=15, - 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: - args = load_config(args.config) - args = parser.parse_args(namespace=argparse.Namespace(**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.instance_identifier is None: - raise ValueError("You must specify --instance_identifier") - - if isinstance(args.initializer_token, str): - args.initializer_token = [args.initializer_token] - - if isinstance(args.placeholder_token, str): - args.placeholder_token = [args.placeholder_token] - - if len(args.placeholder_token) == 0: - args.placeholder_token = [f"<*{i}>" for i in range(len(args.initializer_token))] - - if len(args.placeholder_token) != len(args.initializer_token): - raise ValueError("Number of items in --placeholder_token and --initializer_token must match") - - if args.output_dir is None: - raise ValueError("You must specify --output_dir") - - return args - - -class Checkpointer(CheckpointerBase): - def __init__( - self, - datamodule, - accelerator, - vae, - unet, - tokenizer, - text_encoder, - unet_lora, - scheduler, - instance_identifier, - placeholder_token, - placeholder_token_id, - output_dir: Path, - sample_image_size, - sample_batches, - sample_batch_size, - seed - ): - super().__init__( - datamodule=datamodule, - output_dir=output_dir, - instance_identifier=instance_identifier, - placeholder_token=placeholder_token, - placeholder_token_id=placeholder_token_id, - sample_image_size=sample_image_size, - seed=seed or torch.random.seed(), - sample_batches=sample_batches, - sample_batch_size=sample_batch_size - ) - - self.accelerator = accelerator - self.vae = vae - self.unet = unet - self.tokenizer = tokenizer - self.text_encoder = text_encoder - self.unet_lora = unet_lora - self.scheduler = scheduler - - @torch.no_grad() - def save_model(self): - print("Saving model...") - - unet_lora = self.accelerator.unwrap_model(self.unet_lora) - unet_lora.save_pretrained(self.output_dir.joinpath("model")) - - del unet_lora - - if torch.cuda.is_available(): - torch.cuda.empty_cache() - - @torch.no_grad() - def save_samples(self, step, num_inference_steps, guidance_scale=7.5, eta=0.0): - # Save a sample image - pipeline = VlpnStableDiffusion( - text_encoder=self.text_encoder, - vae=self.vae, - unet=self.unet, - tokenizer=self.tokenizer, - scheduler=self.scheduler, - ).to(self.accelerator.device) - pipeline.set_progress_bar_config(dynamic_ncols=True) - - super().save_samples(pipeline, step, num_inference_steps, guidance_scale, eta) - - del pipeline - del generator - del stable_latents - - if torch.cuda.is_available(): - torch.cuda.empty_cache() - - -def main(): - args = parse_args() - - instance_identifier = args.instance_identifier - - if len(args.placeholder_token) != 0: - instance_identifier = instance_identifier.format(args.placeholder_token[0]) - - now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S") - basepath = Path(args.output_dir).joinpath(slugify(instance_identifier), 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) - - args.seed = args.seed or (torch.random.seed() >> 32) - set_seed(args.seed) - - save_args(basepath, args) - - # 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') - - # 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') - noise_scheduler = DDPMScheduler.from_pretrained(args.pretrained_model_name_or_path, subfolder='scheduler') - checkpoint_scheduler = DPMSolverMultistepScheduler.from_pretrained( - args.pretrained_model_name_or_path, subfolder='scheduler') - - unet_lora = LoraAttnProcessor( - cross_attention_dim=unet.cross_attention_dim, - inner_dim=unet.in_channels, - r=4, - ) - - vae.enable_slicing() - vae.set_use_memory_efficient_attention_xformers(True) - unet.set_use_memory_efficient_attention_xformers(True) - unet.set_attn_processor(unet_lora) - - if args.gradient_checkpointing: - unet.enable_gradient_checkpointing() - text_encoder.gradient_checkpointing_enable() - - # Freeze text_encoder and vae - vae.requires_grad_(False) - unet.requires_grad_(False) - - if args.embeddings_dir is not None: - embeddings_dir = Path(args.embeddings_dir) - if not embeddings_dir.exists() or not embeddings_dir.is_dir(): - raise ValueError("--embeddings_dir must point to an existing directory") - added_tokens = load_text_embeddings(tokenizer, text_encoder, embeddings_dir) - print(f"Added {len(added_tokens)} tokens from embeddings dir: {added_tokens}") - - if len(args.placeholder_token) != 0: - # Convert the initializer_token, placeholder_token to ids - initializer_token_ids = torch.stack([ - torch.tensor(tokenizer.encode(token, add_special_tokens=False)[:1]) - for token in args.initializer_token - ]) - - num_added_tokens = tokenizer.add_tokens(args.placeholder_token) - print(f"Added {num_added_tokens} new tokens.") - - placeholder_token_id = tokenizer.convert_tokens_to_ids(args.placeholder_token) - - # Resize the token embeddings as we are adding new special tokens to the tokenizer - text_encoder.resize_token_embeddings(len(tokenizer)) - - token_embeds = text_encoder.get_input_embeddings().weight.data - original_token_embeds = token_embeds.clone().to(accelerator.device) - initializer_token_embeddings = text_encoder.get_input_embeddings()(initializer_token_ids) - - for (token_id, embeddings) in zip(placeholder_token_id, initializer_token_embeddings): - token_embeds[token_id] = embeddings - else: - placeholder_token_id = [] - - print(f"Training added text embeddings") - - text_encoder.text_model.encoder.requires_grad_(False) - text_encoder.text_model.final_layer_norm.requires_grad_(False) - text_encoder.text_model.embeddings.position_embedding.requires_grad_(False) - - index_fixed_tokens = torch.arange(len(tokenizer)) - index_fixed_tokens = index_fixed_tokens[~torch.isin(index_fixed_tokens, torch.tensor(placeholder_token_id))] - - prompt_processor = PromptProcessor(tokenizer, text_encoder) - - if args.scale_lr: - args.learning_rate = ( - args.learning_rate * 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_lora.parameters(), - 'lr': args.learning_rate, - }, - ], - betas=(args.adam_beta1, args.adam_beta2), - weight_decay=args.adam_weight_decay, - eps=args.adam_epsilon, - ) - - 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) - - inputs = prompt_processor.unify_input_ids(input_ids) - - batch = { - "prompts": prompts, - "nprompts": nprompts, - "input_ids": inputs.input_ids, - "pixel_values": pixel_values, - "attention_mask": inputs.attention_mask, - } - return batch - - datamodule = CSVDataModule( - data_file=args.train_data_file, - batch_size=args.train_batch_size, - prompt_processor=prompt_processor, - instance_identifier=instance_identifier, - class_identifier=args.class_identifier, - class_subdir="cls", - num_class_images=args.num_class_images, - size=args.resolution, - repeats=args.repeats, - mode=args.mode, - dropout=args.tag_dropout, - center_crop=args.center_crop, - template_key=args.train_data_template, - valid_set_size=args.valid_set_size, - num_workers=args.dataloader_num_workers, - 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) - ] - - pipeline = VlpnStableDiffusion( - text_encoder=text_encoder, - vae=vae, - unet=unet, - tokenizer=tokenizer, - scheduler=checkpoint_scheduler, - ).to(accelerator.device) - pipeline.set_progress_bar_config(dynamic_ncols=True) - - with torch.autocast("cuda"), torch.inference_mode(): - for batch in batched_data: - image_name = [item.class_image_path for item in batch] - prompt = [item.prompt.format(identifier=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) - - warmup_steps = args.lr_warmup_epochs * num_update_steps_per_epoch * args.gradient_accumulation_steps - - if args.lr_scheduler == "one_cycle": - lr_scheduler = get_one_cycle_schedule( - optimizer=optimizer, - num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, - ) - elif args.lr_scheduler == "cosine_with_restarts": - lr_scheduler = get_cosine_with_hard_restarts_schedule_with_warmup( - optimizer=optimizer, - num_warmup_steps=warmup_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 - warmup_steps) / num_update_steps_per_epoch))), - ) - else: - lr_scheduler = get_scheduler( - args.lr_scheduler, - optimizer=optimizer, - num_warmup_steps=warmup_steps, - num_training_steps=args.max_train_steps * args.gradient_accumulation_steps, - ) - - unet_lora, optimizer, train_dataloader, val_dataloader, lr_scheduler = accelerator.prepare( - unet_lora, optimizer, train_dataloader, val_dataloader, lr_scheduler - ) - - # Move text_encoder and vae to device - vae.to(accelerator.device, dtype=weight_dtype) - unet.to(accelerator.device, dtype=weight_dtype) - text_encoder.to(accelerator.device, dtype=weight_dtype) - - # Keep text_encoder and vae in eval mode as we don't train these - vae.eval() - unet.eval() - text_encoder.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: - config = vars(args).copy() - config["initializer_token"] = " ".join(config["initializer_token"]) - config["placeholder_token"] = " ".join(config["placeholder_token"]) - accelerator.init_trackers("lora", config=config) - - # 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 - - avg_loss = AverageMeter() - avg_acc = AverageMeter() - - avg_loss_val = AverageMeter() - avg_acc_val = AverageMeter() - - max_acc_val = 0.0 - - checkpointer = Checkpointer( - datamodule=datamodule, - accelerator=accelerator, - vae=vae, - unet=unet, - tokenizer=tokenizer, - text_encoder=text_encoder, - scheduler=checkpoint_scheduler, - unet_lora=unet_lora, - output_dir=basepath, - instance_identifier=instance_identifier, - placeholder_token=args.placeholder_token, - placeholder_token_id=placeholder_token_id, - 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.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() - - unet_lora.train() - - for step, batch in enumerate(train_dataloader): - with accelerator.accumulate(unet_lora): - # 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"], batch["attention_mask"]) - - # Predict the noise residual - model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - # Get the target for loss depending on the prediction type - if noise_scheduler.config.prediction_type == "epsilon": - target = noise - elif noise_scheduler.config.prediction_type == "v_prediction": - target = noise_scheduler.get_velocity(latents, noise, timesteps) - else: - raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") - - if args.num_class_images != 0: - # Chunk the noise and model_pred into two parts and compute the loss on each part separately. - model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) - target, target_prior = torch.chunk(target, 2, dim=0) - - # Compute instance loss - loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") - - # Compute prior loss - prior_loss = F.mse_loss(model_pred_prior.float(), target_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(model_pred.float(), target.float(), reduction="mean") - - acc = (model_pred == latents).float().mean() - - accelerator.backward(loss) - - if accelerator.sync_gradients: - accelerator.clip_grad_norm_(unet_lora.parameters(), args.max_grad_norm) - - optimizer.step() - if not accelerator.optimizer_step_was_skipped: - lr_scheduler.step() - optimizer.zero_grad(set_to_none=True) - - with torch.no_grad(): - text_encoder.get_input_embeddings( - ).weight[index_fixed_tokens] = original_token_embeds[index_fixed_tokens] - - avg_loss.update(loss.detach_(), bsz) - avg_acc.update(acc.detach_(), bsz) - - # Checks if the accelerator has performed an optimization step behind the scenes - if accelerator.sync_gradients: - local_progress_bar.update(1) - global_progress_bar.update(1) - - global_step += 1 - - logs = { - "train/loss": avg_loss.avg.item(), - "train/acc": avg_acc.avg.item(), - "train/cur_loss": loss.item(), - "train/cur_acc": acc.item(), - "lr/unet": lr_scheduler.get_last_lr()[0], - "lr/text": lr_scheduler.get_last_lr()[1] - } - - accelerator.log(logs, step=global_step) - - local_progress_bar.set_postfix(**logs) - - if global_step >= args.max_train_steps: - break - - accelerator.wait_for_everyone() - - unet_lora.eval() - - with torch.inference_mode(): - for step, batch in enumerate(val_dataloader): - 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"], batch["attention_mask"]) - - model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - # Get the target for loss depending on the prediction type - if noise_scheduler.config.prediction_type == "epsilon": - target = noise - elif noise_scheduler.config.prediction_type == "v_prediction": - target = noise_scheduler.get_velocity(latents, noise, timesteps) - else: - raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") - - loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") - - acc = (model_pred == latents).float().mean() - - avg_loss_val.update(loss.detach_(), bsz) - avg_acc_val.update(acc.detach_(), bsz) - - if accelerator.sync_gradients: - local_progress_bar.update(1) - global_progress_bar.update(1) - - logs = { - "val/loss": avg_loss_val.avg.item(), - "val/acc": avg_acc_val.avg.item(), - "val/cur_loss": loss.item(), - "val/cur_acc": acc.item(), - } - local_progress_bar.set_postfix(**logs) - - accelerator.log({ - "val/loss": avg_loss_val.avg.item(), - "val/acc": avg_acc_val.avg.item(), - }, step=global_step) - - local_progress_bar.clear() - global_progress_bar.clear() - - if avg_acc_val.avg.item() > max_acc_val: - accelerator.print( - f"Global step {global_step}: Validation accuracy reached new maximum: {max_acc_val:.2e} -> {avg_acc_val.avg.item():.2e}") - max_acc_val = avg_acc_val.avg.item() - - if accelerator.is_main_process: - if (epoch + 1) % args.sample_frequency == 0: - checkpointer.save_samples(global_step, 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.save_model() - - accelerator.end_training() - - except KeyboardInterrupt: - if accelerator.is_main_process: - print("Interrupted, saving checkpoint and resume state...") - checkpointer.save_model() - accelerator.end_training() - quit() - - -if __name__ == "__main__": - main() diff --git a/train_ti.py b/train_ti.py index 8ada98c..5df6850 100644 --- a/train_ti.py +++ b/train_ti.py @@ -3,9 +3,9 @@ import math import datetime import logging from pathlib import Path +from functools import partial import torch -import torch.nn.functional as F import torch.utils.checkpoint from accelerate import Accelerator @@ -18,9 +18,10 @@ from tqdm.auto import tqdm from transformers import CLIPTextModel from slugify import slugify -from common import load_config, load_embeddings_from_dir +from util import load_config, load_embeddings_from_dir from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion from data.csv import CSVDataModule, CSVDataItem +from training.common import run_model from training.optimization import get_one_cycle_schedule from training.lr import LRFinder from training.util import AverageMeter, CheckpointerBase, save_args @@ -570,8 +571,8 @@ def main(): if not embeddings_dir.exists() or not embeddings_dir.is_dir(): raise ValueError("--embeddings_dir must point to an existing directory") - added_tokens_from_dir = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir) - print(f"Added {len(added_tokens_from_dir)} tokens from embeddings dir: {added_tokens_from_dir}") + added_tokens, added_ids = load_embeddings_from_dir(tokenizer, embeddings, embeddings_dir) + print(f"Added {len(added_tokens)} tokens from embeddings dir: {zip(added_tokens, added_ids)}") # Convert the initializer_token, placeholder_token to ids initializer_token_ids = [ @@ -579,13 +580,15 @@ def main(): for token in args.initializer_token ] - new_tokens = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors) + new_ids = tokenizer.add_multi_tokens(args.placeholder_token, args.num_vectors) embeddings.resize(len(tokenizer)) - for (new_token, init_ids) in zip(new_tokens, initializer_token_ids): - embeddings.add_embed(new_token.ids, init_ids) + init_ratios = [ + embeddings.add_embed(new_id, init_ids) + for (new_id, init_ids) in zip(new_ids, initializer_token_ids) + ] - print(f"Added {len(new_tokens)} new tokens.") + print(f"Added {len(new_ids)} new tokens: {zip(args.placeholder_token, new_ids, init_ratios)}") vae.requires_grad_(False) unet.requires_grad_(False) @@ -807,63 +810,16 @@ def main(): def on_eval(): tokenizer.eval() - def loop(step: int, batch, eval: bool = False): - # Convert images to latent space - latents = vae.encode(batch["pixel_values"]).latent_dist.sample().detach() - 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_gen = torch.Generator(device=latents.device).manual_seed(args.seed + step) if eval else None - timesteps = torch.randint( - 0, - noise_scheduler.config.num_train_timesteps, - (bsz,), - generator=timesteps_gen, - 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"], batch["attention_mask"]) - encoder_hidden_states = encoder_hidden_states.to(dtype=weight_dtype) - - # Predict the noise residual - model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample - - # Get the target for loss depending on the prediction type - if noise_scheduler.config.prediction_type == "epsilon": - target = noise - elif noise_scheduler.config.prediction_type == "v_prediction": - target = noise_scheduler.get_velocity(latents, noise, timesteps) - else: - raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") - - if args.num_class_images != 0: - # Chunk the noise and model_pred into two parts and compute the loss on each part separately. - model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) - target, target_prior = torch.chunk(target, 2, dim=0) - - # Compute instance loss - loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") - - # Compute prior loss - prior_loss = F.mse_loss(model_pred_prior.float(), target_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(model_pred.float(), target.float(), reduction="mean") - - acc = (model_pred == target).float().mean() - - return loss, acc, bsz + loop = partial( + run_model, + vae=vae, + noise_scheduler=noise_scheduler, + unet=unet, + prompt_processor=prompt_processor, + num_class_images=args.num_class_images, + prior_loss_weight=args.prior_loss_weight, + seed=args.seed, + ) # We need to initialize the trackers we use, and also store our configuration. # The trackers initializes automatically on the main process. diff --git a/training/common.py b/training/common.py new file mode 100644 index 0000000..99a6e67 --- /dev/null +++ b/training/common.py @@ -0,0 +1,75 @@ +import torch +import torch.nn.functional as F + +from diffusers import AutoencoderKL, DDPMScheduler, UNet2DConditionModel + + +def run_model( + vae: AutoencoderKL, + noise_scheduler: DDPMScheduler, + unet: UNet2DConditionModel, + prompt_processor, + num_class_images: int, + prior_loss_weight: float, + seed: int, + step: int, + batch, + eval: bool = False +): + # Convert images to latent space + latents = vae.encode(batch["pixel_values"]).latent_dist.sample().detach() + 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_gen = torch.Generator(device=latents.device).manual_seed(seed + step) if eval else None + timesteps = torch.randint( + 0, + noise_scheduler.config.num_train_timesteps, + (bsz,), + generator=timesteps_gen, + 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) + noisy_latents = noisy_latents.to(dtype=unet.dtype) + + # Get the text embedding for conditioning + encoder_hidden_states = prompt_processor.get_embeddings(batch["input_ids"], batch["attention_mask"]) + encoder_hidden_states = encoder_hidden_states.to(dtype=unet.dtype) + + # Predict the noise residual + model_pred = unet(noisy_latents, timesteps, encoder_hidden_states).sample + + # Get the target for loss depending on the prediction type + if noise_scheduler.config.prediction_type == "epsilon": + target = noise + elif noise_scheduler.config.prediction_type == "v_prediction": + target = noise_scheduler.get_velocity(latents, noise, timesteps) + else: + raise ValueError(f"Unknown prediction type {noise_scheduler.config.prediction_type}") + + if num_class_images != 0: + # Chunk the noise and model_pred into two parts and compute the loss on each part separately. + model_pred, model_pred_prior = torch.chunk(model_pred, 2, dim=0) + target, target_prior = torch.chunk(target, 2, dim=0) + + # Compute instance loss + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + # Compute prior loss + prior_loss = F.mse_loss(model_pred_prior.float(), target_prior.float(), reduction="mean") + + # Add the prior loss to the instance loss. + loss = loss + prior_loss_weight * prior_loss + else: + loss = F.mse_loss(model_pred.float(), target.float(), reduction="mean") + + acc = (model_pred == target).float().mean() + + return loss, acc, bsz diff --git a/util.py b/util.py new file mode 100644 index 0000000..545bcb5 --- /dev/null +++ b/util.py @@ -0,0 +1,45 @@ +from pathlib import Path +import json + +from models.clip.embeddings import ManagedCLIPTextEmbeddings +from models.clip.tokenizer import MultiCLIPTokenizer + +from safetensors import safe_open + + +def load_config(filename): + with open(filename, 'rt') as f: + config = json.load(f) + + args = config["args"] + + if "base" in config: + args = load_config(Path(filename).parent.joinpath(config["base"])) | args + + return args + + +def load_embeddings_from_dir(tokenizer: MultiCLIPTokenizer, embeddings: ManagedCLIPTextEmbeddings, embeddings_dir: Path): + if not embeddings_dir.exists() or not embeddings_dir.is_dir(): + return [] + + filenames = [filename for filename in embeddings_dir.iterdir() if filename.is_file()] + tokens = [filename.stem for filename in filenames] + + new_ids: list[list[int]] = [] + new_embeds = [] + + for filename in filenames: + with safe_open(filename, framework="pt", device="cpu") as file: + embed = file.get_tensor("embed") + + added = tokenizer.add_multi_tokens(filename.stem, embed.shape[0]) + new_ids.append(added) + new_embeds.append(embed) + + embeddings.resize(len(tokenizer)) + + for (new_id, embeds) in zip(new_ids, new_embeds): + embeddings.add_embed(new_id, embeds) + + return tokens, new_ids -- cgit v1.2.3-54-g00ecf