



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 							A__ (  self   :  str  ):
       lowercase__   					=			self.config_class(**self.inputs_dict  )
       self.parent.assertTrue(hasattr(UpperCamelCase_,   "hidden_sizes"  )  )
       self.parent.assertTrue(hasattr(UpperCamelCase_,   "num_attention_heads"  )  )
class 			_snake_case     :




    def __init__(  self   :  Dict,   __lowercase   :  List[Any],   __lowercase   :  str=13,   __lowercase   :  Optional[Any]=64,   __lowercase   :  Optional[Any]=3,   __lowercase   :  Dict=3,   __lowercase   :  Optional[int]=2,   __lowercase   :  Any=1,   __lowercase   :  List[str]=16,   __lowercase   :  List[str]=[128, 256, 384],   __lowercase   :  Optional[int]=[4, 6, 8],   __lowercase   :  Dict=[2, 3, 4],   __lowercase   :  List[Any]=[16, 16, 16],   __lowercase   :  Union[str, Any]=0,   __lowercase   :  List[str]=[2, 2, 2],   __lowercase   :  int=[2, 2, 2],   __lowercase   :  Tuple=0.02,   __lowercase   :  List[str]=True,   __lowercase   :  Tuple=True,   __lowercase   :  Union[str, Any]=2,   ):
       lowercase__   					=			parent
       lowercase__   					=			batch_size
       lowercase__   					=			image_size
       lowercase__   					=			num_channels
       lowercase__   					=			kernel_size
       lowercase__   					=			stride
       lowercase__   					=			padding
       lowercase__   					=			hidden_sizes
       lowercase__   					=			num_attention_heads
       lowercase__   					=			depths
       lowercase__   					=			key_dim
       lowercase__   					=			drop_path_rate
       lowercase__   					=			patch_size
       lowercase__   					=			attention_ratio
       lowercase__   					=			mlp_ratio
       lowercase__   					=			initializer_range
       lowercase__   					=			[
           ["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],
       ]
       lowercase__   					=			is_training
       lowercase__   					=			use_labels
       lowercase__   					=			num_labels
       lowercase__   					=			initializer_range




    def 							A__ (  self   :  str  ):
       lowercase__   					=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

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




    def 							A__ (  self   :  Tuple  ):
       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 							A__ (  self   :  Union[str, Any],   __lowercase   :  Any,   __lowercase   :  List[str],   __lowercase   :  List[str]  ):
       lowercase__   					=			LevitModel(config=UpperCamelCase_  )
       model.to(UpperCamelCase_  )
       model.eval()
       lowercase__   					=			model(UpperCamelCase_  )
       lowercase__   					=			(self.image_size, self.image_size)
       lowercase__					,    lowercase__   					=			image_size[0], image_size[1]
       for _ in range(4  ):
          lowercase__   					=			floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1  )
          lowercase__   					=			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 							A__ (  self   :  List[Any],   __lowercase   :  List[Any],   __lowercase   :  str,   __lowercase   :  List[str]  ):
       lowercase__   					=			self.num_labels
       lowercase__   					=			LevitForImageClassification(UpperCamelCase_  )
       model.to(UpperCamelCase_  )
       model.eval()
       lowercase__   					=			model(UpperCamelCase_,   labels=UpperCamelCase_  )
       self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.num_labels)  )




    def 							A__ (  self   :  str  ):
       lowercase__   					=			self.prepare_config_and_inputs()
       lowercase__					,    lowercase__					,    lowercase__   					=			config_and_inputs
       lowercase__   					=			{"pixel_values": pixel_values}
       return config, inputs_dict
