




import inspect
import unittest
import warnings
from math import ceil, floor

from transformers import LevitConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 transformers import (
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_MAPPING,
      LevitForImageClassification,
      LevitForImageClassificationWithTeacher,
      LevitModel,
  )
  from transformers.models.levit.modeling_levit import LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import LevitImageProcessor


class     UpperCamelCase_   (			SCREAMING_SNAKE_CASE__					):

    '''simple docstring'''






    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Tuple:





           '''simple docstring'''

           A__							=   self.config_class(**self.inputs_dict)
           self.parent.assertTrue(hasattr(A__ ,			'''hidden_sizes'''))
           self.parent.assertTrue(hasattr(A__ ,			'''num_attention_heads'''))


class     UpperCamelCase_   :

    '''simple docstring'''






    def __init__(      self				:     Union[str, Any] ,			UpperCAmelCase__				:     Union[str, Any] ,			UpperCAmelCase__				:     List[Any]=13 ,			UpperCAmelCase__				:     str=64 ,			UpperCAmelCase__				:     Optional[int]=3 ,			UpperCAmelCase__				:     Optional[Any]=3 ,			UpperCAmelCase__				:     int=2 ,			UpperCAmelCase__				:     Optional[Any]=1 ,			UpperCAmelCase__				:     Optional[Any]=16 ,			UpperCAmelCase__				:     Optional[int]=[128, 256, 384] ,			UpperCAmelCase__				:     Tuple=[4, 6, 8] ,			UpperCAmelCase__				:     Any=[2, 3, 4] ,			UpperCAmelCase__				:     Union[str, Any]=[16, 16, 16] ,			UpperCAmelCase__				:     List[str]=0 ,			UpperCAmelCase__				:     Tuple=[2, 2, 2] ,			UpperCAmelCase__				:     List[Any]=[2, 2, 2] ,			UpperCAmelCase__				:     List[Any]=0.02 ,			UpperCAmelCase__				:     str=True ,			UpperCAmelCase__				:     Union[str, Any]=True ,			UpperCAmelCase__				:     Tuple=2 ,			)						->int:





           '''simple docstring'''

           A__							=   parent
           A__							=   batch_size
           A__							=   image_size
           A__							=   num_channels
           A__							=   kernel_size
           A__							=   stride
           A__							=   padding
           A__							=   hidden_sizes
           A__							=   num_attention_heads
           A__							=   depths
           A__							=   key_dim
           A__							=   drop_path_rate
           A__							=   patch_size
           A__							=   attention_ratio
           A__							=   mlp_ratio
           A__							=   initializer_range
           A__							=   [
               ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
               ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
           ]
           A__							=   is_training
           A__							=   use_labels
           A__							=   num_labels
           A__							=   initializer_range


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Union[str, Any]:





           '''simple docstring'''

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

           A__							=   None
           if self.use_labels:
                  A__							=   ids_tensor([self.batch_size] ,			self.num_labels)

           A__							=   self.get_config()
           return config, pixel_values, labels


    def 	SCREAMING_SNAKE_CASE							(      self				:     Tuple)						->List[str]:





           '''simple docstring'''

           return LevitConfig(
               image_size=self.image_size ,			num_channels=self.num_channels ,			kernel_size=self.kernel_size ,			stride=self.stride ,			padding=self.padding ,			patch_size=self.patch_size ,			hidden_sizes=self.hidden_sizes ,			num_attention_heads=self.num_attention_heads ,			depths=self.depths ,			key_dim=self.key_dim ,			drop_path_rate=self.drop_path_rate ,			mlp_ratio=self.mlp_ratio ,			attention_ratio=self.attention_ratio ,			initializer_range=self.initializer_range ,			down_ops=self.down_ops ,			)


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[str] ,			UpperCAmelCase__				:     List[Any] ,			UpperCAmelCase__				:     List[Any] ,			UpperCAmelCase__				:     Tuple)						->int:





           '''simple docstring'''

           A__							=   LevitModel(config=A__)
           model.to(A__)
           model.eval()
           A__							=   model(A__)
           A__							=   (self.image_size, self.image_size)
           A__			,							A__							=   image_size[0], image_size[1]
           for _ in range(4):
                  A__							=   floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1)
                  A__							=   floor(((width + 2 * self.padding - self.kernel_size) / self.stride) + 1)
           self.parent.assertEqual(
               result.last_hidden_state.shape ,			(self.batch_size, ceil(height / 4) * ceil(width / 4), self.hidden_sizes[-1]) ,			)


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[str] ,			UpperCAmelCase__				:     int ,			UpperCAmelCase__				:     Dict ,			UpperCAmelCase__				:     Any)						->int:





           '''simple docstring'''

           A__							=   self.num_labels
           A__							=   LevitForImageClassification(A__)
           model.to(A__)
           model.eval()
           A__							=   model(A__ ,			labels=A__)
           self.parent.assertEqual(result.logits.shape ,			(self.batch_size, self.num_labels))





    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->List[str]:





           '''simple docstring'''

           A__							=   self.prepare_config_and_inputs()
           A__			,							A__			,							A__							=   config_and_inputs
           A__							=   {'''pixel_values''': pixel_values}
           return config, inputs_dict


