






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()
__magic_name__:					str							=     logging.get_logger(__name__)

__magic_name__:					int							=     {
    "b0": efficientnet.EfficientNetBa,
    "b1": efficientnet.EfficientNetBa,
    "b2": efficientnet.EfficientNetBa,
    "b3": efficientnet.EfficientNetBa,
    "b4": efficientnet.EfficientNetBa,
    "b5": efficientnet.EfficientNetBa,
    "b6": efficientnet.EfficientNetBa,
    "b7": efficientnet.EfficientNetBa,
}

__magic_name__:					Any							=     {
    "b0": {
        "hidden_dim": 1_280,
        "width_coef": 1.0,
        "depth_coef": 1.0,
        "image_size": 224,
        "dropout_rate": 0.2,
        "dw_padding": [],
    },
    "b1": {
        "hidden_dim": 1_280,
        "width_coef": 1.0,
        "depth_coef": 1.1,
        "image_size": 240,
        "dropout_rate": 0.2,
        "dw_padding": [16],
    },
    "b2": {
        "hidden_dim": 1_408,
        "width_coef": 1.1,
        "depth_coef": 1.2,
        "image_size": 260,
        "dropout_rate": 0.3,
        "dw_padding": [5, 8, 16],
    },
    "b3": {
        "hidden_dim": 1_536,
        "width_coef": 1.2,
        "depth_coef": 1.4,
        "image_size": 300,
        "dropout_rate": 0.3,
        "dw_padding": [5, 18],
    },
    "b4": {
        "hidden_dim": 1_792,
        "width_coef": 1.4,
        "depth_coef": 1.8,
        "image_size": 380,
        "dropout_rate": 0.4,
        "dw_padding": [6],
    },
    "b5": {
        "hidden_dim": 2_048,
        "width_coef": 1.6,
        "depth_coef": 2.2,
        "image_size": 456,
        "dropout_rate": 0.4,
        "dw_padding": [13, 27],
    },
    "b6": {
        "hidden_dim": 2_304,
        "width_coef": 1.8,
        "depth_coef": 2.6,
        "image_size": 528,
        "dropout_rate": 0.5,
        "dw_padding": [31],
    },
    "b7": {
        "hidden_dim": 2_560,
        "width_coef": 2.0,
        "depth_coef": 3.1,
        "image_size": 600,
        "dropout_rate": 0.5,
        "dw_padding": [18],
    },
}

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       Dict       						= EfficientNetConfig()
						__magic_name__      :       Optional[int]       						= CONFIG_MAP[model_name]["""hidden_dim"""]
						__magic_name__      :       Dict       						= CONFIG_MAP[model_name]["""width_coef"""]
						__magic_name__      :       str       						= CONFIG_MAP[model_name]["""depth_coef"""]
						__magic_name__      :       Optional[int]       						= CONFIG_MAP[model_name]["""image_size"""]
						__magic_name__      :       Union[str, Any]       						= CONFIG_MAP[model_name]["""dropout_rate"""]
						__magic_name__      :       Tuple       						= CONFIG_MAP[model_name]["""dw_padding"""]

						__magic_name__      :       Dict       						= """huggingface/label-files"""
						__magic_name__      :       Any       						= """imagenet-1k-id2label.json"""
						__magic_name__      :       Dict       						= 1000
						__magic_name__      :       Optional[int]       						= json.load(open(hf_hub_download(_lowerCAmelCase,   _lowerCAmelCase,   repo_type="""dataset"""			),   """r"""			)			)
						__magic_name__      :       Any       						= {int(_lowerCAmelCase			): v for k, v in idalabel.items()}

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

def    UpperCamelCase						(	):






						"""simple docstring"""







						__magic_name__      :       Optional[int]       						= """http://images.cocodataset.org/val2017/000000039769.jpg"""
						__magic_name__      :       Tuple       						= Image.open(requests.get(_lowerCAmelCase,   stream=_lowerCAmelCase			).raw			)
						return im

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







						__magic_name__      :       List[Any]       						= CONFIG_MAP[model_name]["""image_size"""]
						__magic_name__      :       Optional[Any]       						= EfficientNetImageProcessor(
						    size={"""height""": size, """width""": size},   image_mean=[0.485, 0.456, 0.406],   image_std=[0.47853944, 0.4732864, 0.47434163],   do_center_crop=_lowerCAmelCase,   )
						return preprocessor