@require_torch
class 			_snake_case     (   UpperCamelCase__      ,		UpperCamelCase__      ,		unittest.TestCase):
    UpperCamelCase__			:   str       						=(
        (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
        if is_torch_available()
        else ()
    )
    UpperCamelCase__			:   Tuple       						=(
        {
            '''feature-extraction''': LevitModel,
            '''image-classification''': (LevitForImageClassification, LevitForImageClassificationWithTeacher),
        }
        if is_torch_available()
        else {}
    )

    UpperCamelCase__			:   Any       						=False
    UpperCamelCase__			:   Union[str, Any]       						=False
    UpperCamelCase__			:   Tuple       						=False
    UpperCamelCase__			:   Dict       						=False
    UpperCamelCase__			:   Any       						=False




    def 							A__ (  self   :  int  ):
       lowercase__   					=			LevitModelTester(self  )
       lowercase__   					=			ConfigTester(self,   config_class=UpperCamelCase_,   has_text_modality=UpperCamelCase_,   hidden_size=37  )




    def 							A__ (  self   :  Optional[int]  ):
       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 							A__ (  self   :  Any  ):
       return




    @unittest.skip(reason="Levit does not use inputs_embeds"  )
    def 							A__ (  self   :  List[Any]  ):
       pass




    @unittest.skip(reason="Levit does not support input and output embeddings"  )
    def 							A__ (  self   :  Dict  ):
       pass




    @unittest.skip(reason="Levit does not output attentions"  )
    def 							A__ (  self   :  Optional[int]  ):
       pass




    def 							A__ (  self   :  Tuple  ):
       lowercase__					,    lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()

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

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




    def 							A__ (  self   :  Optional[int]  ):







       def check_hidden_states_output(__lowercase   :  int,   __lowercase   :  Any,   __lowercase   :  str  ):
          lowercase__   					=			model_class(UpperCamelCase_  )
          model.to(UpperCamelCase_  )
          model.eval()

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

          lowercase__   					=			outputs.hidden_states

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

          lowercase__   					=			(self.model_tester.image_size, self.model_tester.image_size)
          lowercase__					,    lowercase__   					=			image_size[0], image_size[1]
          for _ in range(4  ):
             lowercase__   					=			floor(
                 (
                     (height + 2 * self.model_tester.padding - self.model_tester.kernel_size)
                     / self.model_tester.stride
                 )
                 + 1  )
             lowercase__   					=			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],
              ],   )

       lowercase__					,    lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()

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

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

          check_hidden_states_output(UpperCamelCase_,   UpperCamelCase_,   UpperCamelCase_  )




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




    def 							A__ (  self   :  Union[str, Any],   __lowercase   :  str,   __lowercase   :  Any,   __lowercase   :  Optional[int]=False  ):
       lowercase__   					=			super()._prepare_for_class(UpperCamelCase_,   UpperCamelCase_,   return_labels=UpperCamelCase_  )

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

       return inputs_dict




    def 							A__ (  self   :  Any  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCamelCase_  )




    def 							A__ (  self   :  Tuple  ):
       lowercase__   					=			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCamelCase_  )




    def 							A__ (  self   :  Union[str, Any]  ):







       if not self.model_tester.is_training:
          return

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

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




    def 							A__ (  self   :  Optional[Any]  ):
       lowercase__					,    lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
          return

       lowercase__   					=			False
       lowercase__   					=			True

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




    def 							A__ (  self   :  List[Any]  ):
       lowercase__					,    lowercase__   					=			self.model_tester.prepare_config_and_inputs_for_common()

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

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

                lowercase__   					=			model_class(UpperCamelCase_  )
                model.to(UpperCamelCase_  )
                model.train()

                lowercase__   					=			self._prepare_for_class(UpperCamelCase_,   UpperCamelCase_,   return_labels=UpperCamelCase_  )

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

                lowercase__   					=			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:
                   lowercase__   					=			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 							A__ (  self   :  Dict  ):







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



def __lowerCAmelCase	(       ):
   lowercase__   					=			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
   return image




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




    @cached_property
    def 							A__ (  self   :  Any  ):
       return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )




    @slow
    def 							A__ (  self   :  List[Any]  ):
       lowercase__   					=			LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]  ).to(
           UpperCamelCase_  )

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

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

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

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

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









def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			int(SCREAMING_SNAKE_CASE_					)
			if decimal in (0, 1):  # Exit cases for the recursion
						return str(SCREAMING_SNAKE_CASE_					)
			lowercase__					,    lowercase__   					=			divmod(SCREAMING_SNAKE_CASE_  ,					2					)
			return binary_recursive(SCREAMING_SNAKE_CASE_					) + str(SCREAMING_SNAKE_CASE_					)



def __lowerCAmelCase	(       SCREAMING_SNAKE_CASE_					):
			lowercase__   					=			str(SCREAMING_SNAKE_CASE_					).strip()
			if not number:
						raise ValueError("No input value was provided"					)
			lowercase__   					=			"-" if number.startswith("-"					) else ""
			lowercase__   					=			number.lstrip("-"					)
			if not number.isnumeric():
						raise ValueError("Input value is not an integer"					)
			return f'''{negative}0b{binary_recursive(int(SCREAMING_SNAKE_CASE_					)					)}'''


if __name__ == "__main__":
							from doctest import testmod

							testmod()




