
import inspect
import unittest
import warnings

from transformers import DeiTConfig
from transformers.models.auto import get_values
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_gpu,
    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 torch import nn

			from transformers import (
			    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
			    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    MODEL_MAPPING,
			    DeiTForImageClassification,
			    DeiTForImageClassificationWithTeacher,
			    DeiTForMaskedImageModeling,
			    DeiTModel,
			)
			from transformers.models.deit.modeling_deit import DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image

			from transformers import DeiTImageProcessor







class 					lowerCamelCase		:





					def __init__(self				:   Tuple    ,   _A				:   List[Any]    ,   _A				:   Tuple=1_3    ,   _A				:   Any=3_0    ,   _A				:   Any=2    ,   _A				:   List[str]=3    ,   _A				:   Any=True    ,   _A				:   Union[str, Any]=True    ,   _A				:   Any=3_2    ,   _A				:   Dict=5    ,   _A				:   Optional[int]=4    ,   _A				:   List[Any]=3_7    ,   _A				:   Any="gelu"    ,   _A				:   Tuple=0.1    ,   _A				:   str=0.1    ,   _A				:   int=1_0    ,   _A				:   str=0.02    ,   _A				:   Tuple=3    ,   _A				:   Tuple=None    ,   _A				:   str=2    ,   )						->						str:
									snake_case								= parent
									snake_case								= batch_size
									snake_case								= image_size
									snake_case								= patch_size
									snake_case								= num_channels
									snake_case								= is_training
									snake_case								= use_labels
									snake_case								= hidden_size
									snake_case								= num_hidden_layers
									snake_case								= num_attention_heads
									snake_case								= intermediate_size
									snake_case								= hidden_act
									snake_case								= hidden_dropout_prob
									snake_case								= attention_probs_dropout_prob
									snake_case								= type_sequence_label_size
									snake_case								= initializer_range
									snake_case								= scope
									snake_case								= encoder_stride

									# in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
									snake_case								= (image_size // patch_size) ** 2
									snake_case								= num_patches + 2





					def 		UpperCAmelCase(self				:   List[str]       )						->						List[Any]:
									snake_case								= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

									snake_case								= None
									if self.use_labels:
													snake_case								= ids_tensor([self.batch_size]    ,   self.type_sequence_label_size       )

									snake_case								= self.get_config()

									return config, pixel_values, labels





					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Optional[int]:
									return DeiTConfig(
									    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=a__    ,   initializer_range=self.initializer_range    ,   encoder_stride=self.encoder_stride    ,   )





					def 		UpperCAmelCase(self				:   List[str]    ,   _A				:   str    ,   _A				:   str    ,   _A				:   int       )						->						Optional[int]:
									snake_case								= DeiTModel(config=a__       )
									model.to(a__       )
									model.eval()
									snake_case								= model(a__       )
									self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)       )





					def 		UpperCAmelCase(self				:   str    ,   _A				:   Union[str, Any]    ,   _A				:   Optional[Any]    ,   _A				:   Union[str, Any]       )						->						List[str]:
									snake_case								= DeiTForMaskedImageModeling(config=a__       )
									model.to(a__       )
									model.eval()
									snake_case								= model(a__       )
									self.parent.assertEqual(
									    result.reconstruction.shape    ,   (self.batch_size, self.num_channels, self.image_size, self.image_size)       )

									# test greyscale images
									snake_case								= 1
									snake_case								= DeiTForMaskedImageModeling(a__       )
									model.to(a__       )
									model.eval()

									snake_case								= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
									snake_case								= model(a__       )
									self.parent.assertEqual(result.reconstruction.shape    ,   (self.batch_size, 1, self.image_size, self.image_size)       )





					def 		UpperCAmelCase(self				:   Dict    ,   _A				:   List[str]    ,   _A				:   str    ,   _A				:   int       )						->						List[str]:
									snake_case								= self.type_sequence_label_size
									snake_case								= DeiTForImageClassification(a__       )
									model.to(a__       )
									model.eval()
									snake_case								= model(a__    ,   labels=a__       )
									self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.type_sequence_label_size)       )

									# test greyscale images
									snake_case								= 1
									snake_case								= DeiTForImageClassification(a__       )
									model.to(a__       )
									model.eval()

									snake_case								= floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
									snake_case								= model(a__    ,   labels=a__       )
									self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.type_sequence_label_size)       )





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







