



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						,					__UpperCAmelCase						,					__UpperCAmelCase=13						,					__UpperCAmelCase=30						,					__UpperCAmelCase=2						,					__UpperCAmelCase=3						,					__UpperCAmelCase=True						,					__UpperCAmelCase=True						,					__UpperCAmelCase=32						,					__UpperCAmelCase=5						,					__UpperCAmelCase=4						,					__UpperCAmelCase=37						,					__UpperCAmelCase="gelu"						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=0.1						,					__UpperCAmelCase=10						,					__UpperCAmelCase=0.02						,					__UpperCAmelCase=3						,					__UpperCAmelCase=None						,					__UpperCAmelCase=2						,					):



    '''simple docstring'''
    __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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __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 							lowerCamelCase   (    self					):



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




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     DeiTModel(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(__UpperCAmelCase					)
    self.parent.assertEqual(result.last_hidden_state.shape						,					(self.batch_size, self.seq_length, self.hidden_size)					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     DeiTForMaskedImageModeling(config=__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(__UpperCAmelCase					)
    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(__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()

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




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.type_sequence_label_size
    __lowerCamelCase    				=     DeiTForImageClassification(__UpperCAmelCase					)
    model.to(__UpperCAmelCase					)
    model.eval()
    __lowerCamelCase    				=     model(__UpperCAmelCase						,					labels=__UpperCAmelCase					)
    self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.type_sequence_label_size)					)

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

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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __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  (						lowerCAmelCase__	,						lowerCAmelCase__	,						unittest.TestCase ):
 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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     DeiTModelTester(self					)
    __lowerCamelCase    				=     ConfigTester(self						,					config_class=__UpperCAmelCase						,					has_text_modality=__UpperCAmelCase						,					hidden_size=37					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    self.config_tester.run_common_tests()




 @unittest.skip(reason='''DeiT does not use inputs_embeds'''					)
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    pass




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase				,__lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs_for_common()

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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase				,__lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs_for_common()

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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase					)




 def 							lowerCamelCase   (    self						,					__UpperCAmelCase						,					__UpperCAmelCase						,					__UpperCAmelCase=False					):



    '''simple docstring'''
    __lowerCamelCase    				=     super()._prepare_for_class(__UpperCAmelCase						,					__UpperCAmelCase						,					return_labels=__UpperCAmelCase					)

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

    return inputs_dict




 def 							lowerCamelCase   (    self					):



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




 def 							lowerCamelCase   (    self					):



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




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __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(__UpperCAmelCase					),
               *get_values(__UpperCAmelCase					),
           ]
           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(__UpperCAmelCase					)
             model.to(__UpperCAmelCase					)
             model.train()

             __lowerCamelCase    				=     self._prepare_for_class(__UpperCAmelCase						,					__UpperCAmelCase						,					return_labels=__UpperCAmelCase					)

             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=__UpperCAmelCase					) as warning_list:
                __lowerCamelCase    				=     model(**__UpperCAmelCase					).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 							lowerCamelCase   (    self					):



    '''simple docstring'''
    for model_name in DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowerCamelCase    				=     DeiTModel.from_pretrained(__UpperCAmelCase					)
       self.assertIsNotNone(__UpperCAmelCase					)





def 		a__      (		):
   __lowerCamelCase    				=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
   return image





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




 @cached_property
 def 							lowerCamelCase   (    self					):



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




 @slow
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     DeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''					).to(
        __UpperCAmelCase					)

    __lowerCamelCase    				=     self.default_image_processor
    __lowerCamelCase    				=     prepare_img()
    __lowerCamelCase    				=     image_processor(images=__UpperCAmelCase						,					return_tensors='''pt'''					).to(__UpperCAmelCase					)

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

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

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

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




 @slow
 @require_accelerate
 @require_torch_gpu
 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __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=__UpperCAmelCase						,					return_tensors='''pt'''					)
    __lowerCamelCase    				=     inputs.pixel_values.to(__UpperCAmelCase					)

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











def 		a__      (		_UpperCamelCase      :			int			,_UpperCamelCase      :			int				):
   while second != 0:
      __lowerCamelCase    				=     first & second
      first ^= second
      __lowerCamelCase    				=     c << 1
   return first


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  a_								=       int(input("""Enter the first number: """).strip())
  a_								=       int(input("""Enter the second number: """).strip())
  print(f"{add(first, second) = }")






