



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__		(			lowerCAmelCase_	):






     """simple docstring"""


     def   lowercase_  (			self    :    List[Any]   )  ->Union[str, Any]:
            snake_case__				:      int        =      self.config_class(**self.inputs_dict   )
            self.parent.assertTrue(hasattr(_snake_case,					'hidden_sizes'   )   )
            self.parent.assertTrue(hasattr(_snake_case,					'num_attention_heads'   )   )




class    snake_case__		:






     """simple docstring"""


     def __init__(			self    :    Optional[Any],					_snake_case    :    Optional[int],					_snake_case    :    Tuple=1_3,					_snake_case    :    Union[str, Any]=6_4,					_snake_case    :    Any=3,					_snake_case    :    Any=3,					_snake_case    :    Tuple=2,					_snake_case    :    Optional[int]=1,					_snake_case    :    Any=1_6,					_snake_case    :    str=[1_2_8, 2_5_6, 3_8_4],					_snake_case    :    str=[4, 6, 8],					_snake_case    :    int=[2, 3, 4],					_snake_case    :    Optional[int]=[1_6, 1_6, 1_6],					_snake_case    :    Optional[Any]=0,					_snake_case    :    Tuple=[2, 2, 2],					_snake_case    :    Optional[Any]=[2, 2, 2],					_snake_case    :    Dict=0.0_2,					_snake_case    :    List[str]=True,					_snake_case    :    Any=True,					_snake_case    :    Optional[Any]=2,					)  ->Dict:
            snake_case__				:      List[str]        =      parent
            snake_case__				:      Optional[Any]        =      batch_size
            snake_case__				:      Optional[int]        =      image_size
            snake_case__				:      Union[str, Any]        =      num_channels
            snake_case__				:      List[Any]        =      kernel_size
            snake_case__				:      Tuple        =      stride
            snake_case__				:      Optional[int]        =      padding
            snake_case__				:      Union[str, Any]        =      hidden_sizes
            snake_case__				:      List[Any]        =      num_attention_heads
            snake_case__				:      Optional[Any]        =      depths
            snake_case__				:      Tuple        =      key_dim
            snake_case__				:      List[Any]        =      drop_path_rate
            snake_case__				:      Any        =      patch_size
            snake_case__				:      Any        =      attention_ratio
            snake_case__				:      List[str]        =      mlp_ratio
            snake_case__				:      int        =      initializer_range
            snake_case__				:      Optional[int]        =      [
                ['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],
            ]
            snake_case__				:      str        =      is_training
            snake_case__				:      Optional[int]        =      use_labels
            snake_case__				:      Optional[Any]        =      num_labels
            snake_case__				:      List[Any]        =      initializer_range






     def   lowercase_  (			self    :    Optional[Any]   )  ->Union[str, Any]:
            snake_case__				:      Optional[Any]        =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

            snake_case__				:      Dict        =      None
            if self.use_labels:
                   snake_case__				:      List[str]        =      ids_tensor([self.batch_size],					self.num_labels   )

            snake_case__				:      str        =      self.get_config()
            return config, pixel_values, labels






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






     def   lowercase_  (			self    :    str   )  ->Any:
            snake_case__				:      Optional[int]        =      self.prepare_config_and_inputs()
            snake_case__				:      str        =      config_and_inputs
            snake_case__				:      Optional[int]        =      {'pixel_values': pixel_values}
            return config, inputs_dict




@require_torch
class    snake_case__		(			lowerCAmelCase_							,	lowerCAmelCase_							,	unittest.TestCase	):






     """simple docstring"""


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

     _SCREAMING_SNAKE_CASE          =      False
     _SCREAMING_SNAKE_CASE          =      False
     _SCREAMING_SNAKE_CASE          =      False
     _SCREAMING_SNAKE_CASE          =      False
     _SCREAMING_SNAKE_CASE          =      False






     def   lowercase_  (			self    :    str   )  ->str:
            snake_case__				:      List[Any]        =      LevitModelTester(self   )
            snake_case__				:      Dict        =      ConfigTester(self,					config_class=_snake_case,					has_text_modality=_snake_case,					hidden_size=3_7   )






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






     @unittest.skip(reason='Levit does not use inputs_embeds'   )
     def   lowercase_  (			self    :    Dict   )  ->List[Any]:
            pass






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






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






     def   lowercase_  (			self    :    Tuple   )  ->Dict:
            snake_case__				:      Tuple        =      self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   snake_case__				:      Union[str, Any]        =      model_class(_snake_case   )
                   snake_case__				:      Optional[int]        =      inspect.signature(model.forward   )
                   # signature.parameters is an OrderedDict => so arg_names order is deterministic
                   snake_case__				:      Union[str, Any]        =      [*signature.parameters.keys()]

                   snake_case__				:      List[Any]        =      ['pixel_values']
                   self.assertListEqual(arg_names[:1],					_snake_case   )






     def   lowercase_  (			self    :    Dict   )  ->int:







            def check_hidden_states_output(_snake_case    :    Tuple,					_snake_case    :    Tuple,					_snake_case    :    List[Any]   ):
                   snake_case__				:      Any        =      model_class(_snake_case   )
                   model.to(_snake_case   )
                   model.eval()

                   with torch.no_grad():
                          snake_case__				:      Tuple        =      model(**self._prepare_for_class(_snake_case,					_snake_case   )   )

                   snake_case__				:      Optional[int]        =      outputs.hidden_states

                   snake_case__				:      Dict        =      len(self.model_tester.depths   ) + 1
                   self.assertEqual(len(_snake_case   ),					_snake_case   )

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

            snake_case__				:      Optional[Any]        =      self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                   snake_case__				:      Tuple        =      True
                   check_hidden_states_output(_snake_case,					_snake_case,					_snake_case   )

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

                   check_hidden_states_output(_snake_case,					_snake_case,					_snake_case   )






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






     def   lowercase_  (			self    :    List[Any],					_snake_case    :    Dict,					_snake_case    :    str,					_snake_case    :    int=False   )  ->str:
            snake_case__				:      Optional[int]        =      super()._prepare_for_class(_snake_case,					_snake_case,					return_labels=_snake_case   )

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

            return inputs_dict






     def   lowercase_  (			self    :    List[str]   )  ->Dict:
            snake_case__				:      List[Any]        =      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*_snake_case   )






     def   lowercase_  (			self    :    List[Any]   )  ->List[str]:
            snake_case__				:      Optional[Any]        =      self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*_snake_case   )






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







            if not self.model_tester.is_training:
                   return

            snake_case__				:      Optional[int]        =      self.model_tester.prepare_config_and_inputs_for_common()
            snake_case__				:      Dict        =      True

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






     def   lowercase_  (			self    :    Tuple   )  ->List[Any]:
            snake_case__				:      Tuple        =      self.model_tester.prepare_config_and_inputs_for_common()
            if not self.model_tester.is_training:
                   return

            snake_case__				:      Tuple        =      False
            snake_case__				:      Union[str, Any]        =      True

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






     def   lowercase_  (			self    :    Optional[int]   )  ->Dict:
            snake_case__				:      List[str]        =      self.model_tester.prepare_config_and_inputs_for_common()

            snake_case__				:      Optional[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(_snake_case   ),
                       ]
                       or model_class.__name__ == "LevitForImageClassificationWithTeacher"
                   ):
                          continue

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

                                 snake_case__				:      Tuple        =      model_class(_snake_case   )
                                 model.to(_snake_case   )
                                 model.train()

                                 snake_case__				:      Tuple        =      self._prepare_for_class(_snake_case,					_snake_case,					return_labels=_snake_case   )

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

                                 snake_case__				:      Optional[int]        =      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=_snake_case   ) as warning_list:
                                        snake_case__				:      Optional[Any]        =      model(**_snake_case   ).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   lowercase_  (			self    :    Union[str, Any]   )  ->Any:







            for model_name in LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   snake_case__				:      List[str]        =      LevitModel.from_pretrained(_snake_case   )
                   self.assertIsNotNone(_snake_case   )


