





import inspect
import unittest

from transformers import ConvNextConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
      import torch

      from transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
      from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import AutoImageProcessor
class        SCREAMING_SNAKE_CASE     :


   def __init__(					self    :       Optional[Any]    ,  a    :       List[str]    ,  a    :       List[Any]=13    ,  a    :       str=32    ,  a    :       Tuple=3    ,  a    :       int=4    ,  a    :       Optional[Any]=[10, 20, 30, 40]    ,  a    :       int=[2, 2, 3, 2]    ,  a    :       Any=True    ,  a    :       Tuple=True    ,  a    :       int=37    ,  a    :       List[Any]="gelu"    ,  a    :       str=10    ,  a    :       int=0.02    ,  a    :       List[Any]=["stage2", "stage3", "stage4"]    ,  a    :       str=[2, 3, 4]    ,  a    :       str=None    ,  )->     Optional[int]:





     """simple docstring"""







     lowercase__			    =						parent
     lowercase__			    =						batch_size
     lowercase__			    =						image_size
     lowercase__			    =						num_channels
     lowercase__			    =						num_stages
     lowercase__			    =						hidden_sizes
     lowercase__			    =						depths
     lowercase__			    =						is_training
     lowercase__			    =						use_labels
     lowercase__			    =						intermediate_size
     lowercase__			    =						hidden_act
     lowercase__			    =						num_labels
     lowercase__			    =						initializer_range
     lowercase__			    =						out_features
     lowercase__			    =						out_indices
     lowercase__			    =						scope


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

     lowercase__			    =						None
     if self.use_labels:
       lowercase__			    =						ids_tensor([self.batch_size]    ,  self.num_labels )

     lowercase__			    =						self.get_config()
     return config, pixel_values, labels


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Optional[Any]:





     """simple docstring"""







     return ConvNextConfig(
         num_channels=self.num_channels    ,  hidden_sizes=self.hidden_sizes    ,  depths=self.depths    ,  num_stages=self.num_stages    ,  hidden_act=self.hidden_act    ,  is_decoder=a    ,  initializer_range=self.initializer_range    ,  out_features=self.out_features    ,  out_indices=self.out_indices    ,  num_labels=self.num_labels    ,  )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple    ,  a    :       Optional[int]    ,  a    :       Any    ,  a    :       Union[str, Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						ConvNextModel(config=a )
     model.to(a )
     model.eval()
     lowercase__			    =						model(a )
     # expected last hidden states: B, C, H // 32, W // 32
     self.parent.assertEqual(
         result.last_hidden_state.shape    ,  (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)    ,  )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict    ,  a    :       Optional[Any]    ,  a    :       Dict    ,  a    :       List[Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						ConvNextForImageClassification(a )
     model.to(a )
     model.eval()
     lowercase__			    =						model(a    ,  labels=a )
     self.parent.assertEqual(result.logits.shape    ,  (self.batch_size, self.num_labels) )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any]    ,  a    :       Optional[int]    ,  a    :       List[Any]    ,  a    :       Optional[int] )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						ConvNextBackbone(config=a )
     model.to(a )
     model.eval()
     lowercase__			    =						model(a )

     # verify hidden states
     self.parent.assertEqual(len(result.feature_maps )    ,  len(config.out_features ) )
     self.parent.assertListEqual(list(result.feature_maps[0].shape )    ,  [self.batch_size, self.hidden_sizes[1], 4, 4] )

     # verify channels
     self.parent.assertEqual(len(model.channels )    ,  len(config.out_features ) )
     self.parent.assertListEqual(model.channels    ,  config.hidden_sizes[1:] )

     # verify backbone works with out_features=None
     lowercase__			    =						None
     lowercase__			    =						ConvNextBackbone(config=a )
     model.to(a )
     model.eval()
     lowercase__			    =						model(a )

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps )    ,  1 )
     self.parent.assertListEqual(list(result.feature_maps[0].shape )    ,  [self.batch_size, self.hidden_sizes[-1], 1, 1] )

     # verify channels
     self.parent.assertEqual(len(model.channels )    ,  1 )
     self.parent.assertListEqual(model.channels    ,  [config.hidden_sizes[-1]] )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Union[str, Any] )->     Any:





     """simple docstring"""







     lowercase__			    =						self.prepare_config_and_inputs()
     lowercase__    ,					lowercase__    ,					lowercase__			    =						config_and_inputs
     lowercase__			    =						{'pixel_values': pixel_values}
     return config, inputs_dict






