path: root/training/common.py

import math
from contextlib import _GeneratorContextManager, nullcontext
from typing import Callable, Any, Tuple, Union

import torch
import torch.nn.functional as F
from torch.utils.data import DataLoader

from accelerate import Accelerator
from transformers import CLIPTextModel
from diffusers import AutoencoderKL, DDPMScheduler, UNet2DConditionModel, DPMSolverMultistepScheduler

from tqdm.auto import tqdm

from pipelines.stable_diffusion.vlpn_stable_diffusion import VlpnStableDiffusion
from models.clip.embeddings import ManagedCLIPTextEmbeddings, patch_managed_embeddings
from models.clip.util import get_extended_embeddings
from models.clip.tokenizer import MultiCLIPTokenizer
from training.util import AverageMeter, CheckpointerBase


def noop(*args, **kwards):
    pass


def noop_ctx(*args, **kwards):
    return nullcontext()


def noop_on_log():
    return {}


def generate_class_images(
    accelerator,
    text_encoder,
    vae,
    unet,
    tokenizer,
    scheduler,
    data_train,
    sample_batch_size,
    sample_image_size,
    sample_steps
):
    missing_data = [item for item in data_train if not item.class_image_path.exists()]

    if len(missing_data) == 0:
        return

    batched_data = [
        missing_data[i:i+sample_batch_size]
        for i in range(0, len(missing_data), sample_batch_size)
    ]

    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.cprompt for item in batch]
            nprompt = [item.nprompt for item in batch]

            images = pipeline(
                prompt=prompt,
                negative_prompt=nprompt,
                height=sample_image_size,
                width=sample_image_size,
                num_inference_steps=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()


def get_models(pretrained_model_name_or_path: str):
    tokenizer = MultiCLIPTokenizer.from_pretrained(pretrained_model_name_or_path, subfolder='tokenizer')
    text_encoder = CLIPTextModel.from_pretrained(pretrained_model_name_or_path, subfolder='text_encoder')
    vae = AutoencoderKL.from_pretrained(pretrained_model_name_or_path, subfolder='vae')
    unet = UNet2DConditionModel.from_pretrained(pretrained_model_name_or_path, subfolder='unet')
    noise_scheduler = DDPMScheduler.from_pretrained(pretrained_model_name_or_path, subfolder='scheduler')
    sample_scheduler = DPMSolverMultistepScheduler.from_pretrained(
        pretrained_model_name_or_path, subfolder='scheduler')

    vae.enable_slicing()
    vae.set_use_memory_efficient_attention_xformers(True)
    unet.set_use_memory_efficient_attention_xformers(True)

    embeddings = patch_managed_embeddings(text_encoder)

    return tokenizer, text_encoder, vae, unet, noise_scheduler, sample_scheduler, embeddings


def add_placeholder_tokens(
    tokenizer: MultiCLIPTokenizer,
    embeddings: ManagedCLIPTextEmbeddings,
    placeholder_tokens: list[str],
    initializer_tokens: list[str],
    num_vectors: Union[list[int], int]
):
    initializer_token_ids = [
        tokenizer.encode(token, add_special_tokens=False)
        for token in initializer_tokens
    ]
    placeholder_token_ids = tokenizer.add_multi_tokens(placeholder_tokens, num_vectors)

    embeddings.resize(len(tokenizer))

    for (placeholder_token_id, initializer_token_id) in zip(placeholder_token_ids, initializer_token_ids):
        embeddings.add_embed(placeholder_token_id, initializer_token_id)

    return placeholder_token_ids, initializer_token_ids


def loss_step(
    vae: AutoencoderKL,
    noise_scheduler: DDPMScheduler,
    unet: UNet2DConditionModel,
    text_encoder: CLIPTextModel,
    prior_loss_weight: float,
    seed: int,
    step: int,
    batch: dict[str, Any],
    eval: bool = False
):
    # Convert images to latent space
    latents = vae.encode(batch["pixel_values"]).latent_dist.sample().detach()
    latents = latents * 0.18215

    generator = torch.Generator(device=latents.device).manual_seed(seed + step) if eval else None

    # Sample noise that we'll add to the latents
    noise = torch.randn(
        latents.shape,
        dtype=latents.dtype,
        layout=latents.layout,
        device=latents.device,
        generator=generator
    )
    bsz = latents.shape[0]
    # Sample a random timestep for each image
    timesteps = torch.randint(
        0,
        noise_scheduler.config.num_train_timesteps,
        (bsz,),
        generator=generator,
        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 = get_extended_embeddings(
        text_encoder,
        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 batch["with_prior"].all():
        # 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


def train_loop(
    accelerator: Accelerator,
    optimizer: torch.optim.Optimizer,
    lr_scheduler: torch.optim.lr_scheduler._LRScheduler,
    model: torch.nn.Module,
    checkpointer: CheckpointerBase,
    train_dataloader: DataLoader,
    val_dataloader: DataLoader,
    loss_step: Union[Callable[[int, Any], Tuple[Any, Any, int]], Callable[[int, Any, bool], Tuple[Any, Any, int]]],
    sample_frequency: int = 10,
    checkpoint_frequency: int = 50,
    global_step_offset: int = 0,
    num_epochs: int = 100,
    on_log: Callable[[], dict[str, Any]] = noop_on_log,
    on_train: Callable[[int], _GeneratorContextManager] = noop_ctx,
    on_before_optimize: Callable[[int], None] = noop,
    on_after_optimize: Callable[[float], None] = noop,
    on_eval: Callable[[], _GeneratorContextManager] = noop_ctx
):
    num_training_steps_per_epoch = math.ceil(len(train_dataloader) / accelerator.gradient_accumulation_steps)
    num_val_steps_per_epoch = len(val_dataloader)

    num_training_steps = num_training_steps_per_epoch * num_epochs
    num_val_steps = num_val_steps_per_epoch * num_epochs

    global_step = 0

    avg_loss = AverageMeter()
    avg_acc = AverageMeter()

    avg_loss_val = AverageMeter()
    avg_acc_val = AverageMeter()

    max_acc_val = 0.0

    local_progress_bar = tqdm(
        range(num_training_steps_per_epoch + num_val_steps_per_epoch),
        disable=not accelerator.is_local_main_process,
        dynamic_ncols=True
    )
    local_progress_bar.set_description(f"Epoch 1 / {num_epochs}")

    global_progress_bar = tqdm(
        range(num_training_steps + num_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):
            if accelerator.is_main_process:
                if epoch % sample_frequency == 0:
                    checkpointer.save_samples(global_step + global_step_offset)

                if epoch % checkpoint_frequency == 0 and epoch != 0:
                    checkpointer.checkpoint(global_step + global_step_offset, "training")

            local_progress_bar.set_description(f"Epoch {epoch + 1} / {num_epochs}")
            local_progress_bar.reset()

            model.train()

            with on_train(epoch):
                for step, batch in enumerate(train_dataloader):
                    with accelerator.accumulate(model):
                        loss, acc, bsz = loss_step(step, batch)

                        accelerator.backward(loss)

                        on_before_optimize(epoch)

                        optimizer.step()
                        lr_scheduler.step()
                        optimizer.zero_grad(set_to_none=True)

                        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:
                        on_after_optimize(lr_scheduler.get_last_lr()[0])

                        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": lr_scheduler.get_last_lr()[0],
                    }
                    logs.update(on_log())

                    accelerator.log(logs, step=global_step)

                    local_progress_bar.set_postfix(**logs)

                    if global_step >= num_training_steps:
                        break

            accelerator.wait_for_everyone()

            model.eval()

            cur_loss_val = AverageMeter()
            cur_acc_val = AverageMeter()

            with torch.inference_mode():
                with on_eval():
                    for step, batch in enumerate(val_dataloader):
                        loss, acc, bsz = loss_step(step, batch, True)

                        loss = loss.detach_()
                        acc = acc.detach_()

                        cur_loss_val.update(loss, bsz)
                        cur_acc_val.update(acc, bsz)

                        avg_loss_val.update(loss, bsz)
                        avg_acc_val.update(acc, bsz)

                        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)

            logs["val/cur_loss"] = cur_loss_val.avg.item()
            logs["val/cur_acc"] = cur_acc_val.avg.item()

            accelerator.log(logs, step=global_step)

            local_progress_bar.clear()
            global_progress_bar.clear()

            if accelerator.is_main_process:
                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}")
                    checkpointer.checkpoint(global_step + global_step_offset, "milestone")
                    max_acc_val = avg_acc_val.avg.item()

        # Create the pipeline using using the trained modules and save it.
        if accelerator.is_main_process:
            print("Finished!")
            checkpointer.checkpoint(global_step + global_step_offset, "end")
            checkpointer.save_samples(global_step + global_step_offset)
            accelerator.end_training()

    except KeyboardInterrupt:
        if accelerator.is_main_process:
            print("Interrupted")
            checkpointer.checkpoint(global_step + global_step_offset, "end")
            accelerator.end_training()
        quit()