


import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileViTConfig,
    MobileViTForImageClassification,
    MobileViTForSemanticSegmentation,
    MobileViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
snake_case_						:			List[Any]													=							logging.get_logger(__name__)







def 						lowerCamelCase(   a__):
				_SCREAMING_SNAKE_CASE			  =MobileViTConfig()

				# size of the architecture
				if "mobilevit_s" in mobilevit_name:
								_SCREAMING_SNAKE_CASE			  =[144, 192, 240]
								_SCREAMING_SNAKE_CASE			  =[16, 32, 64, 96, 128, 160, 640]
				elif "mobilevit_xs" in mobilevit_name:
								_SCREAMING_SNAKE_CASE			  =[96, 120, 144]
								_SCREAMING_SNAKE_CASE			  =[16, 32, 48, 64, 80, 96, 384]
				elif "mobilevit_xxs" in mobilevit_name:
								_SCREAMING_SNAKE_CASE			  =[64, 80, 96]
								_SCREAMING_SNAKE_CASE			  =[16, 16, 24, 48, 64, 80, 320]
								_SCREAMING_SNAKE_CASE			  =0.05
								_SCREAMING_SNAKE_CASE			  =2.0

				if mobilevit_name.startswith('''deeplabv3_'''):
								_SCREAMING_SNAKE_CASE			  =512
								_SCREAMING_SNAKE_CASE			  =16
								_SCREAMING_SNAKE_CASE			  =21
								_SCREAMING_SNAKE_CASE			  ='''pascal-voc-id2label.json'''
				else:
								_SCREAMING_SNAKE_CASE			  =1000
								_SCREAMING_SNAKE_CASE			  ='''imagenet-1k-id2label.json'''

				_SCREAMING_SNAKE_CASE			  ='''huggingface/label-files'''
				_SCREAMING_SNAKE_CASE			  =json.load(open(hf_hub_download(a__	,a__	,repo_type='''dataset''')	,'''r'''))
				_SCREAMING_SNAKE_CASE			  ={int(a__): v for k, v in idalabel.items()}
				_SCREAMING_SNAKE_CASE			  =idalabel
				_SCREAMING_SNAKE_CASE			  ={v: k for k, v in idalabel.items()}

				return config







def 						lowerCamelCase(   a__	,a__=False):
				for i in range(1	,6):
								if f"layer_{i}." in name:
												_SCREAMING_SNAKE_CASE			  =name.replace(f"layer_{i}."	,f"encoder.layer.{i - 1}.")

				if "conv_1." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''conv_1.'''	,'''conv_stem.''')
				if ".block." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.block.'''	,'''.''')

				if "exp_1x1" in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''exp_1x1'''	,'''expand_1x1''')
				if "red_1x1" in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''red_1x1'''	,'''reduce_1x1''')
				if ".local_rep.conv_3x3." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.local_rep.conv_3x3.'''	,'''.conv_kxk.''')
				if ".local_rep.conv_1x1." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.local_rep.conv_1x1.'''	,'''.conv_1x1.''')
				if ".norm." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.norm.'''	,'''.normalization.''')
				if ".conv." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.conv.'''	,'''.convolution.''')
				if ".conv_proj." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.conv_proj.'''	,'''.conv_projection.''')

				for i in range(0	,2):
								for j in range(0	,4):
												if f".{i}.{j}." in name:
																_SCREAMING_SNAKE_CASE			  =name.replace(f".{i}.{j}."	,f".{i}.layer.{j}.")

				for i in range(2	,6):
								for j in range(0	,4):
												if f".{i}.{j}." in name:
																_SCREAMING_SNAKE_CASE			  =name.replace(f".{i}.{j}."	,f".{i}.")
																if "expand_1x1" in name:
																				_SCREAMING_SNAKE_CASE			  =name.replace('''expand_1x1'''	,'''downsampling_layer.expand_1x1''')
																if "conv_3x3" in name:
																				_SCREAMING_SNAKE_CASE			  =name.replace('''conv_3x3'''	,'''downsampling_layer.conv_3x3''')
																if "reduce_1x1" in name:
																				_SCREAMING_SNAKE_CASE			  =name.replace('''reduce_1x1'''	,'''downsampling_layer.reduce_1x1''')

				for i in range(2	,5):
								if f".global_rep.{i}.weight" in name:
												_SCREAMING_SNAKE_CASE			  =name.replace(f".global_rep.{i}.weight"	,'''.layernorm.weight''')
								if f".global_rep.{i}.bias" in name:
												_SCREAMING_SNAKE_CASE			  =name.replace(f".global_rep.{i}.bias"	,'''.layernorm.bias''')

				if ".global_rep." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.global_rep.'''	,'''.transformer.''')
				if ".pre_norm_mha.0." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.pre_norm_mha.0.'''	,'''.layernorm_before.''')
				if ".pre_norm_mha.1.out_proj." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.pre_norm_mha.1.out_proj.'''	,'''.attention.output.dense.''')
				if ".pre_norm_ffn.0." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.pre_norm_ffn.0.'''	,'''.layernorm_after.''')
				if ".pre_norm_ffn.1." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.pre_norm_ffn.1.'''	,'''.intermediate.dense.''')
				if ".pre_norm_ffn.4." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.pre_norm_ffn.4.'''	,'''.output.dense.''')
				if ".transformer." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.transformer.'''	,'''.transformer.layer.''')

				if ".aspp_layer." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.aspp_layer.'''	,'''.''')
				if ".aspp_pool." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''.aspp_pool.'''	,'''.''')
				if "seg_head." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''seg_head.'''	,'''segmentation_head.''')
				if "segmentation_head.classifier.classifier." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''segmentation_head.classifier.classifier.'''	,'''segmentation_head.classifier.''')

				if "classifier.fc." in name:
								_SCREAMING_SNAKE_CASE			  =name.replace('''classifier.fc.'''	,'''classifier.''')
				elif (not base_model) and ("segmentation_head." not in name):
								_SCREAMING_SNAKE_CASE			  ='''mobilevit.''' + name

				return name







