



import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import VivitImageProcessor




class    snake_case__		(			unittest.TestCase	):






     """simple docstring"""


     def __init__(			self    :    Dict,					_snake_case    :    Optional[int],					_snake_case    :    Any=7,					_snake_case    :    Dict=3,					_snake_case    :    int=1_0,					_snake_case    :    Dict=1_8,					_snake_case    :    str=3_0,					_snake_case    :    Optional[int]=4_0_0,					_snake_case    :    Any=True,					_snake_case    :    Optional[Any]=None,					_snake_case    :    Union[str, Any]=True,					_snake_case    :    Tuple=[0.5, 0.5, 0.5],					_snake_case    :    Optional[Any]=[0.5, 0.5, 0.5],					_snake_case    :    Any=None,					)  ->Optional[int]:
            snake_case__				:      Tuple        =      size if size is not None else {'shortest_edge': 1_8}
            snake_case__				:      Dict        =      crop_size if crop_size is not None else {'height': 1_8, 'width': 1_8}

            snake_case__				:      Optional[Any]        =      parent
            snake_case__				:      Dict        =      batch_size
            snake_case__				:      Dict        =      num_channels
            snake_case__				:      int        =      num_frames
            snake_case__				:      Dict        =      image_size
            snake_case__				:      Dict        =      min_resolution
            snake_case__				:      Optional[Any]        =      max_resolution
            snake_case__				:      int        =      do_resize
            snake_case__				:      str        =      size
            snake_case__				:      str        =      do_normalize
            snake_case__				:      Union[str, Any]        =      image_mean
            snake_case__				:      Any        =      image_std
            snake_case__				:      Tuple        =      crop_size






     def   lowercase_  (			self    :    List[Any]   )  ->List[Any]:
            return {
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_normalize": self.do_normalize,
                "do_resize": self.do_resize,
                "size": self.size,
                "crop_size": self.crop_size,
            }




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






     """simple docstring"""


     _SCREAMING_SNAKE_CASE          =      VivitImageProcessor if is_vision_available() else None






     def   lowercase_  (			self    :    List[Any]   )  ->List[str]:
            snake_case__				:      Optional[int]        =      VivitImageProcessingTester(self   )






     @property
     def   lowercase_  (			self    :    int   )  ->Optional[Any]:
            return self.image_processor_tester.prepare_image_processor_dict()






     def   lowercase_  (			self    :    Optional[int]   )  ->int:
            snake_case__				:      Dict        =      self.image_processing_class(**self.image_processor_dict   )
            self.assertTrue(hasattr(_snake_case,					'image_mean'   )   )
            self.assertTrue(hasattr(_snake_case,					'image_std'   )   )
            self.assertTrue(hasattr(_snake_case,					'do_normalize'   )   )
            self.assertTrue(hasattr(_snake_case,					'do_resize'   )   )
            self.assertTrue(hasattr(_snake_case,					'do_center_crop'   )   )
            self.assertTrue(hasattr(_snake_case,					'size'   )   )






     def   lowercase_  (			self    :    List[Any]   )  ->List[Any]:
            snake_case__				:      List[str]        =      self.image_processing_class.from_dict(self.image_processor_dict   )
            self.assertEqual(image_processor.size,					{'shortest_edge': 1_8}   )
            self.assertEqual(image_processor.crop_size,					{'height': 1_8, 'width': 1_8}   )

            snake_case__				:      Any        =      self.image_processing_class.from_dict(self.image_processor_dict,					size=4_2,					crop_size=8_4   )
            self.assertEqual(image_processor.size,					{'shortest_edge': 4_2}   )
            self.assertEqual(image_processor.crop_size,					{'height': 8_4, 'width': 8_4}   )






     def   lowercase_  (			self    :    List[Any]   )  ->List[str]:
            snake_case__				:      int        =      self.image_processing_class(**self.image_processor_dict   )
            # create random PIL videos
            snake_case__				:      Tuple        =      prepare_video_inputs(self.image_processor_tester,					equal_resolution=_snake_case   )
            for video in video_inputs:
                   self.assertIsInstance(_snake_case,					_snake_case   )
                   self.assertIsInstance(video[0],					Image.Image   )

            # Test not batched input
            snake_case__				:      int        =      image_processing(video_inputs[0],					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    1,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)

            # Test batched
            snake_case__				:      Optional[int]        =      image_processing(_snake_case,					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)






     def   lowercase_  (			self    :    Optional[Any]   )  ->Optional[int]:
            snake_case__				:      str        =      self.image_processing_class(**self.image_processor_dict   )
            # create random numpy tensors
            snake_case__				:      Any        =      prepare_video_inputs(self.image_processor_tester,					equal_resolution=_snake_case,					numpify=_snake_case   )
            for video in video_inputs:
                   self.assertIsInstance(_snake_case,					_snake_case   )
                   self.assertIsInstance(video[0],					np.ndarray   )

            # Test not batched input
            snake_case__				:      Any        =      image_processing(video_inputs[0],					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    1,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)

            # Test batched
            snake_case__				:      str        =      image_processing(_snake_case,					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)






     def   lowercase_  (			self    :    Any   )  ->Any:
            snake_case__				:      Optional[int]        =      self.image_processing_class(**self.image_processor_dict   )
            # create random PyTorch tensors
            snake_case__				:      Tuple        =      prepare_video_inputs(self.image_processor_tester,					equal_resolution=_snake_case,					torchify=_snake_case   )
            for video in video_inputs:
                   self.assertIsInstance(_snake_case,					_snake_case   )
                   self.assertIsInstance(video[0],					torch.Tensor   )

            # Test not batched input
            snake_case__				:      List[Any]        =      image_processing(video_inputs[0],					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    1,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)

            # Test batched
            snake_case__				:      Dict        =      image_processing(_snake_case,					return_tensors='pt'   ).pixel_values
            self.assertEqual(
                encoded_videos.shape,					(
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_frames,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),					)












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


