



"""simple docstring"""
import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
__SCREAMING_SNAKE_CASE  :						Optional[int]    							=      logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE  :						Union[str, Any]    							=      {
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

__SCREAMING_SNAKE_CASE  :						int    							=      {
    '''b0''': {
        '''hidden_dim''': 1_2_8_0,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 2_2_4,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1_2_8_0,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 2_4_0,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [1_6],
    },
    '''b2''': {
        '''hidden_dim''': 1_4_0_8,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 2_6_0,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 1_6],
    },
    '''b3''': {
        '''hidden_dim''': 1_5_3_6,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 3_0_0,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 1_8],
    },
    '''b4''': {
        '''hidden_dim''': 1_7_9_2,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 3_8_0,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2_0_4_8,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 4_5_6,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [1_3, 2_7],
    },
    '''b6''': {
        '''hidden_dim''': 2_3_0_4,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 5_2_8,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [3_1],
    },
    '''b7''': {
        '''hidden_dim''': 2_5_6_0,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 6_0_0,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [1_8],
    },
}



def        lowerCAmelCase_(   lowercase_     :							str							)	->       Optional[Any]:
				_lowerCamelCase        =				EfficientNetConfig()
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''hidden_dim''']
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''width_coef''']
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''depth_coef''']
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''image_size''']
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''dropout_rate''']
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''dw_padding''']

				_lowerCamelCase        =				'''huggingface/label-files'''
				_lowerCamelCase        =				'''imagenet-1k-id2label.json'''
				_lowerCamelCase        =				10_00
				_lowerCamelCase        =				json.load(open(hf_hub_download(lowercase_						,   lowercase_						,   repo_type='''dataset'''							)						,   '''r'''							)							)
				_lowerCamelCase        =				{int(lowercase_							): v for k, v in idalabel.items()}

				_lowerCamelCase        =				idalabel
				_lowerCamelCase        =				{v: k for k, v in idalabel.items()}
				return config



def        lowerCAmelCase_(   )	->       str:
				_lowerCamelCase        =				'''http://images.cocodataset.org/val2017/000000039769.jpg'''
				_lowerCamelCase        =				Image.open(requests.get(lowercase_						,   stream=lowercase_							).raw							)
				return im



