| |
| import os |
| os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com' |
|
|
| import torch |
| from diffusers.utils.torch_utils import randn_tensor |
| from diffusion_model.Processor import AttnProcessorForCallBack, DIFFUSION_LAYERS |
| from torch import autocast, nn |
| from diffusers import StableDiffusionPipeline |
|
|
|
|
| class diffusion(nn.Module): |
|
|
| def __init__(self, |
| attention_layers_to_use=None, |
| model="v2.1", |
| time_step=45, |
| dtype=torch.float16, |
| device='cuda:0'): |
| super().__init__() |
| |
| if model == "v2.1": |
| model = "stabilityai/stable-diffusion-2-1-base" |
| elif model == "v1.5": |
| model = "runwayml/stable-diffusion-v1-5" |
| elif model == "v1.4": |
| model = "CompVis/stable-diffusion-v1-4" |
| else: |
| raise ValueError(f"Not supported model {model}") |
| self.model = StableDiffusionPipeline.from_pretrained(model, torch_dtype=dtype) |
| self.setup(device) |
| self.dtype = dtype |
| self.time_step = time_step |
| |
| self.attention_maps = {} |
| if attention_layers_to_use is None: |
| attention_layers_to_use = [-1] |
| self.layers = attention_layers_to_use |
| for layer_idx in attention_layers_to_use: |
| attn = eval(f"self.model.unet.{DIFFUSION_LAYERS[layer_idx]}") |
| attn.processor = AttnProcessorForCallBack(self, layer_idx) |
|
|
| def one_step(self, latents, prompts): |
|
|
| self.model._guidance_scale = 1 |
| self.model._clip_skip = None |
| self.model._joint_attention_kwargs = None |
| self.model._interrupt = False |
|
|
| self.model.scheduler.set_timesteps(50, device=self.device) |
| t = self.model.scheduler.timesteps[self.time_step] |
|
|
| noise = randn_tensor(latents.shape, device=latents.device, dtype=latents.dtype) |
| |
| latents = self.model.scheduler.add_noise(latents, noise, t) |
|
|
| prompt_embeds, _ = self.model.encode_prompt( |
| prompts, self.device, 1, do_classifier_free_guidance=False, |
| negative_prompt=None, |
| prompt_embeds=None, |
| negative_prompt_embeds=None, |
| lora_scale=None, |
| clip_skip=self.model.clip_skip, |
| ) |
| noise_pred = self.model.unet( |
| latents, |
| t, |
| encoder_hidden_states=prompt_embeds, |
| return_dict=False, |
| )[0] |
|
|
| def generate_image(self, prompts): |
| with autocast("cuda"): |
| image = self.model(prompts)["images"][0] |
| return image |
|
|
| @property |
| def device(self): |
| return self.model._execution_device |
|
|
| def setup(self, device): |
| self.model.to(device) |
|
|
| for param in self.model.vae.parameters(): |
| param.requires_grad = False |
| for param in self.model.unet.parameters(): |
| param.requires_grad = False |
| for param in self.model.text_encoder.parameters(): |
| param.requires_grad = False |
|
|
| def forward(self, img, prompts=""): |
| latent = self.model.image_processor.preprocess(img, height=512, width=512).to(self.dtype) |
| latent = self.model.vae.encode(latent)[0].mean * self.model.vae.config.scaling_factor |
| self.one_step(latent, prompts=prompts) |
|
|
| def forward_wo_preprocess(self, img, prompts=""): |
| latent = img.to(self.dtype) |
| latent = self.model.vae.encode(latent)[0].mean * self.model.vae.config.scaling_factor |
| self.one_step(latent, prompts=prompts) |
|
|
| if __name__ == "__main__": |
| iseg = diffusion(attention_layers_to_use=[-2]) |
| prompt = "two dogs running under the sea. " |
| iseg.one_step(torch.randn((1, 4, 64, 64), dtype=torch.float16, device='cuda'), prompts='') |
| img = iseg.generate_image(prompt) |
| print(iseg.attention_maps[-2].shape) |
|
|
