





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


      def __init__(self       :      str				,			a__       :      Any				,			a__       :      Tuple=13				,			a__       :      int=30				,			a__       :      Tuple=2				,			a__       :      Optional[Any]=3				,			a__       :      Optional[int]=True				,			a__       :      Optional[int]=True				,			a__       :      Union[str, Any]=32				,			a__       :      Any=5				,			a__       :      List[Any]=4				,			a__       :      Any=37				,			a__       :      List[Any]="gelu"				,			a__       :      Optional[Any]=0.1				,			a__       :      Optional[Any]=0.1				,			a__       :      Union[str, Any]=10				,			a__       :      int=0.0_2				,			a__       :      List[Any]=3				,			a__       :      int=None				,			a__       :      Dict=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    a (self       :      Optional[Any]      ):





         """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    a (self       :      Dict      ):





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


      def    a (self       :      Optional[int]				,			a__       :      str				,			a__       :      List[str]				,			a__       :      Tuple      ):





         """simple docstring"""



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


      def    a (self       :      str				,			a__       :      List[str]				,			a__       :      Dict				,			a__       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   DeiTForMaskedImageModeling(config=lowercase_      )
         model.to(lowercase_      )
         model.eval()
         __snake_case							       =   model(lowercase_      )
         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(lowercase_      )
         model.to(lowercase_      )
         model.eval()

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


      def    a (self       :      Optional[Any]				,			a__       :      Dict				,			a__       :      List[Any]				,			a__       :      Dict      ):





         """simple docstring"""



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

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

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


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.prepare_config_and_inputs()
         (
             __snake_case   
         )							       =   config_and_inputs
         __snake_case							       =   {"pixel_values": pixel_values}
         return config, inputs_dict






@require_torch
class 		SCREAMING_SNAKE_CASE__				(       lowercase__						,      lowercase__						,      unittest.TestCase  ):
      A_						:				Any							=    (
          (
              DeiTModel,
              DeiTForImageClassification,
              DeiTForImageClassificationWithTeacher,
              DeiTForMaskedImageModeling,
          )
          if is_torch_available()
          else ()
      )
      A_						:				Tuple							=    (
          {
              """feature-extraction""": DeiTModel,
              """image-classification""": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
          }
          if is_torch_available()
          else {}
      )

      A_						:				List[Any]							=    False
      A_						:				Optional[Any]							=    False
      A_						:				List[str]							=    False


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   DeiTModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=lowercase_				,			has_text_modality=lowercase_				,			hidden_size=37      )


      def    a (self       :      Any      ):





         """simple docstring"""



         self.config_tester.run_common_tests()


      @unittest.skip(reason='''DeiT does not use inputs_embeds'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

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


      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

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


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowercase_      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case							       =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowercase_      )


      def    a (self       :      int				,			a__       :      List[Any]				,			a__       :      str				,			a__       :      str=False      ):





         """simple docstring"""



         __snake_case							       =   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       :      int      ):





         """simple docstring"""



         if not self.model_tester.is_training:
            return

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


      def    a (self       :      int      ):





         """simple docstring"""



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


      def    a (self       :      str      ):





         """simple docstring"""



         __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(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']}"""      ):
                  __snake_case							       =   problem_type["title"]
                  __snake_case							       =   problem_type["num_labels"]

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

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

                  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=lowercase_      ) as warning_list:
                     __snake_case							       =   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       :      Tuple      ):





         """simple docstring"""



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






def lowerCamelCase__    (							)      ->				Any:
   __snake_case							       =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )
   return image







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


      @cached_property
      def    a (self       :      Tuple      ):





         """simple docstring"""



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


      @slow
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         __snake_case							       =   DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''      ).to(
             lowercase_      )

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

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

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

         __snake_case							       =   torch.tensor([-1.0_2_6_6, 0.1_9_1_2, -1.2_8_6_1]      ).to(lowercase_      )

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


      @slow
      @require_accelerate
      @require_torch_gpu
      def    a (self       :      int      ):





         """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=lowercase_				,			return_tensors='''pt'''      )
         __snake_case							       =   inputs.pixel_values.to(lowercase_      )

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



"""simple docstring"""





from collections import namedtuple

_a		       =							namedtuple('from_to', 'from_ to')

_a		       =							{
    'cubicmeter': from_to(1, 1),
    'litre': from_to(0.001, 1_000),
    'kilolitre': from_to(1, 1),
    'gallon': from_to(0.0_0454, 264.172),
    'cubicyard': from_to(0.7_6455, 1.3_0795),
    'cubicfoot': from_to(0.028, 35.3147),
    'cup': from_to(0.0_0023_6588, 4226.75),
}







def 	__a     (		__lowerCamelCase,		__lowerCamelCase,		__lowerCamelCase  ):
   if from_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'from_type' value: {from_type!r}  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   if to_type not in METRIC_CONVERSION:
      raise ValueError(
          f"""Invalid 'to_type' value: {to_type!r}.  Supported values are:\n"""
          + ", ".join(__lowerCamelCase  )  )
   return value * METRIC_CONVERSION[from_type].from_ * METRIC_CONVERSION[to_type].to


if __name__ == "__main__":
    import doctest

    doctest.testmod()


