


'''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_					:    Tuple          =    logging.get_logger(__name__)

a_					:    Union[str, 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,
}

a_					:    Optional[Any]          =    {
    "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 	_A				(lowerCAmelCase__  :List[str]		)   ->  List[Any]:




     '''simple docstring'''



     _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			      =							10_00
     _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 	_A				()   ->  str:




     '''simple docstring'''



     _a			      =							'http://images.cocodataset.org/val2017/000000039769.jpg'
     _a			      =							Image.open(requests.get(lowerCAmelCase__				,						stream=lowerCAmelCase__		).raw		)
     return im






def 	_A				(lowerCAmelCase__  :List[str]		)   ->  str:




     '''simple docstring'''



     _a			      =							CONFIG_MAP[model_name]['image_size']
     _a			      =							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 	_A				(lowerCAmelCase__  :Optional[int]		)   ->  int:




     '''simple docstring'''



     _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 	_A				(lowerCAmelCase__  :int				,						lowerCAmelCase__  :Dict				,						lowerCAmelCase__  :int		)   ->  Optional[int]:




     '''simple docstring'''



     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 	_A				(lowerCAmelCase__  :int				,						lowerCAmelCase__  :Tuple				,						lowerCAmelCase__  :Optional[Any]				,						lowerCAmelCase__  :Optional[Any]		)   ->  Union[str, Any]:




     '''simple docstring'''



     _a			      =							model_classes[model_name](
         include_top=lowerCAmelCase__				,						weights='imagenet'				,						input_tensor=lowerCAmelCase__				,						input_shape=lowerCAmelCase__				,						pooling=lowerCAmelCase__				,						classes=10_00				,						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_					:    Any          =    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_					:    Any          =    parser.parse_args()
 convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)





'''simple docstring'''






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


a_					:    str          =    {
    "configuration_data2vec_audio": ["DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP", "Data2VecAudioConfig"],
    "configuration_data2vec_text": [
        "DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecTextConfig",
        "Data2VecTextOnnxConfig",
    ],
    "configuration_data2vec_vision": [
        "DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "Data2VecVisionConfig",
        "Data2VecVisionOnnxConfig",
    ],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 a_					:    List[str]          =    [
     "DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST",
     "Data2VecAudioForAudioFrameClassification",
     "Data2VecAudioForCTC",
     "Data2VecAudioForSequenceClassification",
     "Data2VecAudioForXVector",
     "Data2VecAudioModel",
     "Data2VecAudioPreTrainedModel",
 ]
 a_					:    str          =    [
     "DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST",
     "Data2VecTextForCausalLM",
     "Data2VecTextForMaskedLM",
     "Data2VecTextForMultipleChoice",
     "Data2VecTextForQuestionAnswering",
     "Data2VecTextForSequenceClassification",
     "Data2VecTextForTokenClassification",
     "Data2VecTextModel",
     "Data2VecTextPreTrainedModel",
 ]
 a_					:    Tuple          =    [
     "DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST",
     "Data2VecVisionForImageClassification",
     "Data2VecVisionForMaskedImageModeling",
     "Data2VecVisionForSemanticSegmentation",
     "Data2VecVisionModel",
     "Data2VecVisionPreTrainedModel",
 ]

if is_tf_available():
 a_					:    Dict          =    [
     "TFData2VecVisionForImageClassification",
     "TFData2VecVisionForSemanticSegmentation",
     "TFData2VecVisionModel",
     "TFData2VecVisionPreTrainedModel",
 ]

if TYPE_CHECKING:
 from .configuration_dataavec_audio import DATA2VEC_AUDIO_PRETRAINED_CONFIG_ARCHIVE_MAP, DataaVecAudioConfig
 from .configuration_dataavec_text import (
     DATA2VEC_TEXT_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DataaVecTextConfig,
     DataaVecTextOnnxConfig,
 )
 from .configuration_dataavec_vision import (
     DATA2VEC_VISION_PRETRAINED_CONFIG_ARCHIVE_MAP,
     DataaVecVisionConfig,
     DataaVecVisionOnnxConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_dataavec_audio import (
      DATA2VEC_AUDIO_PRETRAINED_MODEL_ARCHIVE_LIST,
      DataaVecAudioForAudioFrameClassification,
      DataaVecAudioForCTC,
      DataaVecAudioForSequenceClassification,
      DataaVecAudioForXVector,
      DataaVecAudioModel,
      DataaVecAudioPreTrainedModel,
  )
  from .modeling_dataavec_text import (
      DATA2VEC_TEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
      DataaVecTextForCausalLM,
      DataaVecTextForMaskedLM,
      DataaVecTextForMultipleChoice,
      DataaVecTextForQuestionAnswering,
      DataaVecTextForSequenceClassification,
      DataaVecTextForTokenClassification,
      DataaVecTextModel,
      DataaVecTextPreTrainedModel,
  )
  from .modeling_dataavec_vision import (
      DATA2VEC_VISION_PRETRAINED_MODEL_ARCHIVE_LIST,
      DataaVecVisionForImageClassification,
      DataaVecVisionForMaskedImageModeling,
      DataaVecVisionForSemanticSegmentation,
      DataaVecVisionModel,
      DataaVecVisionPreTrainedModel,
  )
 if is_tf_available():
  from .modeling_tf_dataavec_vision import (
      TFDataaVecVisionForImageClassification,
      TFDataaVecVisionForSemanticSegmentation,
      TFDataaVecVisionModel,
      TFDataaVecVisionPreTrainedModel,
  )

else:
 import sys

 a_					:    List[Any]          =    _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

