




import os
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from huggingface_hub.file_download import http_get
from requests.exceptions import HTTPError

from transformers import (
    AlbertTokenizer,
    AutoTokenizer,
    BertTokenizer,
    BertTokenizerFast,
    GPTaTokenizerFast,
    is_tokenizers_available,
)
from transformers.testing_utils import TOKEN, USER, is_staging_test, require_tokenizers
from transformers.tokenization_utils import Trie


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
  from test_module.custom_tokenization_fast import CustomTokenizerFast







class 						lowercase							(   unittest.TestCase		):

     def 					a__	(  self				)						->							Any:
           # A mock response for an HTTP head request to emulate server down
           _A							:     Optional[int]			=						mock.Mock()
           _A							:     Optional[Any]			=						500
           _A							:     Dict			=						{}
           _A							:     Union[str, Any]			=						HTTPError
           _A							:     List[Any]			=						{}

           # Download this model to make sure it's in the cache.
           _A							:     int			=						BertTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""				)

           # Under the mock environment we get a 500 error when trying to reach the tokenizer.
           with mock.patch("""requests.Session.request"""		,     return_value=_a				) as mock_head:
                 _A							:     List[Any]			=						BertTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""				)
                 # This check we did call the fake head request
                 mock_head.assert_called()

     @require_tokenizers
     def 					a__	(  self				)						->							Optional[Any]:
           # A mock response for an HTTP head request to emulate server down
           _A							:     str			=						mock.Mock()
           _A							:     Any			=						500
           _A							:     Optional[int]			=						{}
           _A							:     List[str]			=						HTTPError
           _A							:     int			=						{}

           # Download this model to make sure it's in the cache.
           _A							:     int			=						GPTaTokenizerFast.from_pretrained("""gpt2"""				)

           # Under the mock environment we get a 500 error when trying to reach the tokenizer.
           with mock.patch("""requests.Session.request"""		,     return_value=_a				) as mock_head:
                 _A							:     str			=						GPTaTokenizerFast.from_pretrained("""gpt2"""				)
                 # This check we did call the fake head request
                 mock_head.assert_called()

     def 					a__	(  self				)						->							Optional[int]:
           # This test is for deprecated behavior and can be removed in v5
           try:
                 _A							:     Tuple			=						tempfile.mktemp()
                 with open(_a		,     """wb"""				) as f:
                       http_get("""https://huggingface.co/albert-base-v1/resolve/main/spiece.model"""		,     _a				)

                 _A							:     str			=						AlbertTokenizer.from_pretrained(_a				)
           finally:
                 os.remove(_a				)

           # Supporting this legacy load introduced a weird bug where the tokenizer would load local files if they are in
           # the current folder and have the right name.
           if os.path.isfile("""tokenizer.json"""				):
                 # We skip the test if the user has a `tokenizer.json` in this folder to avoid deleting it.
                 return
           try:
                 with open("""tokenizer.json"""		,     """wb"""				) as f:
                       http_get("""https://huggingface.co/hf-internal-testing/tiny-random-bert/blob/main/tokenizer.json"""		,     _a				)
                 _A							:     Optional[int]			=						AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-gpt2"""				)
                 # The tiny random BERT has a vocab size of 1024, tiny gpt2 as a vocab size of 1000
                 self.assertEqual(tokenizer.vocab_size		,     1000				)
                 # Tokenizer should depend on the remote checkpoint, not the local tokenizer.json file.

           finally:
                 os.remove("""tokenizer.json"""				)



     def 					a__	(  self				)						->							Union[str, Any]:
           # This test is for deprecated behavior and can be removed in v5
           _A							:     Dict			=						AlbertTokenizer.from_pretrained("""https://huggingface.co/albert-base-v1/resolve/main/spiece.model"""				)







