



import argparse
import json
import os

import fairseq
import torch
from fairseq.data import Dictionary

from transformers import (
    UniSpeechConfig,
    UniSpeechForCTC,
    UniSpeechForPreTraining,
    WavaVecaFeatureExtractor,
    WavaVecaPhonemeCTCTokenizer,
    WavaVecaProcessor,
    logging,
)


logging.set_verbosity_info()
__A       =						logging.get_logger(__name__)

__A       =						{
    '''post_extract_proj''': '''feature_projection.projection''',
    '''encoder.pos_conv.0''': '''encoder.pos_conv_embed.conv''',
    '''self_attn.k_proj''': '''encoder.layers.*.attention.k_proj''',
    '''self_attn.v_proj''': '''encoder.layers.*.attention.v_proj''',
    '''self_attn.q_proj''': '''encoder.layers.*.attention.q_proj''',
    '''self_attn.out_proj''': '''encoder.layers.*.attention.out_proj''',
    '''self_attn_layer_norm''': '''encoder.layers.*.layer_norm''',
    '''fc1''': '''encoder.layers.*.feed_forward.intermediate_dense''',
    '''fc2''': '''encoder.layers.*.feed_forward.output_dense''',
    '''final_layer_norm''': '''encoder.layers.*.final_layer_norm''',
    '''encoder.layer_norm''': '''encoder.layer_norm''',
    '''w2v_model.layer_norm''': '''feature_projection.layer_norm''',
    '''quantizer.weight_proj''': '''quantizer.weight_proj''',
    '''quantizer.vars''': '''quantizer.codevectors''',
    '''project_q''': '''project_q''',
    '''final_proj''': '''project_hid''',
    '''w2v_encoder.proj''': '''ctc_proj''',
    '''mask_emb''': '''masked_spec_embed''',
}
__A       =						[
    '''ctc_proj''',
    '''quantizer.weight_proj''',
    '''quantizer.codevectors''',
    '''project_q''',
    '''project_hid''',
]



def 	__a					(   lowerCAmelCase_       : Optional[int]      ,lowerCAmelCase_       : int      ,lowerCAmelCase_       : Dict      ,lowerCAmelCase_       : int      ,lowerCAmelCase_       : Any      ,lowerCAmelCase_       : List[Any]    )				->			List[str]:






						'''simple docstring'''



						for attribute in key.split("""."""    ):
												if is_finetuned:
																		if attribute in ["quantizer", "project_q", "project_hid"]:
																								# those layers are only relevant for pretraining and should be dropped
																								return

																		if attribute == "ctc_proj":
																								# we should rename `ctc_proj` to `lm_head` for fine-tuned phoneme models
																								UpperCAmelCase_=       """lm_head"""

												UpperCAmelCase_=       getattr(lowerCAmelCase_      ,lowerCAmelCase_    )

						if weight_type is not None:
												UpperCAmelCase_=       getattr(lowerCAmelCase_      ,lowerCAmelCase_    ).shape
						else:
												UpperCAmelCase_=       hf_pointer.shape

						assert hf_shape == value.shape, (
						    F"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be"""
						    F""" {value.shape} for {full_name}"""
						)

						if weight_type == "weight":
												UpperCAmelCase_=       value
						elif weight_type == "weight_g":
												UpperCAmelCase_=       value
						elif weight_type == "weight_v":
												UpperCAmelCase_=       value
						elif weight_type == "bias":
												UpperCAmelCase_=       value
						else:
												UpperCAmelCase_=       value

						logger.info(F"""{key + "." + weight_type if weight_type is not None else ""} was initialized from {full_name}."""    )



