


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()
__lowerCAmelCase	: List[str]  				=logging.get_logger(__name__)

__lowerCAmelCase	: 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,
}

__lowerCAmelCase	: Optional[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        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     Any					=		EfficientNetConfig()
						__SCREAMING_SNAKE_CASE						:     Any					=		CONFIG_MAP[model_name]['''hidden_dim''']
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		CONFIG_MAP[model_name]['''width_coef''']
						__SCREAMING_SNAKE_CASE						:     List[str]					=		CONFIG_MAP[model_name]['''depth_coef''']
						__SCREAMING_SNAKE_CASE						:     Tuple					=		CONFIG_MAP[model_name]['''image_size''']
						__SCREAMING_SNAKE_CASE						:     Any					=		CONFIG_MAP[model_name]['''dropout_rate''']
						__SCREAMING_SNAKE_CASE						:     Any					=		CONFIG_MAP[model_name]['''dw_padding''']

						__SCREAMING_SNAKE_CASE						:     int					=		'''huggingface/label-files'''
						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''imagenet-1k-id2label.json'''
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		1000
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		json.load(open(hf_hub_download(lowercase__    ,       lowercase__    ,       repo_type='''dataset'''      )    ,       '''r'''      )      )
						__SCREAMING_SNAKE_CASE						:     str					=		{int(lowercase__      ): v for k, v in idalabel.items()}

						__SCREAMING_SNAKE_CASE						:     Any					=		idalabel
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		{v: k for k, v in idalabel.items()}
						return config


def        _UpperCamelCase							(      ):
						__SCREAMING_SNAKE_CASE						:     int					=		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
						__SCREAMING_SNAKE_CASE						:     Any					=		Image.open(requests.get(lowercase__    ,       stream=lowercase__      ).raw      )
						return im


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		CONFIG_MAP[model_name]['''image_size''']
						__SCREAMING_SNAKE_CASE						:     int					=		EfficientNetImageProcessor(
						    size={'''height''': size, '''width''': size}    ,       image_mean=[0.485, 0.456, 0.406]    ,       image_std=[0.4785_3944, 0.473_2864, 0.4743_4163]    ,       do_center_crop=lowercase__    ,       )
						return preprocessor


def        _UpperCamelCase							(      lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     int					=		[v.split('''_'''      )[0].split('''block'''      )[1] for v in original_param_names if v.startswith('''block'''      )]
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		sorted(set(lowercase__      )      )
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		len(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		{b: str(lowercase__      ) for b, i in zip(lowercase__    ,       range(lowercase__      )      )}

						__SCREAMING_SNAKE_CASE						:     str					=		[]
						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:
												__SCREAMING_SNAKE_CASE						:     Tuple					=		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''')      )

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

						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''classifier.weight'''
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		'''classifier.bias'''
						return key_mapping


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

												__SCREAMING_SNAKE_CASE						:     List[str]					=		key_mapping[key]
												if "_conv" in key and "kernel" in key:
																		__SCREAMING_SNAKE_CASE						:     str					=		torch.from_numpy(lowercase__      ).permute(3    ,       2    ,       0    ,       1      )
												elif "depthwise_kernel" in key:
																		__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		torch.from_numpy(lowercase__      ).permute(2    ,       3    ,       0    ,       1      )
												elif "kernel" in key:
																		__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		torch.from_numpy(np.transpose(lowercase__      )      )
												else:
																		__SCREAMING_SNAKE_CASE						:     str					=		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        _UpperCamelCase							(      lowercase__    ,       lowercase__    ,       lowercase__    ,       lowercase__      ):
						__SCREAMING_SNAKE_CASE						:     str					=		model_classes[model_name](
						    include_top=lowercase__    ,       weights='''imagenet'''    ,       input_tensor=lowercase__    ,       input_shape=lowercase__    ,       pooling=lowercase__    ,       classes=1000    ,       classifier_activation='''softmax'''    ,       )

						__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		original_model.trainable_variables
						__SCREAMING_SNAKE_CASE						:     Tuple					=		original_model.non_trainable_variables
						__SCREAMING_SNAKE_CASE						:     str					=		{param.name: param.numpy() for param in tf_params}
						for param in tf_non_train_params:
												__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		param.numpy()
						__SCREAMING_SNAKE_CASE						:     Dict					=		list(tf_params.keys()      )

						# Load HuggingFace model
						__SCREAMING_SNAKE_CASE						:     List[str]					=		get_efficientnet_config(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		EfficientNetForImageClassification(lowercase__      ).eval()
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		hf_model.state_dict()

						# Create src-to-dst parameter name mapping dictionary
						print('''Converting parameters...'''      )
						__SCREAMING_SNAKE_CASE						:     Dict					=		rename_keys(lowercase__      )
						replace_params(lowercase__    ,       lowercase__    ,       lowercase__      )

						# Initialize preprocessor and preprocess input image
						__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		convert_image_processor(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     Any					=		preprocessor(images=prepare_img()    ,       return_tensors='''pt'''      )

						# HF model inference
						hf_model.eval()
						with torch.no_grad():
												__SCREAMING_SNAKE_CASE						:     str					=		hf_model(**lowercase__      )
						__SCREAMING_SNAKE_CASE						:     List[Any]					=		outputs.logits.detach().numpy()

						# Original model inference
						__SCREAMING_SNAKE_CASE						:     int					=		False
						__SCREAMING_SNAKE_CASE						:     List[str]					=		CONFIG_MAP[model_name]['''image_size''']
						__SCREAMING_SNAKE_CASE						:     str					=		prepare_img().resize((image_size, image_size)    ,       resample=PIL.Image.NEAREST      )
						__SCREAMING_SNAKE_CASE						:     Optional[int]					=		image.img_to_array(lowercase__      )
						__SCREAMING_SNAKE_CASE						:     List[str]					=		np.expand_dims(lowercase__    ,       axis=0      )
						__SCREAMING_SNAKE_CASE						:     Tuple					=		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...'''      )
												__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		F'''efficientnet-{model_name}'''
												preprocessor.push_to_hub(lowercase__      )
												hf_model.push_to_hub(lowercase__      )


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

						__lowerCAmelCase	: Dict  				=parser.parse_args()
						convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)




