






"""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      UpperCamelCase_			(__A	):





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     str:
				UpperCAmelCase_	:					Dict     	=   self.config_class(**self.inputs_dict		)
				self.parent.assertTrue(hasattr(lowerCAmelCase_      ,      "hidden_sizes"		)		)
				self.parent.assertTrue(hasattr(lowerCAmelCase_      ,      "num_attention_heads"		)		)







class      UpperCamelCase_			:





	def __init__( self   :					List[Any]      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					List[Any]=13      ,      lowerCAmelCase_   :					Tuple=64      ,      lowerCAmelCase_   :					str=3      ,      lowerCAmelCase_   :					Optional[int]=3      ,      lowerCAmelCase_   :					List[str]=2      ,      lowerCAmelCase_   :					Optional[Any]=1      ,      lowerCAmelCase_   :					Optional[int]=16      ,      lowerCAmelCase_   :					Any=[128, 256, 384]      ,      lowerCAmelCase_   :					int=[4, 6, 8]      ,      lowerCAmelCase_   :					Optional[int]=[2, 3, 4]      ,      lowerCAmelCase_   :					List[Any]=[16, 16, 16]      ,      lowerCAmelCase_   :					List[str]=0      ,      lowerCAmelCase_   :					int=[2, 2, 2]      ,      lowerCAmelCase_   :					List[Any]=[2, 2, 2]      ,      lowerCAmelCase_   :					str=0.0_2      ,      lowerCAmelCase_   :					Optional[Any]=True      ,      lowerCAmelCase_   :					List[Any]=True      ,      lowerCAmelCase_   :					int=2      ,      )		->     Any:
				UpperCAmelCase_	:					str     	=   parent
				UpperCAmelCase_	:					str     	=   batch_size
				UpperCAmelCase_	:					Tuple     	=   image_size
				UpperCAmelCase_	:					Dict     	=   num_channels
				UpperCAmelCase_	:					List[Any]     	=   kernel_size
				UpperCAmelCase_	:					List[Any]     	=   stride
				UpperCAmelCase_	:					Optional[int]     	=   padding
				UpperCAmelCase_	:					Dict     	=   hidden_sizes
				UpperCAmelCase_	:					List[Any]     	=   num_attention_heads
				UpperCAmelCase_	:					Optional[int]     	=   depths
				UpperCAmelCase_	:					Union[str, Any]     	=   key_dim
				UpperCAmelCase_	:					Any     	=   drop_path_rate
				UpperCAmelCase_	:					List[str]     	=   patch_size
				UpperCAmelCase_	:					str     	=   attention_ratio
				UpperCAmelCase_	:					str     	=   mlp_ratio
				UpperCAmelCase_	:					List[Any]     	=   initializer_range
				UpperCAmelCase_	:					Union[str, 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],
				]
				UpperCAmelCase_	:					List[Any]     	=   is_training
				UpperCAmelCase_	:					Optional[Any]     	=   use_labels
				UpperCAmelCase_	:					Dict     	=   num_labels
				UpperCAmelCase_	:					Any     	=   initializer_range





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Tuple:
				UpperCAmelCase_	:					Optional[Any]     	=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

				UpperCAmelCase_	:					List[str]     	=   None
				if self.use_labels:
							UpperCAmelCase_	:					Dict     	=   ids_tensor([self.batch_size]      ,      self.num_labels		)

				UpperCAmelCase_	:					Optional[Any]     	=   self.get_config()
				return config, pixel_values, labels





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     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 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]      ,      lowerCAmelCase_   :					int      ,      lowerCAmelCase_   :					List[str]      ,      lowerCAmelCase_   :					Optional[Any]		)		->     Optional[int]:
				UpperCAmelCase_	:					Any     	=   LevitModel(config=lowerCAmelCase_		)
				model.to(lowerCAmelCase_		)
				model.eval()
				UpperCAmelCase_	:					Any     	=   model(lowerCAmelCase_		)
				UpperCAmelCase_	:					Dict     	=   (self.image_size, self.image_size)
				UpperCAmelCase_	,      UpperCAmelCase_	:					Tuple     	=   image_size[0], image_size[1]
				for _ in range(4		):
							UpperCAmelCase_	:					List[str]     	=   floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1		)
							UpperCAmelCase_	:					Dict     	=   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 	_SCREAMING_SNAKE_CASE ( self   :					Optional[int]      ,      lowerCAmelCase_   :					Union[str, Any]      ,      lowerCAmelCase_   :					List[Any]      ,      lowerCAmelCase_   :					int		)		->     Optional[Any]:
				UpperCAmelCase_	:					Optional[int]     	=   self.num_labels
				UpperCAmelCase_	:					Optional[Any]     	=   LevitForImageClassification(lowerCAmelCase_		)
				model.to(lowerCAmelCase_		)
				model.eval()
				UpperCAmelCase_	:					Dict     	=   model(lowerCAmelCase_      ,      labels=lowerCAmelCase_		)
				self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.num_labels)		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     List[Any]:
				UpperCAmelCase_	:					str     	=   self.prepare_config_and_inputs()
				UpperCAmelCase_	,      UpperCAmelCase_	,      UpperCAmelCase_	:					int     	=   config_and_inputs
				UpperCAmelCase_	:					Optional[Any]     	=   {"pixel_values": pixel_values}
				return config, inputs_dict







@require_torch
class      UpperCamelCase_			(__A							,		__A							,		unittest.TestCase	):
	__magic_name__       =							(
	    (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
	    if is_torch_available()
	    else ()
	)
	__magic_name__       =							(
	    {
	        '''feature-extraction''': LevitModel,
	        '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
	    }
	    if is_torch_available()
	    else {}
	)

	__magic_name__       =							False
	__magic_name__       =							False
	__magic_name__       =							False
	__magic_name__       =							False
	__magic_name__       =							False





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     List[Any]:
				UpperCAmelCase_	:					str     	=   LevitModelTester(self		)
				UpperCAmelCase_	:					Any     	=   ConfigTester(self      ,      config_class=lowerCAmelCase_      ,      has_text_modality=lowerCAmelCase_      ,      hidden_size=37		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]		)		->     Optional[int]:
				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 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     Tuple:
				return





	@unittest.skip(reason="Levit does not use inputs_embeds"		)
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     str:
				pass





	@unittest.skip(reason="Levit does not support input and output embeddings"		)
	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     Optional[int]:
				pass





	@unittest.skip(reason="Levit does not output attentions"		)
	def 	_SCREAMING_SNAKE_CASE ( self   :					Dict		)		->     Dict:
				pass





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[str]		)		->     Optional[int]:
				UpperCAmelCase_	,      UpperCAmelCase_	:					Any     	=   self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase_	:					Any     	=   model_class(lowerCAmelCase_		)
							UpperCAmelCase_	:					Any     	=   inspect.signature(model.forward		)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							UpperCAmelCase_	:					int     	=   [*signature.parameters.keys()]

							UpperCAmelCase_	:					Any     	=   ["pixel_values"]
							self.assertListEqual(arg_names[:1]      ,      lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Tuple:
				def check_hidden_states_output(lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					Optional[int]      ,      lowerCAmelCase_   :					List[str]		):
							UpperCAmelCase_	:					Dict     	=   model_class(lowerCAmelCase_		)
							model.to(lowerCAmelCase_		)
							model.eval()

							with torch.no_grad():
										UpperCAmelCase_	:					Any     	=   model(**self._prepare_for_class(lowerCAmelCase_      ,      lowerCAmelCase_		)		)

							UpperCAmelCase_	:					str     	=   outputs.hidden_states

							UpperCAmelCase_	:					List[str]     	=   len(self.model_tester.depths		) + 1
							self.assertEqual(len(lowerCAmelCase_		)      ,      lowerCAmelCase_		)

							UpperCAmelCase_	:					Dict     	=   (self.model_tester.image_size, self.model_tester.image_size)
							UpperCAmelCase_	,      UpperCAmelCase_	:					List[str]     	=   image_size[0], image_size[1]
							for _ in range(4		):
										UpperCAmelCase_	:					Dict     	=   floor(
										    (
										        (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
										        / self.model_tester.stride
										    )
										    + 1		)
										UpperCAmelCase_	:					List[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],
							    ]      ,      )

				UpperCAmelCase_	,      UpperCAmelCase_	:					str     	=   self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							UpperCAmelCase_	:					List[str]     	=   True
							check_hidden_states_output(lowerCAmelCase_      ,      lowerCAmelCase_      ,      lowerCAmelCase_		)

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

							check_hidden_states_output(lowerCAmelCase_      ,      lowerCAmelCase_      ,      lowerCAmelCase_		)





	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
	def 	_SCREAMING_SNAKE_CASE ( self   :					Union[str, Any]		)		->     List[str]:
				pass





	def 	_SCREAMING_SNAKE_CASE ( self   :					Optional[Any]      ,      lowerCAmelCase_   :					Tuple      ,      lowerCAmelCase_   :					Union[str, Any]      ,      lowerCAmelCase_   :					Dict=False		)		->     Optional[Any]:
				UpperCAmelCase_	:					List[Any]     	=   super()._prepare_for_class(lowerCAmelCase_      ,      lowerCAmelCase_      ,      return_labels=lowerCAmelCase_		)

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

				return inputs_dict





	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Any:
				UpperCAmelCase_	:					Optional[int]     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Optional[Any]:
				UpperCAmelCase_	:					str     	=   self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_		)





	def 	_SCREAMING_SNAKE_CASE ( self   :					List[Any]		)		->     Dict:
				if not self.model_tester.is_training:
							return

				UpperCAmelCase_	,      UpperCAmelCase_	:					List[str]     	=   self.model_tester.prepare_config_and_inputs_for_common()
				UpperCAmelCase_	:					Optional[Any]     	=   True

				for model_class in self.all_model_classes:
							# LevitForImageClassificationWithTeacher supports inference-only
							if (
							    model_class in get_values(lowerCAmelCase_		)
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue
							UpperCAmelCase_	:					int     	=   model_class(lowerCAmelCase_		)
							model.to(lowerCAmelCase_		)
							model.train()
							UpperCAmelCase_	:					Dict     	=   self._prepare_for_class(lowerCAmelCase_      ,      lowerCAmelCase_      ,      return_labels=lowerCAmelCase_		)
							UpperCAmelCase_	:					Any     	=   model(**lowerCAmelCase_		).loss
							loss.backward()





	def 	_SCREAMING_SNAKE_CASE ( self   :					int		)		->     List[Any]:
				UpperCAmelCase_	,      UpperCAmelCase_	:					Tuple     	=   self.model_tester.prepare_config_and_inputs_for_common()
				if not self.model_tester.is_training:
							return

				UpperCAmelCase_	:					Tuple     	=   False
				UpperCAmelCase_	:					Tuple     	=   True

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





	def 	_SCREAMING_SNAKE_CASE ( self   :					Tuple		)		->     Any:
				UpperCAmelCase_	,      UpperCAmelCase_	:					Union[str, Any]     	=   self.model_tester.prepare_config_and_inputs_for_common()

				UpperCAmelCase_	:					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(lowerCAmelCase_		),
							    ]
							    or model_class.__name__ == "LevitForImageClassificationWithTeacher"
							):
										continue

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

													UpperCAmelCase_	:					Dict     	=   model_class(lowerCAmelCase_		)
													model.to(lowerCAmelCase_		)
													model.train()

													UpperCAmelCase_	:					int     	=   self._prepare_for_class(lowerCAmelCase_      ,      lowerCAmelCase_      ,      return_labels=lowerCAmelCase_		)

													if problem_type["num_labels"] > 1:
																UpperCAmelCase_	:					Optional[Any]     	=   inputs["labels"].unsqueeze(1		).repeat(1      ,      problem_type["num_labels"]		)

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





def 							snake_case (  ):
			UpperCAmelCase_	:					Dict     	=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
			return image







@require_torch
@require_vision
class      UpperCamelCase_			(unittest.TestCase	):





	@cached_property
	def 	_SCREAMING_SNAKE_CASE ( self   :					Any		)		->     Optional[Any]:
				return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		)





	@slow
	def 	_SCREAMING_SNAKE_CASE ( self   :					str		)		->     str:
				UpperCAmelCase_	:					Optional[Any]     	=   LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]		).to(
				    lowerCAmelCase_		)

				UpperCAmelCase_	:					Any     	=   self.default_image_processor
				UpperCAmelCase_	:					Dict     	=   prepare_img()
				UpperCAmelCase_	:					int     	=   image_processor(images=lowerCAmelCase_      ,      return_tensors="pt"		).to(lowerCAmelCase_		)

				# forward pass
				with torch.no_grad():
							UpperCAmelCase_	:					Union[str, Any]     	=   model(**lowerCAmelCase_		)

				# verify the logits
				UpperCAmelCase_	:					Dict     	=   torch.Size((1, 1_000)		)
				self.assertEqual(outputs.logits.shape      ,      lowerCAmelCase_		)

				UpperCAmelCase_	:					Dict     	=   torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]		).to(lowerCAmelCase_		)

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







'''simple docstring'''
from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels