diff --git a/README.md b/README.md index 9b13f72..435302d 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ - # IP-Adapter: Text Compatible Image Prompt Adapter for Text-to-Image Diffusion Models +# IP-Adapter: Text Compatible Image Prompt Adapter for Text-to-Image Diffusion Models
@@ -7,3 +7,61 @@ --- + +## Introduction + +we present IP-Adapter, an effective and lightweight +adapter to achieve image prompt capability for the pretrained +text-to-image diffusion models. An IP-Adapter +with only 22M parameters can achieve comparable or even +better performance to a fine-tuned image prompt model. IPAdapter +can be generalized not only to other custom models +fine-tuned from the same base model, but also to controllable +generation using existing controllable tools. Moreover, the image prompt +can also work well with the text prompt to accomplish multimodal +image generation. + +![arch](assets/figs/fig1.png) + +## Release +- [2023/8/16] 🔥 We release the code and models. + + +## Dependencies +- diffusers >= 0.19.3 + +## Download Models + +you can download models from [here](https://huggingface.co/h94/IP-Adapter). To run the demo, you should also download the following models: +- [runwayml/stable-diffusion-v1-5](https://huggingface.co/runwayml/stable-diffusion-v1-5) +- [stabilityai/sd-vae-ft-mse](https://huggingface.co/stabilityai/sd-vae-ft-mse) +- [SG161222/Realistic_Vision_V4.0_noVAE](https://huggingface.co/SG161222/Realistic_Vision_V4.0_noVAE) + +## How to Use + +- [**ip_adapter_demo**](ip_adapter_demo.ipynb): image variations, image-to-image, and inpainting with image prompt. + +![image variations](assets/demo/image_variations.jpg) + +![image-to-image](assets/demo/image-to-image.jpg) + +![inpainting](assets/demo/inpainting.jpg) +- [**ip_adapter_controlnet_demo**](ip_adapter_controlnet_demo.ipynb): structural generation with image prompt. + +![structural_cond](assets/demo/structural_cond.jpg) + +- [**ip_adapter_multimodal_prompts_demo**](ip_adapter_multimodal_prompts_demo.ipynb): generation with multimodal prompts. + +![multi_prompts](assets/demo/multi_prompts.jpg) + + +## Citation +If you find IP-Adapter useful for your your research and applications, please cite using this BibTeX: +```bibtex +@article{ye2023ip-adapter, + title={IP-Adapter: Text Compatible Image Prompt Adapter for Text-to-Image Diffusion Models}, + author={Ye, Hu and Zhang, Jun and Liu, Sibo and Han, Xiao and Yang, Wei}, + booktitle={arXiv preprint arxiv:2308.06721}, + year={2023} +} +``` diff --git a/assets/demo/image-to-image.jpg b/assets/demo/image-to-image.jpg new file mode 100644 index 0000000..41945a6 Binary files /dev/null and b/assets/demo/image-to-image.jpg differ diff --git a/assets/demo/image_variations.jpg b/assets/demo/image_variations.jpg new file mode 100644 index 0000000..a773875 Binary files /dev/null and b/assets/demo/image_variations.jpg differ diff --git a/assets/demo/inpainting.jpg b/assets/demo/inpainting.jpg new file mode 100644 index 0000000..fc1a796 Binary files /dev/null and b/assets/demo/inpainting.jpg differ diff --git a/assets/demo/multi_prompts.jpg b/assets/demo/multi_prompts.jpg new file mode 100644 index 0000000..01c443a Binary files /dev/null and b/assets/demo/multi_prompts.jpg differ diff --git a/assets/demo/structural_cond.jpg b/assets/demo/structural_cond.jpg new file mode 100644 index 0000000..05f5c98 Binary files /dev/null and b/assets/demo/structural_cond.jpg differ diff --git a/assets/figs/fig1.png b/assets/figs/fig1.png new file mode 100644 index 0000000..bb8f977 Binary files /dev/null and b/assets/figs/fig1.png differ diff --git a/assets/images/girl.png b/assets/images/girl.png new file mode 100644 index 0000000..6fda66d Binary files /dev/null and b/assets/images/girl.png differ diff --git a/assets/images/river.png b/assets/images/river.png new file mode 100644 index 0000000..9697d8c Binary files /dev/null and b/assets/images/river.png differ diff --git a/assets/images/statue.png b/assets/images/statue.png new file mode 100644 index 0000000..68fdece Binary files /dev/null and b/assets/images/statue.png differ diff --git a/assets/images/stone.png b/assets/images/stone.png new file mode 100644 index 0000000..4fa644d Binary files /dev/null and b/assets/images/stone.png differ diff --git a/assets/images/vermeer.jpg b/assets/images/vermeer.jpg new file mode 100644 index 0000000..7d6fb9e Binary files /dev/null and b/assets/images/vermeer.jpg differ diff --git a/assets/images/woman.png b/assets/images/woman.png new file mode 100644 index 0000000..c1dad16 Binary files /dev/null and b/assets/images/woman.png differ diff --git a/assets/inpainting/image.png b/assets/inpainting/image.png new file mode 100644 index 0000000..9246e1e Binary files /dev/null and b/assets/inpainting/image.png differ diff --git a/assets/inpainting/mask.png b/assets/inpainting/mask.png new file mode 100644 index 0000000..441e4df Binary files /dev/null and b/assets/inpainting/mask.png differ diff --git a/assets/structure_controls/depth.png b/assets/structure_controls/depth.png new file mode 100644 index 0000000..812cf0f Binary files /dev/null and b/assets/structure_controls/depth.png differ diff --git a/assets/structure_controls/openpose.png b/assets/structure_controls/openpose.png new file mode 100644 index 0000000..8ad81b4 Binary files /dev/null and b/assets/structure_controls/openpose.png differ diff --git a/ip_adapter/__init__.py b/ip_adapter/__init__.py new file mode 100644 index 0000000..7359e86 --- /dev/null +++ b/ip_adapter/__init__.py @@ -0,0 +1 @@ +from .ip_adapter import IPAdapter diff --git a/ip_adapter/attention_processor.py b/ip_adapter/attention_processor.py new file mode 100644 index 0000000..7e5e7a5 --- /dev/null +++ b/ip_adapter/attention_processor.py @@ -0,0 +1,176 @@ +import torch +import torch.nn as nn + + +class AttnProcessor(nn.Module): + r""" + Default processor for performing attention-related computations. + """ + def __init__( + self, + hidden_size=None, + cross_attention_dim=None, + ): + super().__init__() + + def __call__( + self, + attn, + hidden_states, + encoder_hidden_states=None, + attention_mask=None, + temb=None, + ): + residual = hidden_states + + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + batch_size, sequence_length, _ = ( + hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) + + if attn.group_norm is not None: + hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) + + query = attn.to_q(hidden_states) + + if encoder_hidden_states is None: + encoder_hidden_states = hidden_states + elif attn.norm_cross: + encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + + key = attn.to_k(encoder_hidden_states) + value = attn.to_v(encoder_hidden_states) + + query = attn.head_to_batch_dim(query) + key = attn.head_to_batch_dim(key) + value = attn.head_to_batch_dim(value) + + attention_probs = attn.get_attention_scores(query, key, attention_mask) + hidden_states = torch.bmm(attention_probs, value) + hidden_states = attn.batch_to_head_dim(hidden_states) + + # linear proj + hidden_states = attn.to_out[0](hidden_states) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + if input_ndim == 4: + hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + return hidden_states + + +class IPAttnProcessor(nn.Module): + r""" + Attention processor for IP-Adapater. + Args: + hidden_size (`int`): + The hidden size of the attention layer. + cross_attention_dim (`int`): + The number of channels in the `encoder_hidden_states`. + text_context_len (`int`, defaults to 77): + The context length of the text features. + scale (`float`, defaults to 1.0): + the weight scale of image prompt. + """ + + def __init__(self, hidden_size, cross_attention_dim=None, text_context_len=77, scale=1.0): + super().__init__() + + self.hidden_size = hidden_size + self.cross_attention_dim = cross_attention_dim + self.text_context_len = text_context_len + self.scale = scale + + self.to_k_ip = nn.Linear(cross_attention_dim or hidden_size, hidden_size, bias=False) + self.to_v_ip = nn.Linear(cross_attention_dim or hidden_size, hidden_size, bias=False) + + def __call__( + self, + attn, + hidden_states, + encoder_hidden_states=None, + attention_mask=None, + temb=None, + ): + residual = hidden_states + + if attn.spatial_norm is not None: + hidden_states = attn.spatial_norm(hidden_states, temb) + + input_ndim = hidden_states.ndim + + if input_ndim == 4: + batch_size, channel, height, width = hidden_states.shape + hidden_states = hidden_states.view(batch_size, channel, height * width).transpose(1, 2) + + batch_size, sequence_length, _ = ( + hidden_states.shape if encoder_hidden_states is None else encoder_hidden_states.shape + ) + attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) + + if attn.group_norm is not None: + hidden_states = attn.group_norm(hidden_states.transpose(1, 2)).transpose(1, 2) + + query = attn.to_q(hidden_states) + + if encoder_hidden_states is None: + encoder_hidden_states = hidden_states + elif attn.norm_cross: + encoder_hidden_states = attn.norm_encoder_hidden_states(encoder_hidden_states) + + # split hidden states + encoder_hidden_states, ip_hidden_states = encoder_hidden_states[:, :self.text_context_len, :], encoder_hidden_states[:, self.text_context_len:, :] + + key = attn.to_k(encoder_hidden_states) + value = attn.to_v(encoder_hidden_states) + + query = attn.head_to_batch_dim(query) + key = attn.head_to_batch_dim(key) + value = attn.head_to_batch_dim(value) + + attention_probs = attn.get_attention_scores(query, key, attention_mask) + hidden_states = torch.bmm(attention_probs, value) + hidden_states = attn.batch_to_head_dim(hidden_states) + + # for ip-adapter + ip_key = self.to_k_ip(ip_hidden_states) + ip_value = self.to_v_ip(ip_hidden_states) + + ip_key = attn.head_to_batch_dim(ip_key) + ip_value = attn.head_to_batch_dim(ip_value) + + ip_attention_probs = attn.get_attention_scores(query, ip_key, None) + ip_hidden_states = torch.bmm(ip_attention_probs, ip_value) + ip_hidden_states = attn.batch_to_head_dim(ip_hidden_states) + + hidden_states = hidden_states + self.scale * ip_hidden_states + + # linear proj + hidden_states = attn.to_out[0](hidden_states) + # dropout + hidden_states = attn.to_out[1](hidden_states) + + if input_ndim == 4: + hidden_states = hidden_states.transpose(-1, -2).reshape(batch_size, channel, height, width) + + if attn.residual_connection: + hidden_states = hidden_states + residual + + hidden_states = hidden_states / attn.rescale_output_factor + + return hidden_states diff --git a/ip_adapter/ip_adapter.py b/ip_adapter/ip_adapter.py new file mode 100644 index 0000000..9125e74 --- /dev/null +++ b/ip_adapter/ip_adapter.py @@ -0,0 +1,184 @@ +import os +from typing import List + +import torch +from diffusers import StableDiffusionPipeline +from transformers import CLIPVisionModelWithProjection, CLIPImageProcessor +from PIL import Image + +from .attention_processor import IPAttnProcessor, AttnProcessor + + +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 IPAdapter: + + def __init__(self, sd_pipe, image_encoder_path, ip_ckpt, device): + + self.device = device + self.image_encoder_path = image_encoder_path + self.ip_ckpt = ip_ckpt + + self.pipe = sd_pipe.to(self.device) + self.set_ip_adapter() + + # load image encoder + self.image_encoder = CLIPVisionModelWithProjection.from_pretrained(self.image_encoder_path).to(self.device, dtype=torch.float16) + self.clip_image_processor = CLIPImageProcessor() + # image proj model + self.image_proj_model = ImageProjModel(cross_attention_dim=768, clip_embeddings_dim=1024, + clip_extra_context_tokens=4).to(self.device, dtype=torch.float16) + + self.load_ip_adapter() + + def set_ip_adapter(self): + unet = self.pipe.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] = AttnProcessor() + else: + attn_procs[name] = IPAttnProcessor(hidden_size=hidden_size, cross_attention_dim=cross_attention_dim, + scale=1.0).to(self.device, dtype=torch.float16) + unet.set_attn_processor(attn_procs) + + def load_ip_adapter(self): + state_dict = torch.load(self.ip_ckpt, map_location="cpu") + self.image_proj_model.load_state_dict(state_dict["image_proj"]) + ip_layers = torch.nn.ModuleList(self.pipe.unet.attn_processors.values()) + ip_layers.load_state_dict(state_dict["ip_adapter"]) + + @torch.inference_mode() + def get_image_embeds(self, pil_image): + if isinstance(pil_image, Image.Image): + pil_image = [pil_image] + clip_image = self.clip_image_processor(images=pil_image, return_tensors="pt").pixel_values + clip_image_embeds = self.image_encoder(clip_image.to(self.device, dtype=torch.float16)).image_embeds + 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 set_scale(self, scale): + for attn_processor in self.pipe.unet.attn_processors.values(): + if isinstance(attn_processor, IPAttnProcessor): + attn_processor.scale = scale + + def generate( + self, + pil_image, + prompt=None, + negative_prompt=None, + scale=1.0, + num_samples=4, + seed=-1, + guidance_scale=7.5, + num_inference_steps=30, + **kwargs, + ): + self.set_scale(scale) + + if isinstance(pil_image, Image.Image): + num_prompts = 1 + else: + num_prompts = len(pil_image) + + if prompt is None: + prompt = "best quality, high quality" + if negative_prompt is None: + negative_prompt = "monochrome, lowres, bad anatomy, worst quality, low quality" + + if not isinstance(prompt, List): + prompt = [prompt] * num_prompts + if not isinstance(negative_prompt, List): + negative_prompt = [negative_prompt] * num_prompts + + image_prompt_embeds, uncond_image_prompt_embeds = self.get_image_embeds(pil_image) + 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) + + with torch.inference_mode(): + prompt_embeds = self.pipe._encode_prompt(prompt, self.device, num_samples, True, negative_prompt) + negative_prompt_embeds_, prompt_embeds_ = prompt_embeds.chunk(2) + prompt_embeds = torch.cat([prompt_embeds_, image_prompt_embeds], dim=1) + negative_prompt_embeds = torch.cat([negative_prompt_embeds_, uncond_image_prompt_embeds], dim=1) + + generator = torch.Generator(self.device).manual_seed(seed) if seed is not None else None + images = self.pipe( + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + guidance_scale=guidance_scale, + num_inference_steps=num_inference_steps, + generator=generator, + **kwargs, + ).images + + return images + + +def image_grid(imgs, rows, cols): + assert len(imgs) == rows*cols + + w, h = imgs[0].size + grid = Image.new('RGB', size=(cols*w, rows*h)) + grid_w, grid_h = grid.size + + for i, img in enumerate(imgs): + grid.paste(img, box=(i%cols*w, i//cols*h)) + return grid + + +if __name__ == "__main__": + base_model_path = "/mnt/aigc_cq/shared/txt2img_models/Realistic_Vision_V5.1_noVAE/" + image_encoder_path = "/mnt/aigc_cq/private/huye/t2i_trained_models/ip_adapter_sd15_clip-H/image_encoder/" + ip_ckpt = "/mnt/aigc_cq/private/huye/t2i_trained_models/ip_adapter_sd15_clip-H/ip-dapter_1000000.bin" + device = "cuda:3" + + + pipe = StableDiffusionPipeline.from_pretrained( + base_model_path, + torch_dtype=torch.float16, + feature_extractor=None, + safety_checker=None, + ) + + + ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device) + + image_files = ["../assets/Taylor_Swift.png", "../assets/3.png"] + num_samples = 2 + pil_images = [Image.open(image_file) for image_file in image_files] + + images = ip_model.generate(pil_image=pil_images, num_samples=num_samples) + grid = image_grid(images, 1, 4) + grid.save("output.png") + + images = ip_model.generate(pil_image=pil_images, num_samples=num_samples, prompt="best quality, high quality, wearing a hat on the beach", scale=0.5) + grid = image_grid(images, 1, 4) + grid.save("output_hat.png") diff --git a/ip_adapter/utils.py b/ip_adapter/utils.py new file mode 100644 index 0000000..5413ea7 --- /dev/null +++ b/ip_adapter/utils.py @@ -0,0 +1,362 @@ +import inspect +import warnings +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import numpy as np +import PIL.Image +import torch +from diffusers.utils import is_compiled_module +from diffusers.pipelines.controlnet.multicontrolnet import MultiControlNetModel +from diffusers.models import ControlNetModel +from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput + + +@torch.no_grad() +def generate( + self, + prompt: Union[str, List[str]] = None, + image: Union[ + torch.FloatTensor, + PIL.Image.Image, + np.ndarray, + List[torch.FloatTensor], + List[PIL.Image.Image], + List[np.ndarray], + ] = None, + height: Optional[int] = None, + width: Optional[int] = None, + num_inference_steps: int = 50, + guidance_scale: float = 7.5, + negative_prompt: Optional[Union[str, List[str]]] = None, + num_images_per_prompt: Optional[int] = 1, + eta: float = 0.0, + generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None, + latents: Optional[torch.FloatTensor] = None, + prompt_embeds: Optional[torch.FloatTensor] = None, + negative_prompt_embeds: Optional[torch.FloatTensor] = None, + output_type: Optional[str] = "pil", + return_dict: bool = True, + callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None, + callback_steps: int = 1, + cross_attention_kwargs: Optional[Dict[str, Any]] = None, + controlnet_conditioning_scale: Union[float, List[float]] = 1.0, + guess_mode: bool = False, + control_guidance_start: Union[float, List[float]] = 0.0, + control_guidance_end: Union[float, List[float]] = 1.0, +): + r""" + Function invoked when calling the pipeline for generation. + + Args: + prompt (`str` or `List[str]`, *optional*): + The prompt or prompts to guide the image generation. If not defined, one has to pass `prompt_embeds`. + instead. + image (`torch.FloatTensor`, `PIL.Image.Image`, `np.ndarray`, `List[torch.FloatTensor]`, `List[PIL.Image.Image]`, `List[np.ndarray]`,: + `List[List[torch.FloatTensor]]`, `List[List[np.ndarray]]` or `List[List[PIL.Image.Image]]`): + The ControlNet input condition. ControlNet uses this input condition to generate guidance to Unet. If + the type is specified as `Torch.FloatTensor`, it is passed to ControlNet as is. `PIL.Image.Image` can + also be accepted as an image. The dimensions of the output image defaults to `image`'s dimensions. If + height and/or width are passed, `image` is resized according to them. If multiple ControlNets are + specified in init, images must be passed as a list such that each element of the list can be correctly + batched for input to a single controlnet. + height (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The height in pixels of the generated image. + width (`int`, *optional*, defaults to self.unet.config.sample_size * self.vae_scale_factor): + The width in pixels of the generated image. + num_inference_steps (`int`, *optional*, defaults to 50): + The number of denoising steps. More denoising steps usually lead to a higher quality image at the + expense of slower inference. + guidance_scale (`float`, *optional*, defaults to 7.5): + Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598). + `guidance_scale` is defined as `w` of equation 2. of [Imagen + Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale > + 1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`, + usually at the expense of lower image quality. + negative_prompt (`str` or `List[str]`, *optional*): + The prompt or prompts not to guide the image generation. If not defined, one has to pass + `negative_prompt_embeds` instead. Ignored when not using guidance (i.e., ignored if `guidance_scale` is + less than `1`). + num_images_per_prompt (`int`, *optional*, defaults to 1): + The number of images to generate per prompt. + eta (`float`, *optional*, defaults to 0.0): + Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to + [`schedulers.DDIMScheduler`], will be ignored for others. + generator (`torch.Generator` or `List[torch.Generator]`, *optional*): + One or a list of [torch generator(s)](https://pytorch.org/docs/stable/generated/torch.Generator.html) + to make generation deterministic. + latents (`torch.FloatTensor`, *optional*): + Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image + generation. Can be used to tweak the same generation with different prompts. If not provided, a latents + tensor will ge generated by sampling using the supplied random `generator`. + prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt weighting. If not + provided, text embeddings will be generated from `prompt` input argument. + negative_prompt_embeds (`torch.FloatTensor`, *optional*): + Pre-generated negative text embeddings. Can be used to easily tweak text inputs, *e.g.* prompt + weighting. If not provided, negative_prompt_embeds will be generated from `negative_prompt` input + argument. + output_type (`str`, *optional*, defaults to `"pil"`): + The output format of the generate image. Choose between + [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`. + return_dict (`bool`, *optional*, defaults to `True`): + Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a + plain tuple. + callback (`Callable`, *optional*): + A function that will be called every `callback_steps` steps during inference. The function will be + called with the following arguments: `callback(step: int, timestep: int, latents: torch.FloatTensor)`. + callback_steps (`int`, *optional*, defaults to 1): + The frequency at which the `callback` function will be called. If not specified, the callback will be + called at every step. + cross_attention_kwargs (`dict`, *optional*): + A kwargs dictionary that if specified is passed along to the `AttentionProcessor` as defined under + `self.processor` in + [diffusers.models.attention_processor](https://github.com/huggingface/diffusers/blob/main/src/diffusers/models/attention_processor.py). + controlnet_conditioning_scale (`float` or `List[float]`, *optional*, defaults to 1.0): + The outputs of the controlnet are multiplied by `controlnet_conditioning_scale` before they are added + to the residual in the original unet. If multiple ControlNets are specified in init, you can set the + corresponding scale as a list. + guess_mode (`bool`, *optional*, defaults to `False`): + In this mode, the ControlNet encoder will try best to recognize the content of the input image even if + you remove all prompts. The `guidance_scale` between 3.0 and 5.0 is recommended. + control_guidance_start (`float` or `List[float]`, *optional*, defaults to 0.0): + The percentage of total steps at which the controlnet starts applying. + control_guidance_end (`float` or `List[float]`, *optional*, defaults to 1.0): + The percentage of total steps at which the controlnet stops applying. + + Examples: + + Returns: + [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`: + [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple. + When returning a tuple, the first element is a list with the generated images, and the second element is a + list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work" + (nsfw) content, according to the `safety_checker`. + """ + controlnet = self.controlnet._orig_mod if is_compiled_module(self.controlnet) else self.controlnet + + # align format for control guidance + if not isinstance(control_guidance_start, list) and isinstance(control_guidance_end, list): + control_guidance_start = len(control_guidance_end) * [control_guidance_start] + elif not isinstance(control_guidance_end, list) and isinstance(control_guidance_start, list): + control_guidance_end = len(control_guidance_start) * [control_guidance_end] + elif not isinstance(control_guidance_start, list) and not isinstance(control_guidance_end, list): + mult = len(controlnet.nets) if isinstance(controlnet, MultiControlNetModel) else 1 + control_guidance_start, control_guidance_end = mult * [control_guidance_start], mult * [ + control_guidance_end + ] + + # 1. Check inputs. Raise error if not correct + self.check_inputs( + prompt, + image, + callback_steps, + negative_prompt, + prompt_embeds, + negative_prompt_embeds, + controlnet_conditioning_scale, + control_guidance_start, + control_guidance_end, + ) + + # 2. Define call parameters + if prompt is not None and isinstance(prompt, str): + batch_size = 1 + elif prompt is not None and isinstance(prompt, list): + batch_size = len(prompt) + else: + batch_size = prompt_embeds.shape[0] + + device = self._execution_device + # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2) + # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1` + # corresponds to doing no classifier free guidance. + do_classifier_free_guidance = guidance_scale > 1.0 + + if isinstance(controlnet, MultiControlNetModel) and isinstance(controlnet_conditioning_scale, float): + controlnet_conditioning_scale = [controlnet_conditioning_scale] * len(controlnet.nets) + + global_pool_conditions = ( + controlnet.config.global_pool_conditions + if isinstance(controlnet, ControlNetModel) + else controlnet.nets[0].config.global_pool_conditions + ) + guess_mode = guess_mode or global_pool_conditions + + # 3. Encode input prompt + text_encoder_lora_scale = ( + cross_attention_kwargs.get("scale", None) if cross_attention_kwargs is not None else None + ) + prompt_embeds = self._encode_prompt( + prompt, + device, + num_images_per_prompt, + do_classifier_free_guidance, + negative_prompt, + prompt_embeds=prompt_embeds, + negative_prompt_embeds=negative_prompt_embeds, + lora_scale=text_encoder_lora_scale, + ) + + # 4. Prepare image + if isinstance(controlnet, ControlNetModel): + image = self.prepare_image( + image=image, + width=width, + height=height, + batch_size=batch_size * num_images_per_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + dtype=controlnet.dtype, + do_classifier_free_guidance=do_classifier_free_guidance, + guess_mode=guess_mode, + ) + height, width = image.shape[-2:] + elif isinstance(controlnet, MultiControlNetModel): + images = [] + + for image_ in image: + image_ = self.prepare_image( + image=image_, + width=width, + height=height, + batch_size=batch_size * num_images_per_prompt, + num_images_per_prompt=num_images_per_prompt, + device=device, + dtype=controlnet.dtype, + do_classifier_free_guidance=do_classifier_free_guidance, + guess_mode=guess_mode, + ) + + images.append(image_) + + image = images + height, width = image[0].shape[-2:] + else: + assert False + + # 5. Prepare timesteps + self.scheduler.set_timesteps(num_inference_steps, device=device) + timesteps = self.scheduler.timesteps + + # 6. Prepare latent variables + num_channels_latents = self.unet.config.in_channels + latents = self.prepare_latents( + batch_size * num_images_per_prompt, + num_channels_latents, + height, + width, + prompt_embeds.dtype, + device, + generator, + latents, + ) + + # 7. Prepare extra step kwargs. TODO: Logic should ideally just be moved out of the pipeline + extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta) + + # 7.1 Create tensor stating which controlnets to keep + controlnet_keep = [] + for i in range(len(timesteps)): + keeps = [ + 1.0 - float(i / len(timesteps) < s or (i + 1) / len(timesteps) > e) + for s, e in zip(control_guidance_start, control_guidance_end) + ] + controlnet_keep.append(keeps[0] if isinstance(controlnet, ControlNetModel) else keeps) + + # 8. Denoising loop + num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order + with self.progress_bar(total=num_inference_steps) as progress_bar: + for i, t in enumerate(timesteps): + # expand the latents if we are doing classifier free guidance + latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents + latent_model_input = self.scheduler.scale_model_input(latent_model_input, t) + + # controlnet(s) inference + if guess_mode and do_classifier_free_guidance: + # Infer ControlNet only for the conditional batch. + control_model_input = latents + control_model_input = self.scheduler.scale_model_input(control_model_input, t) + controlnet_prompt_embeds = prompt_embeds[:, :77, :].chunk(2)[1] + else: + control_model_input = latent_model_input + controlnet_prompt_embeds = prompt_embeds[:, :77, :] + + if isinstance(controlnet_keep[i], list): + cond_scale = [c * s for c, s in zip(controlnet_conditioning_scale, controlnet_keep[i])] + else: + controlnet_cond_scale = controlnet_conditioning_scale + if isinstance(controlnet_cond_scale, list): + controlnet_cond_scale = controlnet_cond_scale[0] + cond_scale = controlnet_cond_scale * controlnet_keep[i] + + down_block_res_samples, mid_block_res_sample = self.controlnet( + control_model_input, + t, + encoder_hidden_states=controlnet_prompt_embeds, + controlnet_cond=image, + conditioning_scale=cond_scale, + guess_mode=guess_mode, + return_dict=False, + ) + + if guess_mode and do_classifier_free_guidance: + # Infered ControlNet only for the conditional batch. + # To apply the output of ControlNet to both the unconditional and conditional batches, + # add 0 to the unconditional batch to keep it unchanged. + down_block_res_samples = [torch.cat([torch.zeros_like(d), d]) for d in down_block_res_samples] + mid_block_res_sample = torch.cat([torch.zeros_like(mid_block_res_sample), mid_block_res_sample]) + + # predict the noise residual + noise_pred = self.unet( + latent_model_input, + t, + encoder_hidden_states=prompt_embeds, + cross_attention_kwargs=cross_attention_kwargs, + down_block_additional_residuals=down_block_res_samples, + mid_block_additional_residual=mid_block_res_sample, + return_dict=False, + )[0] + + # perform guidance + if do_classifier_free_guidance: + noise_pred_uncond, noise_pred_text = noise_pred.chunk(2) + noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond) + + # compute the previous noisy sample x_t -> x_t-1 + latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs, return_dict=False)[0] + + # call the callback, if provided + if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0): + progress_bar.update() + if callback is not None and i % callback_steps == 0: + callback(i, t, latents) + + # If we do sequential model offloading, let's offload unet and controlnet + # manually for max memory savings + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.unet.to("cpu") + self.controlnet.to("cpu") + torch.cuda.empty_cache() + + if not output_type == "latent": + image = self.vae.decode(latents / self.vae.config.scaling_factor, return_dict=False)[0] + image, has_nsfw_concept = self.run_safety_checker(image, device, prompt_embeds.dtype) + else: + image = latents + has_nsfw_concept = None + + if has_nsfw_concept is None: + do_denormalize = [True] * image.shape[0] + else: + do_denormalize = [not has_nsfw for has_nsfw in has_nsfw_concept] + + image = self.image_processor.postprocess(image, output_type=output_type, do_denormalize=do_denormalize) + + # Offload last model to CPU + if hasattr(self, "final_offload_hook") and self.final_offload_hook is not None: + self.final_offload_hook.offload() + + if not return_dict: + return (image, has_nsfw_concept) + + return StableDiffusionPipelineOutput(images=image, nsfw_content_detected=has_nsfw_concept) \ No newline at end of file diff --git a/ip_adapter_controlnet_demo.ipynb b/ip_adapter_controlnet_demo.ipynb new file mode 100644 index 0000000..920af09 --- /dev/null +++ b/ip_adapter_controlnet_demo.ipynb @@ -0,0 +1,367 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "411c59b3-f177-4a10-8925-d931ce572eaa", + "metadata": {}, + "outputs": [], + "source": [ + "from types import MethodType\n", + "\n", + "import torch\n", + "from diffusers import StableDiffusionControlNetPipeline, DDIMScheduler, AutoencoderKL, ControlNetModel\n", + "from PIL import Image\n", + "\n", + "from ip_adapter import IPAdapter\n", + "from ip_adapter.utils import generate" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6b6dc69c-192d-4d74-8b1e-f0d9ccfbdb49", + "metadata": {}, + "outputs": [], + "source": [ + "base_model_path = \"runwayml/stable-diffusion-v1-5\"\n", + "vae_model_path = \"stabilityai/sd-vae-ft-mse\"\n", + "image_encoder_path = \"models/image_encoder/\"\n", + "ip_ckpt = \"models/ip-adapter_sd15.bin\"\n", + "device = \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "63ec542f-8474-4f38-9457-073425578073", + "metadata": {}, + "outputs": [], + "source": [ + "def image_grid(imgs, rows, cols):\n", + " assert len(imgs) == rows*cols\n", + "\n", + " w, h = imgs[0].size\n", + " grid = Image.new('RGB', size=(cols*w, rows*h))\n", + " grid_w, grid_h = grid.size\n", + " \n", + " for i, img in enumerate(imgs):\n", + " grid.paste(img, box=(i%cols*w, i//cols*h))\n", + " return grid\n", + "\n", + "noise_scheduler = DDIMScheduler(\n", + " num_train_timesteps=1000,\n", + " beta_start=0.00085,\n", + " beta_end=0.012,\n", + " beta_schedule=\"scaled_linear\",\n", + " clip_sample=False,\n", + " set_alpha_to_one=False,\n", + " steps_offset=1,\n", + ")\n", + "vae = AutoencoderKL.from_pretrained(vae_model_path).to(dtype=torch.float16)" + ] + }, + { + "cell_type": "markdown", + "id": "fed4baf0-eb72-47c6-8b5b-4046c7c7c72e", + "metadata": {}, + "source": [ + "## ControlNet Depth" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3849f9d0-5f68-4a49-9190-69dd50720cae", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a822c255f80642e08cd22dc1c9545550", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00 by passing `safety_checker=None`. Ensure that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling it only for use-cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .\n" + ] + } + ], + "source": [ + "# load controlnet\n", + "controlnet_model_path = \"lllyasviel/control_v11f1p_sd15_depth\"\n", + "controlnet = ControlNetModel.from_pretrained(controlnet_model_path, torch_dtype=torch.float16)\n", + "# load SD pipeline\n", + "pipe = StableDiffusionControlNetPipeline.from_pretrained(\n", + " base_model_path,\n", + " controlnet=controlnet,\n", + " torch_dtype=torch.float16,\n", + " scheduler=noise_scheduler,\n", + " vae=vae,\n", + " feature_extractor=None,\n", + " safety_checker=None\n", + ")\n", + "pipe.__call__ = MethodType(generate, pipe)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec09e937-3904-4d8e-a559-9066502ded36", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/statue.png\")\n", + "depth_map = Image.open(\"assets/structure_controls/depth.png\")\n", + "image_grid([image.resize((256, 256)), depth_map.resize((256, 256))], 1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "81b1ab06-d3ed-4a7e-a356-9ddf1a2eecd6", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b77f52de-a9e4-44e1-aeec-8165414f1273", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ed4a64933b414202a1c2724bd1988289", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# generate image variations\n", + "images = ip_model.generate(pil_image=image, image=depth_map, num_samples=4, num_inference_steps=50, seed=42)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "markdown", + "id": "cf199405-7cb5-4f78-9973-5fe51c632a41", + "metadata": {}, + "source": [ + "## ControlNet OpenPose" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6f089ad0-4683-46d7-ab58-9e5fe8f34c67", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e9fb34c2936e412e844881f4fe07b4f0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00 by passing `safety_checker=None`. Ensure that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling it only for use-cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .\n" + ] + } + ], + "source": [ + "# load SD Img2Img pipe\n", + "del pipe, ip_model\n", + "torch.cuda.empty_cache()\n", + "# load controlnet\n", + "controlnet_model_path = \"lllyasviel/control_v11p_sd15_openpose\"\n", + "controlnet = ControlNetModel.from_pretrained(controlnet_model_path, torch_dtype=torch.float16)\n", + "# load SD pipeline\n", + "pipe = StableDiffusionControlNetPipeline.from_pretrained(\n", + " base_model_path,\n", + " controlnet=controlnet,\n", + " torch_dtype=torch.float16,\n", + " scheduler=noise_scheduler,\n", + " vae=vae,\n", + " feature_extractor=None,\n", + " safety_checker=None\n", + ")\n", + "pipe.__call__ = MethodType(generate, pipe)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b8db2b55-2f56-4eef-b2ca-c5126b14feb7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/girl.png\")\n", + "image.resize((256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "346d1e25-5b50-4d2e-851d-4ba620a55ce3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "openpose_image = Image.open(\"assets/structure_controls/openpose.png\")\n", + "openpose_image.resize((256, 384))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "a501f284-f295-4673-96ab-e34378da62ab", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f58fff74-9ff2-46e6-bc8a-2ad4ae1fbe0f", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "dd20f0f010174f63b7588c9a3152e7df", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# generate\n", + "images = ip_model.generate(pil_image=image, image=openpose_image, width=512, height=768, num_samples=4, num_inference_steps=50, seed=42)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ip_adapter_demo.ipynb b/ip_adapter_demo.ipynb new file mode 100644 index 0000000..8ddf552 --- /dev/null +++ b/ip_adapter_demo.ipynb @@ -0,0 +1,489 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "411c59b3-f177-4a10-8925-d931ce572eaa", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionInpaintPipelineLegacy, DDIMScheduler, AutoencoderKL\n", + "from PIL import Image\n", + "\n", + "from ip_adapter import IPAdapter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6b6dc69c-192d-4d74-8b1e-f0d9ccfbdb49", + "metadata": {}, + "outputs": [], + "source": [ + "base_model_path = \"runwayml/stable-diffusion-v1-5\"\n", + "vae_model_path = \"stabilityai/sd-vae-ft-mse\"\n", + "image_encoder_path = \"models/image_encoder/\"\n", + "ip_ckpt = \"models/ip-adapter_sd15.bin\"\n", + "device = \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "63ec542f-8474-4f38-9457-073425578073", + "metadata": {}, + "outputs": [], + "source": [ + "def image_grid(imgs, rows, cols):\n", + " assert len(imgs) == rows*cols\n", + "\n", + " w, h = imgs[0].size\n", + " grid = Image.new('RGB', size=(cols*w, rows*h))\n", + " grid_w, grid_h = grid.size\n", + " \n", + " for i, img in enumerate(imgs):\n", + " grid.paste(img, box=(i%cols*w, i//cols*h))\n", + " return grid\n", + "\n", + "noise_scheduler = DDIMScheduler(\n", + " num_train_timesteps=1000,\n", + " beta_start=0.00085,\n", + " beta_end=0.012,\n", + " beta_schedule=\"scaled_linear\",\n", + " clip_sample=False,\n", + " set_alpha_to_one=False,\n", + " steps_offset=1,\n", + ")\n", + "vae = AutoencoderKL.from_pretrained(vae_model_path).to(dtype=torch.float16)" + ] + }, + { + "cell_type": "markdown", + "id": "d8081d92-8f42-4bcd-9f83-44aec3f549a9", + "metadata": {}, + "source": [ + "## Image Variations" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3849f9d0-5f68-4a49-9190-69dd50720cae", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "7226ae3609a44cdd83e38c5acee81bcf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00 by passing `safety_checker=None`. Ensure that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling it only for use-cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .\n" + ] + } + ], + "source": [ + "# load SD pipeline\n", + "pipe = StableDiffusionPipeline.from_pretrained(\n", + " base_model_path,\n", + " torch_dtype=torch.float16,\n", + " scheduler=noise_scheduler,\n", + " vae=vae,\n", + " feature_extractor=None,\n", + " safety_checker=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "ec09e937-3904-4d8e-a559-9066502ded36", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/woman.png\")\n", + "image.resize((256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "81b1ab06-d3ed-4a7e-a356-9ddf1a2eecd6", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b77f52de-a9e4-44e1-aeec-8165414f1273", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9cf9cf02f0284a6f849f717d7c552952", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# generate image variations\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "markdown", + "id": "cf199405-7cb5-4f78-9973-5fe51c632a41", + "metadata": {}, + "source": [ + "## Image-to-Image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "6f089ad0-4683-46d7-ab58-9e5fe8f34c67", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "41232aaa4fda4c0795b52a94350dffb8", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00 by passing `safety_checker=None`. Ensure that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling it only for use-cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .\n" + ] + } + ], + "source": [ + "# load SD Img2Img pipe\n", + "del pipe, ip_model\n", + "torch.cuda.empty_cache()\n", + "pipe = StableDiffusionImg2ImgPipeline.from_pretrained(\n", + " base_model_path,\n", + " torch_dtype=torch.float16,\n", + " scheduler=noise_scheduler,\n", + " vae=vae,\n", + " feature_extractor=None,\n", + " safety_checker=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b8db2b55-2f56-4eef-b2ca-c5126b14feb7", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/river.png\")\n", + "g_image = Image.open(\"assets/images/vermeer.jpg\")\n", + "image_grid([image.resize((256, 256)), g_image.resize((256, 256))], 1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "a501f284-f295-4673-96ab-e34378da62ab", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "f58fff74-9ff2-46e6-bc8a-2ad4ae1fbe0f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/conda/lib/python3.10/site-packages/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion_img2img.py:545: FutureWarning: You have passed 4 text prompts (`prompt`), but only 1 initial images (`image`). Initial images are now duplicating to match the number of text prompts. Note that this behavior is deprecated and will be removed in a version 1.0.0. Please make sure to update your script to pass as many initial images as text prompts to suppress this warning.\n", + " deprecate(\"len(prompt) != len(image)\", \"1.0.0\", deprecation_message, standard_warn=False)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8a5dd099a5da4c3bb53d0678721159f0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/30 [00:00" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# generate\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42, image=g_image, strength=0.6)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "markdown", + "id": "420a7c45-8697-411f-8374-3c81d5d972e3", + "metadata": {}, + "source": [ + "## Inpainting" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "385cb339-3326-4523-a7db-b09e62d39c80", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5a7def607faa4f8982596bdb13a4491a", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00 is deprecated and will be removed in v1.0.0. You can achieve exactly the same functionalityby loading your model into `StableDiffusionInpaintPipeline` instead. See https://github.com/huggingface/diffusers/pull/3533for more information.\n", + " deprecate(\"legacy is outdated\", \"1.0.0\", deprecation_message, standard_warn=False)\n", + "You have disabled the safety checker for by passing `safety_checker=None`. Ensure that you abide to the conditions of the Stable Diffusion license and do not expose unfiltered results in services or applications open to the public. Both the diffusers team and Hugging Face strongly recommend to keep the safety filter enabled in all public facing circumstances, disabling it only for use-cases that involve analyzing network behavior or auditing its results. For more information, please have a look at https://github.com/huggingface/diffusers/pull/254 .\n" + ] + } + ], + "source": [ + "# load SD Inpainting pipe\n", + "del pipe, ip_model\n", + "torch.cuda.empty_cache()\n", + "pipe = StableDiffusionInpaintPipelineLegacy.from_pretrained(\n", + " base_model_path,\n", + " torch_dtype=torch.float16,\n", + " scheduler=noise_scheduler,\n", + " vae=vae,\n", + " feature_extractor=None,\n", + " safety_checker=None\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c47f8ce5-eed0-41ef-9dbb-2272ec4bc224", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/girl.png\")\n", + "image.resize((256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f9b77289-65f5-459b-ada5-5c7c265bb4a6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "masked_image = Image.open(\"assets/inpainting/image.png\").resize((512, 768))\n", + "mask = Image.open(\"assets/inpainting/mask.png\").resize((512, 768))\n", + "image_grid([masked_image.resize((256, 384)), mask.resize((256, 384))], 1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "e49dbdaa-58eb-4bcf-acab-fa5e08f96dcb", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "945f6800-18b8-4d95-9f5e-e7035166cbbd", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "471d070b36bc4883b7abadba368bd16f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/35 [00:00" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# generate\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50,\n", + " seed=42, image=masked_image, mask_image=mask, strength=0.7, )\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ip_adapter_multimodal_prompts_demo.ipynb b/ip_adapter_multimodal_prompts_demo.ipynb new file mode 100644 index 0000000..66fb19e --- /dev/null +++ b/ip_adapter_multimodal_prompts_demo.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "411c59b3-f177-4a10-8925-d931ce572eaa", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from diffusers import StableDiffusionPipeline, StableDiffusionImg2ImgPipeline, StableDiffusionInpaintPipelineLegacy, DDIMScheduler, AutoencoderKL\n", + "from PIL import Image\n", + "\n", + "from ip_adapter import IPAdapter" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6b6dc69c-192d-4d74-8b1e-f0d9ccfbdb49", + "metadata": {}, + "outputs": [], + "source": [ + "base_model_path = \"SG161222/Realistic_Vision_V4.0_noVAE\"\n", + "vae_model_path = \"stabilityai/sd-vae-ft-mse\"\n", + "image_encoder_path = \"models/image_encoder/\"\n", + "ip_ckpt = \"models/ip-adapter_sd15.bin\"\n", + "device = \"cuda\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "63ec542f-8474-4f38-9457-073425578073", + "metadata": {}, + "outputs": [], + "source": [ + "def image_grid(imgs, rows, cols):\n", + " assert len(imgs) == rows*cols\n", + "\n", + " w, h = imgs[0].size\n", + " grid = Image.new('RGB', size=(cols*w, rows*h))\n", + " grid_w, grid_h = grid.size\n", + " \n", + " for i, img in enumerate(imgs):\n", + " grid.paste(img, box=(i%cols*w, i//cols*h))\n", + " return grid\n", + "\n", + "noise_scheduler = DDIMScheduler(\n", + " num_train_timesteps=1000,\n", + " beta_start=0.00085,\n", + " beta_end=0.012,\n", + " beta_schedule=\"scaled_linear\",\n", + " clip_sample=False,\n", + " set_alpha_to_one=False,\n", + " steps_offset=1,\n", + ")\n", + "vae = AutoencoderKL.from_pretrained(vae_model_path).to(dtype=torch.float16)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "3849f9d0-5f68-4a49-9190-69dd50720cae", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fdc6b36320b445a9bbb387a40d227d50", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading pipeline components...: 0%| | 0/5 [00:00" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/woman.png\")\n", + "image.resize((256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a23de3d2-169e-470b-8012-960e3d07b04b", + "metadata": {}, + "outputs": [], + "source": [ + "# load ip-adapter\n", + "ip_model = IPAdapter(pipe, image_encoder_path, ip_ckpt, device)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "d83df45f-717d-4bb3-a5fd-0ea30930a431", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "64e5688841e148988401633412f22656", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# only image prompt\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b77f52de-a9e4-44e1-aeec-8165414f1273", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0f7425a81c46477983b31ec6a9a18449", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# multimodal prompts\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42,\n", + " prompt=\"best quality, high quality, wearing a hat on the beach\", scale=0.6)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1e411dbc-423a-4c14-bf93-6423c2444341", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read image prompt\n", + "image = Image.open(\"assets/images/statue.png\")\n", + "image.resize((256, 256))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "36081858-b354-430e-9ff1-015576c0a339", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0b2ee4a6ec2a48998aba48486b49c9b3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# only image prompt\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5d3d874a-49b2-4c7e-ad58-b0ecc085c1fd", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "73d89883ef604416802b28f041da2fa9", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/50 [00:00" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# multimodal prompts\n", + "images = ip_model.generate(pil_image=image, num_samples=4, num_inference_steps=50, seed=42,\n", + " prompt=\"best quality, high quality, in a garden with flowers\", scale=0.5)\n", + "grid = image_grid(images, 1, 4)\n", + "grid" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}