





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()
lowercase				:	Union[str, Any]      						=  logging.get_logger(__name__)

lowercase				:	Optional[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,
}

lowercase				:	str      						=  {
    """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_     (		A__    )  ->		List[Any]:
       a__						:     Dict			=    EfficientNetConfig()
       a__						:     List[str]			=    CONFIG_MAP[model_name]['hidden_dim']
       a__						:     List[str]			=    CONFIG_MAP[model_name]['width_coef']
       a__						:     Any			=    CONFIG_MAP[model_name]['depth_coef']
       a__						:     Union[str, Any]			=    CONFIG_MAP[model_name]['image_size']
       a__						:     List[str]			=    CONFIG_MAP[model_name]['dropout_rate']
       a__						:     Dict			=    CONFIG_MAP[model_name]['dw_padding']

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

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



def A_     (		)  ->		List[Any]:
       a__						:     Any			=    'http://images.cocodataset.org/val2017/000000039769.jpg'
       a__						:     Optional[int]			=    Image.open(requests.get(A__		,				stream=A__    ).raw    )
       return im



def A_     (		A__    )  ->		int:
       a__						:     List[Any]			=    CONFIG_MAP[model_name]['image_size']
       a__						:     Union[str, Any]			=    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=A__		,				)
       return preprocessor



def A_     (		A__    )  ->		Union[str, Any]:
       a__						:     Optional[int]			=    [v.split('_'    )[0].split('block'    )[1] for v in original_param_names if v.startswith('block'    )]
       a__						:     List[str]			=    sorted(set(A__    )    )
       a__						:     Optional[Any]			=    len(A__    )
       a__						:     List[Any]			=    {b: str(A__    ) for b, i in zip(A__		,				range(A__    )    )}

       a__						:     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:
              a__						:     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')    )

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

       a__						:     List[str]			=    'classifier.weight'
       a__						:     List[Any]			=    'classifier.bias'
       return key_mapping



def A_     (		A__		,				A__		,				A__    )  ->		List[Any]:
       for key, value in tf_params.items():
              if "normalization" in key:
                     continue

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

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

       # Load HuggingFace model
       a__						:     Any			=    get_efficientnet_config(A__    )
       a__						:     str			=    EfficientNetForImageClassification(A__    ).eval()
       a__						:     List[str]			=    hf_model.state_dict()

       # Create src-to-dst parameter name mapping dictionary
       print('Converting parameters...'    )
       a__						:     Optional[int]			=    rename_keys(A__    )
       replace_params(A__		,				A__		,				A__    )

       # Initialize preprocessor and preprocess input image
       a__						:     Optional[Any]			=    convert_image_processor(A__    )
       a__						:     List[Any]			=    preprocessor(images=prepare_img()		,				return_tensors='pt'    )

       # HF model inference
       hf_model.eval()
       with torch.no_grad():
              a__						:     Tuple			=    hf_model(**A__    )
       a__						:     Union[str, Any]			=    outputs.logits.detach().numpy()

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


if __name__ == "__main__":
    lowercase				:	List[str]      						=  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""")

    lowercase				:	Optional[int]      						=  parser.parse_args()
    convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)









import unittest

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
    import tensorflow as tf
    from tensorflow.python.eager import context
    from tensorflow.python.framework import ops

    from transformers import GradientAccumulator, create_optimizer





@require_tf
class 			A__   (							unittest.TestCase     ):




   """simple docstring"""



   def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						List[str]:







          '''simple docstring'''

          self.assertEqual(len(lowercase) ,  len(lowercase))
          for a, b in zip(lowercase ,  lowercase):
                 self.assertAlmostEqual(lowercase ,  lowercase ,  delta=lowercase)

   def 							__lowercase		( self)      ->						Any:







          '''simple docstring'''

          a__						:     Tuple			=    GradientAccumulator()
          accumulator([tf.constant([1.0, 2.0])])
          accumulator([tf.constant([-2.0, 1.0])])
          accumulator([tf.constant([-1.0, 2.0])])
          with self.assertRaises(lowercase):
                 accumulator([tf.constant([1.0, 1.0]), tf.constant([2.0, 2.0])])
          self.assertEqual(accumulator.step ,  3)
          self.assertEqual(len(accumulator.gradients) ,  1)
          self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist() ,  [-2.0, 5.0] ,  tol=1e-2)
          accumulator.reset()
          self.assertEqual(accumulator.step ,  0)
          self.assertListAlmostEqual(accumulator.gradients[0].numpy().tolist() ,  [0.0, 0.0] ,  tol=1e-2)

   def 							__lowercase		( self)      ->						List[Any]:







          '''simple docstring'''

          a__						:     Tuple			=    None
          ops.enable_eager_execution_internal()
          a__						:     Optional[int]			=    tf.config.list_physical_devices('CPU')
          if len(lowercase) == 1:
                 tf.config.set_logical_device_configuration(
                     physical_devices[0] ,  [tf.config.LogicalDeviceConfiguration(), tf.config.LogicalDeviceConfiguration()])
          a__						:     int			=    tf.config.list_logical_devices(device_type='CPU')
          a__						:     Union[str, Any]			=    tf.distribute.MirroredStrategy(devices=devices[:2])

          with strategy.scope():
                 a__						:     str			=    GradientAccumulator()
                 a__						:     Tuple			=    tf.Variable([4.0, 3.0])
                 a__			,							a__						:     Tuple			=    create_optimizer(5e-5 ,  10 ,  5)
                 a__						:     Tuple			=    tf.Variable([0.0, 0.0] ,  trainable=lowercase)

          def accumulate_on_replica(lowercase):
                 accumulator([gradient])

          def apply_on_replica():
                 optimizer.apply_gradients(list(zip(accumulator.gradients ,  [variable])))

          @tf.function
          def accumulate(lowercase ,  lowercase):
                 with strategy.scope():
                        a__						:     Union[str, Any]			=    strategy.experimental_local_results(lowercase)
                        local_variables[0].assign(lowercase)
                        local_variables[1].assign(lowercase)
                        strategy.run(lowercase ,  args=(gradient_placeholder,))

          @tf.function
          def apply_grad():
                 with strategy.scope():
                        strategy.run(lowercase)

          def _check_local_values(lowercase ,  lowercase):
                 a__						:     Union[str, Any]			=    strategy.experimental_local_results(accumulator._gradients[0])
                 self.assertListAlmostEqual(values[0].value() ,  lowercase ,  tol=1e-2)
                 self.assertListAlmostEqual(values[1].value() ,  lowercase ,  tol=1e-2)

          accumulate([1.0, 2.0] ,  [-1.0, 1.0])
          accumulate([3.0, -1.0] ,  [-1.0, -1.0])
          accumulate([-2.0, 2.0] ,  [3.0, -2.0])
          self.assertEqual(accumulator.step ,  3)
          _check_local_values([2.0, 3.0] ,  [1.0, -2.0])
          apply_grad()
          self.assertListAlmostEqual(variable.value() ,  [4.0, 3.0] ,  tol=1e-2)
          accumulator.reset()
          self.assertEqual(accumulator.step ,  0)
          _check_local_values([0.0, 0.0] ,  [0.0, 0.0])


