

import unittest

from transformers import AutoTokenizer, FalconConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    FalconForCausalLM,
						    FalconForQuestionAnswering,
						    FalconForSequenceClassification,
						    FalconForTokenClassification,
						    FalconModel,
						)






class 	__magic_name__    :





			def __init__(		self					,  __snake_case					,  __snake_case=3					,  __snake_case=7					,  __snake_case=True					,  __snake_case=True					,  __snake_case=False					,  __snake_case=True					,  __snake_case=99					,  __snake_case=32					,  __snake_case=5					,  __snake_case=4					,  __snake_case=37					,  __snake_case="gelu"					,  __snake_case=0.1					,  __snake_case=0.1					,  __snake_case=512					,  __snake_case=16					,  __snake_case=2					,  __snake_case=0.02					,  __snake_case=3					,  __snake_case=4					,  __snake_case=None					,  )   -> List[Any]:




						'''simple docstring'''
						__a        =parent
						__a        =batch_size
						__a        =seq_length
						__a        =is_training
						__a        =use_input_mask
						__a        =use_token_type_ids
						__a        =use_labels
						__a        =vocab_size
						__a        =hidden_size
						__a        =num_hidden_layers
						__a        =num_attention_heads
						__a        =intermediate_size
						__a        =hidden_act
						__a        =hidden_dropout_prob
						__a        =attention_probs_dropout_prob
						__a        =max_position_embeddings
						__a        =type_vocab_size
						__a        =type_sequence_label_size
						__a        =initializer_range
						__a        =num_labels
						__a        =num_choices
						__a        =scope





			def 		__magic_name__    (		self					)   -> Any:




						'''simple docstring'''
						__a        =ids_tensor([self.batch_size, self.seq_length]					,  self.vocab_size					)

						__a        =None
						if self.use_input_mask:
									__a        =random_attention_mask([self.batch_size, self.seq_length]					)

						__a        =None

						__a        =None
						__a        =None
						__a        =None
						if self.use_labels:
									__a        =ids_tensor([self.batch_size]					,  self.type_sequence_label_size					)
									__a        =ids_tensor([self.batch_size, self.seq_length]					,  self.num_labels					)
									__a        =ids_tensor([self.batch_size]					,  self.num_choices					)

						__a        =self.get_config()

						return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels





			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						return FalconConfig(
						    vocab_size=self.vocab_size					,  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					,  max_position_embeddings=self.max_position_embeddings					,  type_vocab_size=self.type_vocab_size					,  is_decoder=__snake_case					,  initializer_range=self.initializer_range					,  pad_token_id=1					,  new_decoder_architecture=__snake_case					,  )





			def 		__magic_name__    (		self					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					)   -> Any:




						'''simple docstring'''
						__a        =FalconModel(config=__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  attention_mask=__snake_case					)
						__a        =model(__snake_case					)
						self.parent.assertEqual(result.last_hidden_state.shape					,  (self.batch_size, self.seq_length, self.hidden_size)					)





			def 		__magic_name__    (		self					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  )   -> Any:




						'''simple docstring'''
						__a        =True
						__a        =FalconModel(__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(
						    __snake_case					,  attention_mask=__snake_case					,  encoder_hidden_states=__snake_case					,  encoder_attention_mask=__snake_case					,  )
						__a        =model(
						    __snake_case					,  attention_mask=__snake_case					,  encoder_hidden_states=__snake_case					,  )
						__a        =model(__snake_case					,  attention_mask=__snake_case					)
						self.parent.assertEqual(result.last_hidden_state.shape					,  (self.batch_size, self.seq_length, self.hidden_size)					)





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




						'''simple docstring'''
						__a        =FalconForCausalLM(config=__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  attention_mask=__snake_case					,  labels=__snake_case					)
						self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.seq_length, self.vocab_size)					)





			def 		__magic_name__    (		self					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  __snake_case					,  )   -> Optional[Any]:




						'''simple docstring'''
						__a        =True
						__a        =True
						__a        =FalconForCausalLM(config=__snake_case					)
						model.to(__snake_case					)
						model.eval()

						# first forward pass
						__a        =model(
						    __snake_case					,  attention_mask=__snake_case					,  encoder_hidden_states=__snake_case					,  encoder_attention_mask=__snake_case					,  use_cache=__snake_case					,  )
						__a        =outputs.past_key_values

						# create hypothetical multiple next token and extent to next_input_ids
						__a        =ids_tensor((self.batch_size, 3)					,  config.vocab_size					)
						__a        =ids_tensor((self.batch_size, 3)					,  vocab_size=2					)

						# append to next input_ids and
						__a        =torch.cat([input_ids, next_tokens]					,  dim=-1					)
						__a        =torch.cat([input_mask, next_mask]					,  dim=-1					)

						__a        =model(
						    __snake_case					,  attention_mask=__snake_case					,  encoder_hidden_states=__snake_case					,  encoder_attention_mask=__snake_case					,  output_hidden_states=__snake_case					,  )['hidden_states'][0]
						__a        =model(
						    __snake_case					,  attention_mask=__snake_case					,  encoder_hidden_states=__snake_case					,  encoder_attention_mask=__snake_case					,  past_key_values=__snake_case					,  output_hidden_states=__snake_case					,  )['hidden_states'][0]

						# select random slice
						__a        =ids_tensor((1,)					,  output_from_past.shape[-1]					).item()
						__a        =output_from_no_past[:, -3:, random_slice_idx].detach()
						__a        =output_from_past[:, :, random_slice_idx].detach()

						self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)

						# test that outputs are equal for slice
						self.parent.assertTrue(torch.allclose(__snake_case					,  __snake_case					,  atol=1e-3					)					)





			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						__a        =self.prepare_config_and_inputs()
						(
						    (
						    __a
						)      ,    (
						    __a
						)      ,    (
						    __a
						)      ,    (
						    __a
						)      ,    (
						    __a
						)      ,    (
						    __a
						)      ,    (
						    __a
						)      ,    
						)        =config_and_inputs
						__a        ={'input_ids': input_ids, 'attention_mask': input_mask}
						return config, inputs_dict






