


import sacrebleu as scb
from packaging import version
from sacrebleu import TER

import datasets


UpperCAmelCase      =   """\
@inproceedings{snover-etal-2006-study,
    title = \"A Study of Translation Edit Rate with Targeted Human Annotation\",
    author = \"Snover, Matthew  and
      Dorr, Bonnie  and
      Schwartz, Rich  and
      Micciulla, Linnea  and
      Makhoul, John\",
    booktitle = \"Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers\",
    month = aug # \" 8-12\",
    year = \"2006\",
    address = \"Cambridge, Massachusetts, USA\",
    publisher = \"Association for Machine Translation in the Americas\",
    url = \"https://aclanthology.org/2006.amta-papers.25\",
    pages = \"223--231\",
}
@inproceedings{post-2018-call,
    title = \"A Call for Clarity in Reporting {BLEU} Scores\",
    author = \"Post, Matt\",
    booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",
    month = oct,
    year = \"2018\",
    address = \"Belgium, Brussels\",
    publisher = \"Association for Computational Linguistics\",
    url = \"https://www.aclweb.org/anthology/W18-6319\",
    pages = \"186--191\",
}
"""

UpperCAmelCase      =   """\
TER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a
hypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu
(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found
here: https://github.com/jhclark/tercom.

The implementation here is slightly different from sacrebleu in terms of the required input format. The length of
the references and hypotheses lists need to be the same, so you may need to transpose your references compared to
sacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534

See the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.
"""

UpperCAmelCase      =   """
Produces TER scores alongside the number of edits and reference length.

Args:
    predictions (list of str): The system stream (a sequence of segments).
    references (list of list of str): A list of one or more reference streams (each a sequence of segments).
    normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,
                                    as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.
                                    Only applies if `normalized = True`. Defaults to `False`.
    case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.

Returns:
    'score' (float): TER score (num_edits / sum_ref_lengths * 100)
    'num_edits' (int): The cumulative number of edits
    'ref_length' (float): The cumulative average reference length

Examples:
    Example 1:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\",
        ...                     \"What did the TER metric user say to the developer?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],
        ...             [\"Your jokes are...\", \"...TERrible\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 150.0, 'num_edits': 15, 'ref_length': 10.0}

    Example 2:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 62.5, 'num_edits': 5, 'ref_length': 8.0}

    Example 3:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         normalized=True,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 57.14285714285714, 'num_edits': 6, 'ref_length': 10.5}

    Example 4:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {'score': 0.0, 'num_edits': 0, 'ref_length': 8.0}

    Example 5:
        >>> predictions = [\"does this sentence match??\",
        ...                    \"what about this sentence?\",
        ...                    \"What did the TER metric user say to the developer?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],
        ...             [\"Your jokes are...\", \"...TERrible\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {'score': 100.0, 'num_edits': 10, 'ref_length': 10.0}
"""







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION ,						_KWARGS_DESCRIPTION	)
class lowerCAmelCase_						(			datasets.Metric	):

	'''simple docstring'''

	def 						UpperCamelCase__					(     self ):
							if version.parse(scb.__version__ ) < version.parse('''1.4.12''' ):
													raise ImportWarning(
													    '''To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'''
													    '''You can install it with `pip install \"sacrebleu>=1.4.12\"`.''' )
							return datasets.MetricInfo(
							    description=_DESCRIPTION		,				citation=_CITATION		,				homepage='''http://www.cs.umd.edu/~snover/tercom/'''		,				inputs_description=_KWARGS_DESCRIPTION		,				features=datasets.Features(
							        {
							            '''predictions''': datasets.Value('''string'''		,				id='''sequence''' ),
							            '''references''': datasets.Sequence(datasets.Value('''string'''		,				id='''sequence''' )		,				id='''references''' ),
							        } )		,				codebase_urls=['''https://github.com/mjpost/sacreBLEU#ter''']		,				reference_urls=[
							        '''https://github.com/jhclark/tercom''',
							    ]		,				)





	def 						UpperCamelCase__					(     self		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase = False		,				_UpperCAmelCase = False		,				_UpperCAmelCase = False		,				_UpperCAmelCase = False		,				):
							snake_case_	=				len(references[0] )
							if any(len(_lowercase ) != references_per_prediction for refs in references ):
													raise ValueError('''Sacrebleu requires the same number of references for each prediction''' )
							snake_case_	=				[[refs[i] for refs in references] for i in range(_lowercase )]

							snake_case_	=				TER(
							    normalized=_lowercase		,				no_punct=_lowercase		,				asian_support=_lowercase		,				case_sensitive=_lowercase		,				)
							snake_case_	=				sb_ter.corpus_score(_lowercase		,				_lowercase )

							return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}



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

 '''simple docstring'''

 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.config_class(**self.inputs_dict )
       self.parent.assertTrue(hasattr(_UpperCAmelCase		,				'''hidden_sizes''' ) )
       self.parent.assertTrue(hasattr(_UpperCAmelCase		,				'''num_attention_heads''' ) )
       self.parent.assertTrue(hasattr(_UpperCAmelCase		,				'''num_encoder_blocks''' ) )







class lowerCAmelCase_						:

 '''simple docstring'''

 def __init__(     self		,				_UpperCAmelCase		,				_UpperCAmelCase=13		,				_UpperCAmelCase=64		,				_UpperCAmelCase=3		,				_UpperCAmelCase=4		,				_UpperCAmelCase=[2, 2, 2, 2]		,				_UpperCAmelCase=[8, 4, 2, 1]		,				_UpperCAmelCase=[16, 32, 64, 1_28]		,				_UpperCAmelCase=[1, 4, 8, 16]		,				_UpperCAmelCase=[1, 2, 4, 8]		,				_UpperCAmelCase=True		,				_UpperCAmelCase=True		,				_UpperCAmelCase="gelu"		,				_UpperCAmelCase=0.1		,				_UpperCAmelCase=0.1		,				_UpperCAmelCase=0.02		,				_UpperCAmelCase=3		,				_UpperCAmelCase=None		,				):
       snake_case_	=				parent
       snake_case_	=				batch_size
       snake_case_	=				image_size
       snake_case_	=				num_channels
       snake_case_	=				num_encoder_blocks
       snake_case_	=				sr_ratios
       snake_case_	=				depths
       snake_case_	=				hidden_sizes
       snake_case_	=				downsampling_rates
       snake_case_	=				num_attention_heads
       snake_case_	=				is_training
       snake_case_	=				use_labels
       snake_case_	=				hidden_act
       snake_case_	=				hidden_dropout_prob
       snake_case_	=				attention_probs_dropout_prob
       snake_case_	=				initializer_range
       snake_case_	=				num_labels
       snake_case_	=				scope



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

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



 def 						UpperCamelCase__					(     self ):
       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		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				SegformerModel(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(_UpperCAmelCase )
       snake_case_	=				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		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				self.num_labels
       snake_case_	=				SegformerForSemanticSegmentation(_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				model(_UpperCAmelCase )
       self.parent.assertEqual(
           result.logits.shape		,				(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4) )
       snake_case_	=				model(_UpperCAmelCase		,				labels=_UpperCAmelCase )
       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		,				_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
       snake_case_	=				1
       snake_case_	=				SegformerForSemanticSegmentation(config=_UpperCAmelCase )
       model.to(_UpperCAmelCase )
       model.eval()
       snake_case_	=				torch.randint(0		,				1		,				(self.batch_size, self.image_size, self.image_size) ).to(_UpperCAmelCase )
       snake_case_	=				model(_UpperCAmelCase		,				labels=_UpperCAmelCase )
       self.parent.assertGreater(result.loss		,				0.0 )





 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.prepare_config_and_inputs()
       snake_case_	,   snake_case_	,   snake_case_	=				config_and_inputs
       snake_case_	=				{'''pixel_values''': pixel_values}
       return config, inputs_dict







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

 '''simple docstring'''

 __snake_case												=  (
     (
         SegformerModel,
         SegformerForSemanticSegmentation,
         SegformerForImageClassification,
     )
     if is_torch_available()
     else ()
 )
 __snake_case												=  (
     {
         "feature-extraction": SegformerModel,
         "image-classification": SegformerForImageClassification,
         "image-segmentation": SegformerForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 __snake_case												=  True
 __snake_case												=  False
 __snake_case												=  False
 __snake_case												=  False



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				SegformerModelTester(self )
       snake_case_	=				SegformerConfigTester(self		,				config_class=_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       self.config_tester.run_common_tests()



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_binary_image_segmentation(*_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_segmentation(*_UpperCAmelCase )



 @unittest.skip('''SegFormer does not use inputs_embeds''' )
 def 						UpperCamelCase__					(     self ):
       pass



 @unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods''' )
 def 						UpperCamelCase__					(     self ):
       pass



 def 						UpperCamelCase__					(     self ):
       snake_case_	,   snake_case_	=				self.model_tester.prepare_config_and_inputs_for_common()

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

             snake_case_	=				['''pixel_values''']
             self.assertListEqual(arg_names[:1]		,				_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       snake_case_	,   snake_case_	=				self.model_tester.prepare_config_and_inputs_for_common()
       snake_case_	=				True

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

             snake_case_	=				sum(self.model_tester.depths )
             self.assertEqual(len(_UpperCAmelCase )		,				_UpperCAmelCase )

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

             self.assertEqual(len(_UpperCAmelCase )		,				_UpperCAmelCase )

             # verify the first attentions (first block, first layer)
             snake_case_	=				(self.model_tester.image_size // 4) ** 2
             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)
             snake_case_	=				(self.model_tester.image_size // 32) ** 2
             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]		,				)
             snake_case_	=				len(_UpperCAmelCase )

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

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

             snake_case_	=				outputs.attentions

             self.assertEqual(len(_UpperCAmelCase )		,				_UpperCAmelCase )
             # verify the first attentions (first block, first layer)
             snake_case_	=				(self.model_tester.image_size // 4) ** 2
             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 ):
       def check_hidden_states_output(_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase ):
             snake_case_	=				model_class(_UpperCAmelCase )
             model.to(_UpperCAmelCase )
             model.eval()

             with torch.no_grad():
                   snake_case_	=				model(**self._prepare_for_class(_UpperCAmelCase		,				_UpperCAmelCase ) )

             snake_case_	=				outputs.hidden_states

             snake_case_	=				self.model_tester.num_encoder_blocks
             self.assertEqual(len(_UpperCAmelCase )		,				_UpperCAmelCase )

             # 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,
                 ]		,				)

       snake_case_	,   snake_case_	=				self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             snake_case_	=				True
             check_hidden_states_output(_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase )

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

             check_hidden_states_output(_UpperCAmelCase		,				_UpperCAmelCase		,				_UpperCAmelCase )



 def 						UpperCamelCase__					(     self ):
       if not self.model_tester.is_training:
             return

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

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

             snake_case_	=				model_class(_UpperCAmelCase )
             model.to(_UpperCAmelCase )
             model.train()
             snake_case_	=				self._prepare_for_class(_UpperCAmelCase		,				_UpperCAmelCase		,				return_labels=_UpperCAmelCase )
             snake_case_	=				model(**_UpperCAmelCase ).loss
             loss.backward()



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





 @slow
 def 						UpperCamelCase__					(     self ):
       for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case_	=				SegformerModel.from_pretrained(_UpperCAmelCase )
             self.assertIsNotNone(_UpperCAmelCase )






def 	__lowerCAmelCase   ()->  List[str]:




      """simple docstring"""

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







@require_torch
class lowerCAmelCase_						(			unittest.TestCase	):

 '''simple docstring'''

 @slow
 def 						UpperCamelCase__					(     self ):
       # only resize + normalize
       snake_case_	=				SegformerImageProcessor(
           image_scale=(5_12, 5_12)		,				keep_ratio=_UpperCAmelCase		,				align=_UpperCAmelCase		,				do_random_crop=_UpperCAmelCase )
       snake_case_	=				SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512''' ).to(
           _UpperCAmelCase )

       snake_case_	=				prepare_img()
       snake_case_	=				image_processor(images=_UpperCAmelCase		,				return_tensors='''pt''' )
       snake_case_	=				encoded_inputs.pixel_values.to(_UpperCAmelCase )

       with torch.no_grad():
             snake_case_	=				model(_UpperCAmelCase )

       snake_case_	=				torch.Size((1, model.config.num_labels, 1_28, 1_28) )
       self.assertEqual(outputs.logits.shape		,				_UpperCAmelCase )

       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(_UpperCAmelCase )
       self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]		,				_UpperCAmelCase		,				atol=1E-4 ) )



 @slow
 def 						UpperCamelCase__					(     self ):
       # only resize + normalize
       snake_case_	=				SegformerImageProcessor(
           image_scale=(5_12, 5_12)		,				keep_ratio=_UpperCAmelCase		,				align=_UpperCAmelCase		,				do_random_crop=_UpperCAmelCase )
       snake_case_	=				SegformerForSemanticSegmentation.from_pretrained(
           '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024''' ).to(_UpperCAmelCase )

       snake_case_	=				prepare_img()
       snake_case_	=				image_processor(images=_UpperCAmelCase		,				return_tensors='''pt''' )
       snake_case_	=				encoded_inputs.pixel_values.to(_UpperCAmelCase )

       with torch.no_grad():
             snake_case_	=				model(_UpperCAmelCase )

       snake_case_	=				torch.Size((1, model.config.num_labels, 1_28, 1_28) )
       self.assertEqual(outputs.logits.shape		,				_UpperCAmelCase )

       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(_UpperCAmelCase )
       self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]		,				_UpperCAmelCase		,				atol=1E-1 ) )





 @slow
 def 						UpperCamelCase__					(     self ):
       # only resize + normalize
       snake_case_	=				SegformerImageProcessor(
           image_scale=(5_12, 5_12)		,				keep_ratio=_UpperCAmelCase		,				align=_UpperCAmelCase		,				do_random_crop=_UpperCAmelCase )
       snake_case_	=				SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512''' ).to(
           _UpperCAmelCase )

       snake_case_	=				prepare_img()
       snake_case_	=				image_processor(images=_UpperCAmelCase		,				return_tensors='''pt''' )
       snake_case_	=				encoded_inputs.pixel_values.to(_UpperCAmelCase )

       with torch.no_grad():
             snake_case_	=				model(_UpperCAmelCase )

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

       snake_case_	=				image_processor.post_process_semantic_segmentation(outputs=_UpperCAmelCase		,				target_sizes=[(5_00, 3_00)] )
       snake_case_	=				torch.Size((5_00, 3_00) )
       self.assertEqual(segmentation[0].shape		,				_UpperCAmelCase )

       snake_case_	=				image_processor.post_process_semantic_segmentation(outputs=_UpperCAmelCase )
       snake_case_	=				torch.Size((1_28, 1_28) )
       self.assertEqual(segmentation[0].shape		,				_UpperCAmelCase )