@require_torch
class     UpperCamelCase_   (			SCREAMING_SNAKE_CASE__		, SCREAMING_SNAKE_CASE__		, unittest.TestCase					):

    '''simple docstring'''






    UpperCAmelCase__							  =				(
        (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
        if is_torch_available()
        else ()
    )
    UpperCAmelCase__							  =				(
        {
            '''feature-extraction''': LevitModel,
            '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
        }
        if is_torch_available()
        else {}
    )

    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False
    UpperCAmelCase__							  =				False


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Tuple:





           '''simple docstring'''

           A__							=   LevitModelTester(self)
           A__							=   ConfigTester(self ,			config_class=A__ ,			has_text_modality=A__ ,			hidden_size=37)


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[Any])						->int:





           '''simple docstring'''

           self.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.create_and_test_config_with_num_labels()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[Any])						->Any:





           '''simple docstring'''

           return


    @unittest.skip(reason='''Levit does not use inputs_embeds''')
    def 	SCREAMING_SNAKE_CASE							(      self				:     int)						->Any:





           '''simple docstring'''

           pass


    @unittest.skip(reason='''Levit does not support input and output embeddings''')
    def 	SCREAMING_SNAKE_CASE							(      self				:     int)						->Optional[Any]:





           '''simple docstring'''

           pass


    @unittest.skip(reason='''Levit does not output attentions''')
    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->Dict:





           '''simple docstring'''

           pass


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int])						->Tuple:





           '''simple docstring'''

           A__			,							A__							=   self.model_tester.prepare_config_and_inputs_for_common()

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

                  A__							=   ['''pixel_values''']
                  self.assertListEqual(arg_names[:1] ,			A__)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int])						->Optional[Any]:





           '''simple docstring'''

           def check_hidden_states_output(UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     List[Any] ,			UpperCAmelCase__				:     Union[str, Any]):
                  A__							=   model_class(A__)
                  model.to(A__)
                  model.eval()

                  with torch.no_grad():
                         A__							=   model(**self._prepare_for_class(A__ ,			A__))

                  A__							=   outputs.hidden_states

                  A__							=   len(self.model_tester.depths) + 1
                  self.assertEqual(len(A__) ,			A__)

                  A__							=   (self.model_tester.image_size, self.model_tester.image_size)
                  A__			,							A__							=   image_size[0], image_size[1]
                  for _ in range(4):
                         A__							=   floor(
                             (
                                 (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                                 / self.model_tester.stride
                             )
                             + 1)
                         A__							=   floor(
                             (
                                 (width + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                                 / self.model_tester.stride
                             )
                             + 1)
                  # verify the first hidden states (first block)
                  self.assertListEqual(
                      list(hidden_states[0].shape[-2:]) ,			[
                          height * width,
                          self.model_tester.hidden_sizes[0],
                      ] ,			)

           A__			,							A__							=   self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
                  A__							=   True
                  check_hidden_states_output(A__ ,			A__ ,			A__)

                  # check that output_hidden_states also work using config
                  del inputs_dict["output_hidden_states"]
                  A__							=   True

                  check_hidden_states_output(A__ ,			A__ ,			A__)


    @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
    def 	SCREAMING_SNAKE_CASE							(      self				:     str)						->Union[str, Any]:





           '''simple docstring'''

           pass


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int] ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Any ,			UpperCAmelCase__				:     Tuple=False)						->List[Any]:





           '''simple docstring'''

           A__							=   super()._prepare_for_class(A__ ,			A__ ,			return_labels=A__)

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

           return inputs_dict


    def 	SCREAMING_SNAKE_CASE							(      self				:     List[str])						->str:





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A__)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int])						->Optional[Any]:





           '''simple docstring'''

           A__							=   self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*A__)


    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->int:





           '''simple docstring'''

           if not self.model_tester.is_training:
                  return

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

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


    def 	SCREAMING_SNAKE_CASE							(      self				:     Union[str, Any])						->int:





           '''simple docstring'''

           A__			,							A__							=   self.model_tester.prepare_config_and_inputs_for_common()
           if not self.model_tester.is_training:
                  return

           A__							=   False
           A__							=   True

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


    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->List[Any]:





           '''simple docstring'''

           A__			,							A__							=   self.model_tester.prepare_config_and_inputs_for_common()

           A__							=   [
               {'''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__),
                      ]
                      or model_class.__name__ == "LevitForImageClassificationWithTeacher"
                  ):
                         continue

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

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

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

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

                                A__							=   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:
                                       A__							=   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 	SCREAMING_SNAKE_CASE							(      self				:     Optional[Any])						->Union[str, Any]:





           '''simple docstring'''

           for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  A__							=   LevitModel.from_pretrained(A__)
                  self.assertIsNotNone(A__)







def SCREAMING_SNAKE_CASE    (	)       ->	int:



       """simple docstring"""

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


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

    '''simple docstring'''






    @cached_property
    def 	SCREAMING_SNAKE_CASE							(      self				:     Optional[int])						->Optional[Any]:





           '''simple docstring'''

           return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])





    @slow
    def 	SCREAMING_SNAKE_CASE							(      self				:     Any)						->Any:





           '''simple docstring'''

           A__							=   LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
               A__)

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

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

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

           A__							=   torch.tensor([1.0448, -0.3745, -1.8317]).to(A__)

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








_lowerCamelCase     :		dict[str, float]								=       {
    "km/h": 1.0,
    "m/s": 3.6,
    "mph": 1.609_344,
    "knot": 1.852,
}

_lowerCamelCase     :		dict[str, float]								=       {
    "km/h": 1.0,
    "m/s": 0.277_777_778,
    "mph": 0.621_371_192,
    "knot": 0.539_956_803,
}







def SCREAMING_SNAKE_CASE    (	lowercase_			,    lowercase_			,    lowercase_						)       ->	float:



       """simple docstring"""

       if unit_to not in speed_chart or unit_from not in speed_chart_inverse:
              A__							=   (
                  f"""Incorrect 'from_type' or 'to_type' value: {unit_from!r}, {unit_to!r}\n"""
                  f"""Valid values are: {", ".join(lowercase_						)}"""
              )
              raise ValueError(lowercase_						)
       return round(speed * speed_chart[unit_from] * speed_chart_inverse[unit_to]			,    3						)


if __name__ == "__main__":
  import doctest

  doctest.testmod()