def 	__a					(   lowerCAmelCase_       : List[str]      ,lowerCAmelCase_       : List[str]      ,lowerCAmelCase_       : List[Any]    )				->			Union[str, Any]:






						'''simple docstring'''



						UpperCAmelCase_=       []
						UpperCAmelCase_=       fairseq_model.state_dict()

						UpperCAmelCase_=       hf_model.unispeech.feature_extractor

						for name, value in fairseq_dict.items():
												UpperCAmelCase_=       False
												if "conv_layers" in name:
																		load_conv_layer(
																		    lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,hf_model.config.feat_extract_norm == """group"""      ,)
																		UpperCAmelCase_=       True
												else:
																		for key, mapped_key in MAPPING.items():
																								UpperCAmelCase_=       """unispeech.""" + mapped_key if mapped_key not in TOP_LEVEL_KEYS else mapped_key
																								if key in name or key.split("""w2v_model."""    )[-1] == name.split("""."""    )[0]:
																														UpperCAmelCase_=       True
																														if "*" in mapped_key:
																																				UpperCAmelCase_=       name.split(lowerCAmelCase_    )[0].split("""."""    )[-2]
																																				UpperCAmelCase_=       mapped_key.replace("""*"""      ,lowerCAmelCase_    )
																														if "weight_g" in name:
																																				UpperCAmelCase_=       """weight_g"""
																														elif "weight_v" in name:
																																				UpperCAmelCase_=       """weight_v"""
																														elif "bias" in name:
																																				UpperCAmelCase_=       """bias"""
																														elif "weight" in name:
																																				# TODO: don't match quantizer.weight_proj
																																				UpperCAmelCase_=       """weight"""
																														else:
																																				UpperCAmelCase_=       None
																														set_recursively(lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_    )
																								continue
												if not is_used:
																		unused_weights.append(lowerCAmelCase_    )

						logger.warning(F"""Unused weights: {unused_weights}"""    )



def 	__a					(   lowerCAmelCase_       : Dict      ,lowerCAmelCase_       : Tuple      ,lowerCAmelCase_       : Optional[Any]      ,lowerCAmelCase_       : List[Any]      ,lowerCAmelCase_       : List[str]    )				->			Dict:






						'''simple docstring'''



						UpperCAmelCase_=       full_name.split("""conv_layers."""    )[-1]
						UpperCAmelCase_=       name.split("""."""    )
						UpperCAmelCase_=       int(items[0]    )
						UpperCAmelCase_=       int(items[1]    )

						if type_id == 0:
												if "bias" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.bias.data.shape, (
																		    F"""{full_name} has size {value.shape}, but"""
																		    F""" {feature_extractor.conv_layers[layer_id].conv.bias.data.shape} was found."""
																		)
																		UpperCAmelCase_=       value
																		logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""    )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].conv.weight.data.shape, (
																		    F"""{full_name} has size {value.shape}, but"""
																		    F""" {feature_extractor.conv_layers[layer_id].conv.weight.data.shape} was found."""
																		)
																		UpperCAmelCase_=       value
																		logger.info(F"""Feat extract conv layer {layer_id} was initialized from {full_name}."""    )
						elif (type_id == 2 and not use_group_norm) or (type_id == 2 and layer_id == 0 and use_group_norm):
												if "bias" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.bias.data.shape, (
																		    F"""{full_name} has size {value.shape}, but {feature_extractor[layer_id].layer_norm.bias.data.shape} was"""
																		    " found."
																		)
																		UpperCAmelCase_=       value
																		logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""    )
												elif "weight" in name:
																		assert value.shape == feature_extractor.conv_layers[layer_id].layer_norm.weight.data.shape, (
																		    F"""{full_name} has size {value.shape}, but"""
																		    F""" {feature_extractor[layer_id].layer_norm.weight.data.shape} was found."""
																		)
																		UpperCAmelCase_=       value
																		logger.info(F"""Feat extract layer norm weight of layer {layer_id} was initialized from {full_name}."""    )
						else:
												unused_weights.append(lowerCAmelCase_    )



