
"""simple docstring"""



import os
from glob import glob

import imageio
import torch
import torchvision
import wandb
from img_processing import custom_to_pil, loop_post_process, preprocess, preprocess_vqgan
from loaders import load_vqgan
from PIL import Image
from torch import nn

from transformers import CLIPModel, CLIPTokenizerFast
from utils import get_device, get_timestamp, show_pil





class 				a			:



      def __init__(   self     ,	UpperCamelCase_ = "cpu"     ,	UpperCamelCase_ = "openai/clip-vit-large-patch14"      ):
          UpperCAmelCase__	:      List[str]     							=					device
          UpperCAmelCase__	:      Any     							=					CLIPTokenizerFast.from_pretrained(UpperCamelCase_      )
          UpperCAmelCase__	:      Union[str, Any]     							=					[0.48145466, 0.4578275, 0.40821073]
          UpperCAmelCase__	:      int     							=					[0.26862954, 0.26130258, 0.27577711]
          UpperCAmelCase__	:      List[Any]     							=					torchvision.transforms.Normalize(self.image_mean     ,	self.image_std      )
          UpperCAmelCase__	:      List[str]     							=					torchvision.transforms.Resize(224      )
          UpperCAmelCase__	:      Optional[int]     							=					torchvision.transforms.CenterCrop(224      )



      def  __snake_case							(   self     ,	UpperCamelCase_      ):
          UpperCAmelCase__	:      str     							=					self.resize(UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					self.center_crop(UpperCamelCase_      )
          UpperCAmelCase__	:      int     							=					self.normalize(UpperCamelCase_      )
          return images



      def __call__(   self     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	**UpperCamelCase_      ):
          UpperCAmelCase__	:      Any     							=					self.tokenizer(text=UpperCamelCase_     ,	**UpperCamelCase_      )
          UpperCAmelCase__	:      int     							=					self.preprocess_img(UpperCamelCase_      )
          UpperCAmelCase__	:      str     							=					{key: value.to(self.device      ) for (key, value) in encoding.items()}
          return encoding





class 				a			(					nn.Module      ):



      def __init__(   self     ,	UpperCamelCase_=10     ,	UpperCamelCase_=0.01     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=False     ,	UpperCamelCase_=True     ,	UpperCamelCase_="image"     ,	UpperCamelCase_=True     ,	UpperCamelCase_=False     ,	UpperCamelCase_=False     ,	UpperCamelCase_=False     ,	):
          super().__init__()
          UpperCAmelCase__	:      Any     							=					None
          UpperCAmelCase__	:      Any     							=					device if device else get_device()
          if vqgan:
              UpperCAmelCase__	:      List[Any]     							=					vqgan
          else:
              UpperCAmelCase__	:      Optional[int]     							=					load_vqgan(self.device     ,	conf_path=UpperCamelCase_     ,	ckpt_path=UpperCamelCase_      )
          self.vqgan.eval()
          if clip:
              UpperCAmelCase__	:      Union[str, Any]     							=					clip
          else:
              UpperCAmelCase__	:      Optional[Any]     							=					CLIPModel.from_pretrained('openai/clip-vit-base-patch32'      )
          self.clip.to(self.device      )
          UpperCAmelCase__	:      Tuple     							=					ProcessorGradientFlow(device=self.device      )

          UpperCAmelCase__	:      str     							=					iterations
          UpperCAmelCase__	:      List[Any]     							=					lr
          UpperCAmelCase__	:      Optional[Any]     							=					log
          UpperCAmelCase__	:      Optional[Any]     							=					make_grid
          UpperCAmelCase__	:      int     							=					return_val
          UpperCAmelCase__	:      Optional[Any]     							=					quantize
          UpperCAmelCase__	:      Any     							=					self.vqgan.decoder.z_shape



      def  __snake_case							(   self     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=5     ,	UpperCamelCase_=True      ):
          UpperCAmelCase__	:      int     							=					[]
          if output_path is None:
              UpperCAmelCase__	:      Optional[int]     							=					'./animation.gif'
          if input_path is None:
              UpperCAmelCase__	:      Optional[int]     							=					self.save_path
          UpperCAmelCase__	:      List[str]     							=					sorted(glob(input_path + '/*'      )      )
          if not len(UpperCamelCase_      ):
              raise ValueError(
                  'No images found in save path, aborting (did you pass save_intermediate=True to the generate'
                  ' function?)'      )
          if len(UpperCamelCase_      ) == 1:
              print('Only one image found in save path, (did you pass save_intermediate=True to the generate function?)'      )
          UpperCAmelCase__	:      List[Any]     							=					total_duration / len(UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					[frame_duration] * len(UpperCamelCase_      )
          if extend_frames:
              UpperCAmelCase__	:      Optional[int]     							=					1.5
              UpperCAmelCase__	:      List[Any]     							=					3
          for file_name in paths:
              if file_name.endswith('.png'      ):
                  images.append(imageio.imread(UpperCamelCase_      )      )
          imageio.mimsave(UpperCamelCase_     ,	UpperCamelCase_     ,	duration=UpperCamelCase_      )
          print(F'''gif saved to {output_path}'''      )



      def  __snake_case							(   self     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None      ):
          if not (path or img):
              raise ValueError('Input either path or tensor'      )
          if img is not None:
              raise NotImplementedError
          UpperCAmelCase__	:      int     							=					preprocess(Image.open(UpperCamelCase_      )     ,	target_image_size=256      ).to(self.device      )
          UpperCAmelCase__	:      Optional[int]     							=					preprocess_vqgan(UpperCamelCase_      )
          UpperCAmelCase__							,							*UpperCAmelCase__	:      List[str]     							=					self.vqgan.encode(UpperCamelCase_      )
          return z



      def  __snake_case							(   self     ,	UpperCamelCase_      ):
          UpperCAmelCase__	:      Optional[Any]     							=					self.latent.detach().requires_grad_()
          UpperCAmelCase__	:      Dict     							=					base_latent + transform_vector
          if self.quantize:
              UpperCAmelCase__							,							*UpperCAmelCase__	:      Union[str, Any]     							=					self.vqgan.quantize(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      Dict     							=					trans_latent
          return self.vqgan.decode(UpperCamelCase_      )



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_=None      ):
          UpperCAmelCase__	:      List[Any]     							=					self.clip_preprocessor(text=UpperCamelCase_     ,	images=UpperCamelCase_     ,	return_tensors='pt'     ,	padding=UpperCamelCase_      )
          UpperCAmelCase__	:      List[Any]     							=					self.clip(**UpperCamelCase_      )
          UpperCAmelCase__	:      Optional[int]     							=					clip_outputs.logits_per_image
          if weights is not None:
              UpperCAmelCase__	:      Union[str, Any]     							=					similarity_logits * weights
          return similarity_logits.sum()



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      ):
          UpperCAmelCase__	:      Optional[int]     							=					self._get_clip_similarity(pos_prompts['prompts']     ,	UpperCamelCase_     ,	weights=(1 / pos_prompts['weights'])      )
          if neg_prompts:
              UpperCAmelCase__	:      List[str]     							=					self._get_clip_similarity(neg_prompts['prompts']     ,	UpperCamelCase_     ,	weights=neg_prompts['weights']      )
          else:
              UpperCAmelCase__	:      Any     							=					torch.tensor([1]     ,	device=self.device      )
          UpperCAmelCase__	:      Tuple     							=					-torch.log(UpperCamelCase_      ) + torch.log(UpperCamelCase_      )
          return loss



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      ):
          UpperCAmelCase__	:      int     							=					torch.randn_like(self.latent     ,	requires_grad=UpperCamelCase_     ,	device=self.device      )
          UpperCAmelCase__	:      List[str]     							=					torch.optim.Adam([vector]     ,	lr=self.lr      )

          for i in range(self.iterations      ):
              optim.zero_grad()
              UpperCAmelCase__	:      Any     							=					self._add_vector(UpperCamelCase_      )
              UpperCAmelCase__	:      int     							=					loop_post_process(UpperCamelCase_      )
              UpperCAmelCase__	:      List[Any]     							=					self._get_CLIP_loss(UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      )
              print('CLIP loss'     ,	UpperCamelCase_      )
              if self.log:
                  wandb.log({'CLIP Loss': clip_loss}      )
              clip_loss.backward(retain_graph=UpperCamelCase_      )
              optim.step()
              if self.return_val == "image":
                  yield custom_to_pil(transformed_img[0]      )
              else:
                  yield vector



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      ):
          wandb.init(reinit=UpperCamelCase_     ,	project='face-editor'      )
          wandb.config.update({'Positive Prompts': positive_prompts}      )
          wandb.config.update({'Negative Prompts': negative_prompts}      )
          wandb.config.update({'lr': self.lr, 'iterations': self.iterations}      )
          if image_path:
              UpperCAmelCase__	:      Dict     							=					Image.open(UpperCamelCase_      )
              UpperCAmelCase__	:      Tuple     							=					image.resize((256, 256)      )
              wandb.log('Original Image'     ,	wandb.Image(UpperCamelCase_      )      )



      def  __snake_case							(   self     ,	UpperCamelCase_      ):
          if not prompts:
              return []
          UpperCAmelCase__	:      Optional[int]     							=					[]
          UpperCAmelCase__	:      Any     							=					[]
          if isinstance(UpperCamelCase_     ,	UpperCamelCase_      ):
              UpperCAmelCase__	:      Optional[Any]     							=					[prompt.strip() for prompt in prompts.split('|'      )]
          for prompt in prompts:
              if isinstance(UpperCamelCase_     ,	(tuple, list)      ):
                  UpperCAmelCase__	:      int     							=					prompt[0]
                  UpperCAmelCase__	:      Optional[int]     							=					float(prompt[1]      )
              elif ":" in prompt:
                  UpperCAmelCase__							,							UpperCAmelCase__	:      Tuple     							=					prompt.split(':'      )
                  UpperCAmelCase__	:      Dict     							=					float(UpperCamelCase_      )
              else:
                  UpperCAmelCase__	:      int     							=					prompt
                  UpperCAmelCase__	:      Tuple     							=					1.0
              processed_prompts.append(UpperCamelCase_      )
              weights.append(UpperCamelCase_      )
          return {
              "prompts": processed_prompts,
              "weights": torch.tensor(UpperCamelCase_     ,	device=self.device      ),
          }



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_=None     ,	UpperCamelCase_=None     ,	UpperCamelCase_=True     ,	UpperCamelCase_=False     ,	UpperCamelCase_=True     ,	UpperCamelCase_=True     ,	UpperCamelCase_=None     ,	):
          if image_path:
              UpperCAmelCase__	:      Tuple     							=					self._get_latent(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      Any     							=					torch.randn(self.latent_dim     ,	device=self.device      )
          if self.log:
              self._init_logging(UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      )

          assert pos_prompts, "You must provide at least one positive prompt."
          UpperCAmelCase__	:      str     							=					self.process_prompts(UpperCamelCase_      )
          UpperCAmelCase__	:      List[Any]     							=					self.process_prompts(UpperCamelCase_      )
          if save_final and save_path is None:
              UpperCAmelCase__	:      Any     							=					os.path.join('./outputs/'     ,	'_'.join(pos_prompts['prompts']      )      )
          if not os.path.exists(UpperCamelCase_      ):
              os.makedirs(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      Dict     							=					save_path + '_' + get_timestamp()
              os.makedirs(UpperCamelCase_      )
          UpperCAmelCase__	:      List[Any]     							=					save_path

          UpperCAmelCase__	:      Optional[int]     							=					self.vqgan.decode(self.latent      )[0]
          if show_intermediate:
              print('Original Image'      )
              show_pil(custom_to_pil(UpperCamelCase_      )      )

          UpperCAmelCase__	:      List[str]     							=					loop_post_process(UpperCamelCase_      )
          for iter, transformed_img in enumerate(self._optimize_CLIP(UpperCamelCase_     ,	UpperCamelCase_     ,	UpperCamelCase_      )      ):
              if show_intermediate:
                  show_pil(UpperCamelCase_      )
              if save_intermediate:
                  transformed_img.save(os.path.join(self.save_path     ,	F'''iter_{iter:03d}.png'''      )      )
              if self.log:
                  wandb.log({'Image': wandb.Image(UpperCamelCase_      )}      )
          if show_final:
              show_pil(UpperCamelCase_      )
          if save_final:
              transformed_img.save(os.path.join(self.save_path     ,	F'''iter_{iter:03d}_final.png'''      )      )



"""simple docstring"""



import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import XLMRobertaTokenizerFast

from diffusers import DDIMScheduler, KandinskyImgaImgPipeline, KandinskyPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.pipelines.kandinsky.text_encoder import MCLIPConfig, MultilingualCLIP
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


enable_full_determinism()





class 				a			(					lowercase						,		unittest.TestCase      ):
      UpperCamelCase							:   Any           =     KandinskyImgaImgPipeline
      UpperCamelCase							:   int           =     ["""prompt""", """image_embeds""", """negative_image_embeds""", """image"""]
      UpperCamelCase							:   Optional[Any]           =     [
          """prompt""",
          """negative_prompt""",
          """image_embeds""",
          """negative_image_embeds""",
          """image""",
      ]
      UpperCamelCase							:   Union[str, Any]           =     [
          """generator""",
          """height""",
          """width""",
          """strength""",
          """guidance_scale""",
          """negative_prompt""",
          """num_inference_steps""",
          """return_dict""",
          """guidance_scale""",
          """num_images_per_prompt""",
          """output_type""",
          """return_dict""",
      ]
      UpperCamelCase							:   List[str]           =     False



      @property
      def  __snake_case							(   self      ):
          return 32



      @property
      def  __snake_case							(   self      ):
          return 32



      @property
      def  __snake_case							(   self      ):
          return self.time_input_dim



      @property
      def  __snake_case							(   self      ):
          return self.time_input_dim * 4



      @property
      def  __snake_case							(   self      ):
          return 100



      @property
      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      str     							=					XLMRobertaTokenizerFast.from_pretrained('YiYiXu/tiny-random-mclip-base'      )
          return tokenizer



      @property
      def  __snake_case							(   self      ):
          torch.manual_seed(0      )
          UpperCAmelCase__	:      Optional[int]     							=					MCLIPConfig(
              numDims=self.cross_attention_dim     ,	transformerDimensions=self.text_embedder_hidden_size     ,	hidden_size=self.text_embedder_hidden_size     ,	intermediate_size=37     ,	num_attention_heads=4     ,	num_hidden_layers=5     ,	vocab_size=1_005     ,	)

          UpperCAmelCase__	:      Tuple     							=					MultilingualCLIP(UpperCamelCase_      )
          UpperCAmelCase__	:      List[Any]     							=					text_encoder.eval()

          return text_encoder



      @property
      def  __snake_case							(   self      ):
          torch.manual_seed(0      )

          UpperCAmelCase__	:      Optional[Any]     							=					{
              'in_channels': 4,
              # Out channels is double in channels because predicts mean and variance
              'out_channels': 8,
              'addition_embed_type': 'text_image',
              'down_block_types': ('ResnetDownsampleBlock2D', 'SimpleCrossAttnDownBlock2D'),
              'up_block_types': ('SimpleCrossAttnUpBlock2D', 'ResnetUpsampleBlock2D'),
              'mid_block_type': 'UNetMidBlock2DSimpleCrossAttn',
              'block_out_channels': (self.block_out_channels_a, self.block_out_channels_a * 2),
              'layers_per_block': 1,
              'encoder_hid_dim': self.text_embedder_hidden_size,
              'encoder_hid_dim_type': 'text_image_proj',
              'cross_attention_dim': self.cross_attention_dim,
              'attention_head_dim': 4,
              'resnet_time_scale_shift': 'scale_shift',
              'class_embed_type': None,
          }

          UpperCAmelCase__	:      Optional[Any]     							=					UNetaDConditionModel(**UpperCamelCase_      )
          return model



      @property
      def  __snake_case							(   self      ):
          return {
              "block_out_channels": [32, 64],
              "down_block_types": ["DownEncoderBlock2D", "AttnDownEncoderBlock2D"],
              "in_channels": 3,
              "latent_channels": 4,
              "layers_per_block": 1,
              "norm_num_groups": 8,
              "norm_type": "spatial",
              "num_vq_embeddings": 12,
              "out_channels": 3,
              "up_block_types": [
                  "AttnUpDecoderBlock2D",
                  "UpDecoderBlock2D",
              ],
              "vq_embed_dim": 4,
          }



      @property
      def  __snake_case							(   self      ):
          torch.manual_seed(0      )
          UpperCAmelCase__	:      Optional[Any]     							=					VQModel(**self.dummy_movq_kwargs      )
          return model



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Union[str, Any]     							=					self.dummy_text_encoder
          UpperCAmelCase__	:      int     							=					self.dummy_tokenizer
          UpperCAmelCase__	:      int     							=					self.dummy_unet
          UpperCAmelCase__	:      Optional[Any]     							=					self.dummy_movq

          UpperCAmelCase__	:      Any     							=					{
              'num_train_timesteps': 1_000,
              'beta_schedule': 'linear',
              'beta_start': 0.00085,
              'beta_end': 0.012,
              'clip_sample': False,
              'set_alpha_to_one': False,
              'steps_offset': 0,
              'prediction_type': 'epsilon',
              'thresholding': False,
          }

          UpperCAmelCase__	:      List[Any]     							=					DDIMScheduler(**UpperCamelCase_      )

          UpperCAmelCase__	:      Tuple     							=					{
              'text_encoder': text_encoder,
              'tokenizer': tokenizer,
              'unet': unet,
              'scheduler': scheduler,
              'movq': movq,
          }

          return components



      def  __snake_case							(   self     ,	UpperCamelCase_     ,	UpperCamelCase_=0      ):
          UpperCAmelCase__	:      int     							=					floats_tensor((1, self.cross_attention_dim)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )
          UpperCAmelCase__	:      Optional[Any]     							=					floats_tensor((1, self.cross_attention_dim)     ,	rng=random.Random(seed + 1      )      ).to(UpperCamelCase_      )
          # create init_image
          UpperCAmelCase__	:      Optional[int]     							=					floats_tensor((1, 3, 64, 64)     ,	rng=random.Random(UpperCamelCase_      )      ).to(UpperCamelCase_      )
          UpperCAmelCase__	:      int     							=					image.cpu().permute(0     ,	2     ,	3     ,	1      )[0]
          UpperCAmelCase__	:      Union[str, Any]     							=					Image.fromarray(np.uinta(UpperCamelCase_      )      ).convert('RGB'      ).resize((256, 256)      )

          if str(UpperCamelCase_      ).startswith('mps'      ):
              UpperCAmelCase__	:      Dict     							=					torch.manual_seed(UpperCamelCase_      )
          else:
              UpperCAmelCase__	:      Optional[int]     							=					torch.Generator(device=UpperCamelCase_      ).manual_seed(UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					{
              'prompt': 'horse',
              'image': init_image,
              'image_embeds': image_embeds,
              'negative_image_embeds': negative_image_embeds,
              'generator': generator,
              'height': 64,
              'width': 64,
              'num_inference_steps': 10,
              'guidance_scale': 7.0,
              'strength': 0.2,
              'output_type': 'np',
          }
          return inputs



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      Optional[int]     							=					'cpu'

          UpperCAmelCase__	:      Any     							=					self.get_dummy_components()

          UpperCAmelCase__	:      Any     							=					self.pipeline_class(**UpperCamelCase_      )
          UpperCAmelCase__	:      Tuple     							=					pipe.to(UpperCamelCase_      )

          pipe.set_progress_bar_config(disable=UpperCamelCase_      )

          UpperCAmelCase__	:      List[Any]     							=					pipe(**self.get_dummy_inputs(UpperCamelCase_      )      )
          UpperCAmelCase__	:      Optional[int]     							=					output.images

          UpperCAmelCase__	:      Dict     							=					pipe(
              **self.get_dummy_inputs(UpperCamelCase_      )     ,	return_dict=UpperCamelCase_     ,	)[0]

          UpperCAmelCase__	:      Dict     							=					image[0, -3:, -3:, -1]
          UpperCAmelCase__	:      Any     							=					image_from_tuple[0, -3:, -3:, -1]

          assert image.shape == (1, 64, 64, 3)

          UpperCAmelCase__	:      Any     							=					np.array(
              [0.61474943, 0.6073539, 0.43308544, 0.5928269, 0.47493595, 0.46755973, 0.4613838, 0.45368797, 0.50119233]      )
          assert (
              np.abs(image_slice.flatten() - expected_slice      ).max() < 1E-2
          ), F''' expected_slice {expected_slice}, but got {image_slice.flatten()}'''
          assert (
              np.abs(image_from_tuple_slice.flatten() - expected_slice      ).max() < 1E-2
          ), F''' expected_slice {expected_slice}, but got {image_from_tuple_slice.flatten()}'''





@slow
@require_torch_gpu
class 				a			(					unittest.TestCase      ):



      def  __snake_case							(   self      ):
          # clean up the VRAM after each test
          super().tearDown()
          gc.collect()
          torch.cuda.empty_cache()



      def  __snake_case							(   self      ):
          UpperCAmelCase__	:      str     							=					load_numpy(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'
              '/kandinsky/kandinsky_img2img_frog.npy'      )

          UpperCAmelCase__	:      List[Any]     							=					load_image(
              'https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main' '/kandinsky/cat.png'      )
          UpperCAmelCase__	:      Any     							=					'A red cartoon frog, 4k'

          UpperCAmelCase__	:      Union[str, Any]     							=					KandinskyPriorPipeline.from_pretrained(
              'kandinsky-community/kandinsky-2-1-prior'     ,	torch_dtype=torch.floataa      )
          pipe_prior.to(UpperCamelCase_      )

          UpperCAmelCase__	:      Any     							=					KandinskyImgaImgPipeline.from_pretrained(
              'kandinsky-community/kandinsky-2-1'     ,	torch_dtype=torch.floataa      )
          UpperCAmelCase__	:      Optional[Any]     							=					pipeline.to(UpperCamelCase_      )

          pipeline.set_progress_bar_config(disable=UpperCamelCase_      )

          UpperCAmelCase__	:      List[Any]     							=					torch.Generator(device='cpu'      ).manual_seed(0      )
          UpperCAmelCase__							,							UpperCAmelCase__	:      Optional[int]     							=					pipe_prior(
              UpperCamelCase_     ,	generator=UpperCamelCase_     ,	num_inference_steps=5     ,	negative_prompt=''     ,	).to_tuple()

          UpperCAmelCase__	:      Optional[Any]     							=					pipeline(
              UpperCamelCase_     ,	image=UpperCamelCase_     ,	image_embeds=UpperCamelCase_     ,	negative_image_embeds=UpperCamelCase_     ,	generator=UpperCamelCase_     ,	num_inference_steps=100     ,	height=768     ,	width=768     ,	strength=0.2     ,	output_type='np'     ,	)

          UpperCAmelCase__	:      Union[str, Any]     							=					output.images[0]

          assert image.shape == (768, 768, 3)

          assert_mean_pixel_difference(UpperCamelCase_     ,	UpperCamelCase_      )

