import os import random import argparse from pathlib import Path import json import itertools import time import sys from typing import Any, Optional, Tuple, Union sys.path.append( os.path.dirname(os.path.abspath(__file__) ) ) import cv2 import numpy as np import torch import torch.nn.functional as F import torch.nn as nn import matplotlib.cm as cm from torchvision import transforms from PIL import Image from transformers import CLIPImageProcessor from accelerate import Accelerator from accelerate.logging import get_logger from accelerate.utils import ProjectConfiguration from diffusers import AutoencoderKL, DDPMScheduler from diffusers.models.lora import LoRALinearLayer from transformers import CLIPTextModel, CLIPTokenizer, CLIPVisionModelWithProjection from diffusers.models.attention import Attention from attn_processor import NormalJointAttnProcessor2_0 from diffusers.models.attention_processor import JointAttnProcessor2_0 def visual_attn_map(vis_map, vis_token_index): vis_map_list = [] if len(vis_map.shape) == 4: Resolution_vis = int(vis_map.shape[-2]**0.5) vis = vis_map[1].sum(dim=0).transpose(0,1).view(-1,Resolution_vis, Resolution_vis)[vis_token_index].cpu().numpy() vis = ((vis-vis.min())/(vis.max() - vis.min()) *255).astype(np.uint8) colormap = cm.get_cmap('rainbow') rainbow_img_array = colormap(vis / 255.0) rainbow_img_array = (rainbow_img_array[:, :, :3] * 255).astype(np.uint8) return Image.fromarray(rainbow_img_array).resize((512,512)).convert("RGB") def visual_rgb_img(img): rgb_img = img.detach().cpu().numpy() if len(img.shape) == 3: rgb_img = Image.fromarray(((rgb_img-rgb_img.min())/(rgb_img.max() - rgb_img.min()) *255).astype(np.uint8)) elif len(img.shape) == 2: rgb_img = ((rgb_img-rgb_img.min())/(rgb_img.max() - rgb_img.min()) *255).astype(np.uint8) colormap = cm.get_cmap('rainbow') rainbow_img_array = colormap(rgb_img / 255.0) rainbow_img_array = (rainbow_img_array[:, :, :3] * 255).astype(np.uint8) rgb_img = Image.fromarray(rainbow_img_array).resize((512,512)).convert("RGB") return rgb_img class TransformerProjmodel(Attention): def __init__(self, query_dim = None): super().__init__(query_dim = query_dim) class TextProjModel(torch.nn.Module): """Projection Model""" def __init__(self, cross_attention_dim=768, clip_embeddings_dim=768, clip_extra_context_tokens=4): super().__init__() self.generator = None 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 MLPProjModel(torch.nn.Module): """SD model with image prompt""" def __init__(self, cross_attention_dim=768, clip_embeddings_dim=768): super().__init__() self.proj = torch.nn.Sequential( torch.nn.Linear(clip_embeddings_dim, clip_embeddings_dim), torch.nn.GELU(), torch.nn.Linear(clip_embeddings_dim, cross_attention_dim), torch.nn.LayerNorm(cross_attention_dim) ) def forward(self, image_embeds): clip_extra_context_tokens = self.proj(image_embeds) return clip_extra_context_tokens class SPF_Adapter(torch.nn.Module): def __init__(self, transformer, ckpt_path=None, pool_token = False, device = "cuda"): super().__init__() self.device = device self.transformer = transformer class TPPortrait_Adapter(torch.nn.Module): """IP-Adapter""" def __init__(self, unet, cross_attention_dim=768, ckpt_path=None, pool_token = False, device = "cuda"): super().__init__() self.device = device self.unet = unet # self.image_proj_model = image_proj_model if pool_token: self.ShapeText_Projection = TextProjModel(cross_attention_dim, cross_attention_dim) else: self.ShapeText_Projection = MLPProjModel(cross_attention_dim, cross_attention_dim) self.adapter_modules = torch.nn.ModuleList(self.unet.attn_processors.values()) if ckpt_path is not None: self.load_from_checkpoint(ckpt_path) def forward(self, noisy_latents, timesteps, encoder_hidden_states, text_shape_embeds, down_block_res_samples=None, mid_block_res_sample=None, ): text_shape_tokens = self.ShapeText_Projection(text_shape_embeds) encoder_hidden_states = torch.cat([encoder_hidden_states, text_shape_tokens], dim=1) # Predict the noise residual noise_pred = self.unet( noisy_latents, timesteps, encoder_hidden_states, down_block_additional_residuals=[sample.to(dtype=weight_dtype) for sample in down_block_res_samples] if down_block_res_samples is not None else None, mid_block_additional_residual=mid_block_res_sample.to(dtype=weight_dtype) if mid_block_res_sample is not None else None, return_dict = False, )[0] return noise_pred def load_from_checkpoint(self, ckpt_path: str): # Calculate original checksums orig_ip_proj_sum = torch.sum(torch.stack([torch.sum(p) for p in self.ShapeText_Projection.parameters()])) orig_adapter_sum = torch.sum(torch.stack([torch.sum(p) for p in self.adapter_modules.parameters()])) state_dict = torch.load(ckpt_path, map_location="cpu") # Load state dict for image_proj_model and adapter_modules self.ShapeText_Projection.load_state_dict(state_dict["ShapeText_Projection"], strict=True) self.adapter_modules.load_state_dict(state_dict["TP_model"], strict=True) # Calculate new checksums new_ip_proj_sum = torch.sum(torch.stack([torch.sum(p) for p in self.ShapeText_Projection.parameters()])) new_adapter_sum = torch.sum(torch.stack([torch.sum(p) for p in self.adapter_modules.parameters()])) # Verify if the weights have changed assert orig_ip_proj_sum != new_ip_proj_sum, "Weights of image_proj_model did not change!" assert orig_adapter_sum != new_adapter_sum, "Weights of adapter_modules did not change!" print(f"Successfully loaded weights from checkpoint {ckpt_path}") def finegrained_encoder_setting(self, text_encoder, tokenizer): self.TP_Encoder = text_encoder.to(self.device) self.TP_tokenizer = tokenizer def generate( self, pipe, faceid_embeds=None, global_prompt=None, finegrained_prompt=None, negative_prompt=None, scale=1.0, num_samples=1, all_tokens=True, seed=None, generator=None, guidance_scale=7.5, num_inference_steps=30, s_scale=1.0, **kwargs, ): with torch.inference_mode(): global_prompt_embeds_, global_negative_prompt_embeds_ = pipe.encode_prompt( global_prompt, device=pipe.device, num_images_per_prompt=num_samples, do_classifier_free_guidance=True, negative_prompt=negative_prompt, ) assert (hasattr(self, "TP_Encoder") and hasattr(self, "TP_tokenizer")), "Enocder not exisit!" if all_tokens: finegrained_embeds_ = self.TP_Encoder(self.TP_tokenizer(finegrained_prompt, padding="max_length", truncation=True, return_tensors="pt").input_ids.to(pipe.device), output_hidden_states=True)[0] finegrained_negative_prompt_embeds_ = self.TP_Encoder(self.TP_tokenizer("", padding="max_length", truncation=True, return_tensors="pt").input_ids.to(pipe.device), output_hidden_states=True)[0] else: finegrained_embeds_ = self.TP_Encoder.encode_text(self.TP_tokenizer(finegrained_prompt))[0] finegrained_negative_prompt_embeds_ = self.TP_Encoder.encode_text(self.TP_tokenizer(""))[0] finegrained_embeds_ = self.ShapeText_Projection(finegrained_embeds_.to(pipe.device, global_prompt_embeds_.dtype)) finegrained_negative_prompt_embeds_ = self.ShapeText_Projection(finegrained_negative_prompt_embeds_.to(pipe.device, global_prompt_embeds_.dtype)) prompt_embeds = torch.cat([global_prompt_embeds_, finegrained_embeds_], dim=1) negative_prompt_embeds = torch.cat([global_negative_prompt_embeds_, finegrained_negative_prompt_embeds_], dim=1) images = pipe( prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_prompt_embeds, guidance_scale=guidance_scale, num_inference_steps=num_inference_steps, generator=generator, # num_images_per_prompt = num_samples, **kwargs, ) return images def inverse( self, pipe, latents, global_prompt=None, finegrained_prompt=None, negative_prompt=None, scale=1.0, num_samples=1, all_tokens=True, seed=None, generator=None, guidance_scale=7.5, num_inference_steps=30, s_scale=1.0, **kwargs, ): with torch.inference_mode(): global_prompt_embeds_, global_negative_prompt_embeds_ = pipe.encode_prompt( global_prompt, device=pipe.device, num_images_per_prompt=num_samples, do_classifier_free_guidance=True, negative_prompt=negative_prompt, ) assert (hasattr(self, "TP_Encoder") and hasattr(self, "TP_tokenizer")), "Enocder not exisit!" if all_tokens: finegrained_embeds_ = self.TP_Encoder(self.TP_tokenizer(finegrained_prompt, padding="max_length", truncation=True, return_tensors="pt").input_ids.to(pipe.device), output_hidden_states=True)[0] finegrained_negative_prompt_embeds_ = self.TP_Encoder(self.TP_tokenizer("", padding="max_length", truncation=True, return_tensors="pt").input_ids.to(pipe.device), output_hidden_states=True)[0] else: finegrained_embeds_ = self.TP_Encoder.encode_text(self.TP_tokenizer(finegrained_prompt))[0] finegrained_negative_prompt_embeds_ = self.TP_Encoder.encode_text(self.TP_tokenizer(""))[0] finegrained_embeds_ = self.ShapeText_Projection(finegrained_embeds_.to(pipe.device, global_prompt_embeds_.dtype)) finegrained_negative_prompt_embeds_ = self.ShapeText_Projection(finegrained_negative_prompt_embeds_.to(pipe.device, global_prompt_embeds_.dtype)) prompt_embeds = torch.cat([global_prompt_embeds_, finegrained_embeds_], dim=1) negative_prompt_embeds = torch.cat([global_negative_prompt_embeds_, finegrained_negative_prompt_embeds_], dim=1) inv_latents, _ = pipe( prompt_embeds=prompt_embeds, negative_prompt_embeds=negative_prompt_embeds, guidance_scale=guidance_scale, num_inference_steps=num_inference_steps, generator=generator, output_type='latent', latents = latents, return_dict=False, **kwargs, ) return inv_latents def SPF_set_attnprocessor(transformer): # hidden_size = transformer.config.attention_head_dim * transformer.config.num_attention_heads attn_procs = {} # transformers_sd = transformer.state_dict() for name in transformer.attn_processors.keys(): layer_name = name.split(".processor")[0] if 1: # weights = { # "to_k_ip.weight": transformers_sd[layer_name + ".to_k.weight"], # "to_k_ip.bias": transformers_sd[layer_name + ".to_k.bias"], # "to_v_ip.weight": transformers_sd[layer_name + ".to_v.weight"], # "to_v_ip.bias": transformers_sd[layer_name + ".to_v.bias"], # "norm_added_k.weight": transformers_sd[layer_name + ".norm_k.weight"], # "norm_added_k.bias": transformers_sd[layer_name + ".norm_k.bias"], # } attn_procs[name] = NormalJointAttnProcessor2_0() # attn_procs[name].load_state_dict(weights, strict=False) else: attn_procs[name] = JointAttnProcessor2_0() transformer.set_attn_processor(attn_procs) # adapter_modules = torch.nn.ModuleList(components.transformer.attn_processors.values())