o pid@sddlmZmZmZmZddlZddlZddlm Z m Z m Z m Z m Z ddlmZmZmZddlmZmZmZddlmZdd lmZd d lmZd d lmZd d lmZd dl m!Z!d dl"m#Z#dZ$dZ%dZ&GdddeZ'GdddeZ(GdddeZ)dS))CallableListOptionalUnionN)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!sVeZdZdZdZdZdgZdedede de e e fd e ded ed ed ed edeffdd Zd3deefddZd4ddZd5ddZddZeee          !   d6d"e ee efd#ee ee efd$e!d%e"d&e!d'e!d(e!d)e"d*e!d+ee ej#e ej#fd,eej$d-eed.eee!e!ej$gdfd/e!d0e%fd1d2Z&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 (Union[`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) rrrr r!rr"r#r$r%r&)prior image_encoderrrr image_processor)rrrr r!)super__init__register_modulesr prior_piper decoder_pipe selfrrrr r!rr"r#r$r%r& __class__w/home/ubuntu/SoloSpeech/.venv/lib/python3.10/site-packages/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.pyr-:   z"KandinskyCombinedPipeline.__init__N attention_opcC|j|dSNr0*enable_xformers_memory_efficient_attentionr2r8r5r5r6r<zDKandinskyCombinedPipeline.enable_xformers_memory_efficient_attentionrcC |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. gpu_idNr/enable_sequential_cpu_offloadr0r2rAr5r5r6rCsz7KandinskyCombinedPipeline.enable_sequential_cpu_offloadcC.|jj||d|jj||d|jdSN)iterabletotalr/ progress_barr0enable_model_cpu_offloadr2rGrHr5r5r6rJz&KandinskyCombinedPipeline.progress_barcK(|jjdi||jjdi|dSNr5r/set_progress_bar_configr0r2kwargsr5r5r6rQz1KandinskyCombinedPipeline.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://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. 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://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. 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 ge 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 rZr[r^r\rcrdr]rerhrr) rZ image_embedsnegative_image_embedsr`r_r\rcr]rerfrgrh)r/ isinstancelisttuplelenshaper0maybe_free_model_hooks)r2rZr[r\r]r^r_r`rarbrcrdrerfrgrh prior_outputsrkrloutputsr5r5r6__call__s@M (z"KandinskyCombinedPipeline.__call__r:rNNNrUrVrrWrWrVrXNNrYNrT)(__name__ __module__ __qualname____doc___load_connected_pipesmodel_cpu_offload_seq_exclude_from_cpu_offloadrr r rrrrr r rrrrr-rrr<rCrJrQtorchno_gradrTEXT2IMAGE_EXAMPLE_DOC_STRINGstrrintfloat GeneratorTensorboolru __classcell__r5r5r3r6rqs     -       rc%seZdZdZdZdZdgZdedede de e e fd e ded ed ed ed edeffdd Zd6deefddZd7ddZd8ddZddZeee       !   "   d9d#e ee efd$e ej!e"j#j#e ej!e e"j#j#fd%ee ee efd&e$d'e%d(e$d)e%d*e$d+e$d,e%d-e$d.ee ej&e ej&fd/eej!d0eed1eee$e$ej!gdfd2e$d3e'f"d4d5Z(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 (Union[`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->movqrrrrr r!r"r#r$r%r&c r'r()r,r-r.rr/rr0r1r3r5r6r-nr7z)KandinskyImg2ImgCombinedPipeline.__init__Nr8cCr9r:r;r=r5r5r6r<r>zKKandinskyImg2ImgCombinedPipeline.enable_xformers_memory_efficient_attentionrcCr?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@NrBrDr5r5r6rCz>KandinskyImg2ImgCombinedPipeline.enable_sequential_cpu_offloadcCrErFrIrLr5r5r6rJrMz-KandinskyImg2ImgCombinedPipeline.progress_barcKrNrOrPrRr5r5r6rQrTz8KandinskyImg2ImgCombinedPipeline.set_progress_bar_configrUrVr333333?rWrXrYrZimager[r\r]r^strengthr_r`rarbrcrdrerfrgrhcCs|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://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. 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://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. 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 ge 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` riFrjrr)rZrrkrlrr`r_r\rcr]rerfrgrh r/rmrnroPILImagerprqr0rr)r2rZrr[r\r]r^rr_r`rarbrcrdrerfrgrhrsrkrlrtr5r5r6rusPY ( z)KandinskyImg2ImgCombinedPipeline.__call__r:rvrw)NrUrVrrrWrWrVrXNNrYNrT)*ryrzr{r|r}r~rrr r rrrrr r rrrrr-rrr<rCrJrQrrrIMAGE2IMAGE_EXAMPLE_DOC_STRINGrrrrrrrrrrurr5r5r3r6rKs     -  "     rc%seZdZdZdZdZdgZdedede de e e fd e ded ed ed ed edeffdd Zd5deefddZd6ddZd7ddZddZeee          !   d8d"e ee efd#e ej!e"j#j#e ej!e e"j#j#fd$e ej!e"j#j#e ej!e e"j#j#fd%ee ee efd&e$d'e%d(e$d)e$d*e$d+e%d,e$d-ee ej&e ej&fd.eej!d/eed0eee$e$ej!gdfd1e$d2e'f"d3d4Z(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 (Union[`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. Trrrrrr r!r"r#r$r%r&c r'r()r,r-r.rr/rr0r1r3r5r6r-_r7z)KandinskyInpaintCombinedPipeline.__init__Nr8cCr9r:r;r=r5r5r6r<r>zKKandinskyInpaintCombinedPipeline.enable_xformers_memory_efficient_attentionrcCr?rrBrDr5r5r6rCrz>KandinskyInpaintCombinedPipeline.enable_sequential_cpu_offloadcCrErFrIrLr5r5r6rJrMz-KandinskyInpaintCombinedPipeline.progress_barcKrNrOrPrRr5r5r6rQrTz8KandinskyInpaintCombinedPipeline.set_progress_bar_configrUrVrrWrXrYrZr mask_imager[r\r]r^r_r`rarbrcrdrerfrgrhcCs||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://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. 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://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. 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 ge 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` riFrjrr)rZrrrkrlr`r_r\rcr]rerfrgrhr)r2rZrrr[r\r]r^r_r`rarbrcrdrerfrgrhrsrkrlrtr5r5r6rus\X (  z)KandinskyInpaintCombinedPipeline.__call__r:rvrwrx)*ryrzr{r|r}r~rrr r rrrrr r rrrrr-rrr<rCrJrQrrrINPAINT_EXAMPLE_DOC_STRINGrrrrrrrrrrurr5r5r3r6r<s     -  ""     r)*typingrrrr PIL.Imagerr transformersrrrr r modelsr r r schedulersrrrutilsrpipeline_utilsrpipeline_kandinskyrpipeline_kandinsky_img2imgrpipeline_kandinsky_inpaintrpipeline_kandinsky_priorrrrrrrrrrr5r5r5r6s*        [r