





'''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()








'''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    )    )