@torch.no_grad()
def 	__a					(   lowerCAmelCase_       : int      ,lowerCAmelCase_       : Any      ,lowerCAmelCase_       : List[Any]=None      ,lowerCAmelCase_       : Tuple=None      ,lowerCAmelCase_       : Optional[Any]=True    )				->			List[str]:






						'''simple docstring'''



						if config_path is not None:
												UpperCAmelCase_=       UniSpeechConfig.from_pretrained(lowerCAmelCase_    )
						else:
												UpperCAmelCase_=       UniSpeechConfig()

						if is_finetuned:
												if dict_path:
																		UpperCAmelCase_=       Dictionary.load_from_json(lowerCAmelCase_    )

																		# important change bos & pad token id since CTC symbol is <pad> and
																		# not <s> as in fairseq
																		UpperCAmelCase_=       target_dict.pad_index
																		UpperCAmelCase_=       target_dict.bos_index
																		UpperCAmelCase_=       target_dict.eos_index
																		UpperCAmelCase_=       len(target_dict.symbols    )
																		UpperCAmelCase_=       os.path.join(lowerCAmelCase_      ,"""vocab.json"""    )
																		if not os.path.isdir(lowerCAmelCase_    ):
																								logger.error("""--pytorch_dump_folder_path ({}) should be a directory""".format(lowerCAmelCase_    )    )
																								return
																		os.makedirs(lowerCAmelCase_      ,exist_ok=lowerCAmelCase_    )
																		UpperCAmelCase_=       target_dict.indices

																		# fairseq has the <pad> and <s> switched
																		UpperCAmelCase_=       42
																		UpperCAmelCase_=       43
																		with open(lowerCAmelCase_      ,"""w"""      ,encoding="""utf-8"""    ) as vocab_handle:
																								json.dump(lowerCAmelCase_      ,lowerCAmelCase_    )
																		UpperCAmelCase_=       WavaVecaPhonemeCTCTokenizer(
																		    lowerCAmelCase_      ,unk_token=target_dict.unk_word      ,pad_token=target_dict.pad_word      ,bos_token=target_dict.bos_word      ,eos_token=target_dict.eos_word      ,word_delimiter_token="""|"""      ,do_lower_case=lowerCAmelCase_      ,)
																		UpperCAmelCase_=       True if config.feat_extract_norm == """layer""" else False
																		UpperCAmelCase_=       WavaVecaFeatureExtractor(
																		    feature_size=1      ,sampling_rate=1_60_00      ,padding_value=0      ,do_normalize=lowerCAmelCase_      ,return_attention_mask=lowerCAmelCase_      ,)
																		UpperCAmelCase_=       WavaVecaProcessor(feature_extractor=lowerCAmelCase_      ,tokenizer=lowerCAmelCase_    )
																		processor.save_pretrained(lowerCAmelCase_    )

												UpperCAmelCase_=       UniSpeechForCTC(lowerCAmelCase_    )
						else:
												UpperCAmelCase_=       UniSpeechForPreTraining(lowerCAmelCase_    )

						if is_finetuned:
												UpperCAmelCase_,       UpperCAmelCase_,       UpperCAmelCase_=       fairseq.checkpoint_utils.load_model_ensemble_and_task(
												    [checkpoint_path]      ,arg_overrides={"""data""": """/""".join(dict_path.split("""/"""    )[:-1]    ), """w2v_path""": checkpoint_path}    )
						else:
												UpperCAmelCase_,       UpperCAmelCase_,       UpperCAmelCase_=       fairseq.checkpoint_utils.load_model_ensemble_and_task([checkpoint_path]    )

						UpperCAmelCase_=       model[0].eval()

						recursively_load_weights(lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_    )

						hf_unispeech.save_pretrained(lowerCAmelCase_    )


if __name__ == "__main__":
	__A       =						argparse.ArgumentParser()
	parser.add_argument('''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model.''')
	parser.add_argument('''--checkpoint_path''', default=None, type=str, help='''Path to fairseq checkpoint''')
	parser.add_argument('''--dict_path''', default=None, type=str, help='''Path to dict of fine-tuned model''')
	parser.add_argument('''--config_path''', default=None, type=str, help='''Path to hf config.json of model to convert''')
	parser.add_argument(
	    '''--not_finetuned''', action='''store_true''', help='''Whether the model to convert is a fine-tuned model or not'''
	)
	__A       =						parser.parse_args()
	convert_unispeech_checkpoint(
	    args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path, args.dict_path, not args.not_finetuned
	)









import gc
import random
import unittest

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

