






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

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

a__       =     {
    """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   (	a						:	Any ):
							snake_case__	  =       EfficientNetConfig()
							snake_case__	  =       CONFIG_MAP[model_name]["""hidden_dim"""]
							snake_case__	  =       CONFIG_MAP[model_name]["""width_coef"""]
							snake_case__	  =       CONFIG_MAP[model_name]["""depth_coef"""]
							snake_case__	  =       CONFIG_MAP[model_name]["""image_size"""]
							snake_case__	  =       CONFIG_MAP[model_name]["""dropout_rate"""]
							snake_case__	  =       CONFIG_MAP[model_name]["""dw_padding"""]

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

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

def _UpperCAmelCase   (	):
							snake_case__	  =       """http://images.cocodataset.org/val2017/000000039769.jpg"""
							snake_case__	  =       Image.open(requests.get(a  ,					stream=a ).raw )
							return im

def _UpperCAmelCase   (	a						:	str ):
							snake_case__	  =       CONFIG_MAP[model_name]["""image_size"""]
							snake_case__	  =       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=a  ,					)
							return preprocessor

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

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

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

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

def _UpperCAmelCase   (	a						:	Optional[int]  ,					a						:	Any  ,					a						:	Dict ):
							for key, value in tf_params.items():
														if "normalization" in key:
																					continue

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

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

@torch.no_grad()
def _UpperCAmelCase   (	a						:	List[Any]  ,					a						:	Dict  ,					a						:	int  ,					a						:	Any ):
							snake_case__	  =       model_classes[model_name](
							    include_top=a  ,					weights="""imagenet"""  ,					input_tensor=a  ,					input_shape=a  ,					pooling=a  ,					classes=1000  ,					classifier_activation="""softmax"""  ,					)

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

							# Load HuggingFace model
							snake_case__	  =       get_efficientnet_config(a )
							snake_case__	  =       EfficientNetForImageClassification(a ).eval()
							snake_case__	  =       hf_model.state_dict()

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

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

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

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

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

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


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

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








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


a__       =     {
    """configuration_lilt""": ["""LILT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LiltConfig"""],
}

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a__       =     [
	    """LILT_PRETRAINED_MODEL_ARCHIVE_LIST""",
	    """LiltForQuestionAnswering""",
	    """LiltForSequenceClassification""",
	    """LiltForTokenClassification""",
	    """LiltModel""",
	    """LiltPreTrainedModel""",
	]

if TYPE_CHECKING:
	from .configuration_lilt import LILT_PRETRAINED_CONFIG_ARCHIVE_MAP, LiltConfig

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_lilt import (
		    LILT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    LiltForQuestionAnswering,
		    LiltForSequenceClassification,
		    LiltForTokenClassification,
		    LiltModel,
		    LiltPreTrainedModel,
		)

else:
	import sys

	a__       =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
