model_lib/moMA_generator.py

import torch
from model_lib.attention_processor import IPAttnProcessor, IPAttnProcessor_Self, get_mask_from_cross
import tqdm
import diffusers

def get_subject_idx(model,prompt,src_subject,device):
    tokenized_prompt = model.tokenizer(prompt,padding="max_length",max_length=model.tokenizer.model_max_length,truncation=True,return_tensors="pt",).to(device)
    input_ids = tokenized_prompt['input_ids']
    src_subject_idxs = []
    for subject,input_id in zip(src_subject,input_ids):
        src_subject_token_id = [model.tokenizer.encode(i, add_special_tokens=False)[0] for i in subject.split(' ')]
        src_subject_idxs = [i for i, x in enumerate(input_id.tolist()) if x in src_subject_token_id]
    return [src_subject_idxs]


def add_function(model):
    @torch.no_grad()
    def generate_with_adapters(
        model,
        prompt_embeds,
        num_inference_steps,
        generator,
        t_range=list(range(0,950)),
    ):
        
        latents = model.prepare_latents(prompt_embeds.shape[0]//2,4,512,512,prompt_embeds.dtype,prompt_embeds.device,generator)

        model.scheduler.set_timesteps(num_inference_steps)

        iterator = tqdm.tqdm(model.scheduler.timesteps)
        mask_ig_prev = None
        for i, t in enumerate(iterator):
            if not t in t_range: 
                model.moMA_generator.toggle_enable_flag('cross')
            else:
                model.moMA_generator.toggle_enable_flag('all')

            latent_model_input = torch.cat([latents] * 2)
            noise_pred = model.unet(
                latent_model_input,
                t,
                encoder_hidden_states=prompt_embeds,
                return_dict=False,
            )[0]

            # perform guidance
            noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
            noise_pred = noise_pred_uncond + 7.5 * (noise_pred_text - noise_pred_uncond)

            latents = model.scheduler.step(noise_pred, t, latents, return_dict=False)[0]
            
            mask_ig_prev = (get_mask_from_cross(model.unet.attn_processors))[latents.shape[0]:]

            model.moMA_generator.set_self_mask('self','ig',mask_ig_prev)
            model.moMA_generator.set_self_mask('cross',mask=mask_ig_prev.clone().detach())

        image = model.vae.decode(latents / model.vae.config.scaling_factor, return_dict=False)[0]
        return image ,mask_ig_prev.repeat(1,3,1,1) if (not mask_ig_prev==None) else None
    model.generate_with_adapters = generate_with_adapters


class ImageProjModel(torch.nn.Module):
    """Projection Model"""
    def __init__(self, cross_attention_dim=1024, clip_embeddings_dim=1024, clip_extra_context_tokens=4):
        super().__init__()
        
        self.cross_attention_dim = cross_attention_dim
        self.clip_extra_context_tokens = clip_extra_context_tokens
        self.proj = torch.nn.Linear(clip_embeddings_dim, self.clip_extra_context_tokens * cross_attention_dim)
        self.norm = torch.nn.LayerNorm(cross_attention_dim)
        
    def forward(self, image_embeds):
        embeds = image_embeds
        clip_extra_context_tokens = self.proj(embeds).reshape(-1, self.clip_extra_context_tokens, self.cross_attention_dim)
        clip_extra_context_tokens = self.norm(clip_extra_context_tokens)
        return clip_extra_context_tokens


class MoMA_generator:
    def __init__(self, device,args):
        self.args = args
        self.device = device
        
        noise_scheduler = diffusers.DDIMScheduler(num_train_timesteps=1000,beta_start=0.00085,beta_end=0.012,beta_schedule="scaled_linear",clip_sample=False,set_alpha_to_one=False,steps_offset=1,)
        
        print('Loading VAE: stabilityai--sd-vae-ft-mse...')
        vae = diffusers.AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse")
        
        print('Loading StableDiffusion: Realistic_Vision...')
        self.pipe = diffusers.StableDiffusionPipeline.from_pretrained(
            "SG161222/Realistic_Vision_V4.0_noVAE",
            torch_dtype=torch.float16,
            scheduler=noise_scheduler,
            vae=vae,
            feature_extractor=None,
            safety_checker=None,
        ).to(self.device)

        self.unet = self.pipe.unet
        add_function(self.pipe)
        self.pipe.moMA_generator = self

        self.set_ip_adapter()
        self.image_proj_model = self.init_proj()

    def init_proj(self):
        image_proj_model = ImageProjModel(
            cross_attention_dim=768,
            clip_embeddings_dim=1024,
            clip_extra_context_tokens=4,
        ).to(self.device, dtype=torch.float16)
        return image_proj_model
        
    def set_ip_adapter(self):
        unet = self.unet
        attn_procs = {}
        for name in unet.attn_processors.keys():
            cross_attention_dim = None if name.endswith("attn1.processor") else unet.config.cross_attention_dim
            if name.startswith("mid_block"):
                hidden_size = unet.config.block_out_channels[-1]
            elif name.startswith("up_blocks"):
                block_id = int(name[len("up_blocks.")])
                hidden_size = list(reversed(unet.config.block_out_channels))[block_id]
            elif name.startswith("down_blocks"):
                block_id = int(name[len("down_blocks.")])
                hidden_size = unet.config.block_out_channels[block_id]
            if cross_attention_dim is None:
                attn_procs[name] = IPAttnProcessor_Self(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim,scale=1.0,num_tokens=4).to(self.device, dtype=torch.float16)
            else:
                attn_procs[name] = IPAttnProcessor(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim,scale=1.0,num_tokens=4).to(self.device, dtype=torch.float16)
        unet.set_attn_processor(attn_procs)

    @torch.inference_mode()
    def get_image_embeds_CFG(self, llava_emb):
        clip_image_embeds = llava_emb
        image_prompt_embeds = self.image_proj_model(clip_image_embeds)
        uncond_image_prompt_embeds = self.image_proj_model(torch.zeros_like(clip_image_embeds))
        return image_prompt_embeds, uncond_image_prompt_embeds
    
    def get_image_crossAttn_feature(
            self,
            llava_emb,
            num_samples=1,
    ):
        image_prompt_embeds, uncond_image_prompt_embeds = self.get_image_embeds_CFG(llava_emb)
        bs_embed, seq_len, _ = image_prompt_embeds.shape
        image_prompt_embeds = image_prompt_embeds.repeat(1, num_samples, 1)
        image_prompt_embeds = image_prompt_embeds.view(bs_embed * num_samples, seq_len, -1)
        uncond_image_prompt_embeds = uncond_image_prompt_embeds.repeat(1, num_samples, 1)
        uncond_image_prompt_embeds = uncond_image_prompt_embeds.view(bs_embed * num_samples, seq_len, -1)
        return image_prompt_embeds, uncond_image_prompt_embeds

    # feature are from self-attention layers of Unet: feed reference image to Unet with t=0
    def get_image_selfAttn_feature(
            self,
            pil_image,
            prompt,
    ):  
        self.toggle_enable_flag('self')
        self.toggle_extract_inject_flag('self', 'extract')
        tokenized_prompt = self.pipe.tokenizer(prompt,padding="max_length",truncation=True,return_tensors="pt",).to(self.device)
        text_embeddings = self.pipe.text_encoder(input_ids=tokenized_prompt.input_ids)[0]

        ref_image = pil_image
        ref_image.to(self.device)

        with torch.no_grad(): latents = self.pipe.vae.encode(ref_image).latent_dist.sample()
        latents = latents * self.pipe.vae.config.scaling_factor

        noise = torch.randn_like(latents)
        timesteps = torch.tensor([0],device=latents.device).long() # fixed to 0
        noisy_latents = self.pipe.scheduler.add_noise(latents, noise, timesteps)
        
        _ = self.unet(noisy_latents,timestep=timesteps,encoder_hidden_states=text_embeddings)["sample"]
        # features are stored in attn_processors

        return None
    
    @torch.no_grad()
    def generate_with_MoMA(
        self,
        batch,
        llava_emb=None,
        seed=None,
        device='cuda',
    ):
        self.reset_all()
        img_ig,mask_id,subject,prompt = batch['image'].half().to(device),batch['mask'].half().to(device),batch['label'][0],batch['text'][0]

        prompt = [f"photo of a {subject}. "+ prompt]
        subject_idx = get_subject_idx(self.pipe,prompt,[subject],self.device)
        negative_prompt = None 
            
        # get context-cross-attention feature (from MLLM decoder)
        cond_llava_embeds, uncond_llava_embeds = self.get_image_crossAttn_feature(llava_emb,num_samples=1)
        # get subject-cross-attention feature (from Unet)
        self.get_image_selfAttn_feature(img_ig,subject) # features are stored in attn_processors

        with torch.inference_mode():
            prompt_embeds = self.pipe._encode_prompt(
                prompt, device=self.device, num_images_per_prompt=1, do_classifier_free_guidance=True, negative_prompt=negative_prompt)
            negative_prompt_embeds_, prompt_embeds_ = prompt_embeds.chunk(2)
            prompt_embeds = torch.cat([prompt_embeds_, cond_llava_embeds], dim=1)
            negative_prompt_embeds = torch.cat([negative_prompt_embeds_, uncond_llava_embeds], dim=1)
            prompt_embeds = torch.cat([negative_prompt_embeds, prompt_embeds])

        generator = torch.Generator(self.device).manual_seed(seed) if seed is not None else None
        
        self.set_self_mask('eraseAll')
        self.toggle_enable_flag('all')
        self.toggle_extract_inject_flag('all','masked_generation')
        self.set_self_mask('self','id',mask_id) 
        self.set_cross_subject_idxs(subject_idx)
        
        images, mask = self.pipe.generate_with_adapters(
            self.pipe,
            prompt_embeds,
            50,
            generator,
        )
        images = torch.clip((images+1)/2.0,min=0.0,max=1.0)

        return images.cpu(), mask.cpu()
    
    def set_selfAttn_strength(self, strength):
        for attn_processor in self.unet.attn_processors.values():
            if isinstance(attn_processor, IPAttnProcessor):
                attn_processor.scale = 1.0
            if isinstance(attn_processor, IPAttnProcessor_Self):
                attn_processor.scale = strength

    def set_cross_subject_idxs(self, subject_idxs):
        for attn_processor in self.unet.attn_processors.values():
            if isinstance(attn_processor, IPAttnProcessor):
                attn_processor.subject_idxs = subject_idxs

    def set_self_mask(self,mode,id_ig='', mask=None): #only have effect on self attn of the generation process
        for attn_processor in self.unet.attn_processors.values():
            if mode == 'eraseAll':
                if isinstance(attn_processor, IPAttnProcessor_Self):
                    attn_processor.mask_id,attn_processor.mask_ig = None,None
                if isinstance(attn_processor, IPAttnProcessor):
                    attn_processor.mask_i, attn_processor.mask_ig_prev = None, None
            if mode == 'self':
                if isinstance(attn_processor, IPAttnProcessor_Self):
                    if id_ig == 'id':attn_processor.mask_id = mask
                    if id_ig == 'ig':attn_processor.mask_ig = mask
            if mode == 'cross':
                if isinstance(attn_processor, IPAttnProcessor):
                    attn_processor.mask_ig_prev = mask
    
    def toggle_enable_flag(self, processor_enable_mode):
        for attn_processor in self.unet.attn_processors.values():
            if processor_enable_mode == 'cross':
                if isinstance(attn_processor, IPAttnProcessor):attn_processor.enabled = True
                if isinstance(attn_processor, IPAttnProcessor_Self):attn_processor.enabled = False
            if processor_enable_mode == 'self':
                if isinstance(attn_processor, IPAttnProcessor):attn_processor.enabled = False
                if isinstance(attn_processor, IPAttnProcessor_Self):attn_processor.enabled = True
            if processor_enable_mode == 'all':
                attn_processor.enabled = True
            if processor_enable_mode == 'none':
                attn_processor.enabled = False

    def toggle_extract_inject_flag(self, processor_name, mode): # mode: str, 'extract' or 'inject' or 'both'(cross only)
        for attn_processor in self.unet.attn_processors.values():
            if processor_name == 'cross':
                if isinstance(attn_processor, IPAttnProcessor):attn_processor.mode = mode
            if processor_name == 'self':
                if isinstance(attn_processor, IPAttnProcessor_Self):attn_processor.mode = mode
            if processor_name == 'all':
                attn_processor.mode = mode

    def reset_all(self,keep_self=False):
        for attn_processor in self.unet.attn_processors.values():
            if isinstance(attn_processor, IPAttnProcessor):
                attn_processor.store_attn, attn_processor.subject_idxs, attn_processor.mask_i, attn_processor.mask_ig_prev, self.subject_idxs = None, None, None, None, None

            if isinstance(attn_processor, IPAttnProcessor_Self):
                attn_processor.mask_id, attn_processor.mask_ig = None, None
                if not keep_self: attn_processor.store_ks, attn_processor.store_vs = [], []