@is_staging_test
class 						lowercase							(   unittest.TestCase		):
     _a							 =						["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]", "bla", "blou"]

     @classmethod
     def 					a__	(  cls				)						->							Tuple:
           _A							:     int			=						TOKEN
           HfFolder.save_token(_a				)

     @classmethod
     def 					a__	(  cls				)						->							List[Any]:
           try:
                 delete_repo(token=cls._token		,     repo_id="""test-tokenizer"""				)
           except HTTPError:
                 pass

           try:
                 delete_repo(token=cls._token		,     repo_id="""valid_org/test-tokenizer-org"""				)
           except HTTPError:
                 pass

           try:
                 delete_repo(token=cls._token		,     repo_id="""test-dynamic-tokenizer"""				)
           except HTTPError:
                 pass

     def 					a__	(  self				)						->							Dict:
           with tempfile.TemporaryDirectory() as tmp_dir:
                 _A							:     Optional[Any]			=						os.path.join(_a		,     """vocab.txt"""				)
                 with open(_a		,     """w"""		,     encoding="""utf-8"""				) as vocab_writer:
                       vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]				)				)
                 _A							:     Optional[Any]			=						BertTokenizer(_a				)

           tokenizer.push_to_hub("""test-tokenizer"""		,     use_auth_token=self._token				)
           _A							:     List[Any]			=						BertTokenizer.from_pretrained(F'''{USER}/test-tokenizer'''				)
           self.assertDictEqual(new_tokenizer.vocab		,     tokenizer.vocab				)

           # Reset repo
           delete_repo(token=self._token		,     repo_id="""test-tokenizer"""				)

           # Push to hub via save_pretrained
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(_a		,     repo_id="""test-tokenizer"""		,     push_to_hub=_a		,     use_auth_token=self._token				)

           _A							:     List[str]			=						BertTokenizer.from_pretrained(F'''{USER}/test-tokenizer'''				)
           self.assertDictEqual(new_tokenizer.vocab		,     tokenizer.vocab				)

     def 					a__	(  self				)						->							Optional[int]:
           with tempfile.TemporaryDirectory() as tmp_dir:
                 _A							:     Optional[int]			=						os.path.join(_a		,     """vocab.txt"""				)
                 with open(_a		,     """w"""		,     encoding="""utf-8"""				) as vocab_writer:
                       vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]				)				)
                 _A							:     Tuple			=						BertTokenizer(_a				)

           tokenizer.push_to_hub("""valid_org/test-tokenizer-org"""		,     use_auth_token=self._token				)
           _A							:     List[Any]			=						BertTokenizer.from_pretrained("""valid_org/test-tokenizer-org"""				)
           self.assertDictEqual(new_tokenizer.vocab		,     tokenizer.vocab				)

           # Reset repo
           delete_repo(token=self._token		,     repo_id="""valid_org/test-tokenizer-org"""				)

           # Push to hub via save_pretrained
           with tempfile.TemporaryDirectory() as tmp_dir:
                 tokenizer.save_pretrained(
                     _a		,     repo_id="""valid_org/test-tokenizer-org"""		,     push_to_hub=_a		,     use_auth_token=self._token				)

           _A							:     Dict			=						BertTokenizer.from_pretrained("""valid_org/test-tokenizer-org"""				)
           self.assertDictEqual(new_tokenizer.vocab		,     tokenizer.vocab				)



     @require_tokenizers
     def 					a__	(  self				)						->							str:
           CustomTokenizer.register_for_auto_class()
           with tempfile.TemporaryDirectory() as tmp_dir:
                 _A							:     Union[str, Any]			=						os.path.join(_a		,     """vocab.txt"""				)
                 with open(_a		,     """w"""		,     encoding="""utf-8"""				) as vocab_writer:
                       vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]				)				)
                 _A							:     str			=						CustomTokenizer(_a				)

           # No fast custom tokenizer
           tokenizer.push_to_hub("""test-dynamic-tokenizer"""		,     use_auth_token=self._token				)

           _A							:     Optional[int]			=						AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer'''		,     trust_remote_code=_a				)
           # Can't make an isinstance check because the new_model.config is from the CustomTokenizer class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__		,     """CustomTokenizer"""				)

           # Fast and slow custom tokenizer
           CustomTokenizerFast.register_for_auto_class()
           with tempfile.TemporaryDirectory() as tmp_dir:
                 _A							:     Any			=						os.path.join(_a		,     """vocab.txt"""				)
                 with open(_a		,     """w"""		,     encoding="""utf-8"""				) as vocab_writer:
                       vocab_writer.write("""""".join([x + """\n""" for x in self.vocab_tokens]				)				)

                 _A							:     Dict			=						BertTokenizerFast.from_pretrained(_a				)
                 bert_tokenizer.save_pretrained(_a				)
                 _A							:     Dict			=						CustomTokenizerFast.from_pretrained(_a				)

           tokenizer.push_to_hub("""test-dynamic-tokenizer"""		,     use_auth_token=self._token				)

           _A							:     Tuple			=						AutoTokenizer.from_pretrained(F'''{USER}/test-dynamic-tokenizer'''		,     trust_remote_code=_a				)
           # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__		,     """CustomTokenizerFast"""				)
           _A							:     Tuple			=						AutoTokenizer.from_pretrained(
               F'''{USER}/test-dynamic-tokenizer'''		,     use_fast=_a		,     trust_remote_code=_a				)
           # Can't make an isinstance check because the new_model.config is from the FakeConfig class of a dynamic module
           self.assertEqual(tokenizer.__class__.__name__		,     """CustomTokenizer"""				)







class 						lowercase							(   unittest.TestCase		):

     def 					a__	(  self				)						->							List[Any]:
           _A							:     Optional[Any]			=						Trie()
           trie.add("""Hello 友達"""				)
           self.assertEqual(trie.data		,     {"""H""": {"""e""": {"""l""": {"""l""": {"""o""": {""" """: {"""友""": {"""達""": {"""""": 1}}}}}}}}}				)
           trie.add("""Hello"""				)
           trie.data
           self.assertEqual(trie.data		,     {"""H""": {"""e""": {"""l""": {"""l""": {"""o""": {"""""": 1, """ """: {"""友""": {"""達""": {"""""": 1}}}}}}}}}				)

     def 					a__	(  self				)						->							Union[str, Any]:
           _A							:     List[Any]			=						Trie()
           self.assertEqual(trie.split("""[CLS] This is a extra_id_100"""				)		,     ["""[CLS] This is a extra_id_100"""]				)
           trie.add("""[CLS]"""				)
           trie.add("""extra_id_1"""				)
           trie.add("""extra_id_100"""				)
           self.assertEqual(trie.split("""[CLS] This is a extra_id_100"""				)		,     ["""[CLS]""", """ This is a """, """extra_id_100"""]				)

     def 					a__	(  self				)						->							Dict:
           _A							:     List[Any]			=						Trie()
           trie.add("""A"""				)
           self.assertEqual(trie.split("""ABC"""				)		,     ["""A""", """BC"""]				)
           self.assertEqual(trie.split("""BCA"""				)		,     ["""BC""", """A"""]				)

     def 					a__	(  self				)						->							Dict:
           _A							:     Dict			=						Trie()
           trie.add("""TOKEN]"""				)
           trie.add("""[SPECIAL_TOKEN]"""				)
           self.assertEqual(trie.split("""This is something [SPECIAL_TOKEN]"""				)		,     ["""This is something """, """[SPECIAL_TOKEN]"""]				)

     def 					a__	(  self				)						->							List[Any]:
           _A							:     Optional[Any]			=						Trie()
           trie.add("""A"""				)
           trie.add("""P"""				)
           trie.add("""[SPECIAL_TOKEN]"""				)
           self.assertEqual(trie.split("""This is something [SPECIAL_TOKEN]"""				)		,     ["""This is something """, """[SPECIAL_TOKEN]"""]				)

     def 					a__	(  self				)						->							List[Any]:
           _A							:     Dict			=						Trie()
           trie.add("""AB"""				)
           trie.add("""B"""				)
           trie.add("""C"""				)
           self.assertEqual(trie.split("""ABC"""				)		,     ["""AB""", """C"""]				)

     def 					a__	(  self				)						->							int:
           _A							:     Any			=						Trie()
           trie.add("""ABC"""				)
           trie.add("""B"""				)
           trie.add("""CD"""				)
           self.assertEqual(trie.split("""ABCD"""				)		,     ["""ABC""", """D"""]				)



     def 					a__	(  self				)						->							List[Any]:
           # Even if the offsets are wrong, we necessarily output correct string
           # parts.
           _A							:     Tuple			=						Trie()
           _A							:     int			=						trie.cut_text("""ABC"""		,     [0, 0, 2, 1, 2, 3]				)
           self.assertEqual(_a		,     ["""AB""", """C"""]				)







'''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': 12_80,
        'width_coef': 1.0,
        'depth_coef': 1.0,
        'image_size': 2_24,
        'dropout_rate': 0.2,
        'dw_padding': [],
    },
    'b1': {
        'hidden_dim': 12_80,
        'width_coef': 1.0,
        'depth_coef': 1.1,
        'image_size': 2_40,
        'dropout_rate': 0.2,
        'dw_padding': [16],
    },
    'b2': {
        'hidden_dim': 14_08,
        'width_coef': 1.1,
        'depth_coef': 1.2,
        'image_size': 2_60,
        'dropout_rate': 0.3,
        'dw_padding': [5, 8, 16],
    },
    'b3': {
        'hidden_dim': 15_36,
        'width_coef': 1.2,
        'depth_coef': 1.4,
        'image_size': 3_00,
        'dropout_rate': 0.3,
        'dw_padding': [5, 18],
    },
    'b4': {
        'hidden_dim': 17_92,
        'width_coef': 1.4,
        'depth_coef': 1.8,
        'image_size': 3_80,
        'dropout_rate': 0.4,
        'dw_padding': [6],
    },
    'b5': {
        'hidden_dim': 20_48,
        'width_coef': 1.6,
        'depth_coef': 2.2,
        'image_size': 4_56,
        'dropout_rate': 0.4,
        'dw_padding': [13, 27],
    },
    'b6': {
        'hidden_dim': 23_04,
        'width_coef': 1.8,
        'depth_coef': 2.6,
        'image_size': 5_28,
        'dropout_rate': 0.5,
        'dw_padding': [31],
    },
    'b7': {
        'hidden_dim': 25_60,
        'width_coef': 2.0,
        'depth_coef': 3.1,
        'image_size': 6_00,
        'dropout_rate': 0.5,
        'dw_padding': [18],
    },
}