import os
import unittest

from transformers.models.transfo_xl.tokenization_transfo_xl import VOCAB_FILES_NAMES, TransfoXLTokenizer

from ...test_tokenization_common import TokenizerTesterMixin
class        _lowercase      (			A__						,			unittest.TestCase       ):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE__				:			Optional[int]						=		TransfoXLTokenizer
				SCREAMING_SNAKE_CASE__				:			int						=		False
				SCREAMING_SNAKE_CASE__				:			Optional[Any]						=		False


				def 		__magic_name__(       self			:str	)		->			Dict:
										super().setUp()

										__SCREAMING_SNAKE_CASE						:     List[str]					=		[
										    '''<unk>''',
										    '''[CLS]''',
										    '''[SEP]''',
										    '''want''',
										    '''unwanted''',
										    '''wa''',
										    '''un''',
										    '''running''',
										    ''',''',
										    '''low''',
										    '''l''',
										]
										__SCREAMING_SNAKE_CASE						:     Any					=		os.path.join(self.tmpdirname			,			VOCAB_FILES_NAMES['''vocab_file''']	)
										with open(self.vocab_file			,			'''w'''			,			encoding='''utf-8'''	) as vocab_writer:
																vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]	)	)


				def 		__magic_name__(       self			:Any			,			**lowerCAmelCase__			:int	)		->			str:
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		True
										return TransfoXLTokenizer.from_pretrained(self.tmpdirname			,			**lowerCAmelCase__	)


				def 		__magic_name__(       self			:Union[str, Any]			,			lowerCAmelCase__			:List[Any]	)		->			Tuple:
										__SCREAMING_SNAKE_CASE						:     Dict					=		'''<unk> UNwanted , running'''
										__SCREAMING_SNAKE_CASE						:     List[str]					=		'''<unk> unwanted, running'''
										return input_text, output_text


				def 		__magic_name__(       self			:Any	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     int					=		TransfoXLTokenizer(vocab_file=self.vocab_file			,			lower_case=lowerCAmelCase__	)

										__SCREAMING_SNAKE_CASE						:     int					=		tokenizer.tokenize('''<unk> UNwanted , running'''	)
										self.assertListEqual(lowerCAmelCase__			,			['''<unk>''', '''unwanted''', ''',''', '''running''']	)

										self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__	)			,			[0, 4, 8, 7]	)


				def 		__magic_name__(       self			:Tuple	)		->			Union[str, Any]:
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		TransfoXLTokenizer(lower_case=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHeLLo ! how  \n Are yoU ?  '''	)			,			['''hello''', '''!''', '''how''', '''are''', '''you''', '''?''']	)


				def 		__magic_name__(       self			:Tuple	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		TransfoXLTokenizer(lower_case=lowerCAmelCase__	)

										self.assertListEqual(
										    tokenizer.tokenize(''' \tHeLLo ! how  \n Are yoU ?  '''	)			,			['''HeLLo''', '''!''', '''how''', '''Are''', '''yoU''', '''?''']	)


				def 		__magic_name__(       self			:Dict	)		->			List[Any]:
										__SCREAMING_SNAKE_CASE						:     List[str]					=		TransfoXLTokenizer(lower_case=lowerCAmelCase__	)
										__SCREAMING_SNAKE_CASE						:     Optional[Any]					=		'''Hello (bracket) and side-scrolled [and] Henry\'s $5,000 with 3.34 m. What\'s up!?'''
										__SCREAMING_SNAKE_CASE						:     Optional[int]					=		[
										    '''Hello''',
										    '''(''',
										    '''bracket''',
										    ''')''',
										    '''and''',
										    '''side''',
										    '''@-@''',
										    '''scrolled''',
										    '''[''',
										    '''and''',
										    ''']''',
										    '''Henry''',
										    '''\'s''',
										    '''$''',
										    '''5''',
										    '''@,@''',
										    '''000''',
										    '''with''',
										    '''3''',
										    '''@.@''',
										    '''34''',
										    '''m''',
										    '''.''',
										    '''What''',
										    '''\'s''',
										    '''up''',
										    '''!''',
										    '''?''',
										]

										self.assertListEqual(tokenizer.tokenize(lowerCAmelCase__	)			,			lowerCAmelCase__	)

										self.assertEqual(tokenizer.convert_tokens_to_string(lowerCAmelCase__	)			,			lowerCAmelCase__	)



				def 		__magic_name__(       self			:str	)		->			int:
										__SCREAMING_SNAKE_CASE						:     Union[str, Any]					=		self.get_tokenizer()
										__SCREAMING_SNAKE_CASE						:     Any					=		len(lowerCAmelCase__	)

										tokenizer.add_tokens(['''new1''', '''new2''']	)
										tokenizer.move_added_token('''new1'''			,			1	)

										# Check that moved token is not copied (duplicate)
										self.assertEqual(len(lowerCAmelCase__	)			,			original_len + 2	)
										# Check that token is moved to specified id
										self.assertEqual(tokenizer.encode('''new1'''	)			,			[1]	)
										self.assertEqual(tokenizer.decode([1]	)			,			'''new1'''	)
