code: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import math
  from timeit import timeit
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      int:
  			__lowerCAmelCase      		=       0
  			__lowerCAmelCase      		=       abs(lowercase			)
  			while True:
  						__lowerCAmelCase      		=       n // 10
  						digits += 1
  						if n == 0:
  									break
  			return digits
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      int:
  			return 1 if n == 0 else math.floor(math.log(abs(lowercase			)      ,			10			) + 1			)
  
  
  
  
  
  def      _lowerCAmelCase		(		lowercase			)      ->      int:
  			return len(str(abs(lowercase			)			)			)
  
  
  
  
  
  def      _lowerCAmelCase		(		)      ->      None:
  			from collections.abc import Callable
  
  			def benchmark_a_function(lowercase      ,			lowercase			) -> None:
  						__lowerCAmelCase      		=       f'{func.__name__}({value})'
  						__lowerCAmelCase      		=       timeit(f'__main__.{call}'      ,			setup="""import __main__"""			)
  						print(f'{call}: {func(lowercase			)} -- {timing} seconds'			)
  
  			for value in (26_2144, 1125_8999_0684_2624, 126_7650_6002_2822_9401_4967_0320_5376):
  						for func in (num_digits, num_digits_fast, num_digits_faster):
  									benchmark_a_function(lowercase      ,			lowercase			)
  						print()
  
  
  if __name__ == "__main__":
  	import doctest
  
  	doctest.testmod()
  	benchmark()
  
  
