patch-forcing/patch_flow/trainer.py

import torch
import torch.nn as nn
from typing import Union
from copy import deepcopy
from omegaconf import DictConfig
from collections import OrderedDict
from lightning import LightningModule
import warnings

from jutils import instantiate_from_config
from jutils import load_partial_from_config
from jutils import exists, freeze, default

from patch_flow.log_utils import log_images
from patch_flow.metrics import ImageMetricTracker
from patch_flow.diagonal_gaussian import DiagonalGaussian
from torchmetrics.aggregation import CatMetric


def un_normalize_ims(ims):
    """Convert from [-1, 1] to [0, 255]"""
    ims = ((ims * 127.5) + 127.5).clip(0, 255).to(torch.uint8)
    return ims


@torch.no_grad()
def update_ema(ema_model, model, decay=0.9999):
    """
    Step the EMA model towards the current model.
    """
    ema_params = OrderedDict(ema_model.named_parameters())
    model_params = OrderedDict(model.named_parameters())

    for name, param in model_params.items():
        if not param.requires_grad:
            continue
        # unwrap DDP
        if name.startswith("module."):
            name = name.replace("module.", "")
        ema_params[name].mul_(decay).add_(param.data, alpha=1 - decay)


def instantiate_if_needed(config_or_obj):
    if isinstance(config_or_obj, nn.Module):
        return config_or_obj
    elif isinstance(config_or_obj, dict) or isinstance(config_or_obj, DictConfig):
        return instantiate_from_config(config_or_obj)
    else:
        raise ValueError(f"Expected nn.Module or config dict, got {type(config_or_obj)}")


# ===================================================================================================