def 			lowercase_				():
       snake_case__				:      Optional[int]        =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
       return image





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






     """simple docstring"""


     @cached_property
     def   lowercase_  (			self    :    Any   )  ->Dict:
            return LevitImageProcessor.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   )






     @slow
     def   lowercase_  (			self    :    Optional[int]   )  ->Tuple:
            snake_case__				:      str        =      LevitForImageClassificationWithTeacher.from_pretrained(LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[0]   ).to(
                _snake_case   )

            snake_case__				:      List[Any]        =      self.default_image_processor
            snake_case__				:      str        =      prepare_img()
            snake_case__				:      int        =      image_processor(images=_snake_case,					return_tensors='pt'   ).to(_snake_case   )

            # forward pass
            with torch.no_grad():
                   snake_case__				:      List[str]        =      model(**_snake_case   )

            # verify the logits
            snake_case__				:      Any        =      torch.Size((1, 1_0_0_0)   )
            self.assertEqual(outputs.logits.shape,					_snake_case   )

            snake_case__				:      List[str]        =      torch.tensor([1.0_4_4_8, -0.3_7_4_5, -1.8_3_1_7]   ).to(_snake_case   )

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












'''simple docstring'''



import inspect
import unittest

from transformers import MobileViTConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
      from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
      from PIL import Image

      from transformers import MobileViTImageProcessor