@require_torch
class        SCREAMING_SNAKE_CASE     (UpperCAmelCase    ,			UpperCAmelCase    ,			unittest.TestCase   ):
   _UpperCamelCase					:	Tuple				      = (
       (
           ConvNextModel,
           ConvNextForImageClassification,
           ConvNextBackbone,
       )
       if is_torch_available()
       else ()
   )
   _UpperCamelCase					:	Optional[Any]				      = (
       {'feature-extraction': ConvNextModel, 'image-classification': ConvNextForImageClassification}
       if is_torch_available()
       else {}
   )

   _UpperCamelCase					:	Dict				      = True
   _UpperCamelCase					:	Dict				      = False
   _UpperCamelCase					:	Optional[Any]				      = False
   _UpperCamelCase					:	Optional[Any]				      = False
   _UpperCamelCase					:	Union[str, Any]				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Tuple:





     """simple docstring"""







     lowercase__			    =						ConvNextModelTester(self )
     lowercase__			    =						ConfigTester(self    ,  config_class=a    ,  has_text_modality=a    ,  hidden_size=37 )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Any:





     """simple docstring"""







     self.create_and_test_config_common_properties()
     self.config_tester.create_and_test_config_to_json_string()
     self.config_tester.create_and_test_config_to_json_file()
     self.config_tester.create_and_test_config_from_and_save_pretrained()
     self.config_tester.create_and_test_config_with_num_labels()
     self.config_tester.check_config_can_be_init_without_params()
     self.config_tester.check_config_arguments_init()


   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Union[str, Any]:





     """simple docstring"""







     return


   @unittest.skip(reason='ConvNext does not use inputs_embeds' )
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     List[str]:





     """simple docstring"""







     pass


   @unittest.skip(reason='ConvNext does not support input and output embeddings' )
   def  SCREAMING_SNAKE_CASE_							(					self    :       Any )->     Any:





     """simple docstring"""







     pass


   @unittest.skip(reason='ConvNext does not use feedforward chunking' )
   def  SCREAMING_SNAKE_CASE_							(					self    :       int )->     Dict:





     """simple docstring"""







     pass


   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     Tuple:





     """simple docstring"""







     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       lowercase__			    =						model_class(a )
       lowercase__			    =						inspect.signature(model.forward )
       # signature.parameters is an OrderedDict => so arg_names order is deterministic
       lowercase__			    =						[*signature.parameters.keys()]

       lowercase__			    =						['pixel_values']
       self.assertListEqual(arg_names[:1]    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     List[str]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Dict )->     Any:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     int:





     """simple docstring"""







     def check_hidden_states_output(a    :       Tuple    ,  a    :       List[str]    ,  a    :       List[str] ):
       lowercase__			    =						model_class(a )
       model.to(a )
       model.eval()

       with torch.no_grad():
         lowercase__			    =						model(**self._prepare_for_class(a    ,  a ) )

       lowercase__			    =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       lowercase__			    =						self.model_tester.num_stages
       self.assertEqual(len(a )    ,  expected_num_stages + 1 )

       # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
       self.assertListEqual(
           list(hidden_states[0].shape[-2:] )    ,  [self.model_tester.image_size // 4, self.model_tester.image_size // 4]    ,  )

     lowercase__    ,					lowercase__			    =						self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       lowercase__			    =						True
       check_hidden_states_output(a    ,  a    ,  a )

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       lowercase__			    =						True

       check_hidden_states_output(a    ,  a    ,  a )


   def  SCREAMING_SNAKE_CASE_							(					self    :       List[str] )->     Optional[Any]:





     """simple docstring"""







     lowercase__			    =						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*a )


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       List[Any] )->     Union[str, Any]:





     """simple docstring"""







     for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowercase__			    =						ConvNextModel.from_pretrained(a )
       self.assertIsNotNone(a )






