o Gi@sddlmZddlZddlZddlmZmZmZm Z m Z ddl m Z m Z mZddlmZmZmZddlmZdd lmZd d lmZd d lmZd d lmZd dlmZd dlm Z dZ!dZ"dZ#GdddeZ$GdddeZ%GdddeZ&dS))CallableN)CLIPImageProcessorCLIPTextModelWithProjection CLIPTokenizerCLIPVisionModelWithProjectionXLMRobertaTokenizer)PriorTransformerUNet2DConditionModelVQModel) DDIMScheduler DDPMSchedulerUnCLIPScheduler)replace_example_docstring)DiffusionPipeline)KandinskyPipeline)KandinskyImg2ImgPipeline)KandinskyInpaintPipeline)KandinskyPriorPipeline)MultilingualCLIPa Examples: ```py from diffusers import AutoPipelineForText2Image import torch pipe = AutoPipelineForText2Image.from_pretrained( "kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16 ) pipe.enable_model_cpu_offload() prompt = "A lion in galaxies, spirals, nebulae, stars, smoke, iridescent, intricate detail, octane render, 8k" image = pipe(prompt=prompt, num_inference_steps=25).images[0] ``` a~ Examples: ```py from diffusers import AutoPipelineForImage2Image import torch import requests from io import BytesIO from PIL import Image import os pipe = AutoPipelineForImage2Image.from_pretrained( "kandinsky-community/kandinsky-2-1", torch_dtype=torch.float16 ) pipe.enable_model_cpu_offload() prompt = "A fantasy landscape, Cinematic lighting" negative_prompt = "low quality, bad quality" url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg" response = requests.get(url) image = Image.open(BytesIO(response.content)).convert("RGB") image.thumbnail((768, 768)) image = pipe(prompt=prompt, image=original_image, num_inference_steps=25).images[0] ``` a Examples: ```py from diffusers import AutoPipelineForInpainting from diffusers.utils import load_image import torch import numpy as np pipe = AutoPipelineForInpainting.from_pretrained( "kandinsky-community/kandinsky-2-1-inpaint", torch_dtype=torch.float16 ) pipe.enable_model_cpu_offload() prompt = "A fantasy landscape, Cinematic lighting" negative_prompt = "low quality, bad quality" original_image = load_image( "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main" "/kandinsky/cat.png" ) mask = np.zeros((768, 768), dtype=np.float32) # Let's mask out an area above the cat's head mask[:250, 250:-250] = 1 image = pipe(prompt=prompt, image=original_image, mask_image=mask, num_inference_steps=25).images[0] ``` c!sZeZdZdZdZdZdgZdedede de e Bd e de d ed ed ed edeffdd Zd4dedBfddZd5dedBdejeBfddZd5ddZddZeee      !   "   d6d#ee eBd$ee eBdBd%ed&e!d'ed(ed)ed*e!d+ed,ej"e ej"BdBd-ej#dBd.edBd/eeeej#gdfdBd0ed1e$fd2d3Z%Z&S)7KandinskyCombinedPipelinea Combined Pipeline for text-to-image generation using Kandinsky This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) Args: text_encoder ([`MultilingualCLIP`]): Frozen text-encoder. tokenizer ([`XLMRobertaTokenizer`]): Tokenizer of class scheduler (`DDIMScheduler` | `DDPMScheduler`): A scheduler to be used in combination with `unet` to generate image latents. unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the image embedding. movq ([`VQModel`]): MoVQ Decoder to generate the image from the latents. prior_prior ([`PriorTransformer`]): The canonical unCLIP prior to approximate the image embedding from the text embedding. prior_image_encoder ([`CLIPVisionModelWithProjection`]): Frozen image-encoder. prior_text_encoder ([`CLIPTextModelWithProjection`]): Frozen text-encoder. prior_tokenizer (`CLIPTokenizer`): Tokenizer of class [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). prior_scheduler ([`UnCLIPScheduler`]): A scheduler to be used in combination with `prior` to generate image embedding. TzNtext_encoder->unet->movq->prior_prior->prior_image_encoder->prior_text_encoder prior_prior text_encoder tokenizerunet schedulermovqprior_image_encoderprior_text_encoderprior_tokenizerprior_schedulerprior_image_processorc Xt|j||||||||| | | d t|||| | | d|_t|||||d|_dSN) rrrrrrrr r!r"r#)prior image_encoderrrrimage_processor)rrrrr)super__init__register_modulesr prior_piper decoder_pipe selfrrrrrrrr r!r"r# __class__m/home/ubuntu/.local/lib/python3.10/site-packages/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.pyr*:   z"KandinskyCombinedPipeline.__init__N attention_opcC|j|dSNr-*enable_xformers_memory_efficient_attentionr/r5r2r2r3r9zDKandinskyCombinedPipeline.enable_xformers_memory_efficient_attentiongpu_iddevicecC$|jj||d|jj||ddS)u Offloads all models (`unet`, `text_encoder`, `vae`, and `safety checker` state dicts) to CPU using 🤗 Accelerate, significantly reducing memory usage. Models are moved to a `torch.device('meta')` and loaded on a GPU only when their specific submodule's `forward` method is called. Offloading happens on a submodule basis. Memory savings are higher than using `enable_model_cpu_offload`, but performance is lower. r<r=Nr,enable_sequential_cpu_offloadr-r/r<r=r2r2r3rAsz7KandinskyCombinedPipeline.enable_sequential_cpu_offloadcC.|jj||d|jj||d|jdSN)iterabletotalr, progress_barr-enable_model_cpu_offloadr/rErFr2r2r3rHz&KandinskyCombinedPipeline.progress_barcK(|jjdi||jjdi|dSNr2r,set_progress_bar_configr-r/kwargsr2r2r3rOz1KandinskyCombinedPipeline.set_progress_bar_configd@rpilpromptnegative_promptnum_inference_stepsguidance_scalenum_images_per_promptheightwidthprior_guidance_scaleprior_num_inference_steps generatorlatents output_typecallbackcallback_steps return_dictcCs|j|||| | | |ddd }|d}|d}t|ttfs |gn|}t||jdkrA|jdt|dkrA|jdt||}|j||||||| || | ||d }||S)a Function invoked when calling the pipeline for generation. Args: prompt (`str` or `list[str]`): The prompt or prompts to guide the image generation. negative_prompt (`str` or `list[str]`, *optional*): The prompt or prompts not to guide the image generation. 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. num_inference_steps (`int`, *optional*, defaults to 100): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. height (`int`, *optional*, defaults to 512): The height in pixels of the generated image. width (`int`, *optional*, defaults to 512): The width in pixels of the generated image. prior_guidance_scale (`float`, *optional*, defaults to 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. prior_num_inference_steps (`int`, *optional*, defaults to 100): 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 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. 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.Tensor`, *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 be generated by sampling using the supplied random `generator`. output_type (`str`, *optional*, defaults to `"pil"`): The output format of the generate image. Choose between: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) or `"pt"` (`torch.Tensor`). callback (`Callable`, *optional*): A function that calls every `callback_steps` steps during inference. The function is called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *optional*, defaults to 1): The frequency at which the `callback` function is called. If not specified, the callback is called at every step. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple. Examples: Returns: [`~pipelines.ImagePipelineOutput`] or `tuple` ptF rXrYr\rZrarbr[rcrfrr) rX image_embedsnegative_image_embedsr^r]rZrar[rcrdrerf)r, isinstancelisttuplelenshaper-maybe_free_model_hooks)r/rXrYrZr[r\r]r^r_r`rarbrcrdrerf prior_outputsrirjoutputsr2r2r3__call__s@M (z"KandinskyCombinedPipeline.__call__r7NNNrSrTrrUrUrTrVNNrWNrT)'__name__ __module__ __qualname____doc___load_connected_pipesmodel_cpu_offload_seq_exclude_from_cpu_offloadrrr r r r r rrrrrr*rr9inttorchr=strrArHrOno_gradrTEXT2IMAGE_EXAMPLE_DOC_STRINGrlfloat GeneratorTensorboolrs __classcell__r2r2r0r3rqs    -       rc%seZdZdZdZdZdgZdedede de e Bd e de d ed ed ed edeffdd Zd7dedBfddZd8dedBdejeBfddZd8ddZddZeee     ! !  "   #   d9d$ee eBd%ej!e"j#j#Be ej!Be e"j#j#Bd&ee eBdBd'ed(e$d)ed*e$d+ed,ed-e$d.ed/ej%e ej%BdBd0ej!dBd1edBd2eeeej!gdfdBd3ed4e&f"d5d6Z'Z(S): KandinskyImg2ImgCombinedPipelinea Combined Pipeline for image-to-image generation using Kandinsky This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) Args: text_encoder ([`MultilingualCLIP`]): Frozen text-encoder. tokenizer ([`XLMRobertaTokenizer`]): Tokenizer of class scheduler (`DDIMScheduler` | `DDPMScheduler`): A scheduler to be used in combination with `unet` to generate image latents. unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the image embedding. movq ([`VQModel`]): MoVQ Decoder to generate the image from the latents. prior_prior ([`PriorTransformer`]): The canonical unCLIP prior to approximate the image embedding from the text embedding. prior_image_encoder ([`CLIPVisionModelWithProjection`]): Frozen image-encoder. prior_text_encoder ([`CLIPTextModelWithProjection`]): Frozen text-encoder. prior_tokenizer (`CLIPTokenizer`): Tokenizer of class [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). prior_scheduler ([`UnCLIPScheduler`]): A scheduler to be used in combination with `prior` to generate image embedding. TNprior_text_encoder->prior_image_encoder->prior_prior->text_encoder->unet->movqrrrrrrrr r!r"r#c r$r%)r)r*r+rr,rr-r.r0r2r3r*nr4z)KandinskyImg2ImgCombinedPipeline.__init__Nr5cCr6r7r8r:r2r2r3r9r;zKKandinskyImg2ImgCombinedPipeline.enable_xformers_memory_efficient_attentionr<r=cCr>a Offloads all models to CPU using accelerate, significantly reducing memory usage. When called, unet, text_encoder, vae and safety checker have their state dicts saved to CPU and then are moved to a `torch.device('meta') and loaded to GPU only when their specific submodule has its `forward` method called. Note that offloading happens on a submodule basis. Memory savings are higher than with `enable_model_cpu_offload`, but performance is lower. r?Nr@rBr2r2r3rAz>KandinskyImg2ImgCombinedPipeline.enable_sequential_cpu_offloadcCrCrDrGrJr2r2r3rHrKz-KandinskyImg2ImgCombinedPipeline.progress_barcKrLrMrNrPr2r2r3rOrRz8KandinskyImg2ImgCombinedPipeline.set_progress_bar_configrSrTr333333?rUrVrWrXimagerYrZr[r\strengthr]r^r_r`rarbrcrdrerfcCs|j|||| | | | ddd }|d}|d}t|ttfs |gn|}t|tjjr,|gn|}t||jdkrM|jdt|dkrM|jdt||}t|ttfrst||jdkrs|jdt|dkrs|jdt||}|j|||||| ||| |||||d}| |S)a Function invoked when calling the pipeline for generation. Args: prompt (`str` or `list[str]`): The prompt or prompts to guide the image generation. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, or `list[np.ndarray]`): `Image`, or tensor representing an image batch, that will be used as the starting point for the process. Can also accept image latents as `image`, if passing latents directly, it will not be encoded again. negative_prompt (`str` or `list[str]`, *optional*): The prompt or prompts not to guide the image generation. 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. num_inference_steps (`int`, *optional*, defaults to 100): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. height (`int`, *optional*, defaults to 512): The height in pixels of the generated image. width (`int`, *optional*, defaults to 512): The width in pixels of the generated image. strength (`float`, *optional*, defaults to 0.3): Conceptually, indicates how much to transform the reference `image`. Must be between 0 and 1. `image` will be used as a starting point, adding more noise to it the larger the `strength`. The number of denoising steps depends on the amount of noise initially added. When `strength` is 1, added noise will be maximum and the denoising process will run for the full number of iterations specified in `num_inference_steps`. A value of 1, therefore, essentially ignores `image`. prior_guidance_scale (`float`, *optional*, defaults to 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. prior_num_inference_steps (`int`, *optional*, defaults to 100): 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 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. 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.Tensor`, *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 be generated by sampling using the supplied random `generator`. output_type (`str`, *optional*, defaults to `"pil"`): The output format of the generate image. Choose between: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) or `"pt"` (`torch.Tensor`). callback (`Callable`, *optional*): A function that calls every `callback_steps` steps during inference. The function is called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *optional*, defaults to 1): The frequency at which the `callback` function is called. If not specified, the callback is called at every step. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple. Examples: Returns: [`~pipelines.ImagePipelineOutput`] or `tuple` rgFrhrr)rXrrirjrr^r]rZrar[rcrdrerf r,rkrlrmPILImagernror-rp)r/rXrrYrZr[r\rr]r^r_r`rarbrcrdrerfrqrirjrrr2r2r3rssPY ( z)KandinskyImg2ImgCombinedPipeline.__call__r7rt)NrSrTrrrUrUrTrVNNrWNrT))rvrwrxryrzr{r|rrr r r r r rrrrrr*rr9r}r~r=rrArHrOrrIMAGE2IMAGE_EXAMPLE_DOC_STRINGrlrrrrrrrsrr2r2r0r3rKs    -  "     rc%seZdZdZdZdZdgZdedede de e Bd e de d ed ed ed edeffdd Zd6dedBfddZd7dedBdejeBfddZd7ddZddZeee      !   "   d8d#ee eBd$ej!e"j#j#Be ej!Be e"j#j#Bd%ej!e"j#j#Be ej!Be e"j#j#Bd&ee eBdBd'ed(e$d)ed*ed+ed,e$d-ed.ej%e ej%BdBd/ej!dBd0edBd1eeeej!gdfdBd2ed3e&f"d4d5Z'Z(S)9 KandinskyInpaintCombinedPipelinea Combined Pipeline for generation using Kandinsky This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.) Args: text_encoder ([`MultilingualCLIP`]): Frozen text-encoder. tokenizer ([`XLMRobertaTokenizer`]): Tokenizer of class scheduler (`DDIMScheduler` | `DDPMScheduler`): A scheduler to be used in combination with `unet` to generate image latents. unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the image embedding. movq ([`VQModel`]): MoVQ Decoder to generate the image from the latents. prior_prior ([`PriorTransformer`]): The canonical unCLIP prior to approximate the image embedding from the text embedding. prior_image_encoder ([`CLIPVisionModelWithProjection`]): Frozen image-encoder. prior_text_encoder ([`CLIPTextModelWithProjection`]): Frozen text-encoder. prior_tokenizer (`CLIPTokenizer`): Tokenizer of class [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer). prior_scheduler ([`UnCLIPScheduler`]): A scheduler to be used in combination with `prior` to generate image embedding. Trrrrrrrrr r!r"r#c r$r%)r)r*r+rr,rr-r.r0r2r3r*_r4z)KandinskyInpaintCombinedPipeline.__init__Nr5cCr6r7r8r:r2r2r3r9r;zKKandinskyInpaintCombinedPipeline.enable_xformers_memory_efficient_attentionr<r=cCr>rr@rBr2r2r3rArz>KandinskyInpaintCombinedPipeline.enable_sequential_cpu_offloadcCrCrDrGrJr2r2r3rHrKz-KandinskyInpaintCombinedPipeline.progress_barcKrLrMrNrPr2r2r3rOrRz8KandinskyInpaintCombinedPipeline.set_progress_bar_configrSrTrrUrVrWrXr mask_imagerYrZr[r\r]r^r_r`rarbrcrdrerfcCs||j|||| | | | ddd }|d}|d}t|ttfs |gn|}t|tjjr,|gn|}t|tjjr8|gn|}t||jdkrY|jdt|dkrY|jdt||}t|ttfrt||jdkr|jdt|dkr|jdt||}t|ttfrt||jdkr|jdt|dkr|jdt||}|j|||||| ||| |||||d}| |S)a Function invoked when calling the pipeline for generation. Args: prompt (`str` or `list[str]`): The prompt or prompts to guide the image generation. image (`torch.Tensor`, `PIL.Image.Image`, `np.ndarray`, `list[torch.Tensor]`, `list[PIL.Image.Image]`, or `list[np.ndarray]`): `Image`, or tensor representing an image batch, that will be used as the starting point for the process. Can also accept image latents as `image`, if passing latents directly, it will not be encoded again. mask_image (`np.array`): Tensor representing an image batch, to mask `image`. White pixels in the mask will be repainted, while black pixels will be preserved. If `mask_image` is a PIL image, it will be converted to a single channel (luminance) before use. If it's a tensor, it should contain one color channel (L) instead of 3, so the expected shape would be `(B, H, W, 1)`. negative_prompt (`str` or `list[str]`, *optional*): The prompt or prompts not to guide the image generation. 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. num_inference_steps (`int`, *optional*, defaults to 100): The number of denoising steps. More denoising steps usually lead to a higher quality image at the expense of slower inference. height (`int`, *optional*, defaults to 512): The height in pixels of the generated image. width (`int`, *optional*, defaults to 512): The width in pixels of the generated image. prior_guidance_scale (`float`, *optional*, defaults to 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. prior_num_inference_steps (`int`, *optional*, defaults to 100): 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 4.0): Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://huggingface.co/papers/2207.12598). `guidance_scale` is defined as `w` of equation 2. of [Imagen Paper](https://huggingface.co/papers/2205.11487). 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. 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.Tensor`, *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 be generated by sampling using the supplied random `generator`. output_type (`str`, *optional*, defaults to `"pil"`): The output format of the generate image. Choose between: `"pil"` (`PIL.Image.Image`), `"np"` (`np.array`) or `"pt"` (`torch.Tensor`). callback (`Callable`, *optional*): A function that calls every `callback_steps` steps during inference. The function is called with the following arguments: `callback(step: int, timestep: int, latents: torch.Tensor)`. callback_steps (`int`, *optional*, defaults to 1): The frequency at which the `callback` function is called. If not specified, the callback is called at every step. return_dict (`bool`, *optional*, defaults to `True`): Whether or not to return a [`~pipelines.ImagePipelineOutput`] instead of a plain tuple. Examples: Returns: [`~pipelines.ImagePipelineOutput`] or `tuple` rgFrhrr)rXrrrirjr^r]rZrar[rcrdrerfr)r/rXrrrYrZr[r\r]r^r_r`rarbrcrdrerfrqrirjrrr2r2r3rss\X (  z)KandinskyInpaintCombinedPipeline.__call__r7rtru))rvrwrxryrzr{r|rrr r r r r rrrrrr*rr9r}r~r=rrArHrOrrINPAINT_EXAMPLE_DOC_STRINGrlrrrrrrrsrr2r2r0r3r<s    -  ""     r)'typingr PIL.Imagerr~ transformersrrrrrmodelsr r r schedulersr r rutilsrpipeline_utilsrpipeline_kandinskyrpipeline_kandinsky_img2imgrpipeline_kandinsky_inpaintrpipeline_kandinsky_priorrrrrrrrrrr2r2r2r3s*        [r