def 						lowerCamelCase(   a__	,a__	,a__=False):
				if base_model:
								_SCREAMING_SNAKE_CASE			  =''''''
				else:
								_SCREAMING_SNAKE_CASE			  ='''mobilevit.'''

				for key in orig_state_dict.copy().keys():
								_SCREAMING_SNAKE_CASE			  =orig_state_dict.pop(a__)

								if key[:8] == "encoder.":
												_SCREAMING_SNAKE_CASE			  =key[8:]

								if "qkv" in key:
												_SCREAMING_SNAKE_CASE			  =key.split('''.''')
												_SCREAMING_SNAKE_CASE			  =int(key_split[0][6:]) - 1
												_SCREAMING_SNAKE_CASE			  =int(key_split[3])
												_SCREAMING_SNAKE_CASE			  =model.get_submodule(f"{model_prefix}encoder.layer.{layer_num}")
												_SCREAMING_SNAKE_CASE			  =layer.transformer.layer[transformer_num].attention.attention.all_head_size
												_SCREAMING_SNAKE_CASE			  =(
												    f"{model_prefix}encoder.layer.{layer_num}.transformer.layer.{transformer_num}.attention.attention."
												)
												if "weight" in key:
																_SCREAMING_SNAKE_CASE			  =val[:dim, :]
																_SCREAMING_SNAKE_CASE			  =val[dim : dim * 2, :]
																_SCREAMING_SNAKE_CASE			  =val[-dim:, :]
												else:
																_SCREAMING_SNAKE_CASE			  =val[:dim]
																_SCREAMING_SNAKE_CASE			  =val[dim : dim * 2]
																_SCREAMING_SNAKE_CASE			  =val[-dim:]
								else:
												_SCREAMING_SNAKE_CASE			  =val

				return orig_state_dict







def 						lowerCamelCase(   ):
				_SCREAMING_SNAKE_CASE			  ='''http://images.cocodataset.org/val2017/000000039769.jpg'''
				_SCREAMING_SNAKE_CASE			  =Image.open(requests.get(a__	,stream=a__).raw)
				return im