@require_torch
class 	__magic_name__    (			lowerCAmelCase_  ,    lowerCAmelCase_  ,    lowerCAmelCase_  ,    unittest.TestCase      ):
			SCREAMING_SNAKE_CASE							   =						(
			    (
			        FalconModel,
			        FalconForCausalLM,
			        FalconForSequenceClassification,
			        FalconForTokenClassification,
			        FalconForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			SCREAMING_SNAKE_CASE							   =						(FalconForCausalLM,) if is_torch_available() else ()
			SCREAMING_SNAKE_CASE							   =						(
			    {
			        'feature-extraction': FalconModel,
			        'text-classification': FalconForSequenceClassification,
			        'text-generation': FalconForCausalLM,
			        'question-answering': FalconForQuestionAnswering,
			        'token-classification': FalconForTokenClassification,
			        'zero-shot': FalconForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			SCREAMING_SNAKE_CASE							   =						False
			SCREAMING_SNAKE_CASE							   =						False





			def 		__magic_name__    (		self					)   -> str:




						'''simple docstring'''
						__a        =FalconModelTester(self					)
						__a        =ConfigTester(self					,  config_class=__snake_case					,  hidden_size=37					)





			def 		__magic_name__    (		self					)   -> Any:




						'''simple docstring'''
						self.config_tester.run_common_tests()





			def 		__magic_name__    (		self					)   -> List[str]:




						'''simple docstring'''
						__a        =self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__snake_case					)





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




						'''simple docstring'''
						__a      ,    *__a        =self.model_tester.prepare_config_and_inputs()
						for alibi in [True, False]:
									__a        =alibi
									self.model_tester.create_and_check_model(__snake_case					,  *__snake_case					)





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




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()
						__a        =3
						__a        =input_dict['input_ids']
						__a        =input_ids.ne(1					).to(__snake_case					)
						__a        =ids_tensor([self.model_tester.batch_size]					,  self.model_tester.type_sequence_label_size					)
						__a        =FalconForSequenceClassification(__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  attention_mask=__snake_case					,  labels=__snake_case					)
						self.assertEqual(result.logits.shape					,  (self.model_tester.batch_size, self.model_tester.num_labels)					)





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




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()
						__a        =3
						__a        ='single_label_classification'
						__a        =input_dict['input_ids']
						__a        =input_ids.ne(1					).to(__snake_case					)
						__a        =ids_tensor([self.model_tester.batch_size]					,  self.model_tester.type_sequence_label_size					)
						__a        =FalconForSequenceClassification(__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  attention_mask=__snake_case					,  labels=__snake_case					)
						self.assertEqual(result.logits.shape					,  (self.model_tester.batch_size, self.model_tester.num_labels)					)





			def 		__magic_name__    (		self					)   -> int:




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()
						__a        =input_dict['input_ids']
						__a        =FalconForCausalLM(__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  use_cache=__snake_case					)
						__a        =input_ids.shape[0]
						__a        =model._convert_to_rw_cache(result.past_key_values					)
						__a        =model._convert_cache_to_standard_format(__snake_case					,  __snake_case					)
						for layer in range(len(__snake_case					)					):
									for tensor_idx in range(2					):
												self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3					)
												self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4					)
												self.assertTrue(
												    torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]					)					)





			def 		__magic_name__    (		self					)   -> Tuple:




						'''simple docstring'''
						__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()
						__a        =3
						__a        ='multi_label_classification'
						__a        =input_dict['input_ids']
						__a        =input_ids.ne(1					).to(__snake_case					)
						__a        =ids_tensor(
						    [self.model_tester.batch_size, config.num_labels]					,  self.model_tester.type_sequence_label_size					).to(torch.float					)
						__a        =FalconForSequenceClassification(__snake_case					)
						model.to(__snake_case					)
						model.eval()
						__a        =model(__snake_case					,  attention_mask=__snake_case					,  labels=__snake_case					)
						self.assertEqual(result.logits.shape					,  (self.model_tester.batch_size, self.model_tester.num_labels)					)





			def 		__magic_name__    (		self					)   -> Any:




						'''simple docstring'''
						# Falcon can have different numbers of KV-heads than the number of query heads, so we need
						# to override this test to use the right head counts.
						for model_class in self.all_generative_model_classes:
									__a      ,    __a        =self.model_tester.prepare_config_and_inputs_for_common()

									# If it doesn't support cache, pass the test
									if not hasattr(__snake_case					,  'use_cache'					):
												return

									__a        =model_class(__snake_case					).to(__snake_case					)
									if "use_cache" not in inputs:
												__a        =True
									__a        =model(**__snake_case					)

									# If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
									if "past_key_values" not in outputs:
												return

									__a        =(
									    getattr(__snake_case					,  'decoder_layers'					,  __snake_case					)
									    or getattr(__snake_case					,  'num_decoder_layers'					,  __snake_case					)
									    or config.num_hidden_layers
									)
									__a        =getattr(__snake_case					,  'num_kv_heads'					,  config.num_attention_heads					)
									__a        =getattr(__snake_case					,  'd_model'					,  config.hidden_size					)
									__a        =embed_dim // num_attention_heads

									__a        =outputs['past_key_values']
									self.assertEqual(len(__snake_case					)					,  __snake_case					)

									__a      ,    __a        =inputs['input_ids'].shape
									for i in range(__snake_case					):
												if config.new_decoder_architecture:
															__a        =config.num_attention_heads
												elif config.multi_query:
															__a        =1
												self.assertEqual(len(past_kv[0]					)					,  2					)  # K V for the decoder = 2
												self.assertEqual(
												    past_kv[i][0].shape					,  (batch_size, num_attention_heads, seq_length, per_head_embed_dim)					)
												self.assertEqual(
												    past_kv[i][1].shape					,  (batch_size, num_attention_heads, seq_length, per_head_embed_dim)					)






@require_torch
class 	__magic_name__    (			unittest.TestCase      ):





			@slow
			def 		__magic_name__    (		self					)   -> str:




						'''simple docstring'''
						__a        =AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b'					)
						__a        =FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b'					)
						model.eval()
						model.to(__snake_case					)
						__a        =tokenizer('My favorite food is'					,  return_tensors='pt'					).to(__snake_case					)

						__a        =(
						    'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
						)

						__a        =model.generate(**__snake_case					,  do_sample=__snake_case					,  max_new_tokens=19					)
						__a        =tokenizer.batch_decode(__snake_case					)[0]

						self.assertEqual(__snake_case					,  __snake_case					)





			@slow
			def 		__magic_name__    (		self					)   -> Optional[int]:




						'''simple docstring'''
						# The big models are way too big for the CI, so we use tiny random models that resemble their
						# architectures but with much smaller and fewer layers
						for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
									__a        =AutoTokenizer.from_pretrained(__snake_case					)
									__a        =FalconForCausalLM.from_pretrained(__snake_case					)
									model.eval()
									model.to(__snake_case					)
									__a        =tokenizer('My favorite food is'					,  return_tensors='pt'					).to(__snake_case					)

									# We just test that these run without errors - the models are randomly initialized
									# and so the actual text outputs will be garbage
									model.generate(**__snake_case					,  do_sample=__snake_case					,  max_new_tokens=4					)
									model.generate(**__snake_case					,  do_sample=__snake_case					,  max_new_tokens=4					)
									model.generate(**__snake_case					,  num_beams=2					,  max_new_tokens=4					)





			@slow
			def 		__magic_name__    (		self					)   -> Optional[Any]:




						'''simple docstring'''
						# The big models are way too big for the CI, so we use tiny random models that resemble their
						# architectures but with much smaller and fewer layers
						with torch.no_grad():
									for repo in [
									    "Rocketknight1/falcon-rw-1b",
									    "Rocketknight1/tiny-random-falcon-7b",
									    "Rocketknight1/tiny-random-falcon-40b",
									]:
												__a        =AutoTokenizer.from_pretrained(__snake_case					)
												__a        =FalconForCausalLM.from_pretrained(__snake_case					)
												model.eval()
												model.to(device=__snake_case					)
												__a        =tokenizer('My favorite food is'					,  return_tensors='pt'					).to(__snake_case					)

												# Test results are the same with and without cache
												__a        =model.generate(**__snake_case					,  do_sample=__snake_case					,  max_new_tokens=20					,  use_cache=__snake_case					)
												__a        =model.generate(**__snake_case					,  do_sample=__snake_case					,  max_new_tokens=20					,  use_cache=__snake_case					)
												self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0					)









