
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 		__UpperCAmelCase   :


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_=13					,     lowerCAmelCase_=30					,     lowerCAmelCase_=2					,     lowerCAmelCase_=3					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_=32					,     lowerCAmelCase_=5					,     lowerCAmelCase_=4					,     lowerCAmelCase_=37					,     lowerCAmelCase_="gelu"					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=10					,     lowerCAmelCase_=0.02					,     lowerCAmelCase_=3					,     lowerCAmelCase_=None					,     lowerCAmelCase_=2					,     ):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 		__UpperCAmelCase   (      __lowercase		,     __lowercase		,     unittest.TestCase		):
							__lowercase   	= (
							    (
							        DeiTModel,
							        DeiTForImageClassification,
							        DeiTForImageClassificationWithTeacher,
							        DeiTForMaskedImageModeling,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase   	= (
							    {
							        """feature-extraction""": DeiTModel,
							        """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
							    }
							    if is_torch_available()
							    else {}
							)

							__lowercase   	= False
							__lowercase   	= False
							__lowercase   	= False


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	DeiTModelTester(self						)
								_snake_case     		=	ConfigTester(self					,     config_class=_A					,     has_text_modality=_A					,     hidden_size=37						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								self.config_tester.run_common_tests()


							@unittest.skip(reason='DeiT does not use inputs_embeds'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_A						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*_A						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_A						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_=False						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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 				lowerCamelCase       ( self						):





								"""simple docstring"""






								for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case     		=	DeiTModel.from_pretrained(_A						)
									self.assertIsNotNone(_A						)







def        SCREAMING_SNAKE_CASE__			(     ) ->			Tuple:
	_snake_case     		=	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 (
								    DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224'						)
								    if is_vision_available()
								    else None
								)


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_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, 10_00)						)
								self.assertEqual(outputs.logits.shape					,     _A						)

								_snake_case     		=	torch.tensor([-1.0266, 0.1912, -1.2861]						).to(_A						)

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




							@slow
							@require_accelerate
							@require_torch_gpu
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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



'''simple docstring'''







from ..utils import DummyObject, requires_backends


class 		__UpperCAmelCase   (      metaclass=_lowerCamelCase		):
							__lowercase   	= ["""torch""", """torchsde"""]


							def __init__( self					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(self					,     ['torch', 'torchsde']						)


							@classmethod
							def 				lowerCamelCase       ( cls					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(cls					,     ['torch', 'torchsde']						)




							@classmethod
							def 				lowerCamelCase       ( cls					,     *lowerCAmelCase_					,     **lowerCAmelCase_						):





								"""simple docstring"""






								requires_backends(cls					,     ['torch', 'torchsde']						)

