





"""simple docstring"""





import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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,
							    LevitForImageClassification,
							    LevitForImageClassificationWithTeacher,
							    LevitModel,
							)
							from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import LevitImageProcessor
class 		SCREAMING_SNAKE_CASE_				(     snake_case__ ):
				"""simple docstring"""




				def        __lowercase	(  self	:Optional[Any]      ):
											__lowerCamelCase   :   Tuple       =self.config_class(**self.inputs_dict      )
											self.parent.assertTrue(hasattr(__lowercase    ,     '''hidden_sizes'''      )      )
											self.parent.assertTrue(hasattr(__lowercase    ,     '''num_attention_heads'''      )      )

class 		SCREAMING_SNAKE_CASE_				:
				"""simple docstring"""




				def __init__(  self	:Union[str, Any]    ,     __lowercase	:str    ,     __lowercase	:Union[str, Any]=13    ,     __lowercase	:Tuple=64    ,     __lowercase	:Tuple=3    ,     __lowercase	:str=3    ,     __lowercase	:Any=2    ,     __lowercase	:Dict=1    ,     __lowercase	:int=16    ,     __lowercase	:str=[128, 256, 384]    ,     __lowercase	:List[str]=[4, 6, 8]    ,     __lowercase	:Any=[2, 3, 4]    ,     __lowercase	:str=[16, 16, 16]    ,     __lowercase	:str=0    ,     __lowercase	:Any=[2, 2, 2]    ,     __lowercase	:int=[2, 2, 2]    ,     __lowercase	:Dict=0.02    ,     __lowercase	:Any=True    ,     __lowercase	:Union[str, Any]=True    ,     __lowercase	:Optional[int]=2    ,     ):
											__lowerCamelCase   :   Optional[int]       =parent
											__lowerCamelCase   :   Dict       =batch_size
											__lowerCamelCase   :   Dict       =image_size
											__lowerCamelCase   :   Tuple       =num_channels
											__lowerCamelCase   :   Optional[Any]       =kernel_size
											__lowerCamelCase   :   Any       =stride
											__lowerCamelCase   :   Dict       =padding
											__lowerCamelCase   :   Optional[int]       =hidden_sizes
											__lowerCamelCase   :   Optional[Any]       =num_attention_heads
											__lowerCamelCase   :   Dict       =depths
											__lowerCamelCase   :   List[str]       =key_dim
											__lowerCamelCase   :   List[Any]       =drop_path_rate
											__lowerCamelCase   :   Optional[Any]       =patch_size
											__lowerCamelCase   :   List[str]       =attention_ratio
											__lowerCamelCase   :   Optional[int]       =mlp_ratio
											__lowerCamelCase   :   Union[str, Any]       =initializer_range
											__lowerCamelCase   :   Optional[Any]       =[
											    ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
											    ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
											]
											__lowerCamelCase   :   int       =is_training
											__lowerCamelCase   :   Any       =use_labels
											__lowerCamelCase   :   Optional[Any]       =num_labels
											__lowerCamelCase   :   List[Any]       =initializer_range




				def        __lowercase	(  self	:List[Any]      ):
											__lowerCamelCase   :   Optional[Any]       =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

											__lowerCamelCase   :   Optional[int]       =None
											if self.use_labels:
																		__lowerCamelCase   :   Optional[int]       =ids_tensor([self.batch_size]    ,     self.num_labels      )

											__lowerCamelCase   :   str       =self.get_config()
											return config, pixel_values, labels




				def        __lowercase	(  self	:Optional[Any]      ):
											return LevitConfig(
											    image_size=self.image_size    ,     num_channels=self.num_channels    ,     kernel_size=self.kernel_size    ,     stride=self.stride    ,     padding=self.padding    ,     patch_size=self.patch_size    ,     hidden_sizes=self.hidden_sizes    ,     num_attention_heads=self.num_attention_heads    ,     depths=self.depths    ,     key_dim=self.key_dim    ,     drop_path_rate=self.drop_path_rate    ,     mlp_ratio=self.mlp_ratio    ,     attention_ratio=self.attention_ratio    ,     initializer_range=self.initializer_range    ,     down_ops=self.down_ops    ,     )




				def        __lowercase	(  self	:Any    ,     __lowercase	:List[Any]    ,     __lowercase	:List[Any]    ,     __lowercase	:Dict      ):
											__lowerCamelCase   :   str       =LevitModel(config=__lowercase      )
											model.to(__lowercase      )
											model.eval()
											__lowerCamelCase   :   Tuple       =model(__lowercase      )
											__lowerCamelCase   :   Tuple       =(self.image_size, self.image_size)
											__lowerCamelCase     ,    __lowerCamelCase   :   Union[str, Any]       =image_size[0], image_size[1]
											for _ in range(4      ):
																		__lowerCamelCase   :   Tuple       =floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1      )
																		__lowerCamelCase   :   Union[str, Any]       =floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1      )
											self.parent.assertEqual(
											    result.last_hidden_state.shape    ,     (self.batch_size, ceil(height / 4      ) * ceil(width / 4      ), self.hidden_sizes[-1])    ,     )




				def        __lowercase	(  self	:int    ,     __lowercase	:Optional[Any]    ,     __lowercase	:Optional[Any]    ,     __lowercase	:Any      ):
											__lowerCamelCase   :   str       =self.num_labels
											__lowerCamelCase   :   Dict       =LevitForImageClassification(__lowercase      )
											model.to(__lowercase      )
											model.eval()
											__lowerCamelCase   :   int       =model(__lowercase    ,     labels=__lowercase      )
											self.parent.assertEqual(result.logits.shape    ,     (self.batch_size, self.num_labels)      )




				def        __lowercase	(  self	:str      ):
											__lowerCamelCase   :   Optional[int]       =self.prepare_config_and_inputs()
											__lowerCamelCase     ,    __lowerCamelCase     ,    __lowerCamelCase   :   List[str]       =config_and_inputs
											__lowerCamelCase   :   str       ={'''pixel_values''': pixel_values}
											return config, inputs_dict

