




"""simple docstring"""






import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TFEfficientFormerForImageClassification,
				    TFEfficientFormerForImageClassificationWithTeacher,
				    TFEfficientFormerModel,
				)
				from transformers.models.efficientformer.modeling_tf_efficientformer import (
				    TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				)


if is_vision_available():
				from PIL import Image

				from transformers import EfficientFormerImageProcessor




class   a__			:





						def __init__(							self      :	Dict     ,a__      :	Dict     ,a__      :	List[str] = 13     ,a__      :	List[Any] = 64     ,a__      :	Any = 2     ,a__      :	int = 3     ,a__      :	Any = 3     ,a__      :	Union[str, Any] = True     ,a__      :	List[str] = True     ,a__      :	Any = 128     ,a__      :	Optional[Any]=[16, 32, 64, 128]     ,a__      :	Dict = 7     ,a__      :	Optional[int] = 4     ,a__      :	str = 37     ,a__      :	Union[str, Any] = "gelu"     ,a__      :	str = 0.1     ,a__      :	int = 0.1     ,a__      :	Union[str, Any] = 10     ,a__      :	List[str] = 0.02     ,a__      :	List[Any] = 2     ,a__      :	Union[str, Any] = 1     ,a__      :	Tuple = 128     ,a__      :	List[str] = [2, 2, 2, 2]     ,a__      :	Optional[int] = 2     ,a__      :	List[str] = 2     ,)						->       Optional[int]:




									"""simple docstring"""







									_lowerCAmelCase:str									=  parent
									_lowerCAmelCase:List[Any]									=  batch_size
									_lowerCAmelCase:Dict									=  image_size
									_lowerCAmelCase:Dict									=  patch_size
									_lowerCAmelCase:Optional[int]									=  num_channels
									_lowerCAmelCase:List[str]									=  is_training
									_lowerCAmelCase:int									=  use_labels
									_lowerCAmelCase:Tuple									=  hidden_size
									_lowerCAmelCase:str									=  num_hidden_layers
									_lowerCAmelCase:Tuple									=  num_attention_heads
									_lowerCAmelCase:List[str]									=  intermediate_size
									_lowerCAmelCase:Optional[Any]									=  hidden_act
									_lowerCAmelCase:Tuple									=  hidden_dropout_prob
									_lowerCAmelCase:List[Any]									=  attention_probs_dropout_prob
									_lowerCAmelCase:List[str]									=  type_sequence_label_size
									_lowerCAmelCase:int									=  initializer_range
									_lowerCAmelCase:List[Any]									=  encoder_stride
									_lowerCAmelCase:Optional[int]									=  num_attention_outputs
									_lowerCAmelCase:Optional[Any]									=  embed_dim
									_lowerCAmelCase:Union[str, Any]									=  embed_dim + 1
									_lowerCAmelCase:Union[str, Any]									=  resolution
									_lowerCAmelCase:Tuple									=  depths
									_lowerCAmelCase:Any									=  hidden_sizes
									_lowerCAmelCase:int									=  dim
									_lowerCAmelCase:str									=  mlp_expansion_ratio





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




									"""simple docstring"""







									_lowerCAmelCase:List[str]									=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

									_lowerCAmelCase:int									=  None
									if self.use_labels:
												_lowerCAmelCase:int									=  ids_tensor([self.batch_size]     ,self.type_sequence_label_size)

									_lowerCAmelCase:str									=  self.get_config()

									return config, pixel_values, labels





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




									"""simple docstring"""







									return EfficientFormerConfig(
									    image_size=self.image_size     ,patch_size=self.patch_size     ,num_channels=self.num_channels     ,hidden_size=self.hidden_size     ,num_hidden_layers=self.num_hidden_layers     ,num_attention_heads=self.num_attention_heads     ,intermediate_size=self.intermediate_size     ,hidden_act=self.hidden_act     ,hidden_dropout_prob=self.hidden_dropout_prob     ,attention_probs_dropout_prob=self.attention_probs_dropout_prob     ,is_decoder=snake_case_     ,initializer_range=self.initializer_range     ,encoder_stride=self.encoder_stride     ,resolution=self.resolution     ,depths=self.depths     ,hidden_sizes=self.hidden_sizes     ,dim=self.dim     ,mlp_expansion_ratio=self.mlp_expansion_ratio     ,)





						def       __UpperCamelCase     (							self      :	List[str]     ,a__      :	Dict     ,a__      :	Tuple     ,a__      :	str)						->       List[str]:




									"""simple docstring"""







									_lowerCAmelCase:Any									=  TFEfficientFormerModel(config=snake_case_)
									_lowerCAmelCase:Tuple									=  model(snake_case_     ,training=snake_case_)
									self.parent.assertEqual(result.last_hidden_state.shape     ,(self.batch_size, self.seq_length, self.hidden_size))





						def       __UpperCamelCase     (							self      :	str     ,a__      :	int     ,a__      :	List[Any]     ,a__      :	str)						->       Tuple:




									"""simple docstring"""







									_lowerCAmelCase:List[Any]									=  self.type_sequence_label_size
									_lowerCAmelCase:Any									=  TFEfficientFormerForImageClassification(snake_case_)
									_lowerCAmelCase:Tuple									=  model(snake_case_     ,labels=snake_case_     ,training=snake_case_)
									self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size))

									# test greyscale images
									_lowerCAmelCase:Tuple									=  1
									_lowerCAmelCase:Optional[Any]									=  TFEfficientFormerForImageClassification(snake_case_)

									_lowerCAmelCase:Tuple									=  floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
									_lowerCAmelCase:Tuple									=  model(snake_case_     ,labels=snake_case_)
									self.parent.assertEqual(result.logits.shape     ,(self.batch_size, self.type_sequence_label_size))







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




									"""simple docstring"""







									_lowerCAmelCase:str									=  self.prepare_config_and_inputs()
									_lowerCAmelCase:Optional[Any]									=  config_and_inputs
									_lowerCAmelCase:Any									=  {"pixel_values": pixel_values}
									return config, inputs_dict