from diffusers import DDIMScheduler, KandinskyInpaintPipeline, 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 		lowercase						(			snake_case__			,   unittest.TestCase):






	"""simple docstring"""


	a__				: Tuple		       =							KandinskyInpaintPipeline
	a__				: Tuple		       =							["prompt", "image_embeds", "negative_image_embeds", "image", "mask_image"]
	a__				: str		       =							[
	    "prompt",
	    "negative_prompt",
	    "image_embeds",
	    "negative_image_embeds",
	    "image",
	    "mask_image",
	]
	a__				: List[Any]		       =							[
	    "generator",
	    "height",
	    "width",
	    "latents",
	    "guidance_scale",
	    "negative_prompt",
	    "num_inference_steps",
	    "return_dict",
	    "guidance_scale",
	    "num_images_per_prompt",
	    "output_type",
	    "return_dict",
	]
	a__				: Union[str, Any]		       =							False




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Any					)      ->			Any:
							return 32




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			Union[str, Any]:
							return 32




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			Optional[Any]:
							return self.time_input_dim




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Tuple:
							return self.time_input_dim * 4




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						int					)      ->			List[str]:
							return 100




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			List[str]:
							UpperCAmelCase_=       XLMRobertaTokenizerFast.from_pretrained("""YiYiXu/tiny-random-mclip-base"""					)
							return tokenizer




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Any					)      ->			List[str]:
							torch.manual_seed(0					)
							UpperCAmelCase_=       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_=       MultilingualCLIP(__UpperCAmelCase					)
							UpperCAmelCase_=       text_encoder.eval()

							return text_encoder




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			Dict:
							torch.manual_seed(0					)

							UpperCAmelCase_=       {
							    """in_channels""": 9,
							    # 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_=       UNetaDConditionModel(**__UpperCAmelCase					)
							return model




	@property
	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			str:
							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   _SCREAMING_SNAKE_CASE		(     self     :						Any					)      ->			Optional[int]:
							torch.manual_seed(0					)
							UpperCAmelCase_=       VQModel(**self.dummy_movq_kwargs					)
							return model




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[str]					)      ->			Optional[int]:
							UpperCAmelCase_=       self.dummy_text_encoder
							UpperCAmelCase_=       self.dummy_tokenizer
							UpperCAmelCase_=       self.dummy_unet
							UpperCAmelCase_=       self.dummy_movq

							UpperCAmelCase_=       DDIMScheduler(
							    num_train_timesteps=1_000						,  beta_schedule="""linear"""						,  beta_start=0.00_085						,  beta_end=0.012						,  clip_sample=__UpperCAmelCase						,  set_alpha_to_one=__UpperCAmelCase						,  steps_offset=1						,  prediction_type="""epsilon"""						,  thresholding=__UpperCAmelCase						,  )

							UpperCAmelCase_=       {
							    """text_encoder""": text_encoder,
							    """tokenizer""": tokenizer,
							    """unet""": unet,
							    """scheduler""": scheduler,
							    """movq""": movq,
							}

							return components




	def   _SCREAMING_SNAKE_CASE		(     self     :						Union[str, Any]						,  __UpperCAmelCase     :						Tuple						,  __UpperCAmelCase     :						Dict=0					)      ->			Dict:
							UpperCAmelCase_=       floats_tensor((1, self.cross_attention_dim)						,  rng=random.Random(__UpperCAmelCase					)					).to(__UpperCAmelCase					)
							UpperCAmelCase_=       floats_tensor((1, self.cross_attention_dim)						,  rng=random.Random(seed + 1					)					).to(__UpperCAmelCase					)
							# create init_image
							UpperCAmelCase_=       floats_tensor((1, 3, 64, 64)						,  rng=random.Random(__UpperCAmelCase					)					).to(__UpperCAmelCase					)
							UpperCAmelCase_=       image.cpu().permute(0						,  2						,  3						,  1					)[0]
							UpperCAmelCase_=       Image.fromarray(np.uinta(__UpperCAmelCase					)					).convert("""RGB"""					).resize((256, 256)					)
							# create mask
							UpperCAmelCase_=       np.ones((64, 64)						,  dtype=np.floataa					)
							UpperCAmelCase_=       0

							if str(__UpperCAmelCase					).startswith("""mps"""					):
													UpperCAmelCase_=       torch.manual_seed(__UpperCAmelCase					)
							else:
													UpperCAmelCase_=       torch.Generator(device=__UpperCAmelCase					).manual_seed(__UpperCAmelCase					)
							UpperCAmelCase_=       {
							    """prompt""": """horse""",
							    """image""": init_image,
							    """mask_image""": mask,
							    """image_embeds""": image_embeds,
							    """negative_image_embeds""": negative_image_embeds,
							    """generator""": generator,
							    """height""": 64,
							    """width""": 64,
							    """num_inference_steps""": 2,
							    """guidance_scale""": 4.0,
							    """output_type""": """np""",
							}
							return inputs




	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			List[str]:
							UpperCAmelCase_=       """cpu"""

							UpperCAmelCase_=       self.get_dummy_components()

							UpperCAmelCase_=       self.pipeline_class(**__UpperCAmelCase					)
							UpperCAmelCase_=       pipe.to(__UpperCAmelCase					)

							pipe.set_progress_bar_config(disable=__UpperCAmelCase					)

							UpperCAmelCase_=       pipe(**self.get_dummy_inputs(__UpperCAmelCase					)					)
							UpperCAmelCase_=       output.images

							UpperCAmelCase_=       pipe(
							    **self.get_dummy_inputs(__UpperCAmelCase					)						,  return_dict=__UpperCAmelCase						,  )[0]

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

							print(F"""image.shape {image.shape}"""					)

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

							UpperCAmelCase_=       np.array(
							    [0.8_326_919, 0.73_790_467, 0.20_918_581, 0.9_309_612, 0.5_511_791, 0.43_713_328, 0.5_513_321, 0.49_922_934, 0.59_497_786]					)

							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()}"""




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[str]					)      ->			Any:
							super().test_inference_batch_single_identical(expected_max_diff=3E-3					)






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






	"""simple docstring"""


	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Any:
							# clean up the VRAM after each test
							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Optional[Any]:
							UpperCAmelCase_=       load_numpy(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
							    """/kandinsky/kandinsky_inpaint_cat_with_hat_fp16.npy"""					)

							UpperCAmelCase_=       load_image(
							    """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/kandinsky/cat.png"""					)
							UpperCAmelCase_=       np.ones((768, 768)						,  dtype=np.floataa					)
							UpperCAmelCase_=       0

							UpperCAmelCase_=       """a hat"""

							UpperCAmelCase_=       KandinskyPriorPipeline.from_pretrained(
							    """kandinsky-community/kandinsky-2-1-prior"""						,  torch_dtype=torch.floataa					)
							pipe_prior.to(__UpperCAmelCase					)

							UpperCAmelCase_=       KandinskyInpaintPipeline.from_pretrained(
							    """kandinsky-community/kandinsky-2-1-inpaint"""						,  torch_dtype=torch.floataa					)
							UpperCAmelCase_=       pipeline.to(__UpperCAmelCase					)
							pipeline.set_progress_bar_config(disable=__UpperCAmelCase					)

							UpperCAmelCase_=       torch.Generator(device="""cpu"""					).manual_seed(0					)
							UpperCAmelCase_,       UpperCAmelCase_=       pipe_prior(
							    __UpperCAmelCase						,  generator=__UpperCAmelCase						,  num_inference_steps=5						,  negative_prompt=""""""						,  ).to_tuple()

							UpperCAmelCase_=       pipeline(
							    __UpperCAmelCase						,  image=__UpperCAmelCase						,  mask_image=__UpperCAmelCase						,  image_embeds=__UpperCAmelCase						,  negative_image_embeds=__UpperCAmelCase						,  generator=__UpperCAmelCase						,  num_inference_steps=100						,  height=768						,  width=768						,  output_type="""np"""						,  )

							UpperCAmelCase_=       output.images[0]

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

							assert_mean_pixel_difference(__UpperCAmelCase						,  __UpperCAmelCase					)




