






"""simple docstring"""







import unittest

from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


_lowerCAmelCase            =	get_tests_dir('fixtures/test_sentencepiece.model')


@require_sentencepiece
class      UpperCamelCase		(__snake_case						,						unittest.TestCase     ):
						_SCREAMING_SNAKE_CASE  : Optional[Any]												=		XLMProphetNetTokenizer
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		False
						_SCREAMING_SNAKE_CASE  : Optional[int]												=		True






						def      __snake_case      (		self  :Optional[int]				)      ->List[str]:
										super().setUp()

										# We have a SentencePiece fixture for testing
										lowercase    :      List[str]       = XLMProphetNetTokenizer(__magic_name__			, keep_accents=__magic_name__				)
										tokenizer.save_pretrained(self.tmpdirname				)






						def      __snake_case      (		self  :int				)      ->Any:
										lowercase    :      Dict       = """[PAD]"""
										lowercase    :      Tuple       = 0

										self.assertEqual(self.get_tokenizer()._convert_token_to_id(__magic_name__				)			, __magic_name__				)
										self.assertEqual(self.get_tokenizer()._convert_id_to_token(__magic_name__				)			, __magic_name__				)






						def      __snake_case      (		self  :Any				)      ->Union[str, Any]:
										lowercase    :      Optional[int]       = list(self.get_tokenizer().get_vocab().keys()				)

										self.assertEqual(vocab_keys[0]			, """[PAD]"""				)
										self.assertEqual(vocab_keys[1]			, """[CLS]"""				)
										self.assertEqual(vocab_keys[-1]			, """j"""				)
										self.assertEqual(len(__magic_name__				)			, 1_012				)






						def      __snake_case      (		self  :int				)      ->int:
										self.assertEqual(self.get_tokenizer().vocab_size			, 1_012				)






						def      __snake_case      (		self  :Optional[Any]				)      ->List[Any]:
										lowercase    :      Optional[Any]       = XLMProphetNetTokenizer(__magic_name__			, keep_accents=__magic_name__				)

										lowercase    :      Union[str, Any]       = tokenizer.tokenize("""This is a test"""				)
										self.assertListEqual(__magic_name__			, ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

										self.assertListEqual(
										    tokenizer.convert_tokens_to_ids(__magic_name__				)			, [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]			, )

										lowercase    :      Optional[Any]       = tokenizer.tokenize("""I was born in 92000, and this is falsé."""				)
										self.assertListEqual(
										    __magic_name__			, [
										        SPIECE_UNDERLINE + """I""",
										        SPIECE_UNDERLINE + """was""",
										        SPIECE_UNDERLINE + """b""",
										        """or""",
										        """n""",
										        SPIECE_UNDERLINE + """in""",
										        SPIECE_UNDERLINE + """""",
										        """9""",
										        """2""",
										        """0""",
										        """0""",
										        """0""",
										        """,""",
										        SPIECE_UNDERLINE + """and""",
										        SPIECE_UNDERLINE + """this""",
										        SPIECE_UNDERLINE + """is""",
										        SPIECE_UNDERLINE + """f""",
										        """al""",
										        """s""",
										        """é""",
										        """.""",
										    ]			, )
										lowercase    :      Optional[int]       = tokenizer.convert_tokens_to_ids(__magic_name__				)
										self.assertListEqual(
										    __magic_name__			, [
										        value + tokenizer.fairseq_offset
										        for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
										    ]			, )

										lowercase    :      Union[str, Any]       = tokenizer.convert_ids_to_tokens(__magic_name__				)
										self.assertListEqual(
										    __magic_name__			, [
										        SPIECE_UNDERLINE + """I""",
										        SPIECE_UNDERLINE + """was""",
										        SPIECE_UNDERLINE + """b""",
										        """or""",
										        """n""",
										        SPIECE_UNDERLINE + """in""",
										        SPIECE_UNDERLINE + """""",
										        """[UNK]""",
										        """2""",
										        """0""",
										        """0""",
										        """0""",
										        """,""",
										        SPIECE_UNDERLINE + """and""",
										        SPIECE_UNDERLINE + """this""",
										        SPIECE_UNDERLINE + """is""",
										        SPIECE_UNDERLINE + """f""",
										        """al""",
										        """s""",
										        """[UNK]""",
										        """.""",
										    ]			, )






						@cached_property
						def      __snake_case      (		self  :List[Any]				)      ->str:
										return XLMProphetNetTokenizer.from_pretrained("""microsoft/xprophetnet-large-wiki100-cased"""				)






						@slow
						def      __snake_case      (		self  :int				)      ->Optional[Any]:
										lowercase    :      str       = """Hello World!"""
										lowercase    :      Optional[Any]       = [35_389, 6_672, 49, 2]
										self.assertListEqual(__magic_name__			, self.big_tokenizer.encode(__magic_name__				)				)






						@slow
						def      __snake_case      (		self  :Optional[int]				)      ->Union[str, Any]:
										# fmt: off
										lowercase    :      Optional[int]       = {"""input_ids""": [[11_073, 82_783, 18, 26, 82_783, 549, 51_540, 248, 17_209, 1_301, 217, 20, 215_186, 1_325, 147, 17_209, 1_301, 217, 20, 56_370, 53, 122_020, 20, 16_477, 27, 87_355, 4_548, 20, 4_728, 78_392, 17, 159_969, 18, 26, 24_491, 629, 15, 538, 22_704, 5_439, 15, 2_788, 24_491, 9_885, 15, 43_534, 605, 15, 814, 18_403, 33_200, 29, 15, 43_534, 24_458, 12_410, 111, 24_966, 83_669, 9_637, 144_068, 26, 850, 22_346, 27, 147, 24_966, 83_669, 83_490, 26, 39_113, 735, 27, 689, 656, 2_800, 1_339, 4_600, 53, 122_020, 115_785, 34, 816, 1_339, 46_887, 18, 147, 53_905, 1_951, 42_238, 41_170, 17_732, 834, 436, 15, 27_523, 98_733, 217, 147, 5_542, 4_981, 930, 17_347, 16, 2], [20_091, 629, 94, 82_786, 58, 490, 20, 1_528, 84, 53_905, 344, 80_592, 110_128, 18_822, 5_267, 1_306, 62, 152_537, 308, 7_997, 401, 124_427, 549, 35_442, 225, 109, 15_055, 25_748, 147, 7_119, 43_712, 34, 767, 135_366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63_784, 119_466, 17, 147_808, 88_214, 18, 656, 81, 32, 3_296, 10_280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
										# fmt: on

										self.tokenizer_integration_test_util(
										    expected_encoding=__magic_name__			, model_name="""microsoft/xprophetnet-large-wiki100-cased"""			, revision="""1acad1643ddd54a44df6a1b797ada8373685d90e"""			, )








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

_lowerCAmelCase            =	{
    'b0': efficientnet.EfficientNetBa,
    'b1': efficientnet.EfficientNetBa,
    'b2': efficientnet.EfficientNetBa,
    'b3': efficientnet.EfficientNetBa,
    'b4': efficientnet.EfficientNetBa,
    'b5': efficientnet.EfficientNetBa,
    'b6': efficientnet.EfficientNetBa,
    'b7': efficientnet.EfficientNetBa,
}

_lowerCAmelCase            =	{
    '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      UpperCamelCase       ( _A )     ->       List[str]:
				lowercase    :      List[str]       = EfficientNetConfig()
				lowercase    :      Any       = CONFIG_MAP[model_name]["""hidden_dim"""]
				lowercase    :      List[str]       = CONFIG_MAP[model_name]["""width_coef"""]
				lowercase    :      str       = CONFIG_MAP[model_name]["""depth_coef"""]
				lowercase    :      int       = CONFIG_MAP[model_name]["""image_size"""]
				lowercase    :      List[Any]       = CONFIG_MAP[model_name]["""dropout_rate"""]
				lowercase    :      int       = CONFIG_MAP[model_name]["""dw_padding"""]

				lowercase    :      Optional[int]       = """huggingface/label-files"""
				lowercase    :      int       = """imagenet-1k-id2label.json"""
				lowercase    :      Any       = 1_000
				lowercase    :      Any       = json.load(open(hf_hub_download(_A  ,				_A  ,				repo_type="""dataset""" )  ,				"""r""" ) )
				lowercase    :      Optional[int]       = {int(_A ): v for k, v in idalabel.items()}

				lowercase    :      int       = idalabel
				lowercase    :      Optional[Any]       = {v: k for k, v in idalabel.items()}
				return config


def      UpperCamelCase       ( )     ->       Tuple:
				lowercase    :      Any       = """http://images.cocodataset.org/val2017/000000039769.jpg"""
				lowercase    :      Optional[int]       = Image.open(requests.get(_A  ,				stream=_A ).raw )
				return im


def      UpperCamelCase       ( _A )     ->       Optional[Any]:
				lowercase    :      str       = CONFIG_MAP[model_name]["""image_size"""]
				lowercase    :      Optional[int]       = 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      UpperCamelCase       ( _A )     ->       Optional[int]:
				lowercase    :      Union[str, Any]       = [v.split("""_""" )[0].split("""block""" )[1] for v in original_param_names if v.startswith("""block""" )]
				lowercase    :      Optional[Any]       = sorted(set(_A ) )
				lowercase    :      Dict       = len(_A )
				lowercase    :      List[str]       = {b: str(_A ) for b, i in zip(_A  ,				range(_A ) )}

				lowercase    :      Union[str, Any]       = []
				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    :      str       = 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    :      Union[str, Any]       = {}
				for item in rename_keys:
								if item[0] in original_param_names:
												lowercase    :      Optional[int]       = """efficientnet.""" + item[1]

				lowercase    :      Any       = """classifier.weight"""
				lowercase    :      Tuple       = """classifier.bias"""
				return key_mapping


def      UpperCamelCase       ( _A  ,				_A  ,				_A )     ->       Optional[Any]:
				for key, value in tf_params.items():
								if "normalization" in key:
												continue

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

				lowercase    :      Dict       = original_model.trainable_variables
				lowercase    :      Any       = original_model.non_trainable_variables
				lowercase    :      Any       = {param.name: param.numpy() for param in tf_params}
				for param in tf_non_train_params:
								lowercase    :      Dict       = param.numpy()
				lowercase    :      List[str]       = list(tf_params.keys() )

				# Load HuggingFace model
				lowercase    :      str       = get_efficientnet_config(_A )
				lowercase    :      List[Any]       = EfficientNetForImageClassification(_A ).eval()
				lowercase    :      Optional[int]       = hf_model.state_dict()

				# Create src-to-dst parameter name mapping dictionary
				print("""Converting parameters...""" )
				lowercase    :      int       = rename_keys(_A )
				replace_params(_A  ,				_A  ,				_A )

				# Initialize preprocessor and preprocess input image
				lowercase    :      Optional[int]       = convert_image_processor(_A )
				lowercase    :      Any       = preprocessor(images=prepare_img()  ,				return_tensors="""pt""" )

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

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


if __name__ == "__main__":
				_lowerCAmelCase            =	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')

				_lowerCAmelCase            =	parser.parse_args()
				convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)