@require_torch
class 		SCREAMING_SNAKE_CASE_				(     snake_case__							,	snake_case__							,	unittest.TestCase ):
				"""simple docstring"""
				__snake_case :							Union[str, Any]									=		(
				    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
				    if is_torch_available()
				    else ()
				)
				__snake_case :							Optional[Any]									=		(
				    {
				        """feature-extraction""": LevitModel,
				        """image-classification""": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				__snake_case :							Dict									=		False
				__snake_case :							List[Any]									=		False
				__snake_case :							List[str]									=		False
				__snake_case :							List[Any]									=		False
				__snake_case :							List[Any]									=		False




				def        __lowercase	(  self	:Tuple      ):
											__lowerCamelCase   :   int       =LevitModelTester(self      )
											__lowerCamelCase   :   Tuple       =ConfigTester(self    ,     config_class=__lowercase    ,     has_text_modality=__lowercase    ,     hidden_size=37      )




				def        __lowercase	(  self	:Union[str, Any]      ):
											self.create_and_test_config_common_properties()
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()




				def        __lowercase	(  self	:int      ):
											return




				@unittest.skip(reason='''Levit does not use inputs_embeds'''      )
				def        __lowercase	(  self	:Any      ):
											pass




				@unittest.skip(reason='''Levit does not support input and output embeddings'''      )
				def        __lowercase	(  self	:Optional[int]      ):
											pass




				@unittest.skip(reason='''Levit does not output attentions'''      )
				def        __lowercase	(  self	:List[str]      ):
											pass




				def        __lowercase	(  self	:Tuple      ):
											__lowerCamelCase     ,    __lowerCamelCase   :   str       =self.model_tester.prepare_config_and_inputs_for_common()

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

																		__lowerCamelCase   :   str       =['''pixel_values''']
																		self.assertListEqual(arg_names[:1]    ,     __lowercase      )




				def        __lowercase	(  self	:Tuple      ):
											def check_hidden_states_output(__lowercase	:Union[str, Any]    ,     __lowercase	:List[Any]    ,     __lowercase	:Tuple      ):
																		__lowerCamelCase   :   Tuple       =model_class(__lowercase      )
																		model.to(__lowercase      )
																		model.eval()

																		with torch.no_grad():
																									__lowerCamelCase   :   Tuple       =model(**self._prepare_for_class(__lowercase    ,     __lowercase      )      )

																		__lowerCamelCase   :   Any       =outputs.hidden_states

																		__lowerCamelCase   :   Dict       =len(self.model_tester.depths      ) + 1
																		self.assertEqual(len(__lowercase      )    ,     __lowercase      )

																		__lowerCamelCase   :   List[Any]       =(self.model_tester.image_size, self.model_tester.image_size)
																		__lowerCamelCase     ,    __lowerCamelCase   :   Dict       =image_size[0], image_size[1]
																		for _ in range(4      ):
																									__lowerCamelCase   :   Union[str, Any]       =floor(
																									    (
																									        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																									        / self.model_tester.stride
																									    )
																									    + 1      )
																									__lowerCamelCase   :   Union[str, Any]       =floor(
																									    (
																									        (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
																									        / self.model_tester.stride
																									    )
																									    + 1      )
																		# verify the first hidden states (first block)
																		self.assertListEqual(
																		    list(hidden_states[0].shape[-2:]      )    ,     [
																		        height * width,
																		        self.model_tester.hidden_sizes[0],
																		    ]    ,     )

											__lowerCamelCase     ,    __lowerCamelCase   :   Any       =self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		__lowerCamelCase   :   Optional[int]       =True
																		check_hidden_states_output(__lowercase    ,     __lowercase    ,     __lowercase      )

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		__lowerCamelCase   :   int       =True

																		check_hidden_states_output(__lowercase    ,     __lowercase    ,     __lowercase      )




				@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
				def        __lowercase	(  self	:Dict      ):
											pass




				def        __lowercase	(  self	:List[str]    ,     __lowercase	:Dict    ,     __lowercase	:str    ,     __lowercase	:List[str]=False      ):
											__lowerCamelCase   :   str       =super()._prepare_for_class(__lowercase    ,     __lowercase    ,     return_labels=__lowercase      )

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

											return inputs_dict




				def        __lowercase	(  self	:Union[str, Any]      ):
											__lowerCamelCase   :   Any       =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowercase      )




				def        __lowercase	(  self	:Tuple      ):
											__lowerCamelCase   :   List[Any]       =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__lowercase      )




				def        __lowercase	(  self	:Tuple      ):
											if not self.model_tester.is_training:
																		return

											__lowerCamelCase     ,    __lowerCamelCase   :   List[str]       =self.model_tester.prepare_config_and_inputs_for_common()
											__lowerCamelCase   :   str       =True

											for model_class in self.all_model_classes:
																		# LevitForImageClassificationWithTeacher supports inference-only
																		if (
																		    model_class in get_values(__lowercase      )
																		    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																		):
																									continue
																		__lowerCamelCase   :   List[Any]       =model_class(__lowercase      )
																		model.to(__lowercase      )
																		model.train()
																		__lowerCamelCase   :   List[Any]       =self._prepare_for_class(__lowercase    ,     __lowercase    ,     return_labels=__lowercase      )
																		__lowerCamelCase   :   Tuple       =model(**__lowercase      ).loss
																		loss.backward()




				def        __lowercase	(  self	:Optional[Any]      ):
											__lowerCamelCase     ,    __lowerCamelCase   :   Tuple       =self.model_tester.prepare_config_and_inputs_for_common()
											if not self.model_tester.is_training:
																		return

											__lowerCamelCase   :   Optional[Any]       =False
											__lowerCamelCase   :   Optional[int]       =True

											for model_class in self.all_model_classes:
																		if model_class in get_values(__lowercase      ) or not model_class.supports_gradient_checkpointing:
																									continue
																		# LevitForImageClassificationWithTeacher supports inference-only
																		if model_class.__name__ == "LevitForImageClassificationWithTeacher":
																									continue
																		__lowerCamelCase   :   str       =model_class(__lowercase      )
																		model.gradient_checkpointing_enable()
																		model.to(__lowercase      )
																		model.train()
																		__lowerCamelCase   :   int       =self._prepare_for_class(__lowercase    ,     __lowercase    ,     return_labels=__lowercase      )
																		__lowerCamelCase   :   List[Any]       =model(**__lowercase      ).loss
																		loss.backward()




				def        __lowercase	(  self	:List[Any]      ):
											__lowerCamelCase     ,    __lowerCamelCase   :   Optional[Any]       =self.model_tester.prepare_config_and_inputs_for_common()

											__lowerCamelCase   :   Tuple       =[
											    {'''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(__lowercase      ),
																		    ]
																		    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
																		):
																									continue

																		for problem_type in problem_types:
																									with self.subTest(msg=f'Testing {model_class} with {problem_type["title"]}'      ):
																																__lowerCamelCase   :   List[Any]       =problem_type['''title''']
																																__lowerCamelCase   :   List[str]       =problem_type['''num_labels''']

																																__lowerCamelCase   :   Union[str, Any]       =model_class(__lowercase      )
																																model.to(__lowercase      )
																																model.train()

																																__lowerCamelCase   :   Optional[Any]       =self._prepare_for_class(__lowercase    ,     __lowercase    ,     return_labels=__lowercase      )

																																if problem_type["num_labels"] > 1:
																																							__lowerCamelCase   :   Dict       =inputs['''labels'''].unsqueeze(1      ).repeat(1    ,     problem_type['''num_labels''']      )

																																__lowerCamelCase   :   Dict       =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=__lowercase      ) as warning_list:
																																							__lowerCamelCase   :   Dict       =model(**__lowercase      ).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        __lowercase	(  self	:Optional[int]      ):
											for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		__lowerCamelCase   :   List[str]       =LevitModel.from_pretrained(__lowercase      )
																		self.assertIsNotNone(__lowercase      )



def 					lowerCAmelCase_      (   ):


							'''simple docstring'''







							__lowerCamelCase   :   List[Any]       =Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
							return image
@require_torch
@require_vision
class 		SCREAMING_SNAKE_CASE_				(     unittest.TestCase ):
				"""simple docstring"""




				@cached_property
				def        __lowercase	(  self	:str      ):
											return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )




				@slow
				def        __lowercase	(  self	:Optional[int]      ):
											__lowerCamelCase   :   Tuple       =LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(
											    __lowercase      )

											__lowerCamelCase   :   Tuple       =self.default_image_processor
											__lowerCamelCase   :   Dict       =prepare_img()
											__lowerCamelCase   :   List[str]       =image_processor(images=__lowercase    ,     return_tensors='''pt'''      ).to(__lowercase      )

											# forward pass
											with torch.no_grad():
																		__lowerCamelCase   :   List[Any]       =model(**__lowercase      )

											# verify the logits
											__lowerCamelCase   :   List[str]       =torch.Size((1, 1000)      )
											self.assertEqual(outputs.logits.shape    ,     __lowercase      )

											__lowerCamelCase   :   Dict       =torch.tensor([1.0448, -0.3745, -1.8317]      ).to(__lowercase      )

											self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,     __lowercase    ,     atol=1e-4      )      )











"""simple docstring"""





import numpy as np



def 					lowerCAmelCase_      (   SCREAMING_SNAKE_CASE							:				np.array ):


							'''simple docstring'''







							return 1 / (1 + np.exp(-vector ))


if __name__ == "__main__":
							import doctest

							doctest.testmod()