import argparse
import re
from pathlib import Path

import requests
import torch
from PIL import Image
from torchvision.transforms import CenterCrop, Compose, Normalize, Resize, ToTensor

from transformers import (
    EfficientFormerConfig,
    EfficientFormerForImageClassificationWithTeacher,
    EfficientFormerImageProcessor,
)
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling






def        UpperCamelCase_(							_snake_case   :  int       ,     _snake_case   :  int	):




			"""simple docstring"""






			__a        =old_name

			if "patch_embed" in old_name:
						__a      ,    __a      ,    __a        =old_name.split('.'	)

						if layer == "0":
									__a        =old_name.replace('0'       ,     'convolution1'	)
						elif layer == "1":
									__a        =old_name.replace('1'       ,     'batchnorm_before'	)
						elif layer == "3":
									__a        =old_name.replace('3'       ,     'convolution2'	)
						else:
									__a        =old_name.replace('4'       ,     'batchnorm_after'	)

			if "network" in old_name and re.search(r'\d\.\d'       ,     _snake_case	):
						__a        =r'\b\d{2}\b'
						if bool(re.search(_snake_case       ,     _snake_case	)	):
									__a        =re.search(r'\d\.\d\d.'       ,     _snake_case	).group()
						else:
									__a        =re.search(r'\d\.\d.'       ,     _snake_case	).group()
						if int(match[0]	) < 6:
									__a        =old_name.replace(_snake_case       ,     ''	)
									__a        =trimmed_name.replace('network'       ,     match[0] + '.meta4D_layers.blocks.' + match[2:-1]	)
									__a        ='intermediate_stages.' + trimmed_name
						else:
									__a        =old_name.replace(_snake_case       ,     ''	)
									if int(match[2]	) < num_meta4D_last_stage:
												__a        =trimmed_name.replace('network'       ,     'meta4D_layers.blocks.' + match[2]	)
									else:
												__a        =str(int(match[2]	) - num_meta4D_last_stage	)
												__a        =trimmed_name.replace('network'       ,     'meta3D_layers.blocks.' + layer_index	)
												if "norm1" in old_name:
															__a        =trimmed_name.replace('norm1'       ,     'layernorm1'	)
												elif "norm2" in old_name:
															__a        =trimmed_name.replace('norm2'       ,     'layernorm2'	)
												elif "fc1" in old_name:
															__a        =trimmed_name.replace('fc1'       ,     'linear_in'	)
												elif "fc2" in old_name:
															__a        =trimmed_name.replace('fc2'       ,     'linear_out'	)

									__a        ='last_stage.' + trimmed_name

			elif "network" in old_name and re.search(r'.\d.'       ,     _snake_case	):
						__a        =old_name.replace('network'       ,     'intermediate_stages'	)

			if "fc" in new_name:
						__a        =new_name.replace('fc'       ,     'convolution'	)
			elif ("norm1" in new_name) and ("layernorm1" not in new_name):
						__a        =new_name.replace('norm1'       ,     'batchnorm_before'	)
			elif ("norm2" in new_name) and ("layernorm2" not in new_name):
						__a        =new_name.replace('norm2'       ,     'batchnorm_after'	)
			if "proj" in new_name:
						__a        =new_name.replace('proj'       ,     'projection'	)
			if "dist_head" in new_name:
						__a        =new_name.replace('dist_head'       ,     'distillation_classifier'	)
			elif "head" in new_name:
						__a        =new_name.replace('head'       ,     'classifier'	)
			elif "patch_embed" in new_name:
						__a        ='efficientformer.' + new_name
			elif new_name == "norm.weight" or new_name == "norm.bias":
						__a        =new_name.replace('norm'       ,     'layernorm'	)
						__a        ='efficientformer.' + new_name
			else:
						__a        ='efficientformer.encoder.' + new_name

			return new_name






