




"""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()
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   lowerCAmelCase__			(     lowerCamelCase__			) ->							str:
							A         =					EfficientNetConfig()
							A         =					CONFIG_MAP[model_name]['hidden_dim']
							A         =					CONFIG_MAP[model_name]['width_coef']
							A         =					CONFIG_MAP[model_name]['depth_coef']
							A         =					CONFIG_MAP[model_name]['image_size']
							A         =					CONFIG_MAP[model_name]['dropout_rate']
							A         =					CONFIG_MAP[model_name]['dw_padding']

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

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

def   lowerCAmelCase__			(     ) ->							Union[str, Any]:
							A         =					'http://images.cocodataset.org/val2017/000000039769.jpg'
							A         =					Image.open(requests.get(lowerCamelCase__				,      stream=lowerCamelCase__			).raw			)
							return im

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							Optional[Any]:
							A         =					CONFIG_MAP[model_name]['image_size']
							A         =					EfficientNetImageProcessor(
							    size={'height': size, 'width': size}				,      image_mean=[0.4_85, 0.4_56, 0.4_06]				,      image_std=[0.47_85_39_44, 0.4_73_28_64, 0.47_43_41_63]				,      do_center_crop=lowerCamelCase__				,      )
							return preprocessor

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

							A         =					[]
							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:
														A         =					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')			)

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

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

def   lowerCAmelCase__			(     lowerCamelCase__				,      lowerCamelCase__				,      lowerCamelCase__			) ->							int:
							for key, value in tf_params.items():
														if "normalization" in key:
																					continue

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

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

							# Load HuggingFace model
							A         =					get_efficientnet_config(lowerCamelCase__			)
							A         =					EfficientNetForImageClassification(lowerCamelCase__			).eval()
							A         =					hf_model.state_dict()

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

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

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

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


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)








"""simple docstring"""







# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


A    =			{'configuration_mra': ['MRA_PRETRAINED_CONFIG_ARCHIVE_MAP', 'MraConfig']}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							A    =			[
							    'MRA_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'MraForMaskedLM',
							    'MraForMultipleChoice',
							    'MraForQuestionAnswering',
							    'MraForSequenceClassification',
							    'MraForTokenClassification',
							    'MraLayer',
							    'MraModel',
							    'MraPreTrainedModel',
							]


if TYPE_CHECKING:
							from .configuration_mra import MRA_PRETRAINED_CONFIG_ARCHIVE_MAP, MraConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mra import (
														    MRA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MraForMaskedLM,
														    MraForMultipleChoice,
														    MraForQuestionAnswering,
														    MraForSequenceClassification,
														    MraForTokenClassification,
														    MraLayer,
														    MraModel,
														    MraPreTrainedModel,
														)
else:
							import sys

							A    =			_LazyModule(__name__, globals()['__file__'], _import_structure)



