





'''simple docstring'''

from collections import Counter
from pathlib import Path
from typing import Optional, Tuple

import yaml







class __a			( yaml.SafeLoader      ):





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

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							[self.constructed_objects[key_node] for key_node, _ in node.value]
      __SCREAMING_SNAKE_CASE   				=							[tuple(lowerCamelCase     ) if isinstance(lowerCamelCase					,lowerCamelCase     ) else key for key in keys]
      __SCREAMING_SNAKE_CASE   				=							Counter(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							[key for key in counter if counter[key] > 1]
      if duplicate_keys:
         raise TypeError(f"""Got duplicate yaml keys: {duplicate_keys}"""     )





   def   UpperCAmelCase__  (       self					:      List[Any]					,lowerCamelCase					:      Optional[Any]					,lowerCamelCase					:      Optional[Any]=False     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							super().construct_mapping(lowerCamelCase					,deep=lowerCamelCase     )
      self._check_no_duplicates_on_constructed_node(lowerCamelCase     )
      return mapping





def     __magic_name__							(				__UpperCAmelCase   )    ->       Tuple[Optional[str], str]:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE   				=							list(readme_content.splitlines()   )
   if full_content and full_content[0] == "---" and "---" in full_content[1:]:
      __SCREAMING_SNAKE_CASE   				=							full_content[1:].index("""---"""   ) + 1
      __SCREAMING_SNAKE_CASE   				=							"""\n""".join(full_content[1:sep_idx]   )
      return yamlblock, "\n".join(full_content[sep_idx + 1 :]   )

   return None, "\n".join(__UpperCAmelCase   )







class __a			( _snake_case      ):
   # class attributes
   __UpperCamelCase :			Union[str, Any]						   =						{'train_eval_index'}  # train-eval-index in the YAML metadata





   @classmethod
   def   UpperCAmelCase__  (       cls					:      str					,lowerCamelCase					:      Path     ):

      '''simple docstring'''

      with open(lowerCamelCase					,encoding="""utf-8"""     ) as readme_file:
         __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							_split_yaml_from_readme(readme_file.read()     )
      if yaml_string is not None:
         return cls.from_yaml_string(lowerCamelCase     )
      else:
         return cls()





   def   UpperCAmelCase__  (       self					:      Optional[Any]					,lowerCamelCase					:      Path     ):

      '''simple docstring'''

      if path.exists():
         with open(lowerCamelCase					,encoding="""utf-8"""     ) as readme_file:
            __SCREAMING_SNAKE_CASE   				=							readme_file.read()
      else:
         __SCREAMING_SNAKE_CASE   				=							None
      __SCREAMING_SNAKE_CASE   				=							self._to_readme(lowerCamelCase     )
      with open(lowerCamelCase					,"""w"""					,encoding="""utf-8"""     ) as readme_file:
         readme_file.write(lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict					,lowerCamelCase					:      Optional[str] = None     ):

      '''simple docstring'''

      if readme_content is not None:
         __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							_split_yaml_from_readme(lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							"""---\n""" + self.to_yaml_string() + """---\n""" + content
      else:
         __SCREAMING_SNAKE_CASE   				=							"""---\n""" + self.to_yaml_string() + """---\n"""
      return full_content





   @classmethod
   def   UpperCAmelCase__  (       cls					:      Optional[int]					,lowerCamelCase					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							yaml.load(lowerCamelCase					,Loader=_NoDuplicateSafeLoader     ) or {}

      # Convert the YAML keys to DatasetMetadata fields
      __SCREAMING_SNAKE_CASE   				=							{
          (key.replace("""-"""					,"""_"""     ) if key.replace("""-"""					,"""_"""     ) in cls._FIELDS_WITH_DASHES else key): value
          for key, value in metadata_dict.items()
      }
      return cls(**lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      int     ):

      '''simple docstring'''

      return yaml.safe_dump(
          {
              (key.replace("""_"""					,"""-"""     ) if key in self._FIELDS_WITH_DASHES else key): value
              for key, value in self.items()
          }					,sort_keys=lowerCamelCase					,allow_unicode=lowerCamelCase					,encoding="""utf-8"""					,).decode("""utf-8"""     )





a   	=    {
    "image-classification": [],
    "translation": [],
    "image-segmentation": [],
    "fill-mask": [],
    "automatic-speech-recognition": [],
    "token-classification": [],
    "sentence-similarity": [],
    "audio-classification": [],
    "question-answering": [],
    "summarization": [],
    "zero-shot-classification": [],
    "table-to-text": [],
    "feature-extraction": [],
    "other": [],
    "multiple-choice": [],
    "text-classification": [],
    "text-to-image": [],
    "text2text-generation": [],
    "zero-shot-image-classification": [],
    "tabular-classification": [],
    "tabular-regression": [],
    "image-to-image": [],
    "tabular-to-text": [],
    "unconditional-image-generation": [],
    "text-retrieval": [],
    "text-to-speech": [],
    "object-detection": [],
    "audio-to-audio": [],
    "text-generation": [],
    "conversational": [],
    "table-question-answering": [],
    "visual-question-answering": [],
    "image-to-text": [],
    "reinforcement-learning": [],
    "voice-activity-detection": [],
    "time-series-forecasting": [],
    "document-question-answering": [],
}


if __name__ == "__main__":
    from argparse import ArgumentParser

    a   	=    ArgumentParser(usage="Validate the yaml metadata block of a README.md file.")
    ap.add_argument("readme_filepath")
    a   	=    ap.parse_args()

    a   	=    Path(args.readme_filepath)
    a   	=    DatasetMetadata.from_readme(readme_filepath)
    print(dataset_metadata)
    dataset_metadata.to_readme(readme_filepath)












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





