





'''simple docstring'''

from abc import ABC, abstractmethod
from typing import Optional, Union

from .. import Dataset, DatasetDict, Features, IterableDataset, IterableDatasetDict, NamedSplit
from ..utils.typing import NestedDataStructureLike, PathLike







class __a			( _snake_case      ):





   def __init__(       self					:      Optional[int]					,lowerCamelCase					:      Optional[NestedDataStructureLike[PathLike]] = None					,lowerCamelCase					:      Optional[NamedSplit] = None					,lowerCamelCase					:      Optional[Features] = None					,lowerCamelCase					:      str = None					,lowerCamelCase					:      bool = False					,lowerCamelCase					:      bool = False					,lowerCamelCase					:      Optional[int] = None					,**lowerCamelCase					:      Optional[int]					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							path_or_paths
      __SCREAMING_SNAKE_CASE   				=							split if split or isinstance(lowerCamelCase					,lowerCamelCase     ) else """train"""
      __SCREAMING_SNAKE_CASE   				=							features
      __SCREAMING_SNAKE_CASE   				=							cache_dir
      __SCREAMING_SNAKE_CASE   				=							keep_in_memory
      __SCREAMING_SNAKE_CASE   				=							streaming
      __SCREAMING_SNAKE_CASE   				=							num_proc
      __SCREAMING_SNAKE_CASE   				=							kwargs





   @abstractmethod
   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      pass







class __a			( _snake_case      ):





   def __init__(       self					:      Tuple					,lowerCamelCase					:      Optional[Features] = None					,lowerCamelCase					:      str = None					,lowerCamelCase					:      bool = False					,lowerCamelCase					:      bool = False					,lowerCamelCase					:      Optional[int] = None					,**lowerCamelCase					:      Optional[int]					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							features
      __SCREAMING_SNAKE_CASE   				=							cache_dir
      __SCREAMING_SNAKE_CASE   				=							keep_in_memory
      __SCREAMING_SNAKE_CASE   				=							streaming
      __SCREAMING_SNAKE_CASE   				=							num_proc
      __SCREAMING_SNAKE_CASE   				=							kwargs





   @abstractmethod
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      pass












'''simple docstring'''

import inspect
import unittest

from transformers import SegformerConfig, is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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_MAPPING,
        SegformerForImageClassification,
        SegformerForSemanticSegmentation,
        SegformerModel,
    )
    from transformers.models.segformer.modeling_segformer import SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import SegformerImageProcessor







class __a			( _snake_case      ):





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.config_class(**self.inputs_dict     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""hidden_sizes"""     )     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""num_attention_heads"""     )     )
      self.parent.assertTrue(hasattr(lowerCamelCase					,"""num_encoder_blocks"""     )     )