@require_tf
class   a__			(       _snake_case					,	_snake_case					,	unittest.TestCase  ):
						snake_case__             = (
						    (
						        TFEfficientFormerModel,
						        TFEfficientFormerForImageClassificationWithTeacher,
						        TFEfficientFormerForImageClassification,
						    )
						    if is_tf_available()
						    else ()
						)
						snake_case__             = (
						    {
						        """feature-extraction""": TFEfficientFormerModel,
						        """image-classification""": (
						            TFEfficientFormerForImageClassification,
						            TFEfficientFormerForImageClassificationWithTeacher,
						        ),
						    }
						    if is_tf_available()
						    else {}
						)

						snake_case__             = False

						snake_case__             = False
						snake_case__             = False
						snake_case__             = False
						snake_case__             = False





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




									"""simple docstring"""







									_lowerCAmelCase:List[Any]									=  TFEfficientFormerModelTester(self)
									_lowerCAmelCase:Optional[int]									=  ConfigTester(
									    self     ,config_class=snake_case_     ,has_text_modality=snake_case_     ,hidden_size=37)





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




									"""simple docstring"""







									self.config_tester.run_common_tests()





						@unittest.skip(reason='''EfficientFormer does not use inputs_embeds''')
						def       __UpperCamelCase     (							self      :	Optional[int])						->       str:




									"""simple docstring"""







									pass





						@unittest.skip(reason='''EfficientFormer does not support input and output embeddings''')
						def       __UpperCamelCase     (							self      :	Optional[int])						->       Optional[Any]:




									"""simple docstring"""







									pass





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




									"""simple docstring"""







									_lowerCAmelCase:List[str]									=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												_lowerCAmelCase:List[str]									=  model_class(snake_case_)
												_lowerCAmelCase:Union[str, Any]									=  inspect.signature(model.call)
												# signature.parameters is an OrderedDict => so arg_names order is deterministic
												_lowerCAmelCase:Optional[Any]									=  [*signature.parameters.keys()]

												_lowerCAmelCase:Optional[Any]									=  ["pixel_values"]
												self.assertListEqual(arg_names[:1]     ,snake_case_)





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




									"""simple docstring"""







									def check_hidden_states_output(a__      :	List[str]     ,a__      :	Tuple     ,a__      :	List[str]):
												_lowerCAmelCase:str									=  model_class(snake_case_)

												_lowerCAmelCase:Dict									=  model(**self._prepare_for_class(snake_case_     ,snake_case_)     ,training=snake_case_)
												_lowerCAmelCase:Tuple									=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

												_lowerCAmelCase:int									=  getattr(
												    self.model_tester     ,'''expected_num_hidden_layers'''     ,self.model_tester.num_hidden_layers + 1)
												self.assertEqual(len(snake_case_)     ,snake_case_)

												if hasattr(self.model_tester     ,'''encoder_seq_length'''):
															_lowerCAmelCase:List[Any]									=  self.model_tester.encoder_seq_length
															if hasattr(self.model_tester     ,'''chunk_length''') and self.model_tester.chunk_length > 1:
																		_lowerCAmelCase:List[Any]									=  seq_length * self.model_tester.chunk_length
												else:
															_lowerCAmelCase:List[str]									=  self.model_tester.seq_length

												self.assertListEqual(
												    list(hidden_states[-1].shape[-2:])     ,[seq_length, self.model_tester.hidden_size]     ,)

												if config.is_encoder_decoder:
															_lowerCAmelCase:List[str]									=  outputs.decoder_hidden_states

															self.asseretIsInstance(snake_case_     ,(list, tuple))
															self.assertEqual(len(snake_case_)     ,snake_case_)
															_lowerCAmelCase:List[Any]									=  getattr(self.model_tester     ,'''seq_length'''     ,snake_case_)
															_lowerCAmelCase:List[Any]									=  getattr(self.model_tester     ,'''decoder_seq_length'''     ,snake_case_)

															self.assertListEqual(
															    list(hidden_states[-1].shape[-2:])     ,[decoder_seq_length, self.model_tester.hidden_size]     ,)

									_lowerCAmelCase:Union[str, Any]									=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												_lowerCAmelCase:str									=  True
												check_hidden_states_output(snake_case_     ,snake_case_     ,snake_case_)

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												_lowerCAmelCase:List[str]									=  True

												check_hidden_states_output(snake_case_     ,snake_case_     ,snake_case_)





						def       __UpperCamelCase     (							self      :	int     ,a__      :	List[Any]     ,a__      :	Tuple     ,a__      :	Tuple=False)						->       Dict:




									"""simple docstring"""







									_lowerCAmelCase:List[str]									=  super()._prepare_for_class(snake_case_     ,snake_case_     ,return_labels=snake_case_)

									if return_labels:
												if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
															del inputs_dict["labels"]

									return inputs_dict





						def       __UpperCamelCase     (							self      :	List[Any])						->       Tuple:




									"""simple docstring"""







									_lowerCAmelCase:Dict									=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case_)





						@unittest.skip(reason='''EfficientFormer does not implement masked image modeling yet''')
						def       __UpperCamelCase     (							self      :	Optional[int])						->       Any:




									"""simple docstring"""







									_lowerCAmelCase:List[str]									=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*snake_case_)





						def       __UpperCamelCase     (							self      :	Dict)						->       Any:




									"""simple docstring"""







									_lowerCAmelCase:Dict									=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*snake_case_)





						@slow
						def       __UpperCamelCase     (							self      :	Dict)						->       Union[str, Any]:




									"""simple docstring"""







									for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_lowerCAmelCase:Optional[int]									=  TFEfficientFormerModel.from_pretrained(snake_case_)
												self.assertIsNotNone(snake_case_)





						def       __UpperCamelCase     (							self      :	str)						->       Tuple:




									"""simple docstring"""







									_lowerCAmelCase:Any									=  self.model_tester.prepare_config_and_inputs_for_common()
									_lowerCAmelCase:Optional[int]									=  True

									_lowerCAmelCase:str									=  getattr(self.model_tester     ,'''seq_length'''     ,snake_case_)
									_lowerCAmelCase:Optional[int]									=  getattr(self.model_tester     ,'''encoder_seq_length'''     ,snake_case_)
									_lowerCAmelCase:Dict									=  getattr(self.model_tester     ,'''key_length'''     ,snake_case_)
									_lowerCAmelCase:Optional[int]									=  getattr(self.model_tester     ,'''chunk_length'''     ,snake_case_)

									if chunk_length is not None and hasattr(self.model_tester     ,'''num_hashes'''):
												_lowerCAmelCase:List[Any]									=  encoder_seq_length * self.model_tester.num_hashes

									for model_class in self.all_model_classes:
												_lowerCAmelCase:List[str]									=  True
												_lowerCAmelCase:Dict									=  False
												_lowerCAmelCase:Tuple									=  True
												_lowerCAmelCase:Optional[Any]									=  model_class(snake_case_)

												_lowerCAmelCase:Optional[int]									=  model(**self._prepare_for_class(snake_case_     ,snake_case_)     ,training=snake_case_)
												_lowerCAmelCase:List[str]									=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
												self.assertEqual(len(snake_case_)     ,self.model_tester.num_attention_outputs)

												# check that output_attentions also work using config
												del inputs_dict["output_attentions"]
												_lowerCAmelCase:Optional[Any]									=  True
												_lowerCAmelCase:Union[str, Any]									=  model_class(snake_case_)
												_lowerCAmelCase:List[Any]									=  model(**self._prepare_for_class(snake_case_     ,snake_case_)     ,training=snake_case_)

												_lowerCAmelCase:Optional[Any]									=  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
												self.assertEqual(len(snake_case_)     ,self.model_tester.num_attention_outputs)

												if chunk_length is not None:
															self.assertListEqual(
															    list(attentions[0].shape[-4:])     ,[self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]     ,)
												else:
															self.assertListEqual(
															    list(attentions[0].shape[-3:])     ,[self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]     ,)







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




									"""simple docstring"""







									_lowerCAmelCase:List[Any]									=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
												# Prepare our model
												_lowerCAmelCase:Tuple									=  model_class(snake_case_)
												# These are maximally general inputs for the model, with multiple None dimensions
												# Hopefully this will catch any conditionals that fail for flexible shapes
												_lowerCAmelCase:str									=  {
												    key: tf.keras.Input(shape=val.shape[1:]     ,dtype=val.dtype     ,name=snake_case_)
												    for key, val in model.input_signature.items()
												    if key in model.dummy_inputs
												}
												_lowerCAmelCase:str									=  model(snake_case_)
												self.assertTrue(outputs_dict is not None)