@torch.no_grad()
def 						lowerCamelCase(   a__	,a__	,a__	,a__=False):
				_SCREAMING_SNAKE_CASE			  =get_mobilevit_config(a__)

				# load original state_dict
				_SCREAMING_SNAKE_CASE			  =torch.load(a__	,map_location='''cpu''')

				# load 🤗 model
				if mobilevit_name.startswith('''deeplabv3_'''):
								_SCREAMING_SNAKE_CASE			  =MobileViTForSemanticSegmentation(a__).eval()
				else:
								_SCREAMING_SNAKE_CASE			  =MobileViTForImageClassification(a__).eval()

				_SCREAMING_SNAKE_CASE			  =convert_state_dict(a__	,a__)
				model.load_state_dict(a__)

				# Check outputs on an image, prepared by MobileViTImageProcessor
				_SCREAMING_SNAKE_CASE			  =MobileViTImageProcessor(crop_size=config.image_size	,size=config.image_size + 32)
				_SCREAMING_SNAKE_CASE			  =image_processor(images=prepare_img()	,return_tensors='''pt''')
				_SCREAMING_SNAKE_CASE			  =model(**a__)
				_SCREAMING_SNAKE_CASE			  =outputs.logits

				if mobilevit_name.startswith('''deeplabv3_'''):
								assert logits.shape == (1, 21, 32, 32)

								if mobilevit_name == "deeplabv3_mobilevit_s":
												_SCREAMING_SNAKE_CASE			  =torch.tensor(
												    [
												        [[6.2065, 6.1292, 6.2070], [6.1079, 6.1254, 6.1747], [6.0042, 6.1071, 6.1034]],
												        [[-6.9253, -6.8653, -7.0398], [-7.3218, -7.3983, -7.3670], [-7.1961, -7.2482, -7.1569]],
												        [[-4.4723, -4.4348, -4.3769], [-5.3629, -5.4632, -5.4598], [-5.1587, -5.3402, -5.5059]],
												    ])
								elif mobilevit_name == "deeplabv3_mobilevit_xs":
												_SCREAMING_SNAKE_CASE			  =torch.tensor(
												    [
												        [[5.4449, 5.5733, 5.6314], [5.1815, 5.3930, 5.5963], [5.1656, 5.4333, 5.4853]],
												        [[-9.4423, -9.7766, -9.6714], [-9.1581, -9.5720, -9.5519], [-9.1006, -9.6458, -9.5703]],
												        [[-7.7721, -7.3716, -7.1583], [-8.4599, -8.0624, -7.7944], [-8.4172, -7.8366, -7.5025]],
												    ])
								elif mobilevit_name == "deeplabv3_mobilevit_xxs":
												_SCREAMING_SNAKE_CASE			  =torch.tensor(
												    [
												        [[6.9811, 6.9743, 7.3123], [7.1777, 7.1931, 7.3938], [7.5633, 7.8050, 7.8901]],
												        [[-10.5536, -10.2332, -10.2924], [-10.2336, -9.8624, -9.5964], [-10.8840, -10.8158, -10.6659]],
												        [[-3.4938, -3.0631, -2.8620], [-3.4205, -2.8135, -2.6875], [-3.4179, -2.7945, -2.8750]],
												    ])
								else:
												raise ValueError(f"Unknown mobilevit_name: {mobilevit_name}")

								assert torch.allclose(logits[0, :3, :3, :3]	,a__	,atol=1e-4)
				else:
								assert logits.shape == (1, 1000)

								if mobilevit_name == "mobilevit_s":
												_SCREAMING_SNAKE_CASE			  =torch.tensor([-0.9866, 0.2392, -1.1241])
								elif mobilevit_name == "mobilevit_xs":
												_SCREAMING_SNAKE_CASE			  =torch.tensor([-2.4761, -0.9399, -1.9587])
								elif mobilevit_name == "mobilevit_xxs":
												_SCREAMING_SNAKE_CASE			  =torch.tensor([-1.9364, -1.2327, -0.4653])
								else:
												raise ValueError(f"Unknown mobilevit_name: {mobilevit_name}")

								assert torch.allclose(logits[0, :3]	,a__	,atol=1e-4)

				Path(a__).mkdir(exist_ok=a__)
				print(f"Saving model {mobilevit_name} to {pytorch_dump_folder_path}")
				model.save_pretrained(a__)
				print(f"Saving image processor to {pytorch_dump_folder_path}")
				image_processor.save_pretrained(a__)

				if push_to_hub:
								_SCREAMING_SNAKE_CASE			  ={
								    '''mobilevit_s''': '''mobilevit-small''',
								    '''mobilevit_xs''': '''mobilevit-x-small''',
								    '''mobilevit_xxs''': '''mobilevit-xx-small''',
								    '''deeplabv3_mobilevit_s''': '''deeplabv3-mobilevit-small''',
								    '''deeplabv3_mobilevit_xs''': '''deeplabv3-mobilevit-x-small''',
								    '''deeplabv3_mobilevit_xxs''': '''deeplabv3-mobilevit-xx-small''',
								}

								print('''Pushing to the hub...''')
								_SCREAMING_SNAKE_CASE			  =model_mapping[mobilevit_name]
								image_processor.push_to_hub(a__	,organization='''apple''')
								model.push_to_hub(a__	,organization='''apple''')


