





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




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

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




 def 				_snake_case (						self		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

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




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				List[str]:
     _lowerCAmelCase						      =   DeiTModel(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase						      =   model(_lowerCAmelCase		)
     self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   DeiTForMaskedImageModeling(config=_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase						      =   model(_lowerCAmelCase		)
     self.parent.assertEqual(
         result.reconstruction.shape      ,  (self.batch_size, self.num_channels, self.image_size, self.image_size)		)

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

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




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase		)     ->				Any:
     _lowerCAmelCase						      =   self.type_sequence_label_size
     _lowerCAmelCase						      =   DeiTForImageClassification(_lowerCAmelCase		)
     model.to(_lowerCAmelCase		)
     model.eval()
     _lowerCAmelCase						      =   model(_lowerCAmelCase      ,  labels=_lowerCAmelCase		)
     self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size)		)

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

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





 def 				_snake_case (						self		)     ->				Tuple:
     _lowerCAmelCase						      =   self.prepare_config_and_inputs()
     (
         (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      (
         _lowerCAmelCase
     )      ,      
     )						      =   config_and_inputs
     _lowerCAmelCase						      =   {"pixel_values": pixel_values}
     return config, inputs_dict







@require_torch
class  lowerCAmelCase_		(		__magic_name__    ,__magic_name__    ,unittest.TestCase		):
 __lowerCamelCase    :				Tuple								=       (
     (
         DeiTModel,
         DeiTForImageClassification,
         DeiTForImageClassificationWithTeacher,
         DeiTForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 __lowerCamelCase    :				int								=       (
     {
         "feature-extraction": DeiTModel,
         "image-classification": (DeiTForImageClassification, DeiTForImageClassificationWithTeacher),
     }
     if is_torch_available()
     else {}
 )

 __lowerCamelCase    :				Dict								=       False
 __lowerCamelCase    :				List[Any]								=       False
 __lowerCamelCase    :				Union[str, Any]								=       False




 def 				_snake_case (						self		)     ->				Union[str, Any]:
     _lowerCAmelCase						      =   DeiTModelTester(self		)
     _lowerCAmelCase						      =   ConfigTester(self      ,  config_class=_lowerCAmelCase      ,  has_text_modality=_lowerCAmelCase      ,  hidden_size=37		)




 def 				_snake_case (						self		)     ->				int:
     self.config_tester.run_common_tests()




 @unittest.skip(reason="DeiT does not use inputs_embeds"		)
 def 				_snake_case (						self		)     ->				List[Any]:
     pass




 def 				_snake_case (						self		)     ->				Any:
     _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs_for_common()

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




 def 				_snake_case (						self		)     ->				Dict:
     _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs_for_common()

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

         _lowerCAmelCase						      =   ["pixel_values"]
         self.assertListEqual(arg_names[:1]      ,  _lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				List[Any]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				List[Any]:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCAmelCase		)




 def 				_snake_case (						self		)     ->				Any:
     _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase		)




 def 				_snake_case (						self      ,  _lowerCAmelCase      ,  _lowerCAmelCase      ,  _lowerCAmelCase=False		)     ->				int:
     _lowerCAmelCase						      =   super()._prepare_for_class(_lowerCAmelCase      ,  _lowerCAmelCase      ,  return_labels=_lowerCAmelCase		)

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

     return inputs_dict




 def 				_snake_case (						self		)     ->				Tuple:
     if not self.model_tester.is_training:
         return

     _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs_for_common()
     _lowerCAmelCase						      =   True

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




 def 				_snake_case (						self		)     ->				int:
     _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs_for_common()
     if not self.model_tester.is_training:
         return

     _lowerCAmelCase						      =   False
     _lowerCAmelCase						      =   True

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




 def 				_snake_case (						self		)     ->				int:
     _lowerCAmelCase      ,      _lowerCAmelCase						      =   self.model_tester.prepare_config_and_inputs_for_common()

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

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

                 _lowerCAmelCase						      =   model_class(_lowerCAmelCase		)
                 model.to(_lowerCAmelCase		)
                 model.train()

                 _lowerCAmelCase						      =   self._prepare_for_class(_lowerCAmelCase      ,  _lowerCAmelCase      ,  return_labels=_lowerCAmelCase		)

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

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







def 						__a():



    '''simple docstring'''





    _lowerCAmelCase						      =   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		)     ->				Any:
     return (
         DeiTImageProcessor.from_pretrained("facebook/deit-base-distilled-patch16-224"		)
         if is_vision_available()
         else None
     )




 @slow
 def 				_snake_case (						self		)     ->				Optional[int]:
     _lowerCAmelCase						      =   DeiTForImageClassificationWithTeacher.from_pretrained("facebook/deit-base-distilled-patch16-224"		).to(
         _lowerCAmelCase		)

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

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

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

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

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





 @slow
 @require_accelerate
 @require_torch_gpu
 def 				_snake_case (						self		)     ->				Optional[Any]:
     _lowerCAmelCase						      =   DeiTModel.from_pretrained(
         "facebook/deit-base-distilled-patch16-224"      ,  torch_dtype=torch.floataa      ,  device_map="auto"		)
     _lowerCAmelCase						      =   self.default_image_processor

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

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





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


__lowercase				      =						logging.get_logger(__name__)

__lowercase				      =						{
    """microsoft/table-transformer-detection""": (
        """https://huggingface.co/microsoft/table-transformer-detection/resolve/main/config.json"""
    ),
}

class    _lowercase				(					__lowerCamelCase			):
   _lowercase     :       Any  					=    'table-transformer'
   _lowercase     :       List[Any]  					=    ['past_key_values']
   _lowercase     :       Union[str, Any]  					=    {
       'hidden_size': 'd_model',
       'num_attention_heads': 'encoder_attention_heads',
   }

   def __init__(				self	:    List[Any]			,						lowerCamelCase__	:    Any=True			,						lowerCamelCase__	:    List[Any]=None			,						lowerCamelCase__	:    Any=3			,						lowerCamelCase__	:    Any=1_0_0			,						lowerCamelCase__	:    int=6			,						lowerCamelCase__	:    List[Any]=2_0_4_8			,						lowerCamelCase__	:    List[str]=8			,						lowerCamelCase__	:    int=6			,						lowerCamelCase__	:    List[str]=2_0_4_8			,						lowerCamelCase__	:    Optional[int]=8			,						lowerCamelCase__	:    Union[str, Any]=0.0			,						lowerCamelCase__	:    Any=0.0			,						lowerCamelCase__	:    str=True			,						lowerCamelCase__	:    Optional[Any]="relu"			,						lowerCamelCase__	:    Optional[int]=2_5_6			,						lowerCamelCase__	:    List[str]=0.1			,						lowerCamelCase__	:    str=0.0			,						lowerCamelCase__	:    Optional[int]=0.0			,						lowerCamelCase__	:    Dict=0.02			,						lowerCamelCase__	:    Union[str, Any]=1.0			,						lowerCamelCase__	:    Union[str, Any]=False			,						lowerCamelCase__	:    Optional[int]="sine"			,						lowerCamelCase__	:    str="resnet50"			,						lowerCamelCase__	:    List[str]=True			,						lowerCamelCase__	:    Optional[Any]=False			,						lowerCamelCase__	:    Any=1			,						lowerCamelCase__	:    int=5			,						lowerCamelCase__	:    Union[str, Any]=2			,						lowerCamelCase__	:    List[str]=1			,						lowerCamelCase__	:    Union[str, Any]=1			,						lowerCamelCase__	:    Optional[Any]=5			,						lowerCamelCase__	:    Tuple=2			,						lowerCamelCase__	:    List[str]=0.1			,						**lowerCamelCase__	:    List[str]			,						) ->			Dict:
         """simple docstring"""





         if backbone_config is not None and use_timm_backbone:
               raise ValueError('''You can\'t specify both `backbone_config` and `use_timm_backbone`.'''       )

         if not use_timm_backbone:
               if backbone_config is None:
                     logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''       )
                     A_							       =		CONFIG_MAPPING['''resnet'''](out_features=['''stage4''']       )
               elif isinstance(lowerCamelCase__			,						lowerCamelCase__       ):
                     A_							       =		backbone_config.get('''model_type'''       )
                     A_							       =		CONFIG_MAPPING[backbone_model_type]
                     A_							       =		config_class.from_dict(lowerCamelCase__       )
               # set timm attributes to None
               A_       ,A_       ,A_							       =		None, None, None

         A_							       =		use_timm_backbone
         A_							       =		backbone_config
         A_							       =		num_channels
         A_							       =		num_queries
         A_							       =		d_model
         A_							       =		encoder_ffn_dim
         A_							       =		encoder_layers
         A_							       =		encoder_attention_heads
         A_							       =		decoder_ffn_dim
         A_							       =		decoder_layers
         A_							       =		decoder_attention_heads
         A_							       =		dropout
         A_							       =		attention_dropout
         A_							       =		activation_dropout
         A_							       =		activation_function
         A_							       =		init_std
         A_							       =		init_xavier_std
         A_							       =		encoder_layerdrop
         A_							       =		decoder_layerdrop
         A_							       =		encoder_layers
         A_							       =		auxiliary_loss
         A_							       =		position_embedding_type
         A_							       =		backbone
         A_							       =		use_pretrained_backbone
         A_							       =		dilation
         # Hungarian matcher
         A_							       =		class_cost
         A_							       =		bbox_cost
         A_							       =		giou_cost
         # Loss coefficients
         A_							       =		mask_loss_coefficient
         A_							       =		dice_loss_coefficient
         A_							       =		bbox_loss_coefficient
         A_							       =		giou_loss_coefficient
         A_							       =		eos_coefficient
         super().__init__(is_encoder_decoder=lowerCamelCase__			,						**lowerCamelCase__       )

   @property
   def     UpperCamelCase					(				self	:    Optional[Any]       ) ->			int:
         """simple docstring"""





         return self.encoder_attention_heads





   @property
   def     UpperCamelCase					(				self	:    Any       ) ->			int:
         """simple docstring"""





         return self.d_model



class    _lowercase				(					__lowerCamelCase			):
   _lowercase     :       Tuple  					=    version.parse('1.11'			)

   @property
   def     UpperCamelCase					(				self	:    Any       ) ->			Mapping[str, Mapping[int, str]]:
         """simple docstring"""





         return OrderedDict(
             [
                 ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
                 ('''pixel_mask''', {0: '''batch'''}),
             ]       )

   @property
   def     UpperCamelCase					(				self	:    List[Any]       ) ->			float:
         """simple docstring"""





         return 1e-5





   @property
   def     UpperCamelCase					(				self	:    List[Any]       ) ->			int:
         """simple docstring"""





         return 1_2





