


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 					lowercase__ (			_UpperCamelCase       ):

   '''simple docstring'''


   def    UpperCamelCase__						(					self							)				->   Dict:






       """simple docstring"""
       UpperCamelCase__							:       int      =   self.config_class(**self.inputs_dict							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''hidden_sizes'''							)							)
       self.parent.assertTrue(hasattr(__magic_name__,	'''num_attention_heads'''							)							)






class 					lowercase__ :

   '''simple docstring'''


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






       """simple docstring"""
       UpperCamelCase__							:       Optional[Any]      =   parent
       UpperCamelCase__							:       Dict      =   batch_size
       UpperCamelCase__							:       str      =   image_size
       UpperCamelCase__							:       Tuple      =   num_channels
       UpperCamelCase__							:       Optional[Any]      =   kernel_size
       UpperCamelCase__							:       List[Any]      =   stride
       UpperCamelCase__							:       Tuple      =   padding
       UpperCamelCase__							:       int      =   hidden_sizes
       UpperCamelCase__							:       Dict      =   num_attention_heads
       UpperCamelCase__							:       Union[str, Any]      =   depths
       UpperCamelCase__							:       Dict      =   key_dim
       UpperCamelCase__							:       int      =   drop_path_rate
       UpperCamelCase__							:       Any      =   patch_size
       UpperCamelCase__							:       Optional[Any]      =   attention_ratio
       UpperCamelCase__							:       List[str]      =   mlp_ratio
       UpperCamelCase__							:       Union[str, Any]      =   initializer_range
       UpperCamelCase__							:       Dict      =   [
           ["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],
       ]
       UpperCamelCase__							:       int      =   is_training
       UpperCamelCase__							:       Any      =   use_labels
       UpperCamelCase__							:       Tuple      =   num_labels
       UpperCamelCase__							:       Optional[Any]      =   initializer_range




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






       """simple docstring"""
       UpperCamelCase__							:       List[Any]      =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

       UpperCamelCase__							:       Optional[Any]      =   None
       if self.use_labels:
           UpperCamelCase__							:       int      =   ids_tensor([self.batch_size],	self.num_labels							)

       UpperCamelCase__							:       Tuple      =   self.get_config()
       return config, pixel_values, labels




   def    UpperCamelCase__						(					self							)				->   Optional[int]:






       """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    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__							)				->   Optional[int]:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   LevitModel(config=__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       str      =   model(__magic_name__							)
       UpperCamelCase__							:       Optional[int]      =   (self.image_size, self.image_size)
       UpperCamelCase__							:       str      =   image_size[0], image_size[1]
       for _ in range(4							):
           UpperCamelCase__							:       Optional[Any]      =   floor(((height + 2 * self.padding - self.kernel_size) / self.stride) + 1							)
           UpperCamelCase__							:       Optional[int]      =   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,	__magic_name__,	__magic_name__,	__magic_name__							)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       Dict      =   self.num_labels
       UpperCamelCase__							:       Tuple      =   LevitForImageClassification(__magic_name__							)
       model.to(__magic_name__							)
       model.eval()
       UpperCamelCase__							:       int      =   model(__magic_name__,	labels=__magic_name__							)
       self.parent.assertEqual(result.logits.shape,	(self.batch_size, self.num_labels)							)




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






       """simple docstring"""
       UpperCamelCase__							:       int      =   self.prepare_config_and_inputs()
       UpperCamelCase__							:       Tuple      =   config_and_inputs
       UpperCamelCase__							:       Optional[int]      =   {"pixel_values": pixel_values}
       return config, inputs_dict






@require_torch
class 					lowercase__ (			_UpperCamelCase    ,       _UpperCamelCase    ,       unittest.TestCase       ):

   '''simple docstring'''


   a		:							int     	=	(
       (LevitModel, LevitForImageClassification, LevitForImageClassificationWithTeacher)
       if is_torch_available()
       else ()
   )
   a		:							Dict     	=	(
       {
           "feature-extraction": LevitModel,
           "image-classification": (LevitForImageClassification, LevitForImageClassificationWithTeacher),
       }
       if is_torch_available()
       else {}
   )

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




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Union[str, Any]      =   LevitModelTester(self							)
       UpperCamelCase__							:       Union[str, Any]      =   ConfigTester(self,	config_class=__magic_name__,	has_text_modality=__magic_name__,	hidden_size=37							)




   def    UpperCamelCase__						(					self							)				->   Any:






       """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    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       return




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






       """simple docstring"""
       pass




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






       """simple docstring"""
       pass




   @unittest.skip(reason='''Levit does not output attentions'''							)
   def    UpperCamelCase__						(					self							)				->   List[Any]:






       """simple docstring"""
       pass




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Union[str, Any]      =   self.model_tester.prepare_config_and_inputs_for_common()

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

           UpperCamelCase__							:       int      =   ["pixel_values"]
           self.assertListEqual(arg_names[:1],	__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       def check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							):
           UpperCamelCase__							:       List[Any]      =   model_class(__magic_name__							)
           model.to(__magic_name__							)
           model.eval()

           with torch.no_grad():
               UpperCamelCase__							:       Union[str, Any]      =   model(**self._prepare_for_class(__magic_name__,	__magic_name__							)							)

           UpperCamelCase__							:       Dict      =   outputs.hidden_states

           UpperCamelCase__							:       str      =   len(self.model_tester.depths							) + 1
           self.assertEqual(len(__magic_name__							),	__magic_name__							)

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

       UpperCamelCase__							:       Union[str, Any]      =   self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
           UpperCamelCase__							:       Optional[int]      =   True
           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           UpperCamelCase__							:       int      =   True

           check_hidden_states_output(__magic_name__,	__magic_name__,	__magic_name__							)




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






       """simple docstring"""
       pass




   def    UpperCamelCase__						(					self,	__magic_name__,	__magic_name__,	__magic_name__=False							)				->   Union[str, Any]:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   super()._prepare_for_class(__magic_name__,	__magic_name__,	return_labels=__magic_name__							)

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

       return inputs_dict




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       int      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   str:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__magic_name__							)




   def    UpperCamelCase__						(					self							)				->   Optional[Any]:






       """simple docstring"""
       if not self.model_tester.is_training:
           return

       UpperCamelCase__							:       List[str]      =   self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase__							:       Any      =   True

       for model_class in self.all_model_classes:
           # LevitForImageClassificationWithTeacher supports inference-only
           if (
               model_class in get_values(__magic_name__							)
               or model_class.__name__ == "LevitForImageClassificationWithTeacher"
           ):
               continue
           UpperCamelCase__							:       Union[str, Any]      =   model_class(__magic_name__							)
           model.to(__magic_name__							)
           model.train()
           UpperCamelCase__							:       int      =   self._prepare_for_class(__magic_name__,	__magic_name__,	return_labels=__magic_name__							)
           UpperCamelCase__							:       Tuple      =   model(**__magic_name__							).loss
           loss.backward()




   def    UpperCamelCase__						(					self							)				->   int:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   self.model_tester.prepare_config_and_inputs_for_common()
       if not self.model_tester.is_training:
           return

       UpperCamelCase__							:       Dict      =   False
       UpperCamelCase__							:       int      =   True

       for model_class in self.all_model_classes:
           if model_class in get_values(__magic_name__							) or not model_class.supports_gradient_checkpointing:
               continue
           # LevitForImageClassificationWithTeacher supports inference-only
           if model_class.__name__ == "LevitForImageClassificationWithTeacher":
               continue
           UpperCamelCase__							:       Union[str, Any]      =   model_class(__magic_name__							)
           model.gradient_checkpointing_enable()
           model.to(__magic_name__							)
           model.train()
           UpperCamelCase__							:       Dict      =   self._prepare_for_class(__magic_name__,	__magic_name__,	return_labels=__magic_name__							)
           UpperCamelCase__							:       List[str]      =   model(**__magic_name__							).loss
           loss.backward()




   def    UpperCamelCase__						(					self							)				->   Optional[int]:






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   self.model_tester.prepare_config_and_inputs_for_common()

       UpperCamelCase__							:       Union[str, Any]      =   [
           {"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(__magic_name__							),
               ]
               or model_class.__name__ == "LevitForImageClassificationWithTeacher"
           ):
               continue

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

                   UpperCamelCase__							:       List[str]      =   model_class(__magic_name__							)
                   model.to(__magic_name__							)
                   model.train()

                   UpperCamelCase__							:       List[Any]      =   self._prepare_for_class(__magic_name__,	__magic_name__,	return_labels=__magic_name__							)

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

                   UpperCamelCase__							:       str      =   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=__magic_name__							) as warning_list:
                       UpperCamelCase__							:       List[str]      =   model(**__magic_name__							).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							)				->   List[Any]:






       """simple docstring"""
       for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           UpperCamelCase__							:       Optional[Any]      =   LevitModel.from_pretrained(__magic_name__							)
           self.assertIsNotNone(__magic_name__							)




def 	lowerCAmelCase_					(						)   ->			Optional[int]:
    UpperCamelCase__							:       Dict      =   Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
    return image






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

   '''simple docstring'''


   @cached_property
   def    UpperCamelCase__						(					self							)				->   Tuple:






       """simple docstring"""
       return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							)




   @slow
   def    UpperCamelCase__						(					self							)				->   Optional[int]:






       """simple docstring"""
       UpperCamelCase__							:       Tuple      =   LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]							).to(
           __magic_name__							)

       UpperCamelCase__							:       List[Any]      =   self.default_image_processor
       UpperCamelCase__							:       Any      =   prepare_img()
       UpperCamelCase__							:       Optional[Any]      =   image_processor(images=__magic_name__,	return_tensors='''pt'''							).to(__magic_name__							)

       # forward pass
       with torch.no_grad():
           UpperCamelCase__							:       Dict      =   model(**__magic_name__							)

       # verify the logits
       UpperCamelCase__							:       Optional[Any]      =   torch.Size((1, 1000)							)
       self.assertEqual(outputs.logits.shape,	__magic_name__							)

       UpperCamelCase__							:       Dict      =   torch.tensor([1.0448, -0.3745, -1.8317]							).to(__magic_name__							)

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








import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import CONFIG_MAPPING


UpperCAmelCase_  							=				logging.get_logger(__name__)






class 					lowercase__ (			__lowerCamelCase       ):

   '''simple docstring'''


   a		:							Any     	=	"upernet"




   def __init__(					self,	__magic_name__=None,	__magic_name__=512,	__magic_name__=0.02,	__magic_name__=[1, 2, 3, 6],	__magic_name__=True,	__magic_name__=0.4,	__magic_name__=384,	__magic_name__=256,	__magic_name__=1,	__magic_name__=False,	__magic_name__=255,	**__magic_name__,	)				->   Dict:






       """simple docstring"""
       super().__init__(**__magic_name__							)

       if backbone_config is None:
           logger.info('''`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone.'''							)
           UpperCamelCase__							:       str      =   CONFIG_MAPPING['''resnet'''](out_features=['''stage1''', '''stage2''', '''stage3''', '''stage4''']							)
       elif isinstance(__magic_name__,	__magic_name__							):
           UpperCamelCase__							:       Tuple      =   backbone_config.get('''model_type'''							)
           UpperCamelCase__							:       List[str]      =   CONFIG_MAPPING[backbone_model_type]
           UpperCamelCase__							:       Optional[int]      =   config_class.from_dict(__magic_name__							)

       UpperCamelCase__							:       Dict      =   backbone_config
       UpperCamelCase__							:       int      =   hidden_size
       UpperCamelCase__							:       int      =   initializer_range
       UpperCamelCase__							:       Dict      =   pool_scales
       UpperCamelCase__							:       Tuple      =   use_auxiliary_head
       UpperCamelCase__							:       Tuple      =   auxiliary_loss_weight
       UpperCamelCase__							:       Optional[int]      =   auxiliary_in_channels
       UpperCamelCase__							:       Optional[Any]      =   auxiliary_channels
       UpperCamelCase__							:       Any      =   auxiliary_num_convs
       UpperCamelCase__							:       Union[str, Any]      =   auxiliary_concat_input
       UpperCamelCase__							:       List[str]      =   loss_ignore_index




   def    UpperCamelCase__						(					self							)				->   Any:






       """simple docstring"""
       UpperCamelCase__							:       List[str]      =   copy.deepcopy(self.__dict__							)
       UpperCamelCase__							:       int      =   self.backbone_config.to_dict()
       UpperCamelCase__							:       Any      =   self.__class__.model_type
       return output

