

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




				def __init__(					self      ,   snake_case      ,   snake_case=13      ,   snake_case=30      ,   snake_case=2      ,   snake_case=3      ,   snake_case=True      ,   snake_case=True      ,   snake_case=32      ,   snake_case=5      ,   snake_case=4      ,   snake_case=37      ,   snake_case="gelu"      ,   snake_case=0.1      ,   snake_case=0.1      ,   snake_case=10      ,   snake_case=0.02      ,   snake_case=3      ,   snake_case=None      ,   snake_case=2      ,   ):
											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     a							(					self       ):
											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     a							(					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=snake_case      ,   initializer_range=self.initializer_range      ,   encoder_stride=self.encoder_stride      ,   )




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




				def     a							(					self      ,   snake_case      ,   snake_case      ,   snake_case       ):
											snake_case_							=    DeiTForMaskedImageModeling(config=snake_case       )
											model.to(snake_case       )
											model.eval()
											snake_case_							=    model(snake_case       )
											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(snake_case       )
											model.to(snake_case       )
											model.eval()

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




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

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

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




				def     a							(					self       ):
											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  lowercase				(       lowercase_	,  lowercase_	,  unittest.TestCase			):
				__SCREAMING_SNAKE_CASE					: List[str]       			=			(
				    (
				        DeiTModel,
				        DeiTForImageClassification,
				        DeiTForImageClassificationWithTeacher,
				        DeiTForMaskedImageModeling,
				    )
				    if is_torch_available()
				    else ()
				)
				__SCREAMING_SNAKE_CASE					: Optional[int]       			=			(
				    {
				        '''feature-extraction''': DeiTModel,
				        '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
				    }
				    if is_torch_available()
				    else {}
				)

				__SCREAMING_SNAKE_CASE					: Dict       			=			False
				__SCREAMING_SNAKE_CASE					: int       			=			False
				__SCREAMING_SNAKE_CASE					: List[Any]       			=			False




				def     a							(					self       ):
											snake_case_							=    DeiTModelTester(self       )
											snake_case_							=    ConfigTester(self      ,   config_class=snake_case      ,   has_text_modality=snake_case      ,   hidden_size=37       )




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




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




				def     a							(					self       ):
											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(snake_case       )
																		self.assertIsInstance(model.get_input_embeddings()      ,   (nn.Module)       )
																		snake_case_							=    model.get_output_embeddings()
																		self.assertTrue(x is None or isinstance(snake_case      ,   nn.Linear       )       )




				def     a							(					self       ):
											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(snake_case       )
																		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]      ,   snake_case       )




				def     a							(					self       ):
											snake_case_							=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*snake_case       )




				def     a							(					self       ):
											snake_case_							=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*snake_case       )




				def     a							(					self       ):
											snake_case_							=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*snake_case       )




				def     a							(					self      ,   snake_case      ,   snake_case      ,   snake_case=False       ):
											snake_case_							=    super()._prepare_for_class(snake_case      ,   snake_case      ,   return_labels=snake_case       )

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

											return inputs_dict




				def     a							(					self       ):
											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(snake_case       )
																		    or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
																		):
																									continue
																		snake_case_							=    model_class(snake_case       )
																		model.to(snake_case       )
																		model.train()
																		snake_case_							=    self._prepare_for_class(snake_case      ,   snake_case      ,   return_labels=snake_case       )
																		snake_case_							=    model(**snake_case       ).loss
																		loss.backward()




				def     a							(					self       ):
											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(snake_case       ) or not model_class.supports_gradient_checkpointing:
																									continue
																		# DeiTForImageClassificationWithTeacher supports inference-only
																		if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
																									continue
																		snake_case_							=    model_class(snake_case       )
																		model.gradient_checkpointing_enable()
																		model.to(snake_case       )
																		model.train()
																		snake_case_							=    self._prepare_for_class(snake_case      ,   snake_case      ,   return_labels=snake_case       )
																		snake_case_							=    model(**snake_case       ).loss
																		loss.backward()




				def     a							(					self       ):
											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(snake_case       ),
																		        *get_values(snake_case       ),
																		    ]
																		    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(snake_case       )
																																model.to(snake_case       )
																																model.train()

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

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





def 					__lowerCamelCase	( ):







							'''simple docstring'''






							snake_case_							=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
							return image







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




				@cached_property
				def     a							(					self       ):
											return (
											    DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224'       )
											    if is_vision_available()
											    else None
											)




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

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

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

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

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

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




				@slow
				@require_accelerate
				@require_torch_gpu
				def     a							(					self       ):
											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=snake_case      ,   return_tensors='pt'       )
											snake_case_							=    inputs.pixel_values.to(snake_case       )

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







from abc import ABC, abstractmethod
from argparse import ArgumentParser







class  lowercase				(       lowercase_			):




				@staticmethod
				@abstractmethod
				def     a							(					snake_case       ):
											raise NotImplementedError()




				@abstractmethod
				def     a							(					self       ):
											raise NotImplementedError()




