



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       ,     ):
									_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 			=  scope
									_lowerCAmelCase 			=  encoder_stride

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





			def 	__lowerCAmelCase							(	self			):
									_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			):
									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=_lowerCAmelCase       ,     initializer_range=self.initializer_range       ,     encoder_stride=self.encoder_stride       ,     )





			def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
									_lowerCAmelCase 			=  DeiTModel(config=_lowerCAmelCase			)
									model.to(_lowerCAmelCase			)
									model.eval()
									_lowerCAmelCase 			=  model(_lowerCAmelCase			)
									self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)			)





			def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
									_lowerCAmelCase 			=  DeiTForMaskedImageModeling(config=_lowerCAmelCase			)
									model.to(_lowerCAmelCase			)
									model.eval()
									_lowerCAmelCase 			=  model(_lowerCAmelCase			)
									self.parent.assertEqual(
									    result.reconstruction.shape       ,     (self.batch_size, self.num_channels, self.image_size, self.image_size)			)

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

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





			def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase			):
									_lowerCAmelCase 			=  self.type_sequence_label_size
									_lowerCAmelCase 			=  DeiTForImageClassification(_lowerCAmelCase			)
									model.to(_lowerCAmelCase			)
									model.eval()
									_lowerCAmelCase 			=  model(_lowerCAmelCase       ,     labels=_lowerCAmelCase			)
									self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)			)

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

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





			def 	__lowerCAmelCase							(	self			):
									_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						(						snake_case_       ,snake_case_       ,unittest.TestCase				):
			SCREAMING_SNAKE_CASE__							=     (
			    (
			        DeiTModel,
			        DeiTForImageClassification,
			        DeiTForImageClassificationWithTeacher,
			        DeiTForMaskedImageModeling,
			    )
			    if is_torch_available()
			    else ()
			)
			SCREAMING_SNAKE_CASE__							=     (
			    {
			        '''feature-extraction''': DeiTModel,
			        '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
			    }
			    if is_torch_available()
			    else {}
			)

			SCREAMING_SNAKE_CASE__							=     False
			SCREAMING_SNAKE_CASE__							=     False
			SCREAMING_SNAKE_CASE__							=     False





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  DeiTModelTester(self			)
									_lowerCAmelCase 			=  ConfigTester(self       ,     config_class=_lowerCAmelCase       ,     has_text_modality=_lowerCAmelCase       ,     hidden_size=37			)





			def 	__lowerCAmelCase							(	self			):
									self.config_tester.run_common_tests()





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





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

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





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
															_lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
															_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]       ,     _lowerCAmelCase			)





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*_lowerCAmelCase			)





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCAmelCase			)





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase			)





			def 	__lowerCAmelCase							(	self       ,     _lowerCAmelCase       ,     _lowerCAmelCase       ,     _lowerCAmelCase=False			):
									_lowerCAmelCase 			=  super()._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)

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

									return inputs_dict





			def 	__lowerCAmelCase							(	self			):
									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:
															# DeiTForImageClassificationWithTeacher supports inference-only
															if (
															    model_class in get_values(_lowerCAmelCase			)
															    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
															):
																					continue
															_lowerCAmelCase 			=  model_class(_lowerCAmelCase			)
															model.to(_lowerCAmelCase			)
															model.train()
															_lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)
															_lowerCAmelCase 			=  model(**_lowerCAmelCase			).loss
															loss.backward()





			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase			,   _lowerCAmelCase 			=  self.model_tester.prepare_config_and_inputs_for_common()
									if not self.model_tester.is_training:
															return

									_lowerCAmelCase 			=  False
									_lowerCAmelCase 			=  True

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





			def 	__lowerCAmelCase							(	self			):
									_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(_lowerCAmelCase			),
															        *get_values(_lowerCAmelCase			),
															    ]
															    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
															):
																					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(_lowerCAmelCase			)
																											model.to(_lowerCAmelCase			)
																											model.train()

																											_lowerCAmelCase 			=  self._prepare_for_class(_lowerCAmelCase       ,     _lowerCAmelCase       ,     return_labels=_lowerCAmelCase			)

																											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=_lowerCAmelCase			) as warning_list:
																																	_lowerCAmelCase 			=  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 	__lowerCAmelCase							(	self			):
									for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															_lowerCAmelCase 			=  DeiTModel.from_pretrained(_lowerCAmelCase			)
															self.assertIsNotNone(_lowerCAmelCase			)






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





			@slow
			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''			).to(
									    _lowerCAmelCase			)

									_lowerCAmelCase 			=  self.default_image_processor
									_lowerCAmelCase 			=  prepare_img()
									_lowerCAmelCase 			=  image_processor(images=_lowerCAmelCase       ,     return_tensors='''pt'''			).to(_lowerCAmelCase			)

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

									# verify the logits
									_lowerCAmelCase 			=  torch.Size((1, 1_000)			)
									self.assertEqual(outputs.logits.shape       ,     _lowerCAmelCase			)

									_lowerCAmelCase 			=  torch.tensor([-1.0_266, 0.1_912, -1.2_861]			).to(_lowerCAmelCase			)

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





			@slow
			@require_accelerate
			@require_torch_gpu
			def 	__lowerCAmelCase							(	self			):
									_lowerCAmelCase 			=  DeiTModel.from_pretrained(
									    '''facebook/deit-base-distilled-patch16-224'''       ,     torch_dtype=torch.floataa       ,     device_map='''auto'''			)
									_lowerCAmelCase 			=  self.default_image_processor

									_lowerCAmelCase 			=  prepare_img()
									_lowerCAmelCase 			=  image_processor(images=_lowerCAmelCase       ,     return_tensors='''pt'''			)
									_lowerCAmelCase 			=  inputs.pixel_values.to(_lowerCAmelCase			)

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




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCAmelCase_									=							{"configuration_deit": ["DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DeiTConfig", "DeiTOnnxConfig"]}

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCAmelCase_									=							["DeiTFeatureExtractor"]
    UpperCAmelCase_									=							["DeiTImageProcessor"]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCAmelCase_									=							[
        "DEIT_PRETRAINED_MODEL_ARCHIVE_LIST",
        "DeiTForImageClassification",
        "DeiTForImageClassificationWithTeacher",
        "DeiTForMaskedImageModeling",
        "DeiTModel",
        "DeiTPreTrainedModel",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCAmelCase_									=							[
        "TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST",
        "TFDeiTForImageClassification",
        "TFDeiTForImageClassificationWithTeacher",
        "TFDeiTForMaskedImageModeling",
        "TFDeiTModel",
        "TFDeiTPreTrainedModel",
    ]


if TYPE_CHECKING:
    from .configuration_deit import DEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, DeiTConfig, DeiTOnnxConfig

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_deit import DeiTFeatureExtractor
        from .image_processing_deit import DeiTImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_deit import (
            DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
            DeiTForImageClassification,
            DeiTForImageClassificationWithTeacher,
            DeiTForMaskedImageModeling,
            DeiTModel,
            DeiTPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_deit import (
            TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFDeiTForImageClassification,
            TFDeiTForImageClassificationWithTeacher,
            TFDeiTForMaskedImageModeling,
            TFDeiTModel,
            TFDeiTPreTrainedModel,
        )


else:
    import sys

    UpperCAmelCase_									=							_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)