def 						snake_case_							(_a	:							List[str]     ):
    UpperCAmelCase			       =		EfficientNetConfig()
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''hidden_dim''']
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''width_coef''']
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''depth_coef''']
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''image_size''']
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''dropout_rate''']
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''dw_padding''']

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

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





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





def 						snake_case_							(_a	:							str     ):
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''image_size''']
    UpperCAmelCase			       =		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 						snake_case_							(_a	:							Optional[Any]     ):
    UpperCAmelCase			       =		[v.split('''_'''     )[0].split('''block'''     )[1] for v in original_param_names if v.startswith('''block'''     )]
    UpperCAmelCase			       =		sorted(set(_a     )     )
    UpperCAmelCase			       =		len(_a     )
    UpperCAmelCase			       =		{b: str(_a     ) for b, i in zip(_a    ,   range(_a     )     )}

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

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

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





def 						snake_case_							(_a	:							Dict    ,   _a	:							List[str]    ,   _a	:							Dict     ):
    for key, value in tf_params.items():
        if "normalization" in key:
            continue

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

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

    # Load HuggingFace model
    UpperCAmelCase			       =		get_efficientnet_config(_a     )
    UpperCAmelCase			       =		EfficientNetForImageClassification(_a     ).eval()
    UpperCAmelCase			       =		hf_model.state_dict()

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

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

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

    # Original model inference
    UpperCAmelCase			       =		False
    UpperCAmelCase			       =		CONFIG_MAP[model_name]['''image_size''']
    UpperCAmelCase			       =		prepare_img().resize((image_size, image_size)    ,   resample=PIL.Image.NEAREST     )
    UpperCAmelCase			       =		image.img_to_array(_a     )
    UpperCAmelCase			       =		np.expand_dims(_a    ,   axis=0     )
    UpperCAmelCase			       =		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..."     )
        UpperCAmelCase			       =		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)




