



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_		:
       def __init__(			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=13,			SCREAMING_SNAKE_CASE_=30,			SCREAMING_SNAKE_CASE_=2,			SCREAMING_SNAKE_CASE_=3,			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=True,			SCREAMING_SNAKE_CASE_=32,			SCREAMING_SNAKE_CASE_=5,			SCREAMING_SNAKE_CASE_=4,			SCREAMING_SNAKE_CASE_=37,			SCREAMING_SNAKE_CASE_="gelu",			SCREAMING_SNAKE_CASE_=0.1,			SCREAMING_SNAKE_CASE_=0.1,			SCREAMING_SNAKE_CASE_=10,			SCREAMING_SNAKE_CASE_=0.02,			SCREAMING_SNAKE_CASE_=3,			SCREAMING_SNAKE_CASE_=None,			SCREAMING_SNAKE_CASE_=2,			)     ->		Dict:
          UpperCamelCase    :  Optional[int]							=	parent
          UpperCamelCase    :  str							=	batch_size
          UpperCamelCase    :  str							=	image_size
          UpperCamelCase    :  str							=	patch_size
          UpperCamelCase    :  int							=	num_channels
          UpperCamelCase    :  Optional[int]							=	is_training
          UpperCamelCase    :  Tuple							=	use_labels
          UpperCamelCase    :  List[str]							=	hidden_size
          UpperCamelCase    :  Any							=	num_hidden_layers
          UpperCamelCase    :  str							=	num_attention_heads
          UpperCamelCase    :  str							=	intermediate_size
          UpperCamelCase    :  str							=	hidden_act
          UpperCamelCase    :  Union[str, Any]							=	hidden_dropout_prob
          UpperCamelCase    :  Any							=	attention_probs_dropout_prob
          UpperCamelCase    :  Tuple							=	type_sequence_label_size
          UpperCamelCase    :  List[Any]							=	initializer_range
          UpperCamelCase    :  Any							=	scope
          UpperCamelCase    :  List[Any]							=	encoder_stride

          # in DeiT, the seq length equals the number of patches + 2 (we add 2 for the [CLS] and distilation tokens)
          UpperCamelCase    :  List[str]							=	(image_size // patch_size) ** 2
          UpperCamelCase    :  Union[str, Any]							=	num_patches + 2
       def 					snake_case_       (			self       )     ->		Dict:
          UpperCamelCase    :  Any							=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

          UpperCamelCase    :  str							=	self.get_config()

          return config, pixel_values, labels
       def 					snake_case_       (			self       )     ->		str:
          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=SCREAMING_SNAKE_CASE_,			initializer_range=self.initializer_range,			encoder_stride=self.encoder_stride,			)
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Dict:
          UpperCamelCase    :  Optional[Any]							=	DeiTModel(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Optional[Any]							=	model(SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.last_hidden_state.shape,			(self.batch_size, self.seq_length, self.hidden_size)       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		str:
          UpperCamelCase    :  Optional[Any]							=	DeiTForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Union[str, Any]							=	model(SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(
              result.reconstruction.shape,			(self.batch_size, self.num_channels, self.image_size, self.image_size)       )

          # test greyscale images
          UpperCamelCase    :  Dict							=	1
          UpperCamelCase    :  Dict							=	DeiTForMaskedImageModeling(SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()

          UpperCamelCase    :  Tuple							=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
          UpperCamelCase    :  Optional[int]							=	model(SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.reconstruction.shape,			(self.batch_size, 1, self.image_size, self.image_size)       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_       )     ->		Optional[Any]:
          UpperCamelCase    :  List[Any]							=	self.type_sequence_label_size
          UpperCamelCase    :  Any							=	DeiTForImageClassification(SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()
          UpperCamelCase    :  Optional[int]							=	model(SCREAMING_SNAKE_CASE_,			labels=SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.type_sequence_label_size)       )

          # test greyscale images
          UpperCamelCase    :  Dict							=	1
          UpperCamelCase    :  Dict							=	DeiTForImageClassification(SCREAMING_SNAKE_CASE_       )
          model.to(SCREAMING_SNAKE_CASE_       )
          model.eval()

          UpperCamelCase    :  int							=	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
          UpperCamelCase    :  Optional[Any]							=	model(SCREAMING_SNAKE_CASE_,			labels=SCREAMING_SNAKE_CASE_       )
          self.parent.assertEqual(result.logits.shape,			(self.batch_size, self.type_sequence_label_size)       )






       def 					snake_case_       (			self       )     ->		List[Any]:
          UpperCamelCase    :  int							=	self.prepare_config_and_inputs()
          (
              (
              UpperCamelCase
          )	,     (
              UpperCamelCase
          )	,     (
              UpperCamelCase
          )	,     
          )    :  Optional[int]							=	config_and_inputs
          UpperCamelCase    :  str							=	{'pixel_values': pixel_values}
          return config, inputs_dict






@require_torch
class 				lowerCAmelCase_		(  a__       ,    a__       ,    unittest.TestCase							):
       UpperCAmelCase__				:					Optional[Any]        =  (
           (
               DeiTModel,
               DeiTForImageClassification,
               DeiTForImageClassificationWithTeacher,
               DeiTForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       UpperCAmelCase__				:					Any        =  (
           {
               "feature-extraction": DeiTModel,
               "image-classification": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
           }
           if is_torch_available()
           else {}
       )

       UpperCAmelCase__				:					Any        =  False
       UpperCAmelCase__				:					Union[str, Any]        =  False
       UpperCAmelCase__				:					Dict        =  False
       def 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  Any							=	DeiTModelTester(self       )
          UpperCamelCase    :  str							=	ConfigTester(self,			config_class=SCREAMING_SNAKE_CASE_,			has_text_modality=SCREAMING_SNAKE_CASE_,			hidden_size=37       )
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          self.config_tester.run_common_tests()
       @unittest.skip(reason='DeiT does not use inputs_embeds'       )
       def 					snake_case_       (			self       )     ->		int:
          pass
       def 					snake_case_       (			self       )     ->		List[Any]:
          UpperCamelCase	,     UpperCamelCase    :  Any							=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             UpperCamelCase    :  List[str]							=	model_class(SCREAMING_SNAKE_CASE_       )
             self.assertIsInstance(model.get_input_embeddings(),			(nn.Module)       )
             UpperCamelCase    :  Optional[int]							=	model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_,			nn.Linear       )       )
       def 					snake_case_       (			self       )     ->		Tuple:
          UpperCamelCase	,     UpperCamelCase    :  List[Any]							=	self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             UpperCamelCase    :  Union[str, Any]							=	model_class(SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Optional[int]							=	inspect.signature(model.forward       )
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             UpperCamelCase    :  Union[str, Any]							=	[*signature.parameters.keys()]

             UpperCamelCase    :  str							=	['pixel_values']
             self.assertListEqual(arg_names[:1],			SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Tuple:
          UpperCamelCase    :  Dict							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		int:
          UpperCamelCase    :  Dict							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self       )     ->		Optional[int]:
          UpperCamelCase    :  Optional[Any]							=	self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_       )
       def 					snake_case_       (			self,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_=False       )     ->		Any:
          UpperCamelCase    :  str							=	super()._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			return_labels=SCREAMING_SNAKE_CASE_       )

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

          return inputs_dict
       def 					snake_case_       (			self       )     ->		List[Any]:
          if not self.model_tester.is_training:
             return

          UpperCamelCase	,     UpperCamelCase    :  Tuple							=	self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase    :  Optional[int]							=	True

          for model_class in self.all_model_classes:
             # DeiTForImageClassificationWithTeacher supports inference-only
             if (
                 model_class in get_values(SCREAMING_SNAKE_CASE_       )
                 or model_class.__name__ == "DeiTForImageClassificationWithTeacher"
             ):
                continue
             UpperCamelCase    :  Tuple							=	model_class(SCREAMING_SNAKE_CASE_       )
             model.to(SCREAMING_SNAKE_CASE_       )
             model.train()
             UpperCamelCase    :  Any							=	self._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			return_labels=SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  int							=	model(**SCREAMING_SNAKE_CASE_       ).loss
             loss.backward()
       def 					snake_case_       (			self       )     ->		Optional[Any]:
          UpperCamelCase	,     UpperCamelCase    :  Any							=	self.model_tester.prepare_config_and_inputs_for_common()
          if not self.model_tester.is_training:
             return

          UpperCamelCase    :  Dict							=	False
          UpperCamelCase    :  Tuple							=	True

          for model_class in self.all_model_classes:
             if model_class in get_values(SCREAMING_SNAKE_CASE_       ) or not model_class.supports_gradient_checkpointing:
                continue
             # DeiTForImageClassificationWithTeacher supports inference-only
             if model_class.__name__ == "DeiTForImageClassificationWithTeacher":
                continue
             UpperCamelCase    :  int							=	model_class(SCREAMING_SNAKE_CASE_       )
             model.gradient_checkpointing_enable()
             model.to(SCREAMING_SNAKE_CASE_       )
             model.train()
             UpperCamelCase    :  Optional[int]							=	self._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			return_labels=SCREAMING_SNAKE_CASE_       )
             UpperCamelCase    :  Any							=	model(**SCREAMING_SNAKE_CASE_       ).loss
             loss.backward()
       def 					snake_case_       (			self       )     ->		Union[str, Any]:
          UpperCamelCase	,     UpperCamelCase    :  Tuple							=	self.model_tester.prepare_config_and_inputs_for_common()

          UpperCamelCase    :  List[str]							=	[
              {'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(SCREAMING_SNAKE_CASE_       ),
                     *get_values(SCREAMING_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"]}"""       ):
                   UpperCamelCase    :  Optional[int]							=	problem_type['title']
                   UpperCamelCase    :  Any							=	problem_type['num_labels']

                   UpperCamelCase    :  str							=	model_class(SCREAMING_SNAKE_CASE_       )
                   model.to(SCREAMING_SNAKE_CASE_       )
                   model.train()

                   UpperCamelCase    :  Dict							=	self._prepare_for_class(SCREAMING_SNAKE_CASE_,			SCREAMING_SNAKE_CASE_,			return_labels=SCREAMING_SNAKE_CASE_       )

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

                   UpperCamelCase    :  str							=	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=SCREAMING_SNAKE_CASE_       ) as warning_list:
                      UpperCamelCase    :  Tuple							=	model(**SCREAMING_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 					snake_case_       (			self       )     ->		Dict:
          for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             UpperCamelCase    :  int							=	DeiTModel.from_pretrained(SCREAMING_SNAKE_CASE_       )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_       )






def 		UpperCamelCase	(   )	->     List[Any]:
   UpperCamelCase    :  Dict							=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
   return image



@require_torch
@require_vision
class 				lowerCAmelCase_		(  unittest.TestCase							):
       @cached_property
       def 					snake_case_       (			self       )     ->		Optional[int]:
          return (
              DeiTImageProcessor.from_pretrained('facebook/deit-base-distilled-patch16-224'       )
              if is_vision_available()
              else None
          )
       @slow
       def 					snake_case_       (			self       )     ->		Union[str, Any]:
          UpperCamelCase    :  Optional[int]							=	DeiTForImageClassificationWithTeacher.from_pretrained('facebook/deit-base-distilled-patch16-224'       ).to(
              SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Optional[Any]							=	self.default_image_processor
          UpperCamelCase    :  Any							=	prepare_img()
          UpperCamelCase    :  List[str]							=	image_processor(images=SCREAMING_SNAKE_CASE_,			return_tensors='pt'       ).to(SCREAMING_SNAKE_CASE_       )

          # forward pass
          with torch.no_grad():
             UpperCamelCase    :  Optional[int]							=	model(**SCREAMING_SNAKE_CASE_       )

          # verify the logits
          UpperCamelCase    :  str							=	torch.Size((1, 1000)       )
          self.assertEqual(outputs.logits.shape,			SCREAMING_SNAKE_CASE_       )

          UpperCamelCase    :  Optional[int]							=	torch.tensor([-1.02_66, 0.19_12, -1.28_61]       ).to(SCREAMING_SNAKE_CASE_       )

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






       @slow
       @require_accelerate
       @require_torch_gpu
       def 					snake_case_       (			self       )     ->		Union[str, Any]:
          UpperCamelCase    :  str							=	DeiTModel.from_pretrained(
              'facebook/deit-base-distilled-patch16-224',			torch_dtype=torch.floataa,			device_map='auto'       )
          UpperCamelCase    :  Any							=	self.default_image_processor

          UpperCamelCase    :  int							=	prepare_img()
          UpperCamelCase    :  List[Any]							=	image_processor(images=SCREAMING_SNAKE_CASE_,			return_tensors='pt'       )
          UpperCamelCase    :  Any							=	inputs.pixel_values.to(SCREAMING_SNAKE_CASE_       )

          # forward pass to make sure inference works in fp16
          with torch.no_grad():
             UpperCamelCase    :  Optional[Any]							=	model(SCREAMING_SNAKE_CASE_       )








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


__UpperCAmelCase          =       {
    '''configuration_transfo_xl''': ['''TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TransfoXLConfig'''],
    '''tokenization_transfo_xl''': ['''TransfoXLCorpus''', '''TransfoXLTokenizer'''],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''AdaptiveEmbedding''',
        '''TransfoXLForSequenceClassification''',
        '''TransfoXLLMHeadModel''',
        '''TransfoXLModel''',
        '''TransfoXLPreTrainedModel''',
        '''load_tf_weights_in_transfo_xl''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __UpperCAmelCase          =       [
        '''TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''TFAdaptiveEmbedding''',
        '''TFTransfoXLForSequenceClassification''',
        '''TFTransfoXLLMHeadModel''',
        '''TFTransfoXLMainLayer''',
        '''TFTransfoXLModel''',
        '''TFTransfoXLPreTrainedModel''',
    ]


if TYPE_CHECKING:
    from .configuration_transfo_xl import TRANSFO_XL_PRETRAINED_CONFIG_ARCHIVE_MAP, TransfoXLConfig
    from .tokenization_transfo_xl import TransfoXLCorpus, TransfoXLTokenizer

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_transfo_xl import (
            TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            AdaptiveEmbedding,
            TransfoXLForSequenceClassification,
            TransfoXLLMHeadModel,
            TransfoXLModel,
            TransfoXLPreTrainedModel,
            load_tf_weights_in_transfo_xl,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_transfo_xl import (
            TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFAdaptiveEmbedding,
            TFTransfoXLForSequenceClassification,
            TFTransfoXLLMHeadModel,
            TFTransfoXLMainLayer,
            TFTransfoXLModel,
            TFTransfoXLPreTrainedModel,
        )

else:
    import sys

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



