





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import DeiTConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TFDeiTForImageClassification,
      TFDeiTForImageClassificationWithTeacher,
      TFDeiTForMaskedImageModeling,
      TFDeiTModel,
  )
  from transformers.models.deit.modeling_tf_deit import TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import DeiTImageProcessor



class 					__snake_case	:


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_=13   ,				A_=30   ,				A_=2   ,				A_=3   ,				A_=True   ,				A_=True   ,				A_=32   ,				A_=2   ,				A_=4   ,				A_=37   ,				A_="gelu"   ,				A_=0.1   ,				A_=0.1   ,				A_=10   ,				A_=0.02   ,				A_=3   ,				A_=None   ,				A_=2   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			parent
        SCREAMING_SNAKE_CASE__											=			batch_size
        SCREAMING_SNAKE_CASE__											=			image_size
        SCREAMING_SNAKE_CASE__											=			patch_size
        SCREAMING_SNAKE_CASE__											=			num_channels
        SCREAMING_SNAKE_CASE__											=			is_training
        SCREAMING_SNAKE_CASE__											=			use_labels
        SCREAMING_SNAKE_CASE__											=			hidden_size
        SCREAMING_SNAKE_CASE__											=			num_hidden_layers
        SCREAMING_SNAKE_CASE__											=			num_attention_heads
        SCREAMING_SNAKE_CASE__											=			intermediate_size
        SCREAMING_SNAKE_CASE__											=			hidden_act
        SCREAMING_SNAKE_CASE__											=			hidden_dropout_prob
        SCREAMING_SNAKE_CASE__											=			attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE__											=			type_sequence_label_size
        SCREAMING_SNAKE_CASE__											=			initializer_range
        SCREAMING_SNAKE_CASE__											=			scope
        SCREAMING_SNAKE_CASE__											=			encoder_stride

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



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

        SCREAMING_SNAKE_CASE__											=			self.get_config()

        return config, pixel_values, labels



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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFDeiTModel(config=A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_     )
        self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFDeiTForMaskedImageModeling(config=A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_     )
        self.parent.assertEqual(
            result.reconstruction.shape   ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)     )

        # test greyscale images
        SCREAMING_SNAKE_CASE__											=			1
        SCREAMING_SNAKE_CASE__											=			TFDeiTForMaskedImageModeling(A_     )

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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.type_sequence_label_size
        SCREAMING_SNAKE_CASE__											=			TFDeiTForImageClassification(A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				labels=A_     )
        self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.type_sequence_label_size)     )

        # test greyscale images
        SCREAMING_SNAKE_CASE__											=			1
        SCREAMING_SNAKE_CASE__											=			TFDeiTForImageClassification(A_     )

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




    def  lowercase_					(       self     ):





        '''simple docstring'''

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





@require_tf
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







    lowerCamelCase__    :		Tuple				=	(
        (
            TFDeiTModel,
            TFDeiTForImageClassification,
            TFDeiTForImageClassificationWithTeacher,
            TFDeiTForMaskedImageModeling,
        )
        if is_tf_available()
        else ()
    )
    lowerCamelCase__    :		Tuple				=	(
        {
            'feature-extraction': TFDeiTModel,
            'image-classification': (TFDeiTForImageClassification, TFDeiTForImageClassificationWithTeacher),
        }
        if is_tf_available()
        else {}
    )

    lowerCamelCase__    :		Union[str, Any]				=	False
    lowerCamelCase__    :		Any				=	False
    lowerCamelCase__    :		List[str]				=	False
    lowerCamelCase__    :		Optional[Any]				=	False



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFDeiTModelTester(self     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_   ,				has_text_modality=A_   ,				hidden_size=37     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



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





        '''simple docstring'''

        pass



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__											=			model_class(A_     )
            self.assertIsInstance(model.get_input_embeddings()   ,				(tf.keras.layers.Layer)     )
            SCREAMING_SNAKE_CASE__											=			model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(A_   ,				tf.keras.layers.Dense     )     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs_for_common()

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

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



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_masked_image_modeling(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*A_     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_=False     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			super()._prepare_for_class(A_   ,				A_   ,				return_labels=A_     )

        if return_labels:
            if "labels" in inputs_dict and "labels" not in inspect.signature(model_class.call     ).parameters:
                del inputs_dict["labels"]

        return inputs_dict




    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        for model_name in TF_DEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__											=			TFDeiTModel.from_pretrained(A_     )
            self.assertIsNotNone(A_     )





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



@require_tf
@require_vision
class 					__snake_case	(  unittest.TestCase    ):


    '''simple docstring'''







    @cached_property
    def  lowercase_					(       self     ):





        '''simple docstring'''

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




    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFDeiTForImageClassificationWithTeacher.from_pretrained('''facebook/deit-base-distilled-patch16-224'''     )

        SCREAMING_SNAKE_CASE__											=			self.default_image_processor
        SCREAMING_SNAKE_CASE__											=			prepare_img()
        SCREAMING_SNAKE_CASE__											=			image_processor(images=A_   ,				return_tensors='''tf'''     )

        # forward pass
        SCREAMING_SNAKE_CASE__											=			model(**A_     )

        # verify the logits
        SCREAMING_SNAKE_CASE__											=			tf.TensorShape((1, 10_00)     )
        self.assertEqual(outputs.logits.shape   ,				A_     )

        SCREAMING_SNAKE_CASE__											=			tf.constant([-1.0266, 0.1912, -1.2861]     )

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








'''simple docstring'''
UpperCamelCase__			=      {
    "joule": 1.0,
    "kilojoule": 1000,
    "megajoule": 1000000,
    "gigajoule": 1000000000,
    "wattsecond": 1.0,
    "watthour": 3600,
    "kilowatthour": 3600000,
    "newtonmeter": 1.0,
    "calorie_nutr": 4186.8,
    "kilocalorie_nutr": 4186800.00,
    "electronvolt": 1.602176634e-19,
    "britishthermalunit_it": 1055.05585,
    "footpound": 1.35_58_18,
}




def 		__SCREAMING_SNAKE_CASE       (	_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase				):


   """simple docstring"""




   if to_type not in ENERGY_CONVERSION or from_type not in ENERGY_CONVERSION:
      lowercase_						:     Union[str, Any]							     =  (
          F"""Incorrect 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"""
          F"""Valid values are: {", ".join(_UpperCamelCase				)}"""
      )
      raise ValueError(_UpperCamelCase				)
   return value * ENERGY_CONVERSION[from_type] / ENERGY_CONVERSION[to_type]


if __name__ == "__main__":
 import doctest

 doctest.testmod()