class 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						self.config_class(**self.inputs_dict  )
             self.parent.assertTrue(hasattr(A,							'hidden_sizes'  )  )
             self.parent.assertTrue(hasattr(A,							'neck_hidden_sizes'  )  )
             self.parent.assertTrue(hasattr(A,							'num_attention_heads'  )  )






class 							_a				:





       '''simple docstring'''






       def __init__(      self,							A,							A=13,							A=32,							A=2,							A=3,							A=640,							A=4,							A="silu",							A=3,							A=32,							A=0.1,							A=0.1,							A=0.1,							A=0.02,							A=True,							A=True,							A=10,							A=None,							):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						parent
             SCREAMING_SNAKE_CASE   :      int    					=						batch_size
             SCREAMING_SNAKE_CASE   :      int    					=						image_size
             SCREAMING_SNAKE_CASE   :      str    					=						patch_size
             SCREAMING_SNAKE_CASE   :      Tuple    					=						num_channels
             SCREAMING_SNAKE_CASE   :      int    					=						last_hidden_size
             SCREAMING_SNAKE_CASE   :      Any    					=						num_attention_heads
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						hidden_act
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						conv_kernel_size
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						output_stride
             SCREAMING_SNAKE_CASE   :      Any    					=						hidden_dropout_prob
             SCREAMING_SNAKE_CASE   :      Dict    					=						attention_probs_dropout_prob
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						classifier_dropout_prob
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						use_labels
             SCREAMING_SNAKE_CASE   :      int    					=						is_training
             SCREAMING_SNAKE_CASE   :      Dict    					=						num_labels
             SCREAMING_SNAKE_CASE   :      Dict    					=						initializer_range
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						scope







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

             SCREAMING_SNAKE_CASE   :      int    					=						self.get_config()

             return config, pixel_values, labels, pixel_labels







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return MobileViTConfig(
                 image_size=self.image_size,							patch_size=self.patch_size,							num_channels=self.num_channels,							num_attention_heads=self.num_attention_heads,							hidden_act=self.hidden_act,							conv_kernel_size=self.conv_kernel_size,							output_stride=self.output_stride,							hidden_dropout_prob=self.hidden_dropout_prob,							attention_probs_dropout_prob=self.attention_probs_dropout_prob,							classifier_dropout_prob=self.classifier_dropout_prob,							initializer_range=self.initializer_range,							)







       def        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      int    					=						MobileViTModel(config=A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						model(A  )
             self.parent.assertEqual(
                 result.last_hidden_state.shape,							(
                     self.batch_size,
                     self.last_hidden_size,
                     self.image_size // self.output_stride,
                     self.image_size // self.output_stride,
                 ),							)







       def        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						self.num_labels
             SCREAMING_SNAKE_CASE   :      Tuple    					=						MobileViTForImageClassification(A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      List[str]    					=						model(A,							labels=A  )
             self.parent.assertEqual(result.logits.shape,							(self.batch_size, self.num_labels)  )







       def        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.num_labels
             SCREAMING_SNAKE_CASE   :      str    					=						MobileViTForSemanticSegmentation(A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      str    					=						model(A  )
             self.parent.assertEqual(
                 result.logits.shape,							(
                     self.batch_size,
                     self.num_labels,
                     self.image_size // self.output_stride,
                     self.image_size // self.output_stride,
                 ),							)
             SCREAMING_SNAKE_CASE   :      int    					=						model(A,							labels=A  )
             self.parent.assertEqual(
                 result.logits.shape,							(
                     self.batch_size,
                     self.num_labels,
                     self.image_size // self.output_stride,
                     self.image_size // self.output_stride,
                 ),							)







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						self.prepare_config_and_inputs()
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Optional[int]    					=						config_and_inputs
             SCREAMING_SNAKE_CASE   :      str    					=						{'pixel_values': pixel_values}
             return config, inputs_dict






@require_torch
class 							_a				(			SCREAMING_SNAKE_CASE ,      SCREAMING_SNAKE_CASE ,      unittest.TestCase ):





       '''simple docstring'''






       A						:				Tuple        =						(
           (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
           if is_torch_available()
           else ()
       )
       A						:				List[Any]        =						(
           {
               '''feature-extraction''': MobileViTModel,
               '''image-classification''': MobileViTForImageClassification,
               '''image-segmentation''': MobileViTForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       A						:				Optional[int]        =						False
       A						:				Dict        =						False
       A						:				List[Any]        =						False
       A						:				Optional[int]        =						False







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						MobileViTModelTester(self  )
             SCREAMING_SNAKE_CASE   :      str    					=						MobileViTConfigTester(self,							config_class=A,							has_text_modality=A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             self.config_tester.run_common_tests()







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







             '''simple docstring'''







             pass







       @unittest.skip(reason='MobileViT does not support input and output embeddings'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       @unittest.skip(reason='MobileViT does not output attentions'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Tuple    					=						self.model_tester.prepare_config_and_inputs_for_common()

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

                   SCREAMING_SNAKE_CASE   :      Any    					=						['pixel_values']
                   self.assertListEqual(arg_names[:1],							A  )







       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             def check_hidden_states_output(A,							A,							A  ):
                   SCREAMING_SNAKE_CASE   :      Any    					=						model_class(A  )
                   model.to(A  )
                   model.eval()

                   with torch.no_grad():
                         SCREAMING_SNAKE_CASE   :      Tuple    					=						model(**self._prepare_for_class(A,							A  )  )

                   SCREAMING_SNAKE_CASE   :      Dict    					=						outputs.hidden_states

                   SCREAMING_SNAKE_CASE   :      List[str]    					=						5
                   self.assertEqual(len(A  ),							A  )

                   # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
                   # with the width and height being successively divided by 2.
                   SCREAMING_SNAKE_CASE   :      int    					=						2
                   for i in range(len(A  )  ):
                         self.assertListEqual(
                             list(hidden_states[i].shape[-2:]  ),							[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor],							)
                         divisor *= 2

                   self.assertEqual(self.model_tester.output_stride,							divisor // 2  )

             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Any    					=						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						True
                   check_hidden_states_output(A,							A,							A  )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						True

                   check_hidden_states_output(A,							A,							A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_semantic_segmentation(*A  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE   :      int    					=						MobileViTModel.from_pretrained(A  )
                   self.assertIsNotNone(A  )




def   lowercase__(			):

      """simple docstring"""






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






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





       '''simple docstring'''






       @cached_property
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return MobileViTImageProcessor.from_pretrained('apple/mobilevit-xx-small'  ) if is_vision_available() else None







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'  ).to(A  )

             SCREAMING_SNAKE_CASE   :      Any    					=						self.default_image_processor
             SCREAMING_SNAKE_CASE   :      Dict    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Dict    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						model(**A  )

             # verify the logits
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						torch.Size((1, 1_000)  )
             self.assertEqual(outputs.logits.shape,							A  )

             SCREAMING_SNAKE_CASE   :      int    					=						torch.tensor([-1.93_64, -1.23_27, -0.46_53]  ).to(A  )

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







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						model.to(A  )

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )

             SCREAMING_SNAKE_CASE   :      str    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE   :      Dict    					=						model(**A  )
             SCREAMING_SNAKE_CASE   :      List[str]    					=						outputs.logits

             # verify the logits
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						torch.Size((1, 21, 32, 32)  )
             self.assertEqual(logits.shape,							A  )

             SCREAMING_SNAKE_CASE   :      Tuple    					=						torch.tensor(
                 [
                     [[6.97_13, 6.97_86, 7.24_22], [7.28_93, 7.28_25, 7.44_46], [7.65_80, 7.87_97, 7.94_20]],
                     [[-10.68_69, -10.32_50, -10.34_71], [-10.42_28, -9.98_68, -9.71_32], [-11.04_05, -11.02_21, -10.73_18]],
                     [[-3.30_89, -2.85_39, -2.67_40], [-3.27_06, -2.56_21, -2.51_08], [-3.25_34, -2.66_15, -2.66_51]],
                 ],							device=A,							)

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







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )
             SCREAMING_SNAKE_CASE   :      List[str]    					=						model.to(A  )

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Any    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						model(**A  )

             SCREAMING_SNAKE_CASE   :      int    					=						outputs.logits.detach().cpu()

             SCREAMING_SNAKE_CASE   :      Dict    					=						image_processor.post_process_semantic_segmentation(outputs=A,							target_sizes=[(50, 60)]  )
             SCREAMING_SNAKE_CASE   :      Dict    					=						torch.Size((50, 60)  )
             self.assertEqual(segmentation[0].shape,							A  )

             SCREAMING_SNAKE_CASE   :      Tuple    					=						image_processor.post_process_semantic_segmentation(outputs=A  )
             SCREAMING_SNAKE_CASE   :      Any    					=						torch.Size((32, 32)  )
             self.assertEqual(segmentation[0].shape,							A  )