def        lowerCAmelCase_(   lowercase_     :							str							)	->       Any:
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''image_size''']
				_lowerCamelCase        =				EfficientNetImageProcessor(
				    size={'''height''': size, '''width''': size}						,   image_mean=[0.4_8_5, 0.4_5_6, 0.4_0_6]						,   image_std=[0.4_7_8_5_3_9_4_4, 0.4_7_3_2_8_6_4, 0.4_7_4_3_4_1_6_3]						,   do_center_crop=lowercase_						,   )
				return preprocessor



def        lowerCAmelCase_(   lowercase_     :							Any							)	->       Dict:
				_lowerCamelCase        =				[v.split('''_'''							)[0].split('''block'''							)[1] for v in original_param_names if v.startswith('''block'''							)]
				_lowerCamelCase        =				sorted(set(lowercase_							)							)
				_lowerCamelCase        =				len(lowercase_							)
				_lowerCamelCase        =				{b: str(lowercase_							) for b, i in zip(lowercase_						,   range(lowercase_							)							)}

				_lowerCamelCase        =				[]
				rename_keys.append(('''stem_conv/kernel:0''', '''embeddings.convolution.weight''')							)
				rename_keys.append(('''stem_bn/gamma:0''', '''embeddings.batchnorm.weight''')							)
				rename_keys.append(('''stem_bn/beta:0''', '''embeddings.batchnorm.bias''')							)
				rename_keys.append(('''stem_bn/moving_mean:0''', '''embeddings.batchnorm.running_mean''')							)
				rename_keys.append(('''stem_bn/moving_variance:0''', '''embeddings.batchnorm.running_var''')							)

				for b in block_names:
								_lowerCamelCase        =				block_name_mapping[b]
								rename_keys.append((F"""block{b}_expand_conv/kernel:0""", F"""encoder.blocks.{hf_b}.expansion.expand_conv.weight""")							)
								rename_keys.append((F"""block{b}_expand_bn/gamma:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.weight""")							)
								rename_keys.append((F"""block{b}_expand_bn/beta:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.bias""")							)
								rename_keys.append(
								    (F"""block{b}_expand_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_mean""")							)
								rename_keys.append(
								    (F"""block{b}_expand_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_var""")							)
								rename_keys.append(
								    (F"""block{b}_dwconv/depthwise_kernel:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight""")							)
								rename_keys.append((F"""block{b}_bn/gamma:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight""")							)
								rename_keys.append((F"""block{b}_bn/beta:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias""")							)
								rename_keys.append(
								    (F"""block{b}_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean""")							)
								rename_keys.append(
								    (F"""block{b}_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var""")							)

								rename_keys.append((F"""block{b}_se_reduce/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.weight""")							)
								rename_keys.append((F"""block{b}_se_reduce/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.bias""")							)
								rename_keys.append((F"""block{b}_se_expand/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.weight""")							)
								rename_keys.append((F"""block{b}_se_expand/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.bias""")							)
								rename_keys.append(
								    (F"""block{b}_project_conv/kernel:0""", F"""encoder.blocks.{hf_b}.projection.project_conv.weight""")							)
								rename_keys.append((F"""block{b}_project_bn/gamma:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.weight""")							)
								rename_keys.append((F"""block{b}_project_bn/beta:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.bias""")							)
								rename_keys.append(
								    (F"""block{b}_project_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_mean""")							)
								rename_keys.append(
								    (F"""block{b}_project_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_var""")							)

				rename_keys.append(('''top_conv/kernel:0''', '''encoder.top_conv.weight''')							)
				rename_keys.append(('''top_bn/gamma:0''', '''encoder.top_bn.weight''')							)
				rename_keys.append(('''top_bn/beta:0''', '''encoder.top_bn.bias''')							)
				rename_keys.append(('''top_bn/moving_mean:0''', '''encoder.top_bn.running_mean''')							)
				rename_keys.append(('''top_bn/moving_variance:0''', '''encoder.top_bn.running_var''')							)

				_lowerCamelCase        =				{}
				for item in rename_keys:
								if item[0] in original_param_names:
												_lowerCamelCase        =				'''efficientnet.''' + item[1]

				_lowerCamelCase        =				'''classifier.weight'''
				_lowerCamelCase        =				'''classifier.bias'''
				return key_mapping



def        lowerCAmelCase_(   lowercase_     :							Optional[int]						,   lowercase_     :							Tuple						,   lowercase_     :							str							)	->       Any:
				for key, value in tf_params.items():
								if "normalization" in key:
												continue

								_lowerCamelCase        =				key_mapping[key]
								if "_conv" in key and "kernel" in key:
												_lowerCamelCase        =				torch.from_numpy(lowercase_							).permute(3						,   2						,   0						,   1							)
								elif "depthwise_kernel" in key:
												_lowerCamelCase        =				torch.from_numpy(lowercase_							).permute(2						,   3						,   0						,   1							)
								elif "kernel" in key:
												_lowerCamelCase        =				torch.from_numpy(np.transpose(lowercase_							)							)
								else:
												_lowerCamelCase        =				torch.from_numpy(lowercase_							)

								# Replace HF parameters with original TF model parameters
								assert hf_params[hf_key].shape == new_hf_value.shape
								hf_params[hf_key].copy_(lowercase_							)



@torch.no_grad()
def        lowerCAmelCase_(   lowercase_     :							Optional[Any]						,   lowercase_     :							int						,   lowercase_     :							str						,   lowercase_     :							Union[str, Any]							)	->       List[Any]:
				_lowerCamelCase        =				model_classes[model_name](
				    include_top=lowercase_						,   weights='''imagenet'''						,   input_tensor=lowercase_						,   input_shape=lowercase_						,   pooling=lowercase_						,   classes=10_00						,   classifier_activation='''softmax'''						,   )

				_lowerCamelCase        =				original_model.trainable_variables
				_lowerCamelCase        =				original_model.non_trainable_variables
				_lowerCamelCase        =				{param.name: param.numpy() for param in tf_params}
				for param in tf_non_train_params:
								_lowerCamelCase        =				param.numpy()
				_lowerCamelCase        =				list(tf_params.keys()							)

				# Load HuggingFace model
				_lowerCamelCase        =				get_efficientnet_config(lowercase_							)
				_lowerCamelCase        =				EfficientNetForImageClassification(lowercase_							).eval()
				_lowerCamelCase        =				hf_model.state_dict()

				# Create src-to-dst parameter name mapping dictionary
				print('''Converting parameters...'''							)
				_lowerCamelCase        =				rename_keys(lowercase_							)
				replace_params(lowercase_						,   lowercase_						,   lowercase_							)

				# Initialize preprocessor and preprocess input image
				_lowerCamelCase        =				convert_image_processor(lowercase_							)
				_lowerCamelCase        =				preprocessor(images=prepare_img()						,   return_tensors='''pt'''							)

				# HF model inference
				hf_model.eval()
				with torch.no_grad():
								_lowerCamelCase        =				hf_model(**lowercase_							)
				_lowerCamelCase        =				outputs.logits.detach().numpy()

				# Original model inference
				_lowerCamelCase        =				False
				_lowerCamelCase        =				CONFIG_MAP[model_name]['''image_size''']
				_lowerCamelCase        =				prepare_img().resize((image_size, image_size)						,   resample=PIL.Image.NEAREST							)
				_lowerCamelCase        =				image.img_to_array(lowercase_							)
				_lowerCamelCase        =				np.expand_dims(lowercase_						,   axis=0							)
				_lowerCamelCase        =				original_model.predict(lowercase_							)

				# Check whether original and HF model outputs match  -> np.allclose
				assert np.allclose(lowercase_						,   lowercase_						,   atol=1e-3							), "The predicted logits are not the same."
				print('''Model outputs match!'''							)

				if save_model:
								# Create folder to save model
								if not os.path.isdir(lowercase_							):
												os.mkdir(lowercase_							)
								# Save converted model and image processor
								hf_model.save_pretrained(lowercase_							)
								preprocessor.save_pretrained(lowercase_							)

				if push_to_hub:
								# Push model and image processor to hub
								print(F"""Pushing converted {model_name} to the hub..."""							)
								_lowerCamelCase        =				F"""efficientnet-{model_name}"""
								preprocessor.push_to_hub(lowercase_							)
								hf_model.push_to_hub(lowercase_							)


if __name__ == "__main__":
			__SCREAMING_SNAKE_CASE  :						List[Any]    							=      argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    '''--model_name''',
			    default='''b0''',
			    type=str,
			    help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
			)
			parser.add_argument(
			    '''--pytorch_dump_folder_path''',
			    default='''hf_model''',
			    type=str,
			    help='''Path to the output PyTorch model directory.''',
			)
			parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
			parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

			__SCREAMING_SNAKE_CASE  :						Optional[int]    							=      parser.parse_args()
			convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)





"""simple docstring"""
import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DiffusionPipeline,
    EulerDiscreteScheduler,
    StableDiffusionXLImgaImgPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import floats_tensor, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()


class 							lowerCamelCase_(   A__,				A__,				unittest.TestCase    ):





					'''simple docstring'''



					lowercase__   :       Tuple										= StableDiffusionXLImgaImgPipeline
					lowercase__   :       List[str]										= TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {'height', 'width'}
					lowercase__   :       int										= PipelineTesterMixin.required_optional_params - {'latents'}
					lowercase__   :       Union[str, Any]										= TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS
					lowercase__   :       Dict										= IMAGE_TO_IMAGE_IMAGE_PARAMS
					lowercase__   :       List[str]										= IMAGE_TO_IMAGE_IMAGE_PARAMS

					def 			snake_case__      (    self   ):
									torch.manual_seed(0   )
									_lowerCamelCase        =				UNetaDConditionModel(
									    block_out_channels=(3_2, 6_4)				,       layers_per_block=2				,       sample_size=3_2				,       in_channels=4				,       out_channels=4				,       down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')				,       up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')				,       attention_head_dim=(2, 4)				,       use_linear_projection=lowerCamelCase__				,       addition_embed_type='''text_time'''				,       addition_time_embed_dim=8				,       transformer_layers_per_block=(1, 2)				,       projection_class_embeddings_input_dim=8_0				,       cross_attention_dim=6_4				,       )
									_lowerCamelCase        =				EulerDiscreteScheduler(
									    beta_start=0.0_0_0_8_5				,       beta_end=0.0_1_2				,       steps_offset=1				,       beta_schedule='''scaled_linear'''				,       timestep_spacing='''leading'''				,       )
									torch.manual_seed(0   )
									_lowerCamelCase        =				AutoencoderKL(
									    block_out_channels=[3_2, 6_4]				,       in_channels=3				,       out_channels=3				,       down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']				,       up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']				,       latent_channels=4				,       sample_size=1_2_8				,       )
									torch.manual_seed(0   )
									_lowerCamelCase        =				CLIPTextConfig(
									    bos_token_id=0				,       eos_token_id=2				,       hidden_size=3_2				,       intermediate_size=3_7				,       layer_norm_eps=1e-05				,       num_attention_heads=4				,       num_hidden_layers=5				,       pad_token_id=1				,       vocab_size=1_0_0_0				,       hidden_act='''gelu'''				,       projection_dim=3_2				,       )
									_lowerCamelCase        =				CLIPTextModel(lowerCamelCase__   )
									_lowerCamelCase        =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				,       local_files_only=lowerCamelCase__   )

									_lowerCamelCase        =				CLIPTextModelWithProjection(lowerCamelCase__   )
									_lowerCamelCase        =				CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''				,       local_files_only=lowerCamelCase__   )

									_lowerCamelCase        =				{
									    '''unet''': unet,
									    '''scheduler''': scheduler,
									    '''vae''': vae,
									    '''text_encoder''': text_encoder,
									    '''tokenizer''': tokenizer,
									    '''text_encoder_2''': text_encoder_a,
									    '''tokenizer_2''': tokenizer_a,
									    # "safety_checker": None,
									    # "feature_extractor": None,
									}
									return components

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__=0   ):
									_lowerCamelCase        =				floats_tensor((1, 3, 3_2, 3_2)				,       rng=random.Random(lowerCamelCase__   )   ).to(lowerCamelCase__   )
									_lowerCamelCase        =				image / 2 + 0.5
									if str(lowerCamelCase__   ).startswith('''mps'''   ):
													_lowerCamelCase        =				torch.manual_seed(lowerCamelCase__   )
									else:
													_lowerCamelCase        =				torch.Generator(device=lowerCamelCase__   ).manual_seed(lowerCamelCase__   )
									_lowerCamelCase        =				{
									    '''prompt''': '''A painting of a squirrel eating a burger''',
									    '''image''': image,
									    '''generator''': generator,
									    '''num_inference_steps''': 2,
									    '''guidance_scale''': 5.0,
									    '''output_type''': '''numpy''',
									    '''strength''': 0.7_5,
									}
									return inputs

					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				'''cpu'''  # ensure determinism for the device-dependent torch.Generator
									_lowerCamelCase        =				self.get_dummy_components()
									_lowerCamelCase        =				StableDiffusionXLImgaImgPipeline(**lowerCamelCase__   )
									_lowerCamelCase        =				sd_pipe.to(lowerCamelCase__   )
									sd_pipe.set_progress_bar_config(disable=lowerCamelCase__   )

									_lowerCamelCase        =				self.get_dummy_inputs(lowerCamelCase__   )
									_lowerCamelCase        =				sd_pipe(**lowerCamelCase__   ).images
									_lowerCamelCase        =				image[0, -3:, -3:, -1]

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

									_lowerCamelCase        =				np.array([0.4_6_5_6, 0.4_8_4_0, 0.4_4_3_9, 0.6_6_9_8, 0.5_5_7_4, 0.4_5_2_4, 0.5_7_9_9, 0.5_9_4_3, 0.5_1_6_5]   )

									assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2

					def 			snake_case__      (    self   ):
									super().test_attention_slicing_forward_pass(expected_max_diff=3e-3   )

					def 			snake_case__      (    self   ):
									super().test_inference_batch_single_identical(expected_max_diff=3e-3   )

					def 			snake_case__      (    self   ):
									pass





					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				self.get_dummy_components()
									_lowerCamelCase        =				StableDiffusionXLImgaImgPipeline(**lowerCamelCase__   )
									_lowerCamelCase        =				sd_pipe.to(lowerCamelCase__   )
									_lowerCamelCase        =				sd_pipe.to(lowerCamelCase__   )
									sd_pipe.set_progress_bar_config(disable=lowerCamelCase__   )

									# forward without prompt embeds
									_lowerCamelCase        =				self.get_dummy_inputs(lowerCamelCase__   )
									_lowerCamelCase        =				3 * ['''this is a negative prompt''']
									_lowerCamelCase        =				negative_prompt
									_lowerCamelCase        =				3 * [inputs['''prompt''']]

									_lowerCamelCase        =				sd_pipe(**lowerCamelCase__   )
									_lowerCamelCase        =				output.images[0, -3:, -3:, -1]

									# forward with prompt embeds
									_lowerCamelCase        =				self.get_dummy_inputs(lowerCamelCase__   )
									_lowerCamelCase        =				3 * ['''this is a negative prompt''']
									_lowerCamelCase        =				3 * [inputs.pop('''prompt'''   )]

									(
									    (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     (
									    _lowerCamelCase
									)  ,     
									)        =				sd_pipe.encode_prompt(lowerCamelCase__				,       negative_prompt=lowerCamelCase__   )

									_lowerCamelCase        =				sd_pipe(
									    **lowerCamelCase__				,       prompt_embeds=lowerCamelCase__				,       negative_prompt_embeds=lowerCamelCase__				,       pooled_prompt_embeds=lowerCamelCase__				,       negative_pooled_prompt_embeds=lowerCamelCase__				,       )
									_lowerCamelCase        =				output.images[0, -3:, -3:, -1]

									# make sure that it's equal
									assert np.abs(image_slice_a.flatten() - image_slice_a.flatten()   ).max() < 1e-4


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





					'''simple docstring'''



					def 			snake_case__      (    self   ):
									super().tearDown()
									gc.collect()
									torch.cuda.empty_cache()

					def 			snake_case__      (    self				,       lowerCamelCase__				,       lowerCamelCase__="cpu"				,       lowerCamelCase__=torch.floataa				,       lowerCamelCase__=0   ):
									_lowerCamelCase        =				torch.Generator(device=lowerCamelCase__   ).manual_seed(lowerCamelCase__   )
									_lowerCamelCase        =				np.random.RandomState(lowerCamelCase__   ).standard_normal((1, 4, 6_4, 6_4)   )
									_lowerCamelCase        =				torch.from_numpy(lowerCamelCase__   ).to(device=lowerCamelCase__				,       dtype=lowerCamelCase__   )
									_lowerCamelCase        =				{
									    '''prompt''': '''a photograph of an astronaut riding a horse''',
									    '''latents''': latents,
									    '''generator''': generator,
									    '''num_inference_steps''': 3,
									    '''guidance_scale''': 7.5,
									    '''output_type''': '''numpy''',
									}
									return inputs





					def 			snake_case__      (    self   ):
									_lowerCamelCase        =				DiffusionPipeline.from_pretrained('''stabilityai/stable-diffusion-2-base'''   )
									pipe.to(lowerCamelCase__   )
									pipe.set_progress_bar_config(disable=lowerCamelCase__   )

									_lowerCamelCase        =				self.get_inputs(lowerCamelCase__   )
									_lowerCamelCase        =				pipe(**lowerCamelCase__   ).images
									_lowerCamelCase        =				image[0, -3:, -3:, -1].flatten()

									assert image.shape == (1, 5_1_2, 5_1_2, 3)
									_lowerCamelCase        =				np.array([0.4_9_4_9_3, 0.4_7_8_9_6, 0.4_0_7_9_8, 0.5_4_2_1_4, 0.5_3_2_1_2, 0.4_8_2_0_2, 0.4_7_6_5_6, 0.4_6_3_2_9, 0.4_8_5_0_6]   )
									assert np.abs(image_slice - expected_slice   ).max() < 7e-3