@require_torch
class 					lowerCamelCase		(  __a							,			__a							,			unittest.TestCase  ):
					UpperCAmelCase__    :							Optional[Any]									=		(
					    (
					        DeiTModel,
					        DeiTForImageClassification,
					        DeiTForImageClassificationWithTeacher,
					        DeiTForMaskedImageModeling,
					    )
					    if is_torch_available()
					    else ()
					)
					UpperCAmelCase__    :							Optional[Any]									=		(
					    {
					        """feature-extraction""": DeiTModel,
					        """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
					    }
					    if is_torch_available()
					    else {}
					)

					UpperCAmelCase__    :							Tuple									=		False
					UpperCAmelCase__    :							str									=		False
					UpperCAmelCase__    :							Union[str, Any]									=		False





					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Union[str, Any]:
									snake_case								= DeiTModelTester(self       )
									snake_case								= ConfigTester(self    ,   config_class=a__    ,   has_text_modality=a__    ,   hidden_size=3_7       )





					def 		UpperCAmelCase(self				:   Optional[int]       )						->						Union[str, Any]:
									self.config_tester.run_common_tests()





					@unittest.skip(reason="DeiT does not use inputs_embeds"       )
					def 		UpperCAmelCase(self				:   List[Any]       )						->						Optional[Any]:
									pass





					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Union[str, Any]:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
													snake_case								= model_class(a__       )
													self.assertIsInstance(model.get_input_embeddings()    ,   (nn.Module)       )
													snake_case								= model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(a__    ,   nn.Linear       )       )





					def 		UpperCAmelCase(self				:   Dict       )						->						Dict:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

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

													snake_case								= ["pixel_values"]
													self.assertListEqual(arg_names[:1]    ,   a__       )





					def 		UpperCAmelCase(self				:   Dict       )						->						List[str]:
									snake_case								= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*a__       )





					def 		UpperCAmelCase(self				:   Dict       )						->						Optional[int]:
									snake_case								= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*a__       )





					def 		UpperCAmelCase(self				:   List[Any]       )						->						Tuple:
									snake_case								= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*a__       )





					def 		UpperCAmelCase(self				:   int    ,   _A				:   Tuple    ,   _A				:   Tuple    ,   _A				:   Dict=False       )						->						Union[str, Any]:
									snake_case								= super()._prepare_for_class(a__    ,   a__    ,   return_labels=a__       )

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

									return inputs_dict





					def 		UpperCAmelCase(self				:   Dict       )						->						Any:
									if not self.model_tester.is_training:
													return

									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()
									snake_case								= True

									for model_class in self.all_model_classes:
													# DeiTForImageClassificationWithTeacher supports inference-only
													if (
													    model_class in get_values(a__       )
													    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
													):
																	continue
													snake_case								= model_class(a__       )
													model.to(a__       )
													model.train()
													snake_case								= self._prepare_for_class(a__    ,   a__    ,   return_labels=a__       )
													snake_case								= model(**a__       ).loss
													loss.backward()





					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Optional[int]:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
													return

									snake_case								= False
									snake_case								= True

									for model_class in self.all_model_classes:
													if model_class in get_values(a__       ) or not model_class.supports_gradient_checkpointing:
																	continue
													# DeiTForImageClassificationWithTeacher supports inference-only
													if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																	continue
													snake_case								= model_class(a__       )
													model.gradient_checkpointing_enable()
													model.to(a__       )
													model.train()
													snake_case								= self._prepare_for_class(a__    ,   a__    ,   return_labels=a__       )
													snake_case								= model(**a__       ).loss
													loss.backward()





					def 		UpperCAmelCase(self				:   Any       )						->						List[Any]:
									snake_case					,							snake_case								= self.model_tester.prepare_config_and_inputs_for_common()

									snake_case								= [
									    {"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(a__       ),
													        *get_values(a__       ),
													    ]
													    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
													):
																	continue

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

																					snake_case								= model_class(a__       )
																					model.to(a__       )
																					model.train()

																					snake_case								= self._prepare_for_class(a__    ,   a__    ,   return_labels=a__       )

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

																					snake_case								= 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=a__       ) as warning_list:
																									snake_case								= model(**a__       ).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 		UpperCAmelCase(self				:   Optional[Any]       )						->						Tuple:
									for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													snake_case								= DeiTModel.from_pretrained(a__       )
													self.assertIsNotNone(a__       )



def 						lowercase_      (       )							->							Optional[int]:
				"""simple docstring"""

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







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





					@cached_property
					def 		UpperCAmelCase(self				:   List[Any]       )						->						List[Any]:
									return (
									    DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224"       )
									    if is_vision_available()
									    else None
									)





					@slow
					def 		UpperCAmelCase(self				:   Optional[Any]       )						->						Dict:
									snake_case								= DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"       ).to(
									    a__       )

									snake_case								= self.default_image_processor
									snake_case								= prepare_img()
									snake_case								= image_processor(images=a__    ,   return_tensors="pt"       ).to(a__       )

									# forward pass
									with torch.no_grad():
													snake_case								= model(**a__       )

									# verify the logits
									snake_case								= torch.Size((1, 1_0_0_0)       )
									self.assertEqual(outputs.logits.shape    ,   a__       )

									snake_case								= torch.tensor([-1.02_66, 0.19_12, -1.28_61]       ).to(a__       )

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





					@slow
					@require_accelerate
					@require_torch_gpu
					def 		UpperCAmelCase(self				:   Union[str, Any]       )						->						Optional[Any]:
									snake_case								= DeiTModel.from_pretrained(
									    "facebook/deit-base-distilled-patch16-224"    ,   torch_dtype=torch.floataa    ,   device_map="auto"       )
									snake_case								= self.default_image_processor

									snake_case								= prepare_img()
									snake_case								= image_processor(images=a__    ,   return_tensors="pt"       )
									snake_case								= inputs.pixel_values.to(a__       )

									# forward pass to make sure inference works in fp16
									with torch.no_grad():
													snake_case								= model(a__       )



def 						lowercase_      (       A__ = 1000		)							->							int:
    """simple docstring"""

    return sum(2 * a * ((a - 1) // 2) for a in range(3			,		n + 1		)		)


if __name__ == "__main__":
   print(solution())