if __name__ == "__main__":
							snake_case_						:			Optional[int]													=							argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    '''--mobilevit_name''',
							    default='''mobilevit_s''',
							    type=str,
							    help=(
							        '''Name of the MobileViT model you\'d like to convert. Should be one of \'mobilevit_s\', \'mobilevit_xs\','''
							        ''' \'mobilevit_xxs\', \'deeplabv3_mobilevit_s\', \'deeplabv3_mobilevit_xs\', \'deeplabv3_mobilevit_xxs\'.'''
							    ),
							)
							parser.add_argument(
							    '''--checkpoint_path''', required=True, type=str, help='''Path to the original state dict (.pt file).'''
							)
							parser.add_argument(
							    '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.'''
							)
							parser.add_argument(
							    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
							)

							snake_case_						:			List[Any]													=							parser.parse_args()
							convert_movilevit_checkpoint(
							    args.mobilevit_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
							)



import gc
import random
import unittest

import numpy as np
import torch

from diffusers import DDIMScheduler, KandinskyVaaPipeline, KandinskyVaaPriorPipeline, UNetaDConditionModel, VQModel
from diffusers.utils import floats_tensor, 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__							(		UpperCamelCase__   ,     unittest.TestCase  ):
						UpperCAmelCase             =						KandinskyVaaPipeline
						UpperCAmelCase             =						[
						    "image_embeds",
						    "negative_image_embeds",
						]
						UpperCAmelCase             =						["image_embeds", "negative_image_embeds"]
						UpperCAmelCase             =						[
						    "generator",
						    "height",
						    "width",
						    "latents",
						    "guidance_scale",
						    "num_inference_steps",
						    "return_dict",
						    "guidance_scale",
						    "num_images_per_prompt",
						    "output_type",
						    "return_dict",
						]
						UpperCAmelCase             =						False




						@property
						def 							__UpperCamelCase				(       self					:      Tuple  )							->     str:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase				(       self					:      Any  )							->     Optional[Any]:


										"""simple docstring"""





										return 32




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Tuple:


										"""simple docstring"""





										return self.time_input_dim




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Tuple:


										"""simple docstring"""





										return self.time_input_dim * 4




						@property
						def 							__UpperCamelCase				(       self					:      List[str]  )							->     Dict:


										"""simple docstring"""





										return 100




						@property
						def 							__UpperCamelCase				(       self					:      Optional[int]  )							->     Optional[int]:


										"""simple docstring"""





										torch.manual_seed(0  )

										_SCREAMING_SNAKE_CASE			  ={
										    '''in_channels''': 4,
										    # Out channels is double in channels because predicts mean and variance
										    '''out_channels''': 8,
										    '''addition_embed_type''': '''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''': '''image_proj''',
										    '''cross_attention_dim''': self.cross_attention_dim,
										    '''attention_head_dim''': 4,
										    '''resnet_time_scale_shift''': '''scale_shift''',
										    '''class_embed_type''': None,
										}

										_SCREAMING_SNAKE_CASE			  =UNetaDConditionModel(**_a  )
										return model




						@property
						def 							__UpperCamelCase				(       self					:      Tuple  )							->     Tuple:


										"""simple docstring"""





										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 							__UpperCamelCase				(       self					:      Any  )							->     Tuple:


										"""simple docstring"""





										torch.manual_seed(0  )
										_SCREAMING_SNAKE_CASE			  =VQModel(**self.dummy_movq_kwargs  )
										return model




						def 							__UpperCamelCase				(       self					:      Dict  )							->     Optional[Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =self.dummy_unet
										_SCREAMING_SNAKE_CASE			  =self.dummy_movq

										_SCREAMING_SNAKE_CASE			  =DDIMScheduler(
										    num_train_timesteps=1000				,    beta_schedule='''linear'''				,    beta_start=0.0_00_85				,    beta_end=0.0_12				,    clip_sample=_a				,    set_alpha_to_one=_a				,    steps_offset=1				,    prediction_type='''epsilon'''				,    thresholding=_a				,    )

										_SCREAMING_SNAKE_CASE			  ={
										    '''unet''': unet,
										    '''scheduler''': scheduler,
										    '''movq''': movq,
										}
										return components




						def 							__UpperCamelCase				(       self					:      Optional[int]				,    _a					:      Tuple				,    _a					:      Tuple=0  )							->     Optional[int]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =floats_tensor((1, self.text_embedder_hidden_size)				,    rng=random.Random(_a  )  ).to(_a  )
										_SCREAMING_SNAKE_CASE			  =floats_tensor((1, self.text_embedder_hidden_size)				,    rng=random.Random(seed + 1  )  ).to(
										    _a  )
										if str(_a  ).startswith('''mps'''  ):
														_SCREAMING_SNAKE_CASE			  =torch.manual_seed(_a  )
										else:
														_SCREAMING_SNAKE_CASE			  =torch.Generator(device=_a  ).manual_seed(_a  )
										_SCREAMING_SNAKE_CASE			  ={
										    '''image_embeds''': image_embeds,
										    '''negative_image_embeds''': negative_image_embeds,
										    '''generator''': generator,
										    '''height''': 64,
										    '''width''': 64,
										    '''guidance_scale''': 4.0,
										    '''num_inference_steps''': 2,
										    '''output_type''': '''np''',
										}
										return inputs




						def 							__UpperCamelCase				(       self					:      Optional[Any]  )							->     Union[str, Any]:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  ='''cpu'''

										_SCREAMING_SNAKE_CASE			  =self.get_dummy_components()

										_SCREAMING_SNAKE_CASE			  =self.pipeline_class(**_a  )
										_SCREAMING_SNAKE_CASE			  =pipe.to(_a  )

										pipe.set_progress_bar_config(disable=_a  )

										_SCREAMING_SNAKE_CASE			  =pipe(**self.get_dummy_inputs(_a  )  )
										_SCREAMING_SNAKE_CASE			  =output.images

										_SCREAMING_SNAKE_CASE			  =pipe(
										    **self.get_dummy_inputs(_a  )				,    return_dict=_a				,    )[0]

										_SCREAMING_SNAKE_CASE			  =image[0, -3:, -3:, -1]
										_SCREAMING_SNAKE_CASE			  =image_from_tuple[0, -3:, -3:, -1]

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

										_SCREAMING_SNAKE_CASE			  =np.array(
										    [0.6_23_79_76, 1.0, 0.36_44_13_32, 1.0, 0.70_63_96_34, 0.29_87_71_86, 0.85_65_21_25, 0.5_21_68_43, 0.54_45_40_46]  )

										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 							__UpperCamelCase				(       self					:      List[Any]  )							->     Dict:


										"""simple docstring"""





										super().tearDown()
										gc.collect()
										torch.cuda.empty_cache()




						def 							__UpperCamelCase				(       self					:      Union[str, Any]  )							->     str:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE			  =load_numpy(
										    '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
										    '''/kandinskyv22/kandinskyv22_text2img_cat_fp16.npy'''  )

										_SCREAMING_SNAKE_CASE			  =KandinskyVaaPriorPipeline.from_pretrained(
										    '''kandinsky-community/kandinsky-2-2-prior'''				,    torch_dtype=torch.floataa  )
										pipe_prior.to(_a  )

										_SCREAMING_SNAKE_CASE			  =KandinskyVaaPipeline.from_pretrained(
										    '''kandinsky-community/kandinsky-2-2-decoder'''				,    torch_dtype=torch.floataa  )
										_SCREAMING_SNAKE_CASE			  =pipeline.to(_a  )
										pipeline.set_progress_bar_config(disable=_a  )

										_SCREAMING_SNAKE_CASE			  ='''red cat, 4k photo'''

										_SCREAMING_SNAKE_CASE			  =torch.Generator(device='''cuda'''  ).manual_seed(0  )
										_SCREAMING_SNAKE_CASE  ,				_SCREAMING_SNAKE_CASE			  =pipe_prior(
										    _a				,    generator=_a				,    num_inference_steps=5				,    negative_prompt=''''''				,    ).to_tuple()

										_SCREAMING_SNAKE_CASE			  =torch.Generator(device='''cuda'''  ).manual_seed(0  )
										_SCREAMING_SNAKE_CASE			  =pipeline(
										    image_embeds=_a				,    negative_image_embeds=_a				,    generator=_a				,    num_inference_steps=100				,    output_type='''np'''				,    )

										_SCREAMING_SNAKE_CASE			  =output.images[0]

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

										assert_mean_pixel_difference(_a				,    _a  )