src/models/sd.py

"""Vanilla Unconditonal Stable Diffusion."""

import math
import time
import torch
from torch import nn
from typing import List
from collections import OrderedDict
try:
    from IPython import get_ipython
    if 'ipykernel' in str(type(get_ipython())):
        from tqdm.notebook import tqdm
    else:
        from tqdm import tqdm
except ImportError:
    from tqdm import tqdm


from diffusers import AutoencoderKL, UNet2DConditionModel, UNet2DModel
from transformers import CLIPTokenizer, CLIPTextModel
from diffusers import (
    PNDMScheduler,
    EulerDiscreteScheduler,
    EulerAncestralDiscreteScheduler,
    DPMSolverSinglestepScheduler,
    DDIMScheduler,
    DDPMScheduler,
)
from src.utils.dataset_util import map_tensor_range
from src.utils.logging_util import LoggingUtils


logger = LoggingUtils.configure_logger(log_name=__name__)




class UnconditionalStableDiffusion(torch.nn.Module):
    
    def __init__(
        self,
        args,
        model_id: str = "stabilityai/stable-diffusion-2-1-base",
        num_steps: int = 999,
        sample_height: int = 512,
        sample_width: int = 512,
        latent_height: int = 64,
        latent_width: int = 64,
        latent_channels: int = 4,
        model_range: tuple = (-1., 1.),
        device: torch.device = None,
        dtype: torch.dtype = torch.float32,
        is_text_conditional: bool = True,
    ):
        super().__init__()
        
        if args is not None:
            for k, v in vars(args).items():
                setattr(self, k, v)
        
        self.device          = device
        self.num_steps       = num_steps
        self.model_range     = model_range
        self.sample_height   = sample_height
        self.sample_width    = sample_width
        self.latent_height   = latent_height
        self.latent_width    = latent_width
        self.latent_channels = latent_channels
        
        self.is_text_conditional = is_text_conditional
        
        self.dtype = dtype
        self.device_type = str(self.device).split(":")[0]
        self.enable_amp = self.dtype != torch.float
        print(f"[Stable Diffusion] AMP enabled: {self.enable_amp}")
        
        if self.is_text_conditional:
            print("[Stable Diffusion] Loading Text Conditional Model")
            self.tokenizer    = CLIPTokenizer.from_pretrained(model_id, subfolder="tokenizer")
            self.scheduler    = DDPMScheduler.from_pretrained(model_id, subfolder="scheduler")
            self.vae          = AutoencoderKL.from_pretrained(model_id, subfolder="vae", torch_dtype=dtype).to(device)
            self.text_encoder = CLIPTextModel.from_pretrained(model_id, subfolder="text_encoder", torch_dtype=dtype).to(device)
            self.unet         = UNet2DConditionModel.from_pretrained(model_id, subfolder="unet", torch_dtype=dtype).to(device)
        else:
            print("[Stable Diffusion] Loading Unconditional Model")
            self.scheduler    = DDPMScheduler.from_pretrained(model_id, subfolder="scheduler")
            self.vae          = AutoencoderKL.from_pretrained(model_id, subfolder="vae", torch_dtype=dtype).to(device)
            self.unet         = UNet2DModel.from_pretrained(model_id, subfolder="unet", torch_dtype=dtype).to(device)
        
        # if you have xFormers installed, this is even more efficient:
        # self.unet.enable_xformers_memory_efficient_attention()
        
        self.scheduler.set_timesteps(self.num_steps)
        self.scheduler.timesteps = self.scheduler.timesteps.to(device)
        print(f"[Stable Diffusion] len(scheduler.timesteps): {len(self.scheduler.timesteps)}")
        
        self.to(device)
    
    
    def vae_encode_no_grad(self, points, batch_size, sample_posterior=True, scale_latents=True, use_tqdm=True):
        """Function to encode exemplars via VAE."""
        
        with torch.no_grad():
            all_encoded = self.vae_encode_with_grad(points, batch_size, sample_posterior, scale_latents, use_tqdm)
        
        return all_encoded
    
    
    def vae_encode_with_grad(self, points, batch_size, sample_posterior=True, scale_latents=True, use_tqdm=True):
        """Function to encode exemplars via VAE."""
        
        chunks = torch.split(points, batch_size) # [[k,3,H,W], ..]
        processed_chunks = []
        iter = tqdm(chunks, desc="VAE Encoding") if use_tqdm else chunks
        for chunk in iter:
            with torch.autocast(device_type=self.device_type, dtype=self.dtype, enabled=self.enable_amp):
                encoded = self.vae.encode(chunk).latent_dist
            encoded = encoded.sample() if sample_posterior else encoded.mode()
            if scale_latents:
                encoded = encoded * self.vae.config.scaling_factor
            processed_chunks.append(encoded)
        
        all_encoded = torch.cat(processed_chunks, dim=0) # [K,lc,lh,lw]
        return all_encoded
    
    
    def vae_decode_no_grad(self, points, batch_size, unscale_latents=True, use_tqdm=True):
        """Function to decode exemplars via VAE."""
        
        with torch.no_grad():
            all_decoded = self.vae_decode_with_grad(points, batch_size, unscale_latents, use_tqdm)
        
        return all_decoded
    
    
    def vae_decode_with_grad(self, points, batch_size, unscale_latents=True, use_tqdm=True):
        """Function to decode exemplars via VAE."""
        
        chunks = torch.split(points, batch_size) # [[k,lc,lh,lw], ..]
        processed_chunks = []
        iter = tqdm(chunks, desc="VAE Decoding") if use_tqdm else chunks
        for chunk in iter:
            with torch.autocast(device_type=self.device_type, dtype=self.dtype, enabled=self.enable_amp):
                if unscale_latents:
                    decoded = self.vae.decode(chunk / self.vae.config.scaling_factor).sample
                else:
                    decoded = self.vae.decode(chunk).sample
            processed_chunks.append(decoded)
        
        all_decoded = torch.cat(processed_chunks, dim=0) # [K,3,H,W]
        return all_decoded
    
    
    def phi(self, latents, t, encoder_hidden_states):
        """Wrapper function for UNet model."""
        
        with torch.autocast(device_type=self.device_type, dtype=self.dtype, enabled=self.enable_amp):
            if self.is_text_conditional:
                noise_pred = self.unet(latents, t, encoder_hidden_states=encoder_hidden_states).sample
            else:
                noise_pred = self.unet(latents, t).sample
        
        return noise_pred
    
    
    def convert_decoded_latents(self, decoded, batch_size, clamp=True, use_tqdm=True):
        """Function to convert decoded latents to numpy / visualisation-ready tensors."""
        
        chunks = torch.split(decoded, batch_size) # [[k,3,h,w], ..]
        processed_chunks = []
        iter = tqdm(chunks, desc="Convertting decoded latents") if use_tqdm else chunks
        for chunk in iter:
            with torch.autocast(device_type=self.device_type, dtype=self.dtype, enabled=self.enable_amp):
                processed_chunk = map_tensor_range(
                    tensor    = chunk,
                    in_range  = self.model_range,
                    out_range = (0., 1.),
                )
                if clamp:
                    processed_chunk = processed_chunk.clamp(0, 1)
            processed_chunks.append(processed_chunk)
        
        all_processed = torch.cat(processed_chunks, dim=0) # [K,3,H,W]
        return all_processed
    
    
    def get_empty_prompt_embeddings(self, num_samples):
        """Function to get `num_images` embedded tokens of empty string for unconditional diffusion."""
        
        if self.is_text_conditional:
            prompts = [""] * num_samples
            conditional_tokens = self.tokenizer(
                prompts, 
                padding="max_length",
                max_length=self.tokenizer.model_max_length,
                truncation=True, 
                return_tensors="pt"
            )
            unconditional_tokens = self.tokenizer(
                prompts, 
                padding="max_length",
                max_length=self.tokenizer.model_max_length,
                return_tensors="pt"
            )
            with torch.autocast(device_type=self.device_type, dtype=self.dtype, enabled=self.enable_amp):
                conditional_emb = self.text_encoder(conditional_tokens.input_ids.to(self.device))[0]
                unconditional_emb = self.text_encoder(unconditional_tokens.input_ids.to(self.device))[0]
            
            emb = torch.cat([unconditional_emb, conditional_emb], dim=0)
        else:
            emb = None  # dummy return value (not usesd anyway)
        
        return emb
    
    
    def configure_train(self, vae=True, unet=True, text_encoder=True):
        """
        Set training mode and unfreeze all weights.
        """
        self.train()
        self._set_requires_grad(self.vae, vae)
        self._set_requires_grad(self.unet, unet)
        if self.is_text_conditional:
            self._set_requires_grad(self.text_encoder, text_encoder)
    
    
    def configure_eval(self, vae=False, unet=False, text_encoder=False):
        """
        Set evaluation mode and freeze all weights.
        """
        self.eval()
        self._set_requires_grad(self.vae, vae)
        self._set_requires_grad(self.unet, unet)
        if self.is_text_conditional:
            self._set_requires_grad(self.text_encoder, text_encoder)
    
    
    def _set_requires_grad(self, module: nn.Module, requires: bool):
        for p in module.parameters():
            p.requires_grad = requires




    "00_no_projection"
    def backward_process(self, num_images, prior=torch.randn, decode_intermediates=False, intermediates_idx=[]):
        """
        Function to generate `num_images` samples with unconditional latent diffusion.
        """
        
        # Storing decoded intermediate latents & time benchmarking
        intermediates = {
            "model_raw": [],
            "latents": [],
            "latents_decoded": [],
        }
        
        with torch.no_grad():
            
            # dummy prompt embeds
            uncond_prompt_embs = self.get_empty_prompt_embeddings(num_images)
            cfg_guidance_scale = 0.   # disable cfg
            
            # Sample initial latents, z_{T}
            latents = prior(
                (num_images, self.latent_channels, self.latent_height, self.latent_width),
                device = self.device
            ) * self.scheduler.init_noise_sigma
            
            for step_idx, t in enumerate(tqdm(self.scheduler.timesteps, desc="Diffusion Steps")):
                
                # predict noise
                twice = torch.cat([latents] * 2, dim=0)
                noise_pred = self.phi(twice, t, encoder_hidden_states=uncond_prompt_embs)
                
                # classifier-free guidance
                u, c = noise_pred.chunk(2)
                guided = u + cfg_guidance_scale * (c - u)
                
                # z_{t} -> z_{t-1}
                latents = self.scheduler.step(guided, t, latents).prev_sample
                
                to_keep = torch.stack([guide for idx,guide in enumerate(guided) if idx in intermediates_idx])
                intermediates["model_raw"].append(to_keep.detach().clone().to(self.dtype))
                to_keep = torch.stack([latent for idx,latent in enumerate(latents) if idx in intermediates_idx])
                intermediates["latents"].append(to_keep.detach().clone().to(self.dtype))
                decoded = self.vae_decode_no_grad(latents, num_images, use_tqdm=False)
                to_keep = torch.stack([inter for idx,inter in enumerate(decoded) if idx in intermediates_idx])
                intermediates["latents_decoded"].append(to_keep.detach().clone().to(self.dtype))
                
            
            # decode latents
            samples = self.vae_decode_no_grad(latents, num_images, use_tqdm=False)
            
            # denormalize
            samples = self.convert_decoded_latents(samples, num_images, clamp=True).detach()
            
            intermediates["latents_decoded"] = torch.cat(intermediates["latents_decoded"], dim=0)
            intermediates["latents_decoded"] = self.convert_decoded_latents(intermediates["latents_decoded"], num_images, clamp=True)
            intermediates["latents_decoded"] = list(torch.split(intermediates["latents_decoded"], len(intermediates_idx), dim=0))
        
        return samples, intermediates