"""simple docstring"""



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


 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  ,						):
        __a     				=  parent
        __a     				=  batch_size
        __a     				=  image_size
        __a     				=  patch_size
        __a     				=  num_channels
        __a     				=  is_training
        __a     				=  use_labels
        __a     				=  hidden_size
        __a     				=  num_hidden_layers
        __a     				=  num_attention_heads
        __a     				=  intermediate_size
        __a     				=  hidden_act
        __a     				=  hidden_dropout_prob
        __a     				=  attention_probs_dropout_prob
        __a     				=  type_sequence_label_size
        __a     				=  initializer_range
        __a     				=  scope
        __a     				=  encoder_stride

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


 def 		a__ (				self		):
        __a     				=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

        __a     				=  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=lowercase_  ,						initializer_range=self.initializer_range  ,						encoder_stride=self.encoder_stride  ,						)


 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase		):
        __a     				=  DeiTModel(config=lowercase_		)
        model.to(lowercase_		)
        model.eval()
        __a     				=  model(lowercase_		)
        self.parent.assertEqual(result.last_hidden_state.shape  ,						(self.batch_size, self.seq_length, self.hidden_size)		)


 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase		):
        __a     				=  DeiTForMaskedImageModeling(config=lowercase_		)
        model.to(lowercase_		)
        model.eval()
        __a     				=  model(lowercase_		)
        self.parent.assertEqual(
            result.reconstruction.shape  ,						(self.batch_size, self.num_channels, self.image_size, self.image_size)		)

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

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


 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase		):
        __a     				=  self.type_sequence_label_size
        __a     				=  DeiTForImageClassification(lowercase_		)
        model.to(lowercase_		)
        model.eval()
        __a     				=  model(lowercase_  ,						labels=lowercase_		)
        self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.type_sequence_label_size)		)

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

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






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






@require_torch
class 				snake_case__     (   a_,		a_,		unittest.TestCase   ):
 _snake_case   :			List[str]           =		(
     (
         DeiTModel,
         DeiTForImageClassification,
         DeiTForImageClassificationWithTeacher,
         DeiTForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 _snake_case   :			int           =		(
     {
         """feature-extraction""": DeiTModel,
         """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 _snake_case   :			Union[str, Any]           =		False
 _snake_case   :			Optional[int]           =		False
 _snake_case   :			Optional[int]           =		False


 def 		a__ (				self		):
        __a     				=  DeiTModelTester(self		)
        __a     				=  ConfigTester(self  ,						config_class=lowercase_  ,						has_text_modality=lowercase_  ,						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		):
        __a     				=  self.model_tester.prepare_config_and_inputs_for_common()

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


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs_for_common()

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

               __a     				=  ['''pixel_values''']
               self.assertListEqual(arg_names[:1]  ,						lowercase_		)


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*lowercase_		)


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_		)


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*lowercase_		)


 def 		a__ (				self  ,						lowerCamelCase  ,						lowerCamelCase  ,						lowerCamelCase=False		):
        __a     				=  super()._prepare_for_class(lowercase_  ,						lowercase_  ,						return_labels=lowercase_		)

        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

        __a     				=  self.model_tester.prepare_config_and_inputs_for_common()
        __a     				=  True

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


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs_for_common()
        if not self.model_tester.is_training:
               return

        __a     				=  False
        __a     				=  True

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


 def 		a__ (				self		):
        __a     				=  self.model_tester.prepare_config_and_inputs_for_common()

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

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

                             __a     				=  model_class(lowercase_		)
                             model.to(lowercase_		)
                             model.train()

                             __a     				=  self._prepare_for_class(lowercase_  ,						lowercase_  ,						return_labels=lowercase_		)

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

                             __a     				=  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=lowercase_		) as warning_list:
                                    __a     				=  model(**lowercase_		).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]:
               __a     				=  DeiTModel.from_pretrained(lowercase_		)
               self.assertIsNotNone(lowercase_		)



def 					_lowerCamelCase(					):
       __a     				=  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"							)
       return image






@require_torch
@require_vision
class 				snake_case__     (   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		):
        __a     				=  DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"		).to(
            lowercase_		)

        __a     				=  self.default_image_processor
        __a     				=  prepare_img()
        __a     				=  image_processor(images=lowercase_  ,						return_tensors="pt"		).to(lowercase_		)

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

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

        __a     				=  torch.tensor([-1.0266, 0.1912, -1.2861]		).to(lowercase_		)

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






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

        __a     				=  prepare_img()
        __a     				=  image_processor(images=lowercase_  ,						return_tensors="pt"		)
        __a     				=  inputs.pixel_values.to(lowercase_		)

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

"""simple docstring"""



from ..utils import DummyObject, requires_backends






class 				snake_case__     (   metaclass=snake_case_   ):
 _snake_case   :			Union[str, Any]           =		["""onnx"""]


 def __init__(				self  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(self  ,						["onnx"]		)


 @classmethod
 def 		a__ (				cls  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(cls  ,						["onnx"]		)






 @classmethod
 def 		a__ (				cls  ,						*lowerCamelCase  ,						**lowerCamelCase		):
        requires_backends(cls  ,						["onnx"]		)
