biddlmZmZmZmZddlZddlZddlm 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&GddeZ'GddeZ(GddeZ)y))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!eZdZdZdZdZdgZdedede de e e fd e ded ed ed ed edeffd Zd(deefdZd)deede ej4effdZd)dZdZej>e e! d*de ee"efdee ee"efdede#dededede#d ed!ee ejHe"ejHfd"eejJd#eed$eeeeejJgdfd%ed&e&fd'Z'xZ(S)+KandinskyCombinedPipelinea 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 t ||j||||||||| | |  t|||| | | |_t ||||||_yN) rr r!r"r#rr$r%r&r'r()prior image_encoderrr r"image_processor)rr r!r"r#)super__init__register_modulesr prior_piper decoder_pipe selfrr r!r"r#rr$r%r&r'r( __class__s t/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/diffusers/pipelines/kandinsky/pipeline_kandinsky_combined.pyr/z"KandinskyCombinedPipeline.__init__s  %# 31++"7  1-+%%1  .%  N attention_opc:|jj|yNr2*enable_xformers_memory_efficient_attentionr4r8s r6r<zDKandinskyCombinedPipeline.enable_xformers_memory_efficient_attention DD\Rr7gpu_iddevicecx|jj|||jj||y)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@Nr1enable_sequential_cpu_offloadr2r4r?r@s r6rDz7KandinskyCombinedPipeline.enable_sequential_cpu_offloads4 55VF5S 77vf7Ur7c|jj|||jj|||jjyN)iterabletotalr1 progress_barr2enable_model_cpu_offloadr4rHrIs r6rKz&KandinskyCombinedPipeline.progress_barD $$he$D &&&F 224r7c t|jjdi||jjdi|yNr1set_progress_bar_configr2r4kwargss r6rSz1KandinskyCombinedPipeline.set_progress_bar_config2///9&9111;F;r7promptnegative_promptnum_inference_stepsguidance_scalenum_images_per_promptheightwidthprior_guidance_scaleprior_num_inference_steps generatorlatents output_typecallbackcallback_steps return_dictc|j|||| | | |dd }|d}|d}t|ttfs|gn|}t ||j dkr<|j dt |zdk(r|j dt |z|z}|j ||||||| || | || }|j|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 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 rWrXr[rYr`rarZrbrerr) rW image_embedsnegative_image_embedsr]r\rYr`rZrbrcrdre)r1 isinstancelisttuplelenshaper2maybe_free_model_hooks)r4rWrXrYrZr[r\r]r^r_r`rarbrcrdre prior_outputsrirjoutputss r6__call__z"KandinskyCombinedPipeline.__call__sZ+"7 9/(  %Q' -a 0!+FT5M!B& v;++A. .<3E3Ea3H3v;3VZ[3["((+s6{:fDF##%"7 3)#)#$   ##%r7r:NNNd@rrxrwNNpilNrT))__name__ __module__ __qualname____doc___load_connected_pipesmodel_cpu_offload_seq_exclude_from_cpu_offloadrr rrrrrr r rr rrr/rrr<inttorchr@strrDrKrSno_gradrTEXT2IMAGE_EXAMPLE_DOC_STRINGrfloat GeneratorTensorboolrs __classcell__r5s@r6rrqsC<!l!.+ &+ '+ # +  56 +  + &+ ;+ 8+ '+ )+  2+ ZSxPXGYSVHSMVRWX]XdXdfiXiRjV5 <U]]_<=<@#& #%&&))+MQ*.%*GK !oc49n%o"%T#Y"78o! o  o # ooo$o$'oE%//43H"HIJo%,,'oc]o8S#u||$or7rc%eZdZdZdZdZdgZdedede de e e fd e ded ed ed ed edeffd Zd*deefdZd+deede ej4effdZd+dZdZej>e e! d,de ee"efde ejFe$jJjJe"ejFe"e$jJjJfdee ee"efdede&dede&ded ed!e&d"ed#ee ejNe"ejNfd$eejFd%eed&eeeeejFgdfd'ed(e(f"d)Z)xZ*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->movqrrr r!r"r#r$r%r&r'r(c t ||j||||||||| | |  t|||| | | |_t ||||||_yr*)r.r/r0rr1rr2r3s r6r/z)KandinskyImg2ImgCombinedPipeline.__init__n  %# 31++"7  1-+%%1  5%  r7Nr8c:|jj|yr:r;r=s r6r<zKKandinskyImg2ImgCombinedPipeline.enable_xformers_memory_efficient_attentionr>r7r?r@cx|jj|||jj||ya 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. rBNrCrEs r6rDz>KandinskyImg2ImgCombinedPipeline.enable_sequential_cpu_offload4 55VF5S 77vf7Ur7c|jj|||jj|||jjyrGrJrMs r6rKz-KandinskyImg2ImgCombinedPipeline.progress_barrNr7c t|jjdi||jjdi|yrPrRrTs r6rSz8KandinskyImg2ImgCombinedPipeline.set_progress_bar_configrVr7rWimagerXrYrZr[strengthr\r]r^r_r`rarbrcrdrec|j|||| | | | dd }|d}|d}t|ttfs|gn|}t|tj j r|gn|}t ||jdkr<|jdt |zdk(r|jdt |z|z}t|ttfrWt ||jdkr<|jdt |zdk(r|jdt |z|z}|j|||||| ||| |||||}|j|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 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` rgFrhrr)rWrrirjrr]r\rYr`rZrbrcrdre r1rkrlrmPILImagernror2rp)r4rWrrXrYrZr[rr\r]r^r_r`rarbrcrdrerqrirjrrs r6rsz)KandinskyImg2ImgCombinedPipeline.__call__s~r+"7 9/(  %Q' -a 0!+FT5M!B&%fciioo>E v;++A. .<3E3Ea3H3v;3VZ[3["((+s6{:fDF utUm ,E \//22""1%E 2a7!''*c%j8EAE##%"7 3)#)#$ " ##%r7r:rt)Nrvrwrg333333?rxrxrwryNNrzNrT)+r{r|r}r~rrrrr rrrrrr r rr rrr/rrr<rrr@rrDrKrSrrIMAGE2IMAGE_EXAMPLE_DOC_STRINGrrrrrrrrsrrs@r6rrKs<!l!.+ &+ '+ # +  56 +  + &+ ;+ 8+ '+ )+  2+ ZSxPXGYS VHSM VRWX]XdXdfiXiRj V5 <U]]_=> <@#& #%&&))+MQ*.%*GK %Ec49n%EU\\399??D4FSYY__H]]^E"%T#Y"78 E ! E  E #EEEE$E$'EE%//43H"HIJE%,,'Ec]E 8S#u||$e e! d,de ee"efde ejFe$jJjJe"ejFe"e$jJjJfde ejFe$jJjJe"ejFe"e$jJjJfdee ee"efdede&deded ed!e&d"ed#ee ejNe"ejNfd$eejFd%eed&eeeeejFgdfd'ed(e(f"d)Z)xZ*S)- 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. Trrrr r!r"r#r$r%r&r'r(c t ||j||||||||| | |  t|||| | | |_t ||||||_yr*)r.r/r0rr1rr2r3s r6r/z)KandinskyInpaintCombinedPipeline.__init___rr7Nr8c:|jj|yr:r;r=s r6r<zKKandinskyInpaintCombinedPipeline.enable_xformers_memory_efficient_attentionr>r7r?r@cx|jj|||jj||yrrCrEs r6rDz>KandinskyInpaintCombinedPipeline.enable_sequential_cpu_offloadrr7c|jj|||jj|||jjyrGrJrMs r6rKz-KandinskyInpaintCombinedPipeline.progress_barrNr7c t|jjdi||jjdi|yrPrRrTs r6rSz8KandinskyInpaintCombinedPipeline.set_progress_bar_configrVr7rWr mask_imagerXrYrZr[r\r]r^r_r`rarbrcrdrec|j|||| | | | dd }|d}|d}t|ttfs|gn|}t|tj j r|gn|}t|tj j r|gn|}t ||jdkr<|jdt |zdk(r|jdt |z|z}t|ttfrWt ||jdkr<|jdt |zdk(r|jdt |z|z}t|ttfrWt ||jdkr<|jdt |zdk(r|jdt |z|z}|j|||||| ||| |||||}|j|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 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` rgFrhrr)rWrrrirjr]r\rYr`rZrbrcrdrer)r4rWrrrXrYrZr[r\r]r^r_r`rarbrcrdrerqrirjrrs r6rsz)KandinskyInpaintCombinedPipeline.__call__sp+"7 9/(  %Q' -a 0!+FT5M!B&%fciioo>E%/ CIIOO%Lj\R\ v;++A. .<3E3Ea3H3v;3VZ[3["((+s6{:fDF utUm ,E \//22""1%E 2a7!''*c%j8EAE zD%= 1J,"4"4Q"77""1%J71<&,,Q/3z?BjPJ##!%"7 3)#)#$ " ##%r7r:rtru)+r{r|r}r~rrrrr rrrrrr r rr rrr/rrr<rrr@rrDrKrSrrINPAINT_EXAMPLE_DOC_STRINGrrrrrrrrsrrs@r6rr<s<!l!.+ &+ '+ # +  56 +  + &+ ;+ 8+ '+ )+  2+ ZSxPXGYS VHSM VRWX]XdXdfiXiRj V5 <U]]_9: <@#& #%&&))+MQ*.%*GK %Lc49n%LU\\399??D4FSYY__H]]^L%,, ell9KTRUR[R[RaRaMbbc L "%T#Y"78 L ! LL #LLL$L$'LE%//43H"HIJL%,,'Lc]L 8S#u||$rs32 FEGG/1@@<*!""8:W 1Wtn'8nbu'8ur7