def        UpperCamelCase_(							_snake_case   :  List[str]       ,     _snake_case   :  Dict	):




			"""simple docstring"""






			for key in checkpoint.copy().keys():
						__a        =checkpoint.pop(_snake_case	)
						__a        =val

			return checkpoint






def        UpperCamelCase_(							):




			"""simple docstring"""






			__a        ='http://images.cocodataset.org/val2017/000000039769.jpg'
			__a        =Image.open(requests.get(_snake_case       ,     stream=_snake_case	).raw	)

			return image






def        UpperCamelCase_(							_snake_case   :  Path       ,     _snake_case   :  Path       ,     _snake_case   :  Path       ,     _snake_case   :  bool	):




			"""simple docstring"""






			__a        =torch.load(_snake_case       ,     map_location='cpu'	)['model']
			__a        =EfficientFormerConfig.from_json_file(_snake_case	)
			__a        =EfficientFormerForImageClassificationWithTeacher(_snake_case	)
			__a        ='_'.join(checkpoint_path.split('/'	)[-1].split('.'	)[0].split('_'	)[:-1]	)

			__a        =config.depths[-1] - config.num_metaad_blocks + 1
			__a        =convert_torch_checkpoint(_snake_case       ,     _snake_case	)

			model.load_state_dict(_snake_case	)
			model.eval()

			__a        ={
			    'bilinear': PILImageResampling.BILINEAR,
			    'bicubic': PILImageResampling.BICUBIC,
			    'nearest': PILImageResampling.NEAREST,
			}

			# prepare image
			__a        =prepare_img()
			__a        =256
			__a        =224
			__a        =EfficientFormerImageProcessor(
			    size={'shortest_edge': image_size}       ,     crop_size={'height': crop_size, 'width': crop_size}       ,     resample=pillow_resamplings['bicubic']       ,     )
			__a        =processor(images=_snake_case       ,     return_tensors='pt'	).pixel_values

			# original processing pipeline
			__a        =Compose(
			    [
			        Resize(_snake_case       ,     interpolation=pillow_resamplings['bicubic']	),
			        CenterCrop(_snake_case	),
			        ToTensor(),
			        Normalize(_snake_case       ,     _snake_case	),
			    ]	)
			__a        =image_transforms(_snake_case	).unsqueeze(0	)

			assert torch.allclose(_snake_case       ,     _snake_case	)

			__a        =model(_snake_case	)
			__a        =outputs.logits

			__a        =(1, 1000)

			if "l1" in model_name:
						__a        =torch.Tensor(
						    [-0.1_312, 0.4_353, -1.0_499, -0.5_124, 0.4_183, -0.6_793, -1.3_777, -0.0_893, -0.7_358, -2.4_328]	)
						assert torch.allclose(logits[0, :10]       ,     _snake_case       ,     atol=1e-3	)
						assert logits.shape == expected_shape
			elif "l3" in model_name:
						__a        =torch.Tensor(
						    [-1.3_150, -1.5_456, -1.2_556, -0.8_496, -0.7_127, -0.7_897, -0.9_728, -0.3_052, 0.3_751, -0.3_127]	)
						assert torch.allclose(logits[0, :10]       ,     _snake_case       ,     atol=1e-3	)
						assert logits.shape == expected_shape
			elif "l7" in model_name:
						__a        =torch.Tensor(
						    [-1.0_283, -1.4_131, -0.5_644, -1.3_115, -0.5_785, -1.2_049, -0.7_528, 0.1_992, -0.3_822, -0.0_878]	)
						assert logits.shape == expected_shape
			else:
						raise ValueError(
						    F'Unknown model checkpoint: {checkpoint_path}. Supported version of efficientformer are l1, l3 and l7'	)

			# Save Checkpoints
			Path(_snake_case	).mkdir(exist_ok=_snake_case	)
			model.save_pretrained(_snake_case	)
			print(F'Checkpoint successfuly converted. Model saved at {pytorch_dump_path}'	)
			processor.save_pretrained(_snake_case	)
			print(F'Processor successfuly saved at {pytorch_dump_path}'	)

			if push_to_hub:
						print('Pushing model to the hub...'	)

						model.push_to_hub(
						    repo_id=F'Bearnardd/{pytorch_dump_path}'       ,     commit_message='Add model'       ,     use_temp_dir=_snake_case       ,     )
						processor.push_to_hub(
						    repo_id=F'Bearnardd/{pytorch_dump_path}'       ,     commit_message='Add image processor'       ,     use_temp_dir=_snake_case       ,     )


if __name__ == "__main__":
						_lowerCAmelCase					:			int  				=			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    "--pytorch_model_path",
						    default=None,
						    type=str,
						    required=True,
						    help="Path to EfficientFormer pytorch checkpoint.",
						)
						parser.add_argument(
						    "--config_file",
						    default=None,
						    type=str,
						    required=True,
						    help="The json file for EfficientFormer model config.",
						)
						parser.add_argument(
						    "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
						)

						parser.add_argument("--push_to_hub", action="store_true", help="Push model and image processor to the hub")
						parser.add_argument(
						    "--no-push_to_hub",
						    dest="push_to_hub",
						    action="store_false",
						    help="Do not push model and image processor to the hub",
						)
						parser.set_defaults(push_to_hub=True)

						_lowerCAmelCase					:			Union[str, Any]  				=			parser.parse_args()
						convert_efficientformer_checkpoint(
						    checkpoint_path=args.pytorch_model_path,
						    efficientformer_config_file=args.config_file,
						    pytorch_dump_path=args.pytorch_dump_path,
						    push_to_hub=args.push_to_hub,
						)