def 							UpperCAmelCase		(		):
			_lowerCAmelCase:Any									=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''    )
			return image





@require_tf
@require_vision
class   a__			(       unittest.TestCase  ):





						@cached_property
						def       __UpperCamelCase     (							self      :	Tuple)						->       List[Any]:




									"""simple docstring"""







									return (
									    EfficientFormerImageProcessor.from_pretrained('''snap-research/efficientformer-l1-300''')
									    if is_vision_available()
									    else None
									)





						@slow
						def       __UpperCamelCase     (							self      :	str)						->       Dict:




									"""simple docstring"""







									_lowerCAmelCase:List[str]									=  TFEfficientFormerForImageClassification.from_pretrained('''snap-research/efficientformer-l1-300''')
									_lowerCAmelCase:Any									=  self.default_image_processor
									_lowerCAmelCase:Optional[Any]									=  prepare_img()
									_lowerCAmelCase:str									=  image_processor(images=snake_case_     ,return_tensors='''tf''')
									# forward pass
									_lowerCAmelCase:List[str]									=  model(**snake_case_     ,training=snake_case_)
									# verify the logits
									_lowerCAmelCase:Tuple									=  tf.TensorShape((1, 1000))
									self.assertEqual(outputs.logits.shape     ,snake_case_)
									_lowerCAmelCase:Optional[Any]									=  tf.constant([-0.0555, 0.4825, -0.0852])
									self.assertTrue(np.allclose(outputs.logits[0, :3]     ,snake_case_     ,atol=1E-4))







						@slow
						def       __UpperCamelCase     (							self      :	int)						->       Union[str, Any]:




									"""simple docstring"""







									_lowerCAmelCase:Optional[Any]									=  TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
									    '''snap-research/efficientformer-l1-300''')
									_lowerCAmelCase:str									=  self.default_image_processor
									_lowerCAmelCase:List[Any]									=  prepare_img()
									_lowerCAmelCase:str									=  image_processor(images=snake_case_     ,return_tensors='''tf''')
									# forward pass
									_lowerCAmelCase:Dict									=  model(**snake_case_     ,training=snake_case_)
									# verify the logits
									_lowerCAmelCase:Any									=  tf.TensorShape((1, 1000))
									self.assertEqual(outputs.logits.shape     ,snake_case_)
									_lowerCAmelCase:List[str]									=  tf.constant([-0.1312, 0.4353, -1.0499])
									self.assertTrue(np.allclose(outputs.logits[0, :3]     ,snake_case_     ,atol=1E-4))












