
"""simple docstring"""






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 				snake_case    (			_UpperCAmelCase						):







   def 					UpperCAmelCase__     (      self)					->Optional[Any]:
      a_							=			self.config_class(**self.inputs_dict)
      self.parent.assertTrue(hasattr(lowerCAmelCase__    ,				"hidden_sizes"))
      self.parent.assertTrue(hasattr(lowerCAmelCase__    ,				"num_attention_heads"))






class 				snake_case    :







   def __init__(      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase=13    ,				__UpperCAmelCase=64    ,				__UpperCAmelCase=3    ,				__UpperCAmelCase=3    ,				__UpperCAmelCase=2    ,				__UpperCAmelCase=1    ,				__UpperCAmelCase=16    ,				__UpperCAmelCase=[1_28, 2_56, 3_84]    ,				__UpperCAmelCase=[4, 6, 8]    ,				__UpperCAmelCase=[2, 3, 4]    ,				__UpperCAmelCase=[16, 16, 16]    ,				__UpperCAmelCase=0    ,				__UpperCAmelCase=[2, 2, 2]    ,				__UpperCAmelCase=[2, 2, 2]    ,				__UpperCAmelCase=0.02    ,				__UpperCAmelCase=True    ,				__UpperCAmelCase=True    ,				__UpperCAmelCase=2    ,				)					->Tuple:
      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 					UpperCAmelCase__     (      self)					->Optional[int]:
      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 					UpperCAmelCase__     (      self)					->int:
      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 					UpperCAmelCase__     (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase)					->Tuple:
      a_							=			LevitModel(config=lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      a_							=			model(lowerCAmelCase__)
      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 					UpperCAmelCase__     (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase)					->str:
      a_							=			self.num_labels
      a_							=			LevitForImageClassification(lowerCAmelCase__)
      model.to(lowerCAmelCase__)
      model.eval()
      a_							=			model(lowerCAmelCase__    ,				labels=lowerCAmelCase__)
      self.parent.assertEqual(result.logits.shape    ,				(self.batch_size, self.num_labels))







   def 					UpperCAmelCase__     (      self)					->Union[str, Any]:
      a_							=			self.prepare_config_and_inputs()
      a_					,       a_					,       a_							=			config_and_inputs
      a_							=			{"pixel_values": pixel_values}
      return config, inputs_dict






@require_torch
class 				snake_case    (			_UpperCAmelCase				,    _UpperCAmelCase				,    unittest.TestCase						):
   a_ :						int			 =			(
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   a_ :						List[str]			 =			(
       {
           '''feature-extraction''': LevitModel,
           '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

   a_ :						int			 =			False
   a_ :						Dict			 =			False
   a_ :						Optional[Any]			 =			False
   a_ :						Optional[int]			 =			False
   a_ :						Dict			 =			False







   def 					UpperCAmelCase__     (      self)					->List[Any]:
      a_							=			LevitModelTester(self)
      a_							=			ConfigTester(self    ,				config_class=lowerCAmelCase__    ,				has_text_modality=lowerCAmelCase__    ,				hidden_size=37)







   def 					UpperCAmelCase__     (      self)					->List[Any]:
      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 					UpperCAmelCase__     (      self)					->List[str]:
      return







   @unittest.skip(reason="Levit does not use inputs_embeds")
   def 					UpperCAmelCase__     (      self)					->Union[str, Any]:
      pass







   @unittest.skip(reason="Levit does not support input and output embeddings")
   def 					UpperCAmelCase__     (      self)					->List[str]:
      pass







   @unittest.skip(reason="Levit does not output attentions")
   def 					UpperCAmelCase__     (      self)					->Tuple:
      pass







   def 					UpperCAmelCase__     (      self)					->str:
      a_					,       a_							=			self.model_tester.prepare_config_and_inputs_for_common()

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







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


      def check_hidden_states_output(__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase):
         a_							=			model_class(lowerCAmelCase__)
         model.to(lowerCAmelCase__)
         model.eval()

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

         a_							=			outputs.hidden_states

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

         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(lowerCAmelCase__    ,				lowerCAmelCase__    ,				lowerCAmelCase__)

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

         check_hidden_states_output(lowerCAmelCase__    ,				lowerCAmelCase__    ,				lowerCAmelCase__)







   @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests.")
   def 					UpperCAmelCase__     (      self)					->int:
      pass







   def 					UpperCAmelCase__     (      self    ,				__UpperCAmelCase    ,				__UpperCAmelCase    ,				__UpperCAmelCase=False)					->str:
      a_							=			super()._prepare_for_class(lowerCAmelCase__    ,				lowerCAmelCase__    ,				return_labels=lowerCAmelCase__)

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

      return inputs_dict







   def 					UpperCAmelCase__     (      self)					->Union[str, Any]:
      a_							=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCAmelCase__)







   def 					UpperCAmelCase__     (      self)					->Dict:
      a_							=			self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase__)







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


      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(lowerCAmelCase__)
             or model_class.__name__ == "LevitForImageClassificationWithTeacher"
         ):
            continue
         a_							=			model_class(lowerCAmelCase__)
         model.to(lowerCAmelCase__)
         model.train()
         a_							=			self._prepare_for_class(lowerCAmelCase__    ,				lowerCAmelCase__    ,				return_labels=lowerCAmelCase__)
         a_							=			model(**lowerCAmelCase__).loss
         loss.backward()







   def 					UpperCAmelCase__     (      self)					->Any:
      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(lowerCAmelCase__) or not model_class.supports_gradient_checkpointing:
            continue
         # LevitForImageClassificationWithTeacher supports inference-only
         if model_class.__name__ == "LevitForImageClassificationWithTeacher":
            continue
         a_							=			model_class(lowerCAmelCase__)
         model.gradient_checkpointing_enable()
         model.to(lowerCAmelCase__)
         model.train()
         a_							=			self._prepare_for_class(lowerCAmelCase__    ,				lowerCAmelCase__    ,				return_labels=lowerCAmelCase__)
         a_							=			model(**lowerCAmelCase__).loss
         loss.backward()







   def 					UpperCAmelCase__     (      self)					->str:
      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(lowerCAmelCase__),
             ]
             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(lowerCAmelCase__)
               model.to(lowerCAmelCase__)
               model.train()

               a_							=			self._prepare_for_class(lowerCAmelCase__    ,				lowerCAmelCase__    ,				return_labels=lowerCAmelCase__)

               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=lowerCAmelCase__) as warning_list:
                  a_							=			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 					UpperCAmelCase__     (      self)					->Dict:


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






def 					UpperCamelCase		( )		->Optional[int]:

   """simple docstring"""



   a_							=			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
   return image





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







   @cached_property
   def 					UpperCAmelCase__     (      self)					->str:
      return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0])







   @slow
   def 					UpperCAmelCase__     (      self)					->Dict:
      a_							=			LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(
          lowerCAmelCase__)

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

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

      # verify the logits
      a_							=			torch.Size((1, 10_00))
      self.assertEqual(outputs.logits.shape    ,				lowerCAmelCase__)

      a_							=			torch.tensor([1.0_448, -0.3_745, -1.8_317]).to(lowerCAmelCase__)

      self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,				lowerCAmelCase__    ,				atol=1E-4))
import warnings
from functools import wraps
from typing import Callable





def 				UpperCAmelCase						(    lowercase							):







				"""simple docstring"""



				@wraps(lowercase							)
				def _inner_fn(*lowercase							,			**lowercase							):
								warnings.warn(
								    (F"'{fn.__name__}' is experimental and might be subject to breaking changes in the future.")							,			lowercase							,			)
								return fn(*lowercase							,			**lowercase							)

				return _inner_fn