def     __UpperCamelCase						()       ->     Optional[Any]:
  lowercase__			    =						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
  return image
@require_torch
@require_vision
class        SCREAMING_SNAKE_CASE     (unittest.TestCase   ):


   @cached_property
   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[int] )->     Tuple:





     """simple docstring"""







     return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224' ) if is_vision_available() else None


   @slow
   def  SCREAMING_SNAKE_CASE_							(					self    :       Tuple )->     List[str]:





     """simple docstring"""







     lowercase__			    =						ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224' ).to(a )

     lowercase__			    =						self.default_image_processor
     lowercase__			    =						prepare_img()
     lowercase__			    =						image_processor(images=a    ,  return_tensors='pt' ).to(a )

     # forward pass
     with torch.no_grad():
       lowercase__			    =						model(**a )

     # verify the logits
     lowercase__			    =						torch.Size((1, 1_000) )
     self.assertEqual(outputs.logits.shape    ,  a )

     lowercase__			    =						torch.tensor([-0.0260, -0.4739, 0.1911] ).to(a )

     self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,  a    ,  atol=1E-4 ) )






@require_torch
class        SCREAMING_SNAKE_CASE     (unittest.TestCase    ,			UpperCAmelCase   ):
   _UpperCamelCase					:	Any				      = (ConvNextBackbone,) if is_torch_available() else ()
   _UpperCamelCase					:	Optional[int]				      = ConvNextConfig

   _UpperCamelCase					:	Union[str, Any]				      = False


   def  SCREAMING_SNAKE_CASE_							(					self    :       Optional[Any] )->     Union[str, Any]:





     """simple docstring"""







     lowercase__			    =						ConvNextModelTester(self )









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

lowercase_					     =	{
    """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_					     =	{
    """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						(_SCREAMING_SNAKE_CASE	)       ->     str:
  lowercase__			    =						EfficientNetConfig()
  lowercase__			    =						CONFIG_MAP[model_name]['hidden_dim']
  lowercase__			    =						CONFIG_MAP[model_name]['width_coef']
  lowercase__			    =						CONFIG_MAP[model_name]['depth_coef']
  lowercase__			    =						CONFIG_MAP[model_name]['image_size']
  lowercase__			    =						CONFIG_MAP[model_name]['dropout_rate']
  lowercase__			    =						CONFIG_MAP[model_name]['dw_padding']

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

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




def     __UpperCamelCase						()       ->     Tuple:
  lowercase__			    =						'http://images.cocodataset.org/val2017/000000039769.jpg'
  lowercase__			    =						Image.open(requests.get(_SCREAMING_SNAKE_CASE	,		stream=_SCREAMING_SNAKE_CASE	).raw	)
  return im




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     Optional[Any]:
  lowercase__			    =						CONFIG_MAP[model_name]['image_size']
  lowercase__			    =						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=_SCREAMING_SNAKE_CASE	,		)
  return preprocessor




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

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

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

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




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     Tuple:
  for key, value in tf_params.items():
    if "normalization" in key:
      continue

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

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




@torch.no_grad()
def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	)       ->     Tuple:
  lowercase__			    =						model_classes[model_name](
      include_top=_SCREAMING_SNAKE_CASE	,		weights='imagenet'	,		input_tensor=_SCREAMING_SNAKE_CASE	,		input_shape=_SCREAMING_SNAKE_CASE	,		pooling=_SCREAMING_SNAKE_CASE	,		classes=1000	,		classifier_activation='softmax'	,		)

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

  # Load HuggingFace model
  lowercase__			    =						get_efficientnet_config(_SCREAMING_SNAKE_CASE	)
  lowercase__			    =						EfficientNetForImageClassification(_SCREAMING_SNAKE_CASE	).eval()
  lowercase__			    =						hf_model.state_dict()

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

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

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

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

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

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


if __name__ == "__main__":
      lowercase_					     =	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_					     =	parser.parse_args()
      convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)