"""simple docstring"""






import argparse
import json
import re
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    MobileNetVaConfig,
    MobileNetVaForImageClassification,
    MobileNetVaImageProcessor,
    load_tf_weights_in_mobilenet_va,
)
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase__						=			logging.get_logger(__name__)





def 							UpperCAmelCase		(		snake_case			:					Optional[int]    ):
					_lowerCAmelCase:List[Any]									=  MobileNetVaConfig(layer_norm_eps=0.0_01    )

					if "_quant" in model_name:
										raise ValueError('''Quantized models are not supported.'''    )

					_lowerCAmelCase:List[Any]									=  re.match(R'''^mobilenet_v1_([^_]*)_([^_]*)$'''      ,       snake_case    )
					if matches:
										_lowerCAmelCase:str									=  float(matches[1]    )
										_lowerCAmelCase:str									=  int(matches[2]    )

					# The TensorFlow version of MobileNetV1 predicts 1001 classes instead of
					# the usual 1000. The first class (index 0) is "background".
					_lowerCAmelCase:int									=  1001
					_lowerCAmelCase:Union[str, Any]									=  '''imagenet-1k-id2label.json'''
					_lowerCAmelCase:Optional[int]									=  '''huggingface/label-files'''
					_lowerCAmelCase:List[str]									=  json.load(open(hf_hub_download(snake_case      ,       snake_case      ,       repo_type='''dataset'''    )      ,       '''r'''    )    )
					_lowerCAmelCase:Union[str, Any]									=  {int(snake_case    ) + 1: v for k, v in idalabel.items()}
					_lowerCAmelCase:Optional[Any]									=  '''background'''
					_lowerCAmelCase:Optional[Any]									=  idalabel
					_lowerCAmelCase:List[Any]									=  {v: k for k, v in idalabel.items()}

					return config





