






"""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()
lowercase    			=       logging.get_logger(__name__)

lowercase    			=       {
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

lowercase    			=       {
    '''b0''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 224,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 240,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 1408,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 260,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 1536,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 300,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 1792,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 380,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2048,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 456,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 2304,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 528,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 2560,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 600,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}






def _lowerCAmelCase	(  __lowerCamelCase:Optional[int]   ):

						'''simple docstring'''






						__magic_name__            =     EfficientNetConfig()
						__magic_name__            =     CONFIG_MAP[model_name]["hidden_dim"]
						__magic_name__            =     CONFIG_MAP[model_name]["width_coef"]
						__magic_name__            =     CONFIG_MAP[model_name]["depth_coef"]
						__magic_name__            =     CONFIG_MAP[model_name]["image_size"]
						__magic_name__            =     CONFIG_MAP[model_name]["dropout_rate"]
						__magic_name__            =     CONFIG_MAP[model_name]["dw_padding"]

						__magic_name__            =     "huggingface/label-files"
						__magic_name__            =     "imagenet-1k-id2label.json"
						__magic_name__            =     1_0_0_0
						__magic_name__            =     json.load(open(hf_hub_download(__lowerCamelCase ,						__lowerCamelCase ,						repo_type="dataset"   ) ,						"r"   )   )
						__magic_name__            =     {int(__lowerCamelCase   ): v for k, v in idalabel.items()}

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






def _lowerCAmelCase	(  ):

						'''simple docstring'''






						__magic_name__            =     "http://images.cocodataset.org/val2017/000000039769.jpg"
						__magic_name__            =     Image.open(requests.get(__lowerCamelCase ,						stream=__lowerCamelCase   ).raw   )
						return im






def _lowerCAmelCase	(  __lowerCamelCase:int   ):

						'''simple docstring'''






						__magic_name__            =     CONFIG_MAP[model_name]["image_size"]
						__magic_name__            =     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=__lowerCamelCase ,						)
						return preprocessor






def _lowerCAmelCase	(  __lowerCamelCase:Any   ):

						'''simple docstring'''






						__magic_name__            =     [v.split("_"   )[0].split("block"   )[1] for v in original_param_names if v.startswith("block"   )]
						__magic_name__            =     sorted(set(__lowerCamelCase   )   )
						__magic_name__            =     len(__lowerCamelCase   )
						__magic_name__            =     {b: str(__lowerCamelCase   ) for b, i in zip(__lowerCamelCase ,						range(__lowerCamelCase   )   )}

						__magic_name__            =     []
						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:
												__magic_name__            =     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")   )

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

						__magic_name__            =     "classifier.weight"
						__magic_name__            =     "classifier.bias"
						return key_mapping






def _lowerCAmelCase	(  __lowerCamelCase:Optional[Any] ,						__lowerCamelCase:int ,						__lowerCamelCase:Optional[Any]   ):

						'''simple docstring'''






						for key, value in tf_params.items():
												if "normalization" in key:
																		continue

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

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






@torch.no_grad()
def _lowerCAmelCase	(  __lowerCamelCase:Union[str, Any] ,						__lowerCamelCase:Union[str, Any] ,						__lowerCamelCase:str ,						__lowerCamelCase:List[str]   ):

						'''simple docstring'''






						__magic_name__            =     model_classes[model_name](
						    include_top=__lowerCamelCase ,						weights="imagenet" ,						input_tensor=__lowerCamelCase ,						input_shape=__lowerCamelCase ,						pooling=__lowerCamelCase ,						classes=1_0_0_0 ,						classifier_activation="softmax" ,						)

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

						# Load HuggingFace model
						__magic_name__            =     get_efficientnet_config(__lowerCamelCase   )
						__magic_name__            =     EfficientNetForImageClassification(__lowerCamelCase   ).eval()
						__magic_name__            =     hf_model.state_dict()

						# Create src-to-dst parameter name mapping dictionary
						print("Converting parameters..."   )
						__magic_name__            =     rename_keys(__lowerCamelCase   )
						replace_params(__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase   )

						# Initialize preprocessor and preprocess input image
						__magic_name__            =     convert_image_processor(__lowerCamelCase   )
						__magic_name__            =     preprocessor(images=prepare_img() ,						return_tensors="pt"   )

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

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

						# Check whether original and HF model outputs match  -> np.allclose
						assert np.allclose(__lowerCamelCase ,						__lowerCamelCase ,						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(__lowerCamelCase   ):
																		os.mkdir(__lowerCamelCase   )
												# Save converted model and image processor
												hf_model.save_pretrained(__lowerCamelCase   )
												preprocessor.save_pretrained(__lowerCamelCase   )

						if push_to_hub:
												# Push model and image processor to hub
												print(f'''Pushing converted {model_name} to the hub...'''   )
												__magic_name__            =     f'''efficientnet-{model_name}'''
												preprocessor.push_to_hub(__lowerCamelCase   )
												hf_model.push_to_hub(__lowerCamelCase   )


if __name__ == "__main__":
			lowercase    			=       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''')

			lowercase    			=       parser.parse_args()
			convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)











"""simple docstring"""

import unittest

import numpy as np
import torch
from torch import nn
from transformers import (
    CLIPImageProcessor,
    CLIPTextConfig,
    CLIPTextModelWithProjection,
    CLIPTokenizer,
    CLIPVisionConfig,
    CLIPVisionModelWithProjection,
)

from diffusers import KandinskyVaaPriorPipeline, PriorTransformer, UnCLIPScheduler
from diffusers.utils import torch_device
from diffusers.utils.testing_utils import enable_full_determinism, skip_mps

from ..test_pipelines_common import PipelineTesterMixin


enable_full_determinism()

class 						A_							(      snake_case_					,							unittest.TestCase  ):
				UpperCAmelCase__        =				KandinskyVaaPriorPipeline
				UpperCAmelCase__        =				['''prompt''']
				UpperCAmelCase__        =				['''prompt''', '''negative_prompt''']
				UpperCAmelCase__        =				[
				    '''num_images_per_prompt''',
				    '''generator''',
				    '''num_inference_steps''',
				    '''latents''',
				    '''negative_prompt''',
				    '''guidance_scale''',
				    '''output_type''',
				    '''return_dict''',
				]
				UpperCAmelCase__        =				False







				@property
				def     _snake_case					(							self							:						Dict	)				->					Dict:
										return 3_2







				@property
				def     _snake_case					(							self							:						Tuple	)				->					Tuple:
										return 3_2







				@property
				def     _snake_case					(							self							:						Dict	)				->					Optional[int]:
										return self.time_input_dim







				@property
				def     _snake_case					(							self							:						List[Any]	)				->					str:
										return self.time_input_dim * 4







				@property
				def     _snake_case					(							self							:						List[str]	)				->					List[Any]:
										return 1_0_0







				@property
				def     _snake_case					(							self							:						List[str]	)				->					Tuple:
										__magic_name__            =     CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"	)
										return tokenizer







				@property
				def     _snake_case					(							self							:						Optional[int]	)				->					Optional[int]:
										torch.manual_seed(0	)
										__magic_name__            =     CLIPTextConfig(
										    bos_token_id=0						,    eos_token_id=2						,    hidden_size=self.text_embedder_hidden_size						,    projection_dim=self.text_embedder_hidden_size						,    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						,    )
										return CLIPTextModelWithProjection(__lowerCamelCase	)







				@property
				def     _snake_case					(							self							:						List[str]	)				->					Union[str, Any]:
										torch.manual_seed(0	)

										__magic_name__            =     {
										    "num_attention_heads": 2,
										    "attention_head_dim": 1_2,
										    "embedding_dim": self.text_embedder_hidden_size,
										    "num_layers": 1,
										}

										__magic_name__            =     PriorTransformer(**__lowerCamelCase	)
										# clip_std and clip_mean is initialized to be 0 so PriorTransformer.post_process_latents will always return 0 - set clip_std to be 1 so it won't return 0
										__magic_name__            =     nn.Parameter(torch.ones(model.clip_std.shape	)	)
										return model







				@property
				def     _snake_case					(							self							:						Union[str, Any]	)				->					Union[str, Any]:
										torch.manual_seed(0	)
										__magic_name__            =     CLIPVisionConfig(
										    hidden_size=self.text_embedder_hidden_size						,    image_size=2_2_4						,    projection_dim=self.text_embedder_hidden_size						,    intermediate_size=3_7						,    num_attention_heads=4						,    num_channels=3						,    num_hidden_layers=5						,    patch_size=1_4						,    )

										__magic_name__            =     CLIPVisionModelWithProjection(__lowerCamelCase	)
										return model







				@property
				def     _snake_case					(							self							:						Union[str, Any]	)				->					int:
										__magic_name__            =     CLIPImageProcessor(
										    crop_size=2_2_4						,    do_center_crop=__lowerCamelCase						,    do_normalize=__lowerCamelCase						,    do_resize=__lowerCamelCase						,    image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]						,    image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]						,    resample=3						,    size=2_2_4						,    )

										return image_processor







				def     _snake_case					(							self							:						List[Any]	)				->					Optional[Any]:
										__magic_name__            =     self.dummy_prior
										__magic_name__            =     self.dummy_image_encoder
										__magic_name__            =     self.dummy_text_encoder
										__magic_name__            =     self.dummy_tokenizer
										__magic_name__            =     self.dummy_image_processor

										__magic_name__            =     UnCLIPScheduler(
										    variance_type="fixed_small_log"						,    prediction_type="sample"						,    num_train_timesteps=1_0_0_0						,    clip_sample=__lowerCamelCase						,    clip_sample_range=10.0						,    )

										__magic_name__            =     {
										    "prior": prior,
										    "image_encoder": image_encoder,
										    "text_encoder": text_encoder,
										    "tokenizer": tokenizer,
										    "scheduler": scheduler,
										    "image_processor": image_processor,
										}

										return components







				def     _snake_case					(							self							:						int						,    __lowerCamelCase							:						List[Any]						,    __lowerCamelCase							:						str=0	)				->					Optional[int]:
										if str(__lowerCamelCase	).startswith("mps"	):
																__magic_name__            =     torch.manual_seed(__lowerCamelCase	)
										else:
																__magic_name__            =     torch.Generator(device=__lowerCamelCase	).manual_seed(__lowerCamelCase	)
										__magic_name__            =     {
										    "prompt": "horse",
										    "generator": generator,
										    "guidance_scale": 4.0,
										    "num_inference_steps": 2,
										    "output_type": "np",
										}
										return inputs







				def     _snake_case					(							self							:						Optional[Any]	)				->					Optional[Any]:
										__magic_name__            =     "cpu"

										__magic_name__            =     self.get_dummy_components()

										__magic_name__            =     self.pipeline_class(**__lowerCamelCase	)
										__magic_name__            =     pipe.to(__lowerCamelCase	)

										pipe.set_progress_bar_config(disable=__lowerCamelCase	)

										__magic_name__            =     pipe(**self.get_dummy_inputs(__lowerCamelCase	)	)
										__magic_name__            =     output.image_embeds

										__magic_name__            =     pipe(
										    **self.get_dummy_inputs(__lowerCamelCase	)						,    return_dict=__lowerCamelCase						,    )[0]

										__magic_name__            =     image[0, -1_0:]
										__magic_name__            =     image_from_tuple[0, -1_0:]

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

										__magic_name__            =     np.array(
										    [-0.0532, 1.7120, 0.3656, -1.0852, -0.8946, -1.1756, 0.4348, 0.2482, 0.5146, -0.1156]	)

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







				@skip_mps
				def     _snake_case					(							self							:						Dict	)				->					List[str]:
										__magic_name__            =     torch_device == "cpu"
										__magic_name__            =     True
										__magic_name__            =     False

										self._test_inference_batch_single_identical(
										    test_max_difference=__lowerCamelCase						,    relax_max_difference=__lowerCamelCase						,    test_mean_pixel_difference=__lowerCamelCase						,    )







				@skip_mps
				def     _snake_case					(							self							:						Tuple	)				->					Tuple:
										__magic_name__            =     torch_device == "cpu"
										__magic_name__            =     False

										self._test_attention_slicing_forward_pass(
										    test_max_difference=__lowerCamelCase						,    test_mean_pixel_difference=__lowerCamelCase						,    )