class __a			:





   def __init__(       self					:      Optional[Any]					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      List[Any]=13					,lowerCamelCase					:      Union[str, Any]=64					,lowerCamelCase					:      Dict=3					,lowerCamelCase					:      Optional[Any]=4					,lowerCamelCase					:      Optional[Any]=[2, 2, 2, 2]					,lowerCamelCase					:      Tuple=[8, 4, 2, 1]					,lowerCamelCase					:      Dict=[16, 32, 64, 128]					,lowerCamelCase					:      Tuple=[1, 4, 8, 16]					,lowerCamelCase					:      str=[1, 2, 4, 8]					,lowerCamelCase					:      str=True					,lowerCamelCase					:      Union[str, Any]=True					,lowerCamelCase					:      Optional[Any]="gelu"					,lowerCamelCase					:      Union[str, Any]=0.1					,lowerCamelCase					:      List[str]=0.1					,lowerCamelCase					:      Optional[Any]=0.02					,lowerCamelCase					:      int=3					,lowerCamelCase					:      List[str]=None					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							parent
      __SCREAMING_SNAKE_CASE   				=							batch_size
      __SCREAMING_SNAKE_CASE   				=							image_size
      __SCREAMING_SNAKE_CASE   				=							num_channels
      __SCREAMING_SNAKE_CASE   				=							num_encoder_blocks
      __SCREAMING_SNAKE_CASE   				=							sr_ratios
      __SCREAMING_SNAKE_CASE   				=							depths
      __SCREAMING_SNAKE_CASE   				=							hidden_sizes
      __SCREAMING_SNAKE_CASE   				=							downsampling_rates
      __SCREAMING_SNAKE_CASE   				=							num_attention_heads
      __SCREAMING_SNAKE_CASE   				=							is_training
      __SCREAMING_SNAKE_CASE   				=							use_labels
      __SCREAMING_SNAKE_CASE   				=							hidden_act
      __SCREAMING_SNAKE_CASE   				=							hidden_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							attention_probs_dropout_prob
      __SCREAMING_SNAKE_CASE   				=							initializer_range
      __SCREAMING_SNAKE_CASE   				=							num_labels
      __SCREAMING_SNAKE_CASE   				=							scope





   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

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





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      return SegformerConfig(
          image_size=self.image_size					,num_channels=self.num_channels					,num_encoder_blocks=self.num_encoder_blocks					,depths=self.depths					,hidden_sizes=self.hidden_sizes					,num_attention_heads=self.num_attention_heads					,hidden_act=self.hidden_act					,hidden_dropout_prob=self.hidden_dropout_prob					,attention_probs_dropout_prob=self.attention_probs_dropout_prob					,initializer_range=self.initializer_range					,)





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerModel(config=lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							__SCREAMING_SNAKE_CASE   				=							self.image_size // (self.downsampling_rates[-1] * 2)
      self.parent.assertEqual(
          result.last_hidden_state.shape					,(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)     )





   def   UpperCAmelCase__  (       self					:      Any					,lowerCamelCase					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      Any     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.num_labels
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation(lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      self.parent.assertEqual(
          result.logits.shape					,(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertEqual(
          result.logits.shape					,(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)     )
      self.parent.assertGreater(result.loss					,0.0     )





   def   UpperCAmelCase__  (       self					:      str					,lowerCamelCase					:      Tuple					,lowerCamelCase					:      Optional[Any]					,lowerCamelCase					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							1
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation(config=lowerCamelCase     )
      model.to(lowerCamelCase     )
      model.eval()
      __SCREAMING_SNAKE_CASE   				=							torch.randint(0					,1					,(self.batch_size, self.image_size, self.image_size)     ).to(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertGreater(result.loss					,0.0     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							config_and_inputs
      __SCREAMING_SNAKE_CASE   				=							{"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class __a			( _snake_case, _snake_case, unittest.TestCase      ):
   __UpperCamelCase :			Dict						   =						(
       (
           SegformerModel,
           SegformerForSemanticSegmentation,
           SegformerForImageClassification,
       )
       if is_torch_available()
       else ()
   )
   __UpperCamelCase :			Union[str, Any]						   =						(
       {
           'feature-extraction': SegformerModel,
           'image-classification': SegformerForImageClassification,
           'image-segmentation': SegformerForSemanticSegmentation,
       }
       if is_torch_available()
       else {}
   )

   __UpperCamelCase :			Optional[Any]						   =						True
   __UpperCamelCase :			List[Any]						   =						False
   __UpperCamelCase :			Union[str, Any]						   =						False
   __UpperCamelCase :			Optional[int]						   =						False





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerModelTester(self     )
      __SCREAMING_SNAKE_CASE   				=							SegformerConfigTester(self					,config_class=lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      self.config_tester.run_common_tests()





   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_segmentation(*lowerCamelCase     )





   @unittest.skip("""SegFormer does not use inputs_embeds"""     )
   def   UpperCAmelCase__  (       self					:      List[str]     ):

      '''simple docstring'''

      pass





   @unittest.skip("""SegFormer does not have get_input_embeddings method and get_output_embeddings methods"""     )
   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      pass





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

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

         __SCREAMING_SNAKE_CASE   				=							["""pixel_values"""]
         self.assertListEqual(arg_names[:1]					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

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

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							False
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )
         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         __SCREAMING_SNAKE_CASE   				=							sum(self.model_tester.depths     )
         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )
         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # verify the first attentions (first block, first layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 4) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(attentions[0].shape[-3:]     )					,[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,)

         # verify the last attentions (last block, last layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 32) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (32 * self.model_tester.sr_ratios[-1])) ** 2
         self.assertListEqual(
             list(attentions[-1].shape[-3:]     )					,[self.model_tester.num_attention_heads[-1], expected_seq_len, expected_reduced_seq_len]					,)
         __SCREAMING_SNAKE_CASE   				=							len(lowerCamelCase     )

         # Check attention is always last and order is fine
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							True
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()
         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )

         self.assertEqual(out_len + 1					,len(lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							outputs.attentions

         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )
         # verify the first attentions (first block, first layer)
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // 4) ** 2
         __SCREAMING_SNAKE_CASE   				=							(self.model_tester.image_size // (4 * self.model_tester.sr_ratios[0])) ** 2
         self.assertListEqual(
             list(self_attentions[0].shape[-3:]     )					,[self.model_tester.num_attention_heads[0], expected_seq_len, expected_reduced_seq_len]					,)





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      def check_hidden_states_output(lowerCamelCase					:      Tuple					,lowerCamelCase					:      List[Any]					,lowerCamelCase					:      Dict     ):
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.eval()

         with torch.no_grad():
            __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )

         __SCREAMING_SNAKE_CASE   				=							outputs.hidden_states

         __SCREAMING_SNAKE_CASE   				=							self.model_tester.num_encoder_blocks
         self.assertEqual(len(lowerCamelCase     )					,lowerCamelCase     )

         # verify the first hidden states (first block)
         self.assertListEqual(
             list(hidden_states[0].shape[-3:]     )					,[
                 self.model_tester.hidden_sizes[0],
                 self.model_tester.image_size // 4,
                 self.model_tester.image_size // 4,
             ]					,)

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
         __SCREAMING_SNAKE_CASE   				=							True
         check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )

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

         check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      if not self.model_tester.is_training:
         return

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

      for model_class in self.all_model_classes:
         if model_class in get_values(lowerCamelCase     ):
            continue

         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         model.to(lowerCamelCase     )
         model.train()
         __SCREAMING_SNAKE_CASE   				=							self._prepare_for_class(lowerCamelCase					,lowerCamelCase					,return_labels=lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							model(**lowerCamelCase     ).loss
         loss.backward()





   @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      pass





   @slow
   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE   				=							SegformerModel.from_pretrained(lowerCamelCase     )
         self.assertIsNotNone(lowerCamelCase     )





def     __magic_name__							(				)    ->       List[str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
   return image







@require_torch
class __a			( unittest.TestCase      ):





   @slow
   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
          lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.Size((1, model.config.num_labels, 128, 128)     )
      self.assertEqual(outputs.logits.shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.tensor(
          [
              [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
              [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
              [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
          ]     ).to(lowerCamelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,lowerCamelCase					,atol=1E-4     )     )





   @slow
   def   UpperCAmelCase__  (       self					:      Tuple     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained(
          """nvidia/segformer-b1-finetuned-cityscapes-1024-1024"""     ).to(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.Size((1, model.config.num_labels, 128, 128)     )
      self.assertEqual(outputs.logits.shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							torch.tensor(
          [
              [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
              [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
              [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
          ]     ).to(lowerCamelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]					,lowerCamelCase					,atol=1E-1     )     )





   @slow
   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							SegformerImageProcessor(
          image_scale=(512, 512)					,keep_ratio=lowerCamelCase					,align=lowerCamelCase					,do_random_crop=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
          lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""pt"""     )
      __SCREAMING_SNAKE_CASE   				=							encoded_inputs.pixel_values.to(lowerCamelCase     )

      with torch.no_grad():
         __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							outputs.logits.detach().cpu()

      __SCREAMING_SNAKE_CASE   				=							image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase					,target_sizes=[(500, 300)]     )
      __SCREAMING_SNAKE_CASE   				=							torch.Size((500, 300)     )
      self.assertEqual(segmentation[0].shape					,lowerCamelCase     )

      __SCREAMING_SNAKE_CASE   				=							image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							torch.Size((128, 128)     )
      self.assertEqual(segmentation[0].shape					,lowerCamelCase     )





