





'''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     lowerCAmelCase__ :

       '''simple docstring'''

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

       def 			__snake_case      ( self					:				Optional[int]       ,     a__					:				Tuple       ,     a__					:				Dict       ,     a__					:				Optional[Any]						):
              UpperCAmelCase  =						DeiTModel(config=a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__						)
              self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)						)

       def 			__snake_case      ( self					:				Optional[int]       ,     a__					:				Any       ,     a__					:				Optional[Any]       ,     a__					:				Optional[int]						):
              UpperCAmelCase  =						DeiTForMaskedImageModeling(config=a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__						)
              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(a__						)
              model.to(a__						)
              model.eval()

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

       def 			__snake_case      ( self					:				Optional[Any]       ,     a__					:				Optional[Any]       ,     a__					:				Union[str, Any]       ,     a__					:				Union[str, Any]						):
              UpperCAmelCase  =						self.type_sequence_label_size
              UpperCAmelCase  =						DeiTForImageClassification(a__						)
              model.to(a__						)
              model.eval()
              UpperCAmelCase  =						model(a__       ,     labels=a__						)
              self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.type_sequence_label_size)						)

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

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



       def 			__snake_case      ( self					:				List[Any]						):
              UpperCAmelCase  =						self.prepare_config_and_inputs()
              (
                  (
                  UpperCAmelCase			
              ),					(
                  UpperCAmelCase			
              ),					(
                  UpperCAmelCase			
              ),								
              )  =						config_and_inputs
              UpperCAmelCase  =						{'''pixel_values''': pixel_values}
              return config, inputs_dict






@require_torch
class     lowerCAmelCase__ (				UpperCAmelCase_      , UpperCAmelCase_      , unittest.TestCase    ):

       '''simple docstring'''
       _lowerCamelCase								=(
           (
               DeiTModel,
               DeiTForImageClassification,
               DeiTForImageClassificationWithTeacher,
               DeiTForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       _lowerCamelCase								=(
           {
               '''feature-extraction''': DeiTModel,
               '''image-classification''': (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
           }
           if is_torch_available()
           else {}
       )

       _lowerCamelCase								=False
       _lowerCamelCase								=False
       _lowerCamelCase								=False

       def 			__snake_case      ( self					:				Any						):
              UpperCAmelCase  =						DeiTModelTester(self						)
              UpperCAmelCase  =						ConfigTester(self       ,     config_class=a__       ,     has_text_modality=a__       ,     hidden_size=37						)

       def 			__snake_case      ( self					:				Dict						):
              self.config_tester.run_common_tests()

       @unittest.skip(reason='''DeiT does not use inputs_embeds'''						)
       def 			__snake_case      ( self					:				List[str]						):
              pass

       def 			__snake_case      ( self					:				Optional[Any]						):
              UpperCAmelCase,					UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs_for_common()

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

       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase,					UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs_for_common()

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

       def 			__snake_case      ( self					:				Union[str, Any]						):
              UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*a__						)

       def 			__snake_case      ( self					:				Dict						):
              UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_masked_image_modeling(*a__						)

       def 			__snake_case      ( self					:				List[Any]						):
              UpperCAmelCase  =						self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_image_classification(*a__						)

       def 			__snake_case      ( self					:				Optional[int]       ,     a__					:				int       ,     a__					:				Union[str, Any]       ,     a__					:				List[Any]=False						):
              UpperCAmelCase  =						super()._prepare_for_class(a__       ,     a__       ,     return_labels=a__						)

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

              return inputs_dict

       def 			__snake_case      ( self					:				Any						):


              if not self.model_tester.is_training:
                     return

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

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

       def 			__snake_case      ( self					:				Optional[Any]						):
              UpperCAmelCase,					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(a__						),
                             *get_values(a__						),
                         ]
                         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(a__						)
                                   model.to(a__						)
                                   model.train()

                                   UpperCAmelCase  =						self._prepare_for_class(a__       ,     a__       ,     return_labels=a__						)

                                   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=a__						) as warning_list:
                                          UpperCAmelCase  =						model(**a__						).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 			__snake_case      ( self					:				Union[str, Any]						):


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


def       __snake_case		( )							->     List[str]:

       """simple docstring"""


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






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

       '''simple docstring'''

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

       @slow
       def 			__snake_case      ( self					:				List[str]						):
              UpperCAmelCase  =						DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''						).to(
                  a__						)

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

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

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

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

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



       @slow
       @require_accelerate
       @require_torch_gpu
       def 			__snake_case      ( self					:				Tuple						):
              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=a__       ,     return_tensors='''pt'''						)
              UpperCAmelCase  =						inputs.pixel_values.to(a__						)

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








'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


lowerCAmelCase_     						=				{}

try:
    if not is_sentencepiece_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase_     						=				['''GPTSw3Tokenizer''']


if TYPE_CHECKING:
    try:
        if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_gpt_swa import GPTSwaTokenizer

else:
    import sys

    lowerCAmelCase_     						=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