def    UpperCamelCase						(	_A			):






						"""simple docstring"""







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

						__magic_name__      :       Union[str, Any]       						= []
						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__      :       Optional[Any]       						= 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__      :       Any       						= {}
						for item in rename_keys:
												if item[0] in original_param_names:
																		__magic_name__      :       Dict       						= """efficientnet.""" + item[1]

						__magic_name__      :       Any       						= """classifier.weight"""
						__magic_name__      :       Dict       						= """classifier.bias"""
						return key_mapping

def    UpperCamelCase						(	_A,   _A,   _A			):






						"""simple docstring"""







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

												__magic_name__      :       Union[str, Any]       						= key_mapping[key]
												if "_conv" in key and "kernel" in key:
																		__magic_name__      :       List[str]       						= torch.from_numpy(_lowerCAmelCase			).permute(3,   2,   0,   1			)
												elif "depthwise_kernel" in key:
																		__magic_name__      :       Tuple       						= torch.from_numpy(_lowerCAmelCase			).permute(2,   3,   0,   1			)
												elif "kernel" in key:
																		__magic_name__      :       Optional[Any]       						= torch.from_numpy(np.transpose(_lowerCAmelCase			)			)
												else:
																		__magic_name__      :       Optional[Any]       						= 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    UpperCamelCase						(	_A,   _A,   _A,   _A			):






						"""simple docstring"""







						__magic_name__      :       List[Any]       						= model_classes[model_name](
						    include_top=_lowerCAmelCase,   weights="""imagenet""",   input_tensor=_lowerCAmelCase,   input_shape=_lowerCAmelCase,   pooling=_lowerCAmelCase,   classes=1000,   classifier_activation="""softmax""",   )

						__magic_name__      :       Tuple       						= original_model.trainable_variables
						__magic_name__      :       List[str]       						= original_model.non_trainable_variables
						__magic_name__      :       Tuple       						= {param.name: param.numpy() for param in tf_params}
						for param in tf_non_train_params:
												__magic_name__      :       List[Any]       						= param.numpy()
						__magic_name__      :       List[str]       						= list(tf_params.keys()			)

						# Load HuggingFace model
						__magic_name__      :       Optional[int]       						= get_efficientnet_config(_lowerCAmelCase			)
						__magic_name__      :       int       						= EfficientNetForImageClassification(_lowerCAmelCase			).eval()
						__magic_name__      :       Optional[int]       						= hf_model.state_dict()

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

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

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

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


if __name__ == "__main__":
		__magic_name__:					int							=     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")

		__magic_name__:					Union[str, Any]							=     parser.parse_args()
		convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)








from __future__ import annotations

import math

import numpy as np
from numpy.linalg import norm

def    UpperCamelCase						(	_A,   _A			):






						"""simple docstring"""







						return math.sqrt(sum(pow(a - b,   2			) for a, b in zip(_A,   _A			)			)			)

def    UpperCamelCase						(	_A,   _A			):






						"""simple docstring"""







						if dataset.ndim != value_array.ndim:
												__magic_name__      :       str       						= (
												    """Wrong input data's dimensions... """
												    f'dataset : {dataset.ndim}, value_array : {value_array.ndim}'
												)
												raise ValueError(_A			)

						try:
												if dataset.shape[1] != value_array.shape[1]:
																		__magic_name__      :       Optional[Any]       						= (
																		    """Wrong input data's shape... """
																		    f'dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}'
																		)
																		raise ValueError(_A			)
						except IndexError:
												if dataset.ndim != value_array.ndim:
																		raise TypeError("""Wrong shape"""			)

						if dataset.dtype != value_array.dtype:
												__magic_name__      :       List[Any]       						= (
												    """Input data have different datatype... """
												    f'dataset : {dataset.dtype}, value_array : {value_array.dtype}'
												)
												raise TypeError(_A			)

						__magic_name__      :       Dict       						= []

						for value in value_array:
												__magic_name__      :       Tuple       						= euclidean(_A,   dataset[0]			)
												__magic_name__      :       Any       						= dataset[0].tolist()

												for dataset_value in dataset[1:]:
																		__magic_name__      :       Any       						= euclidean(_A,   _A			)

																		if dist > temp_dist:
																								__magic_name__      :       Dict       						= temp_dist
																								__magic_name__      :       Any       						= dataset_value.tolist()

												answer.append([vector, dist]			)

						return answer

def    UpperCamelCase						(	_A,   _A			):






						"""simple docstring"""







						return np.dot(_A,   _A			) / (norm(_A			) * norm(_A			))


if __name__ == "__main__":
		import doctest

		doctest.testmod()
