


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							:		Dict       ,       __magic_name__							:		Optional[int]       ,       __magic_name__							:		Tuple=1_3       ,       __magic_name__							:		List[str]=3_0       ,       __magic_name__							:		Union[str, Any]=2       ,       __magic_name__							:		Optional[int]=3       ,       __magic_name__							:		Dict=True       ,       __magic_name__							:		Optional[int]=True       ,       __magic_name__							:		Tuple=3_2       ,       __magic_name__							:		List[Any]=5       ,       __magic_name__							:		Any=4       ,       __magic_name__							:		Tuple=3_7       ,       __magic_name__							:		List[str]="gelu"       ,       __magic_name__							:		Dict=0.1       ,       __magic_name__							:		str=0.1       ,       __magic_name__							:		Optional[Any]=1_0       ,       __magic_name__							:		Union[str, Any]=0.02       ,       __magic_name__							:		Tuple=3       ,       __magic_name__							:		str=None       ,       __magic_name__							:		Any=2       ,       ):







						"""simple docstring"""







						UpperCamelCase         =					parent
						UpperCamelCase         =					batch_size
						UpperCamelCase         =					image_size
						UpperCamelCase         =					patch_size
						UpperCamelCase         =					num_channels
						UpperCamelCase         =					is_training
						UpperCamelCase         =					use_labels
						UpperCamelCase         =					hidden_size
						UpperCamelCase         =					num_hidden_layers
						UpperCamelCase         =					num_attention_heads
						UpperCamelCase         =					intermediate_size
						UpperCamelCase         =					hidden_act
						UpperCamelCase         =					hidden_dropout_prob
						UpperCamelCase         =					attention_probs_dropout_prob
						UpperCamelCase         =					type_sequence_label_size
						UpperCamelCase         =					initializer_range
						UpperCamelCase         =					scope
						UpperCamelCase         =					encoder_stride

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




			def   lowerCamelCase_					(						self							:		str						):







						"""simple docstring"""







						UpperCamelCase         =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

						UpperCamelCase         =					self.get_config()

						return config, pixel_values, labels




			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""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=lowerCamelCase_       ,       initializer_range=self.initializer_range       ,       encoder_stride=self.encoder_stride       ,       )




			def   lowerCamelCase_					(						self							:		Optional[Any]       ,       __magic_name__							:		Dict       ,       __magic_name__							:		Optional[Any]       ,       __magic_name__							:		int						):







						"""simple docstring"""







						UpperCamelCase         =					DeiTModel(config=lowerCamelCase_						)
						model.to(lowerCamelCase_						)
						model.eval()
						UpperCamelCase         =					model(lowerCamelCase_						)
						self.parent.assertEqual(result.last_hidden_state.shape       ,       (self.batch_size, self.seq_length, self.hidden_size)						)




			def   lowerCamelCase_					(						self							:		Tuple       ,       __magic_name__							:		Dict       ,       __magic_name__							:		List[Any]       ,       __magic_name__							:		Optional[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					DeiTForMaskedImageModeling(config=lowerCamelCase_						)
						model.to(lowerCamelCase_						)
						model.eval()
						UpperCamelCase         =					model(lowerCamelCase_						)
						self.parent.assertEqual(
						    result.reconstruction.shape       ,       (self.batch_size, self.num_channels, self.image_size, self.image_size)						)

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

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




			def   lowerCamelCase_					(						self							:		Any       ,       __magic_name__							:		List[Any]       ,       __magic_name__							:		Tuple       ,       __magic_name__							:		str						):







						"""simple docstring"""







						UpperCamelCase         =					self.type_sequence_label_size
						UpperCamelCase         =					DeiTForImageClassification(lowerCamelCase_						)
						model.to(lowerCamelCase_						)
						model.eval()
						UpperCamelCase         =					model(lowerCamelCase_       ,       labels=lowerCamelCase_						)
						self.parent.assertEqual(result.logits.shape       ,       (self.batch_size, self.type_sequence_label_size)						)

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

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





			def   lowerCamelCase_					(						self							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					self.prepare_config_and_inputs()
						(
						    UpperCamelCase					
						)         =					config_and_inputs
						UpperCamelCase         =					{'''pixel_values''': pixel_values}
						return config, inputs_dict




@require_torch
class    UpperCAmelCase					(       _UpperCAmelCase      , _UpperCAmelCase      , 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							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					DeiTModelTester(self						)
						UpperCamelCase         =					ConfigTester(self       ,       config_class=lowerCamelCase_       ,       has_text_modality=lowerCamelCase_       ,       hidden_size=3_7						)




			def   lowerCamelCase_					(						self							:		Dict						):







						"""simple docstring"""







						self.config_tester.run_common_tests()




			@unittest.skip(reason="""DeiT does not use inputs_embeds"""						)
			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						pass




			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()

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




			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()

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

									UpperCamelCase         =					['''pixel_values''']
									self.assertListEqual(arg_names[:1]       ,       lowerCamelCase_						)




			def   lowerCamelCase_					(						self							:		Any						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCamelCase_						)




			def   lowerCamelCase_					(						self							:		List[Any]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*lowerCamelCase_						)




			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowerCamelCase_						)




			def   lowerCamelCase_					(						self							:		int       ,       __magic_name__							:		List[str]       ,       __magic_name__							:		Optional[Any]       ,       __magic_name__							:		Optional[int]=False						):







						"""simple docstring"""







						UpperCamelCase         =					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							:		List[Any]						):







						"""simple docstring"""







						if not self.model_tester.is_training:
									return

						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						UpperCamelCase         =					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
									UpperCamelCase         =					model_class(lowerCamelCase_						)
									model.to(lowerCamelCase_						)
									model.train()
									UpperCamelCase         =					self._prepare_for_class(lowerCamelCase_       ,       lowerCamelCase_       ,       return_labels=lowerCamelCase_						)
									UpperCamelCase         =					model(**lowerCamelCase_						).loss
									loss.backward()




			def   lowerCamelCase_					(						self							:		Optional[int]						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()
						if not self.model_tester.is_training:
									return

						UpperCamelCase         =					False
						UpperCamelCase         =					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
									UpperCamelCase         =					model_class(lowerCamelCase_						)
									model.gradient_checkpointing_enable()
									model.to(lowerCamelCase_						)
									model.train()
									UpperCamelCase         =					self._prepare_for_class(lowerCamelCase_       ,       lowerCamelCase_       ,       return_labels=lowerCamelCase_						)
									UpperCamelCase         =					model(**lowerCamelCase_						).loss
									loss.backward()




			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.model_tester.prepare_config_and_inputs_for_common()

						UpperCamelCase         =					[
						    {'''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"]}'						):
															UpperCamelCase         =					problem_type['''title''']
															UpperCamelCase         =					problem_type['''num_labels''']

															UpperCamelCase         =					model_class(lowerCamelCase_						)
															model.to(lowerCamelCase_						)
															model.train()

															UpperCamelCase         =					self._prepare_for_class(lowerCamelCase_       ,       lowerCamelCase_       ,       return_labels=lowerCamelCase_						)

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

															UpperCamelCase         =					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         =					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							:		Optional[int]						):







						"""simple docstring"""







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






def 							_lowercase    (		):





			"""simple docstring"""




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




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




			@cached_property
			def   lowerCamelCase_					(						self							:		int						):







						"""simple docstring"""







						return (
						    DeiTImageProcessor.from_pretrained("""facebook/deit-base-distilled-patch16-224"""						)
						    if is_vision_available()
						    else None
						)




			@slow
			def   lowerCamelCase_					(						self							:		int						):







						"""simple docstring"""







						UpperCamelCase         =					DeiTForImageClassificationWithTeacher.from_pretrained("""facebook/deit-base-distilled-patch16-224"""						).to(
						    lowerCamelCase_						)

						UpperCamelCase         =					self.default_image_processor
						UpperCamelCase         =					prepare_img()
						UpperCamelCase         =					image_processor(images=lowerCamelCase_       ,       return_tensors="""pt"""						).to(lowerCamelCase_						)

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

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

						UpperCamelCase         =					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							:		List[str]						):







						"""simple docstring"""







						UpperCamelCase         =					DeiTModel.from_pretrained(
						    """facebook/deit-base-distilled-patch16-224"""       ,       torch_dtype=torch.floataa       ,       device_map="""auto"""						)
						UpperCamelCase         =					self.default_image_processor

						UpperCamelCase         =					prepare_img()
						UpperCamelCase         =					image_processor(images=lowerCamelCase_       ,       return_tensors="""pt"""						)
						UpperCamelCase         =					inputs.pixel_values.to(lowerCamelCase_						)

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








import warnings
from typing import List, Optional, Union

from ...image_utils import ImageInput
from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType




class    UpperCAmelCase					(       __snake_case    ):
			lowercase						= ["""image_processor""", """tokenizer"""]
			lowercase						= """FlavaImageProcessor"""
			lowercase						= ("""BertTokenizer""", """BertTokenizerFast""")




			def __init__(						self							:		Optional[int]       ,       __magic_name__							:		Optional[int]=None       ,       __magic_name__							:		str=None       ,       **__magic_name__							:		Any						):







						"""simple docstring"""







						UpperCamelCase         =					None
						if "feature_extractor" in kwargs:
									warnings.warn(
									    """The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`"""
									    """ instead."""       ,       __magic_name__       ,       )
									UpperCamelCase         =					kwargs.pop("""feature_extractor"""						)

						UpperCamelCase         =					image_processor if image_processor is not None else feature_extractor
						if image_processor is None:
									raise ValueError("""You need to specify an `image_processor`."""						)
						if tokenizer is None:
									raise ValueError("""You need to specify a `tokenizer`."""						)

						super().__init__(__magic_name__       ,       __magic_name__						)
						UpperCamelCase         =					self.image_processor




			def __call__(						self							:		int       ,       __magic_name__							:		Optional[ImageInput] = None       ,       __magic_name__							:		Optional[Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]]] = None       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Union[bool, str, PaddingStrategy] = False       ,       __magic_name__							:		Union[bool, str, TruncationStrategy] = False       ,       __magic_name__							:		Optional[int] = None       ,       __magic_name__							:		int = 0       ,       __magic_name__							:		Optional[int] = None       ,       __magic_name__							:		Optional[bool] = None       ,       __magic_name__							:		Optional[bool] = None       ,       __magic_name__							:		Optional[bool] = None       ,       __magic_name__							:		Optional[bool] = None       ,       __magic_name__							:		bool = False       ,       __magic_name__							:		bool = False       ,       __magic_name__							:		bool = False       ,       __magic_name__							:		bool = False       ,       __magic_name__							:		bool = True       ,       __magic_name__							:		Optional[Union[str, TensorType]] = None       ,       **__magic_name__							:		str       ,       ):







						"""simple docstring"""







						if text is None and images is None:
									raise ValueError("""You have to specify either text or images. Both cannot be none."""						)

						if text is not None:
									UpperCamelCase         =					self.tokenizer(
									    text=__magic_name__       ,       add_special_tokens=__magic_name__       ,       padding=__magic_name__       ,       truncation=__magic_name__       ,       max_length=__magic_name__       ,       stride=__magic_name__       ,       pad_to_multiple_of=__magic_name__       ,       return_token_type_ids=__magic_name__       ,       return_attention_mask=__magic_name__       ,       return_overflowing_tokens=__magic_name__       ,       return_special_tokens_mask=__magic_name__       ,       return_offsets_mapping=__magic_name__       ,       return_length=__magic_name__       ,       verbose=__magic_name__       ,       return_tensors=__magic_name__       ,       **__magic_name__       ,       )
						if images is not None:
									UpperCamelCase         =					self.image_processor(
									    __magic_name__       ,       return_image_mask=__magic_name__       ,       return_codebook_pixels=__magic_name__       ,       return_tensors=__magic_name__       ,       **__magic_name__       ,       )

						if text is not None and images is not None:
									encoding.update(__magic_name__						)
									return encoding
						elif text is not None:
									return encoding
						else:
									return BatchEncoding(data=dict(**__magic_name__						)       ,       tensor_type=__magic_name__						)




			def   lowerCamelCase_					(						self							:		Tuple       ,       *__magic_name__							:		Dict       ,       **__magic_name__							:		List[Any]						):







						"""simple docstring"""







						return self.tokenizer.batch_decode(*__magic_name__       ,       **__magic_name__						)




			def   lowerCamelCase_					(						self							:		int       ,       *__magic_name__							:		Tuple       ,       **__magic_name__							:		Optional[Any]						):







						"""simple docstring"""







						return self.tokenizer.decode(*__magic_name__       ,       **__magic_name__						)




			@property
			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						UpperCamelCase         =					self.tokenizer.model_input_names
						UpperCamelCase         =					self.image_processor.model_input_names
						return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names						)						)




			@property
			def   lowerCamelCase_					(						self							:		int						):







						"""simple docstring"""







						warnings.warn(
						    """`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead."""       ,       __magic_name__       ,       )
						return self.image_processor_class





			@property
			def   lowerCamelCase_					(						self							:		Tuple						):







						"""simple docstring"""







						warnings.warn(
						    """`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead."""       ,       __magic_name__       ,       )
						return self.image_processor




