path: root/dreambooth_plus.py

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
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

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(
        "--placeholder_token",
        type=str,
        default=None,
        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 per training image."
    )
    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=1600,
        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=5e-6,
        help="Initial learning rate (after the potential warmup period) to use.",
    )
    parser.add_argument(
        "--learning_rate_text",
        type=float,
        default=5e-4,
        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",
        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=500,
        help="Number of steps for the warmup 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=6 / 7
    )
    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(
        "--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 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,
        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.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):
        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.placeholder_token)
                              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'
                    )["sample"]

                    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)

    # If passed along, set the training seed now.
    if args.seed is not None:
        set_seed(args.seed)

    # 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')

    # Add the placeholder token in tokenizer
    num_added_tokens = tokenizer.add_tokens(args.placeholder_token)
    if num_added_tokens == 0:
        raise ValueError(
            f"The tokenizer already contains the token {args.placeholder_token}. Please pass a different"
            " `placeholder_token` that is not already in the tokenizer."
        )

    # Convert the initializer_token, placeholder_token to ids
    initializer_token_ids = tokenizer.encode(args.initializer_token, add_special_tokens=False)
    # Check if initializer_token is a single token or a sequence of tokens
    if len(initializer_token_ids) > 1:
        raise ValueError(
            f"initializer_token_ids must not have more than 1 vector, but it's {len(initializer_token_ids)}.")

    initializer_token_ids = torch.tensor(initializer_token_ids)
    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

    if args.gradient_checkpointing:
        unet.enable_gradient_checkpointing()

    # 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
    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
    )

    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=torch.float32, memory_format=torch.contiguous_format)

        input_ids = tokenizer.pad({"input_ids": input_ids}, padding=True, return_tensors="pt").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,
        tokenizer=tokenizer,
        instance_identifier=args.placeholder_token,
        class_identifier=args.initializer_token,
        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 = [p.class_image_path for p in batch]
                    prompt = [p.prompt.format(args.initializer_token) for p in batch]
                    nprompt = [p.nprompt for p 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

    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)

    # 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,
        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(latents.shape).to(latents.device)
                    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 = text_encoder(batch["input_ids"])[0]

                    # 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, noise, reduction="none").mean([1, 2, 3]).mean()

                        # Compute prior loss
                        prior_loss = F.mse_loss(noise_pred_prior, noise_prior, reduction="none").mean([1, 2, 3]).mean()

                        # Add the prior loss to the instance loss.
                        loss = loss + args.prior_loss_weight * prior_loss
                    else:
                        loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()

                    accelerator.backward(loss)

                    # Zero out the gradients for all token embeddings except the newly added
                    # embeddings for the concept, as we only want to optimize the concept embeddings
                    if accelerator.num_processes > 1:
                        grads = text_encoder.module.get_input_embeddings().weight.grad
                    else:
                        grads = text_encoder.get_input_embeddings().weight.grad
                    # Get the index for tokens that we want to zero the grads for
                    index_grads_to_zero = torch.arange(len(tokenizer)) != placeholder_token_id
                    grads.data[index_grads_to_zero, :] = grads.data[index_grads_to_zero, :].fill_(0)

                    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

                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(latents.shape).to(latents.device)
                    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 = text_encoder(batch["input_ids"])[0]

                    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, noise, reduction="none").mean([1, 2, 3]).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:
                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()

            accelerator.end_training()

    except KeyboardInterrupt:
        if accelerator.is_main_process:
            print("Interrupted, saving checkpoint and resume state...")
            checkpointer.checkpoint()
            accelerator.end_training()
        quit()


if __name__ == "__main__":
    main()