class LatentFlowTrainer(LightningModule):
    def __init__(
        self,
        model: Union[dict, DictConfig, nn.Module],
        first_stage: Union[dict, DictConfig, nn.Module],
        flow: Union[dict, DictConfig, object],
        # learning
        lr: float = 1e-4,
        weight_decay: float = 0.0,
        ema_rate: float = 0.9999,
        lr_scheduler_cfg: dict = None,
        # logging
        sample_kwargs: dict = None,
    ):
        super().__init__()

        # flow logic
        self.flow = instantiate_if_needed(flow)

        # unet/transformer model
        self.model = instantiate_if_needed(model)

        # EMA of unet/transformer model
        self.ema_model = None
        self.ema_rate = ema_rate
        if ema_rate > 0:
            if isinstance(model, nn.Module):
                warnings.warn("EMA model with deepcopy, might run into issues with compile.")
                self.ema_model = deepcopy(self.model)
            else:
                self.ema_model = instantiate_if_needed(model)
                self.ema_model.load_state_dict(self.model.state_dict())
            freeze(self.ema_model)
            self.ema_model.eval()
            update_ema(self.ema_model, self.model, decay=0)  # ensure EMA is in sync

        # first stage autoencoder
        self.first_stage = instantiate_if_needed(first_stage)
        self.first_stage.eval().to(self.device)
        freeze(self.first_stage)

        # training parameters
        self.lr = lr
        self.weight_decay = weight_decay
        self.lr_scheduler_cfg = lr_scheduler_cfg

        # visualization
        self.sample_kwargs = sample_kwargs or {}
        self.generator = torch.Generator()

        # evaluation
        self.metric_tracker = ImageMetricTracker().to(self.device)

        # SD3 & Meta Movie Gen show that val loss correlates with human quality
        # and compute the loss in equidistant segments in (0, 1) to reduce variance
        self.val_losses = CatMetric().to(self.device)  # sync across GPUs
        self.val_images = None
        self.val_epochs = 0

        self.save_hyperparameters()

        # signal handler for slurm, flag to make sure the signal
        # is not handled at an incorrect state, e.g. during weights update

    def configure_optimizers(self):
        opt = torch.optim.AdamW(
            [p for p in self.parameters() if p.requires_grad], lr=self.lr, weight_decay=self.weight_decay
        )
        out = dict(optimizer=opt)
        if exists(self.lr_scheduler_cfg):
            sch = load_partial_from_config(self.lr_scheduler_cfg)
            sch = sch(optimizer=opt)
            out["lr_scheduler"] = sch
        return out

    def on_train_batch_end(self, outputs, batch, batch_idx):
        # first checking for trainer ensures that the module can be also used with accelerate
        if exists(self._trainer) and exists(self.lr_scheduler_cfg):
            self.lr_schedulers().step()
        if exists(self.ema_model):
            update_ema(self.ema_model, self.model, decay=self.ema_rate)

    # ===================================================================================================
    # training logic

    @torch.no_grad()
    def encode(self, x):
        return self.first_stage.encode(x) if exists(self.first_stage) else x

    @torch.no_grad()
    def decode(self, z):
        return self.first_stage.decode(z) if exists(self.first_stage) else z

    def forward(self, batch):
        ims = batch["image"]
        latent = batch.get("latent", None)
        if not exists(latent):
            latent = self.encode(ims)
        label = batch.get("label", None)

        # compute loss
        loss = self.flow.training_losses(model=self.model, x1=latent, y=label)

        return loss

    # ===================================================================================================
    # validation

    def validation_step(self, batch, batch_idx):
        ims = batch["image"]
        label = batch.get("label", None)
        latent = batch.get("latent", None)
        if latent is None:
            latent = self.encode(ims)
        bs = ims.shape[0]

        g = self.generator.manual_seed(batch_idx + self.global_rank * 16102024)
        noise = torch.randn(latent.shape, generator=g, dtype=ims.dtype).to(ims.device)
        sample_model = self.ema_model if exists(self.ema_model) else self.model

        # flow models val loss shows correlation with human quality
        if hasattr(self.flow, "validation_losses"):
            latent = default(latent, self.encode(ims))
            _, val_loss_per_segment = self.flow.validation_losses(model=sample_model, x1=latent, x0=noise, y=label)
            self.val_losses.update(val_loss_per_segment.unsqueeze(0))

        # sample images
        samples = self.flow.generate(model=sample_model, x=noise, y=label, **self.sample_kwargs)
        samples = self.decode(samples)

        # metrics
        self.metric_tracker(ims, samples)

        # save the images for visualization
        if self.val_images is None:
            real_ims = un_normalize_ims(ims)
            fake_ims = un_normalize_ims(samples)
            self.val_images = {
                "real": real_ims[:20],
                "fake": fake_ims[:20],
            }

    def on_validation_epoch_end(self):
        # visualization
        for key, ims in self.val_images.items():
            log_images(self.logger, ims, f"val/{key}/samples", stack="row", split=4, step=self.global_step)

        # reset val images
        self.val_images = None

        # compute metrics
        metrics = self.metric_tracker.aggregate()
        for k, v in metrics.items():
            self.log(f"val/{k}", v, sync_dist=True)
        self.metric_tracker.reset()

        # compute val loss if available (Flow models)
        if len(self.val_losses.value) > 0:
            val_losses = self.val_losses.compute()  # (N batches, segments)
            val_losses = val_losses.mean(0)  # mean per segment
            for i, loss in enumerate(val_losses):
                self.log(f"val/loss_segment_{i}", loss, sync_dist=True)
            self.log("val/loss", val_losses.mean(), sync_dist=True)
            self.val_losses.reset()

        # log some information
        self.val_epochs += 1
        self.print(f"Val epoch {self.val_epochs:,} | Optimizer step {self.global_step:,}")
        metric_str = " | ".join([f"{k}: {v:.4f}" for k, v in metrics.items()])
        self.print(metric_str)


# ===================================================================================================


class LatentPatchForcingTrainer(LatentFlowTrainer):
    def __init__(self, *args, uncertainty_weight: float = 0.01, **kwargs):
        super().__init__(*args, **kwargs)
        self.uncertainty_weight = uncertainty_weight
        assert (
            hasattr(self.model, "predict_uncertainty") and self.model.predict_uncertainty
        ), "Model should be PatchForcingDiT with predict_uncertainty=True."

    def forward(self, batch):
        ims = batch["image"]
        latent = batch.get("latent", None)
        if not exists(latent):
            latent = self.encode(ims)
        label = batch.get("label", None)

        # compute loss
        xt, ut, t = self.flow.get_interpolants(x1=latent)
        vt, logvar_theta = self.model(x=xt, t=t, y=label, return_uncertainty=True)

        # fm loss
        fm_loss = (vt - ut).square().mean()

        # uncertainty loss following SRM
        sigma_theta = torch.exp(0.5 * logvar_theta)
        pred_theta = DiagonalGaussian(mean=vt.detach(), std=sigma_theta)
        sigma_loss = pred_theta.nll(ut).mean()

        loss = fm_loss + self.uncertainty_weight * sigma_loss
        loss_dict = {"flow_loss": fm_loss, "sigma_loss": sigma_loss}

        return loss, loss_dict