style_context: 
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  
  
  import inspect
  import unittest
  import warnings
  from typing import List
  
  from transformers import EfficientFormerConfig
  from transformers.models.auto import get_values
  from transformers.testing_utils import require_torch, require_vision, slow, torch_device
  from transformers.utils import cached_property, is_torch_available, is_vision_available
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
  	import torch
  
  	from transformers import (
  	    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
  	    MODEL_MAPPING,
  	    EfficientFormerForImageClassification,
  	    EfficientFormerForImageClassificationWithTeacher,
  	    EfficientFormerModel,
  	)
  	from transformers.models.efficientformer.modeling_efficientformer import (
  	    EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
  	)
  
  
  if is_vision_available():
  	from PIL import Image
  
  	from transformers import EfficientFormerImageProcessor
  
  
  
  
  
  class 					_UpperCAmelCase							:
  		def __init__(						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE = 13,__SCREAMING_SNAKE_CASE = 64,__SCREAMING_SNAKE_CASE = 2,__SCREAMING_SNAKE_CASE = 3,__SCREAMING_SNAKE_CASE = 3,__SCREAMING_SNAKE_CASE = True,__SCREAMING_SNAKE_CASE = True,__SCREAMING_SNAKE_CASE = 1_28,__SCREAMING_SNAKE_CASE=[16, 32, 64, 1_28],__SCREAMING_SNAKE_CASE = 7,__SCREAMING_SNAKE_CASE = 4,__SCREAMING_SNAKE_CASE = 37,__SCREAMING_SNAKE_CASE = "gelu",__SCREAMING_SNAKE_CASE = 0.1,__SCREAMING_SNAKE_CASE = 0.1,__SCREAMING_SNAKE_CASE = 10,__SCREAMING_SNAKE_CASE = 0.02,__SCREAMING_SNAKE_CASE = 2,__SCREAMING_SNAKE_CASE = 1,__SCREAMING_SNAKE_CASE = 1_28,__SCREAMING_SNAKE_CASE = [2, 2, 2, 2],__SCREAMING_SNAKE_CASE = 2,__SCREAMING_SNAKE_CASE = 2,):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       parent
  					__lowerCAmelCase      		=       batch_size
  					__lowerCAmelCase      		=       image_size
  					__lowerCAmelCase      		=       patch_size
  					__lowerCAmelCase      		=       num_channels
  					__lowerCAmelCase      		=       is_training
  					__lowerCAmelCase      		=       use_labels
  					__lowerCAmelCase      		=       hidden_size
  					__lowerCAmelCase      		=       num_hidden_layers
  					__lowerCAmelCase      		=       num_attention_heads
  					__lowerCAmelCase      		=       intermediate_size
  					__lowerCAmelCase      		=       hidden_act
  					__lowerCAmelCase      		=       hidden_dropout_prob
  					__lowerCAmelCase      		=       attention_probs_dropout_prob
  					__lowerCAmelCase      		=       type_sequence_label_size
  					__lowerCAmelCase      		=       initializer_range
  					__lowerCAmelCase      		=       encoder_stride
  					__lowerCAmelCase      		=       num_attention_outputs
  					__lowerCAmelCase      		=       embed_dim
  					__lowerCAmelCase      		=       embed_dim + 1
  					__lowerCAmelCase      		=       resolution
  					__lowerCAmelCase      		=       depths
  					__lowerCAmelCase      		=       hidden_sizes
  					__lowerCAmelCase      		=       dim
  					__lowerCAmelCase      		=       mlp_expansion_ratio
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )
  
  					__lowerCAmelCase      		=       None
  					if self.use_labels:
  								__lowerCAmelCase      		=       ids_tensor([self.batch_size],self.type_sequence_label_size    )
  
  					__lowerCAmelCase      		=       self.get_config()
  					return config, pixel_values, labels
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''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=__SCREAMING_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 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       EfficientFormerModel(config=__SCREAMING_SNAKE_CASE    )
  					model.to(__SCREAMING_SNAKE_CASE    )
  					model.eval()
  					__lowerCAmelCase      		=       model(__SCREAMING_SNAKE_CASE    )
  					self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)    )
  		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.type_sequence_label_size
  					__lowerCAmelCase      		=       EfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE    )
  					model.to(__SCREAMING_SNAKE_CASE    )
  					model.eval()
  					__lowerCAmelCase      		=       model(__SCREAMING_SNAKE_CASE,labels=__SCREAMING_SNAKE_CASE    )
  					self.parent.assertEqual(result.logits.shape,(self.batch_size, self.type_sequence_label_size)    )
  
  					# test greyscale images
  					__lowerCAmelCase      		=       1
  					__lowerCAmelCase      		=       EfficientFormerForImageClassification(__SCREAMING_SNAKE_CASE    )
  					model.to(__SCREAMING_SNAKE_CASE    )
  					model.eval()
  
  					__lowerCAmelCase      		=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]    )
  					__lowerCAmelCase      		=       model(__SCREAMING_SNAKE_CASE    )
  					self.parent.assertEqual(result.logits.shape,(self.batch_size, self.type_sequence_label_size)    )
  
  
  
  
  
  
  
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.prepare_config_and_inputs()
  					(
  					    (
  					    __lowerCAmelCase
  					)		, (
  					    __lowerCAmelCase
  					)		, (
  					    __lowerCAmelCase
  					)		, 
  					)      		=       config_and_inputs
  					__lowerCAmelCase      		=       {"""pixel_values""": pixel_values}
  					return config, inputs_dict
  
  
  
  
  
  @require_torch
  class 					_UpperCAmelCase							(		lowerCAmelCase_			,      lowerCAmelCase_			,      unittest.TestCase     ):
  		a     :     List[str]     						=(
  		    (
  		        EfficientFormerModel,
  		        EfficientFormerForImageClassificationWithTeacher,
  		        EfficientFormerForImageClassification,
  		    )
  		    if is_torch_available()
  		    else ()
  		)
  		a     :     List[Any]     						=(
  		    {
  		        """feature-extraction""": EfficientFormerModel,
  		        """image-classification""": (
  		            EfficientFormerForImageClassification,
  		            EfficientFormerForImageClassificationWithTeacher,
  		        ),
  		    }
  		    if is_torch_available()
  		    else {}
  		)
  		a     :     Union[str, Any]     						=False
  
  		a     :     str     						=False
  		a     :     List[str]     						=False
  		a     :     List[Any]     						=False
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       EfficientFormerModelTester(self    )
  					__lowerCAmelCase      		=       ConfigTester(
  					    self,config_class=__SCREAMING_SNAKE_CASE,has_text_modality=__SCREAMING_SNAKE_CASE,hidden_size=37    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					self.config_tester.run_common_tests()
  		@unittest.skip(reason="""EfficientFormer does not use inputs_embeds"""    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					pass
  		@unittest.skip(reason="""EfficientFormer does not support input and output embeddings"""    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					pass
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
  
  					for model_class in self.all_model_classes:
  								__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  								__lowerCAmelCase      		=       inspect.signature(model.forward    )
  								# signature.parameters is an OrderedDict => so arg_names order is deterministic
  								__lowerCAmelCase      		=       [*signature.parameters.keys()]
  
  								__lowerCAmelCase      		=       ["""pixel_values"""]
  								self.assertListEqual(arg_names[:1],__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					def check_hidden_states_output(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    ):
  								__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  								model.to(__SCREAMING_SNAKE_CASE    )
  								model.eval()
  
  								with torch.no_grad():
  											__lowerCAmelCase      		=       model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )    )
  
  								__lowerCAmelCase      		=       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states
  
  								__lowerCAmelCase      		=       getattr(
  								    self.model_tester,"""expected_num_hidden_layers""",self.model_tester.num_hidden_layers + 1    )
  								self.assertEqual(len(__SCREAMING_SNAKE_CASE    ),__SCREAMING_SNAKE_CASE    )
  
  								if hasattr(self.model_tester,"""encoder_seq_length"""    ):
  											__lowerCAmelCase      		=       self.model_tester.encoder_seq_length
  											if hasattr(self.model_tester,"""chunk_length"""    ) and self.model_tester.chunk_length > 1:
  														__lowerCAmelCase      		=       seq_length * self.model_tester.chunk_length
  								else:
  											__lowerCAmelCase      		=       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      		=       outputs.decoder_hidden_states
  
  											self.assertIsInstance(__SCREAMING_SNAKE_CASE,(list, tuple)    )
  											self.assertEqual(len(__SCREAMING_SNAKE_CASE    ),__SCREAMING_SNAKE_CASE    )
  											__lowerCAmelCase      		=       getattr(self.model_tester,"""seq_length""",__SCREAMING_SNAKE_CASE    )
  											__lowerCAmelCase      		=       getattr(self.model_tester,"""decoder_seq_length""",__SCREAMING_SNAKE_CASE    )
  
  											self.assertListEqual(
  											    list(hidden_states[-1].shape[-2:]    ),[decoder_seq_length, self.model_tester.hidden_size],)
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
  
  					for model_class in self.all_model_classes:
  								__lowerCAmelCase      		=       True
  								check_hidden_states_output(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )
  
  								# check that output_hidden_states also work using config
  								del inputs_dict["output_hidden_states"]
  								__lowerCAmelCase      		=       True
  
  								check_hidden_states_output(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE=False    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       super()._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,return_labels=__SCREAMING_SNAKE_CASE    )
  
  					if return_labels:
  								if model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher":
  											del inputs_dict["labels"]
  
  					return inputs_dict
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE    )
  		@unittest.skip(reason="""EfficientFormer does not implement masked image modeling yet"""    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_for_masked_image_modeling(*__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_for_image_classification(*__SCREAMING_SNAKE_CASE    )
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					if not self.model_tester.is_training:
  								return
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
  					__lowerCAmelCase      		=       True
  
  					for model_class in self.all_model_classes:
  								# EfficientFormerForImageClassificationWithTeacher supports inference-only
  								if (
  								    model_class in get_values(__SCREAMING_SNAKE_CASE    )
  								    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
  								):
  											continue
  								__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  								model.to(__SCREAMING_SNAKE_CASE    )
  								model.train()
  								__lowerCAmelCase      		=       self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,return_labels=__SCREAMING_SNAKE_CASE    )
  								__lowerCAmelCase      		=       model(**__SCREAMING_SNAKE_CASE    ).loss
  								loss.backward()
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
  
  					__lowerCAmelCase      		=       [
  					    {"""title""": """multi_label_classification""", """num_labels""": 2, """dtype""": torch.float},
  					    {"""title""": """single_label_classification""", """num_labels""": 1, """dtype""": torch.long},
  					    {"""title""": """regression""", """num_labels""": 1, """dtype""": torch.float},
  					]
  
  					for model_class in self.all_model_classes:
  								if (
  								    model_class
  								    not in [
  								        *get_values(__SCREAMING_SNAKE_CASE    ),
  								    ]
  								    or model_class.__name__ == "EfficientFormerForImageClassificationWithTeacher"
  								):
  											continue
  
  								for problem_type in problem_types:
  											with self.subTest(msg=f'Testing {model_class} with {problem_type["title"]}'    ):
  														__lowerCAmelCase      		=       problem_type["""title"""]
  														__lowerCAmelCase      		=       problem_type["""num_labels"""]
  
  														__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  														model.to(__SCREAMING_SNAKE_CASE    )
  														model.train()
  
  														__lowerCAmelCase      		=       self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE,return_labels=__SCREAMING_SNAKE_CASE    )
  
  														if problem_type["num_labels"] > 1:
  																	__lowerCAmelCase      		=       inputs["""labels"""].unsqueeze(1    ).repeat(1,problem_type["""num_labels"""]    )
  
  														__lowerCAmelCase      		=       inputs["""labels"""].to(problem_type["""dtype"""]    )
  
  														# This tests that we do not trigger the warning form PyTorch "Using a target size that is different
  														# to the input size. This will likely lead to incorrect results due to broadcasting. Please ensure
  														# they have the same size." which is a symptom something in wrong for the regression problem.
  														# See https://github.com/huggingface/transformers/issues/11780
  														with warnings.catch_warnings(record=__SCREAMING_SNAKE_CASE    ) as warning_list:
  																	__lowerCAmelCase      		=       model(**__SCREAMING_SNAKE_CASE    ).loss
  														for w in warning_list:
  																	if "Using a target size that is different to the input size" in str(w.message    ):
  																				raise ValueError(
  																				    f'Something is going wrong in the regression problem: intercepted {w.message}'    )
  
  														loss.backward()
  		@slow
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					for model_name in EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  								__lowerCAmelCase      		=       EfficientFormerModel.from_pretrained(__SCREAMING_SNAKE_CASE    )
  								self.assertIsNotNone(__SCREAMING_SNAKE_CASE    )
  
  
  
  
  
  
  
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase		, __lowerCAmelCase      		=       self.model_tester.prepare_config_and_inputs_for_common()
  					__lowerCAmelCase      		=       True
  
  					__lowerCAmelCase      		=       getattr(self.model_tester,"""seq_length""",__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       getattr(self.model_tester,"""encoder_seq_length""",__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       getattr(self.model_tester,"""key_length""",__SCREAMING_SNAKE_CASE    )
  					__lowerCAmelCase      		=       getattr(self.model_tester,"""chunk_length""",__SCREAMING_SNAKE_CASE    )
  
  					if chunk_length is not None and hasattr(self.model_tester,"""num_hashes"""    ):
  								__lowerCAmelCase      		=       encoder_seq_length * self.model_tester.num_hashes
  
  					for model_class in self.all_model_classes:
  								__lowerCAmelCase      		=       True
  								__lowerCAmelCase      		=       False
  								__lowerCAmelCase      		=       True
  								__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  								model.to(__SCREAMING_SNAKE_CASE    )
  								model.eval()
  								with torch.no_grad():
  											__lowerCAmelCase      		=       model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )    )
  								__lowerCAmelCase      		=       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
  								self.assertEqual(len(__SCREAMING_SNAKE_CASE    ),self.model_tester.num_attention_outputs    )
  
  								# check that output_attentions also work using config
  								del inputs_dict["output_attentions"]
  								__lowerCAmelCase      		=       True
  								__lowerCAmelCase      		=       model_class(__SCREAMING_SNAKE_CASE    )
  								model.to(__SCREAMING_SNAKE_CASE    )
  								model.eval()
  								with torch.no_grad():
  											__lowerCAmelCase      		=       model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE,__SCREAMING_SNAKE_CASE    )    )
  								__lowerCAmelCase      		=       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
  								self.assertEqual(len(__SCREAMING_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      _lowerCAmelCase		(		)      ->      List[str]:
  			__lowerCAmelCase      		=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
  			return image
  
  
  
  
  
  
  
  @require_torch
  @require_vision
  class 					_UpperCAmelCase							(		unittest.TestCase     ):
  		@cached_property
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					return (
  					    EfficientFormerImageProcessor.from_pretrained("""snap-research/efficientformer-l1-300"""    )
  					    if is_vision_available()
  					    else None
  					)
  		@slow
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       EfficientFormerForImageClassification.from_pretrained("""snap-research/efficientformer-l1-300"""    ).to(
  					    __SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       self.default_image_processor
  					__lowerCAmelCase      		=       prepare_img()
  					__lowerCAmelCase      		=       image_processor(images=__SCREAMING_SNAKE_CASE,return_tensors="""pt"""    ).to(__SCREAMING_SNAKE_CASE    )
  
  					# forward pass
  					with torch.no_grad():
  								__lowerCAmelCase      		=       model(**__SCREAMING_SNAKE_CASE    )
  
  					# verify the logits
  					__lowerCAmelCase      		=       (1, 10_00)
  					self.assertEqual(outputs.logits.shape,__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       torch.tensor([-0.0555, 0.4825, -0.0852]    ).to(__SCREAMING_SNAKE_CASE    )
  					self.assertTrue(torch.allclose(outputs.logits[0][:3],__SCREAMING_SNAKE_CASE,atol=1e-4    )    )
  
  
  
  
  
  
  
  		@slow
  		def 						lowerCamelCase__    (						self    ):
  
  
  
  					'''simple docstring'''
  
  					__lowerCAmelCase      		=       EfficientFormerForImageClassificationWithTeacher.from_pretrained(
  					    """snap-research/efficientformer-l1-300"""    ).to(__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       self.default_image_processor
  					__lowerCAmelCase      		=       prepare_img()
  					__lowerCAmelCase      		=       image_processor(images=__SCREAMING_SNAKE_CASE,return_tensors="""pt"""    ).to(__SCREAMING_SNAKE_CASE    )
  
  					# forward pass
  					with torch.no_grad():
  								__lowerCAmelCase      		=       model(**__SCREAMING_SNAKE_CASE    )
  
  					# verify the logits
  					__lowerCAmelCase      		=       (1, 10_00)
  					self.assertEqual(outputs.logits.shape,__SCREAMING_SNAKE_CASE    )
  
  					__lowerCAmelCase      		=       torch.tensor([-0.1312, 0.4353, -1.0499]    ).to(__SCREAMING_SNAKE_CASE    )
  					self.assertTrue(torch.allclose(outputs.logits[0][:3],__SCREAMING_SNAKE_CASE,atol=1e-4    )    )
  
  