def 							UpperCAmelCase		(		):
					_lowerCAmelCase:Tuple									=  '''http://images.cocodataset.org/val2017/000000039769.jpg'''
					_lowerCAmelCase:Optional[Any]									=  Image.open(requests.get(snake_case      ,       stream=snake_case    ).raw    )
					return im





@torch.no_grad()
def 							UpperCAmelCase		(		snake_case			:					Any      ,       snake_case			:					Union[str, Any]      ,       snake_case			:					List[Any]      ,       snake_case			:					Any=False    ):
					_lowerCAmelCase:List[str]									=  get_mobilenet_va_config(snake_case    )

					# Load 🤗 model
					_lowerCAmelCase:Any									=  MobileNetVaForImageClassification(snake_case    ).eval()

					# Load weights from TensorFlow checkpoint
					load_tf_weights_in_mobilenet_va(snake_case      ,       snake_case      ,       snake_case    )

					# Check outputs on an image, prepared by MobileNetV1ImageProcessor
					_lowerCAmelCase:Dict									=  MobileNetVaImageProcessor(
					    crop_size={'''width''': config.image_size, '''height''': config.image_size}      ,       size={'''shortest_edge''': config.image_size + 32}      ,       )
					_lowerCAmelCase:List[str]									=  image_processor(images=prepare_img()      ,       return_tensors='''pt'''    )
					_lowerCAmelCase:List[str]									=  model(**snake_case    )
					_lowerCAmelCase:int									=  outputs.logits

					assert logits.shape == (1, 1001)

					if model_name == "mobilenet_v1_1.0_224":
										_lowerCAmelCase:Union[str, Any]									=  torch.tensor([-4.17_39, -1.12_33, 3.12_05]    )
					elif model_name == "mobilenet_v1_0.75_192":
										_lowerCAmelCase:Any									=  torch.tensor([-3.94_40, -2.31_41, -0.33_33]    )
					else:
										_lowerCAmelCase:Dict									=  None

					if expected_logits is not None:
										assert torch.allclose(logits[0, :3]      ,       snake_case      ,       atol=1e-4    )

					Path(snake_case    ).mkdir(exist_ok=snake_case    )
					print(F'Saving model {model_name} to {pytorch_dump_folder_path}'    )
					model.save_pretrained(snake_case    )
					print(F'Saving image processor to {pytorch_dump_folder_path}'    )
					image_processor.save_pretrained(snake_case    )

					if push_to_hub:
										print('''Pushing to the hub...'''    )
										_lowerCAmelCase:List[str]									=  '''google/''' + model_name
										image_processor.push_to_hub(snake_case    )
										model.push_to_hub(snake_case    )


if __name__ == "__main__":
				UpperCamelCase__						=			argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--model_name''',
				    default='''mobilenet_v1_1.0_224''',
				    type=str,
				    help='''Name of the MobileNetV1 model you\'d like to convert. Should in the form \'mobilenet_v1_<depth>_<size>\'.''',
				)
				parser.add_argument(
				    '''--checkpoint_path''', required=True, type=str, help='''Path to the original TensorFlow checkpoint (.ckpt file).'''
				)
				parser.add_argument(
				    '''--pytorch_dump_folder_path''', required=True, type=str, help='''Path to the output PyTorch model directory.'''
				)
				parser.add_argument(
				    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
				)

				UpperCamelCase__						=			parser.parse_args()
				convert_movilevit_checkpoint(
				    args.model_name, args.checkpoint_path, args.pytorch_dump_folder_path, args.push_to_hub
				)






