




'''simple docstring'''



from ..utils import DummyObject, requires_backends






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				List[str]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				List[str]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				str        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Dict        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Union[str, Any]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Any        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				List[str]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Any        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				List[str]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Tuple        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Optional[int]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				Optional[int]        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )






class 							_a				(			metaclass=SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       A						:				int        =						['''flax''']







       def __init__(      self,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(self,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )







       @classmethod
       def        UpperCamelCase_							(      cls,							*A,							**A  ):







             '''simple docstring'''







             requires_backends(cls,							['flax']  )








'''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  )


