




from typing import Dict, List

from nltk.translate import gleu_score

import datasets
from datasets import MetricInfo


__a    :						Dict						      =       """\
@misc{wu2016googles,
      title={Google's Neural Machine Translation System: Bridging the Gap between Human and Machine Translation},
      author={Yonghui Wu and Mike Schuster and Zhifeng Chen and Quoc V. Le and Mohammad Norouzi and Wolfgang Macherey
              and Maxim Krikun and Yuan Cao and Qin Gao and Klaus Macherey and Jeff Klingner and Apurva Shah and Melvin
              Johnson and Xiaobing Liu and Łukasz Kaiser and Stephan Gouws and Yoshikiyo Kato and Taku Kudo and Hideto
              Kazawa and Keith Stevens and George Kurian and Nishant Patil and Wei Wang and Cliff Young and
              Jason Smith and Jason Riesa and Alex Rudnick and Oriol Vinyals and Greg Corrado and Macduff Hughes
              and Jeffrey Dean},
      year={2016},
      eprint={1609.08144},
      archivePrefix={arXiv},
      primaryClass={cs.CL}
}
"""

__a    :						Optional[Any]						      =       """\
The BLEU score has some undesirable properties when used for single
sentences, as it was designed to be a corpus measure. We therefore
use a slightly different score for our RL experiments which we call
the 'GLEU score'. For the GLEU score, we record all sub-sequences of
1, 2, 3 or 4 tokens in output and target sequence (n-grams). We then
compute a recall, which is the ratio of the number of matching n-grams
to the number of total n-grams in the target (ground truth) sequence,
and a precision, which is the ratio of the number of matching n-grams
to the number of total n-grams in the generated output sequence. Then
GLEU score is simply the minimum of recall and precision. This GLEU
score's range is always between 0 (no matches) and 1 (all match) and
it is symmetrical when switching output and target. According to
our experiments, GLEU score correlates quite well with the BLEU
metric on a corpus level but does not have its drawbacks for our per
sentence reward objective.
"""

__a    :						str						      =       """\
Computes corpus-level Google BLEU (GLEU) score of translated segments against one or more references.
Instead of averaging the sentence level GLEU scores (i.e. macro-average precision), Wu et al. (2016) sum up the matching
tokens and the max of hypothesis and reference tokens for each sentence, then compute using the aggregate values.

Args:
    predictions (list of str): list of translations to score.
        Each translation should be tokenized into a list of tokens.
    references (list of list of str): list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
    min_len (int): The minimum order of n-gram this function should extract. Defaults to 1.
    max_len (int): The maximum order of n-gram this function should extract. Defaults to 4.

Returns:
    'google_bleu': google_bleu score

Examples:
    Example 1:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results[\"google_bleu\"], 2))
        0.44

    Example 2:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references)
        >>> print(round(results[\"google_bleu\"], 2))
        0.61

    Example 3:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses, references=list_of_references, min_len=2)
        >>> print(round(results[\"google_bleu\"], 2))
        0.53

    Example 4:
        >>> hyp1 = ['It', 'is', 'a', 'guide', 'to', 'action', 'which',
        ...         'ensures', 'that', 'the', 'rubber', 'duck', 'always',
        ...         'disobeys', 'the', 'commands', 'of', 'the', 'cat']
        >>> ref1a = ['It', 'is', 'the', 'guiding', 'principle', 'which',
        ...          'guarantees', 'the', 'rubber', 'duck', 'forces', 'never',
        ...          'being', 'under', 'the', 'command', 'of', 'the', 'cat']
        >>> ref1b = ['It', 'is', 'a', 'guide', 'to', 'action', 'that',
        ...          'ensures', 'that', 'the', 'rubber', 'duck', 'will', 'never',
        ...          'heed', 'the', 'cat', 'commands']
        >>> ref1c = ['It', 'is', 'the', 'practical', 'guide', 'for', 'the',
        ...          'rubber', 'duck', 'army', 'never', 'to', 'heed', 'the', 'directions',
        ...          'of', 'the', 'cat']

        >>> hyp2 = ['he', 'read', 'the', 'book', 'because', 'he', 'was',
        ...         'interested', 'in', 'world', 'history']
        >>> ref2a = ['he', 'was', 'interested', 'in', 'world', 'history',
        ...          'because', 'he', 'read', 'the', 'book']

        >>> list_of_references = [[ref1a, ref1b, ref1c], [ref2a]]
        >>> hypotheses = [hyp1, hyp2]
        >>> google_bleu = datasets.load_metric(\"google_bleu\")
        >>> results = google_bleu.compute(predictions=hypotheses,references=list_of_references, min_len=2, max_len=6)
        >>> print(round(results[\"google_bleu\"], 2))
        0.4
"""







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



	"""simple docstring"""






	def        __a      (	self							)   ->     MetricInfo:





								"""simple docstring"""


								return datasets.MetricInfo(
								    description=_DESCRIPTION			, citation=_CITATION			, inputs_description=_KWARGS_DESCRIPTION			, features=datasets.Features(
								        {
								            "predictions": datasets.Sequence(datasets.Value("string"			, id="token"							)			, id="sequence"							),
								            "references": datasets.Sequence(
								                datasets.Sequence(datasets.Value("string"			, id="token"							)			, id="sequence"							)			, id="references"							),
								        }							)			, )







	def        __a      (	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase = 1			, lowerCamelCase = 4			, )   ->     Dict[str, float]:





								"""simple docstring"""


								return {
								    "google_bleu": gleu_score.corpus_gleu(
								        list_of_references=lowerCamelCase			, hypotheses=lowerCamelCase			, min_len=lowerCamelCase			, max_len=lowerCamelCase							)
								}







'''simple docstring'''



import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
 from transformers.models.mobilevitva.modeling_mobilevitva import (
     MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
     make_divisible,
 )


if is_vision_available():
 from PIL import Image

 from transformers import MobileViTImageProcessor
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):




      def 			__UpperCamelCase				(	self   )				->List[Any]:



         '''simple docstring'''
         __a					  =     self.config_class(**self.inputs_dict   )
         self.parent.assertTrue(hasattr(lowerCamelCase			, 'width_multiplier'   )   )







class 				__SCREAMING_SNAKE_CASE							:




      def __init__(	self			, lowerCamelCase			, lowerCamelCase=13			, lowerCamelCase=64			, lowerCamelCase=2			, lowerCamelCase=3			, lowerCamelCase="swish"			, lowerCamelCase=3			, lowerCamelCase=32			, lowerCamelCase=0.1			, lowerCamelCase=0.02			, lowerCamelCase=True			, lowerCamelCase=True			, lowerCamelCase=10			, lowerCamelCase=None			, lowerCamelCase=0.25			, lowerCamelCase=0.0			, lowerCamelCase=0.0			, )				->List[str]:



         '''simple docstring'''
         __a					  =     parent
         __a					  =     batch_size
         __a					  =     image_size
         __a					  =     patch_size
         __a					  =     num_channels
         __a					  =     make_divisible(512 * width_multiplier			, divisor=8   )
         __a					  =     hidden_act
         __a					  =     conv_kernel_size
         __a					  =     output_stride
         __a					  =     classifier_dropout_prob
         __a					  =     use_labels
         __a					  =     is_training
         __a					  =     num_labels
         __a					  =     initializer_range
         __a					  =     scope
         __a					  =     width_multiplier
         __a					  =     ffn_dropout
         __a					  =     attn_dropout




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         __a					  =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

         __a					  =     self.get_config()

         return config, pixel_values, labels, pixel_labels




      def 			__UpperCamelCase				(	self   )				->Dict:



         '''simple docstring'''
         return MobileViTVaConfig(
             image_size=self.image_size			, patch_size=self.patch_size			, num_channels=self.num_channels			, hidden_act=self.hidden_act			, conv_kernel_size=self.conv_kernel_size			, output_stride=self.output_stride			, classifier_dropout_prob=self.classifier_dropout_prob			, initializer_range=self.initializer_range			, width_multiplier=self.width_multiplier			, ffn_dropout=self.ffn_dropout_prob			, attn_dropout=self.attn_dropout_prob			, )




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )				->str:



         '''simple docstring'''
         __a					  =     MobileViTVaModel(config=lowerCamelCase   )
         model.to(lowerCamelCase   )
         model.eval()
         __a					  =     model(lowerCamelCase   )
         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			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )				->Any:



         '''simple docstring'''
         __a					  =     self.num_labels
         __a					  =     MobileViTVaForImageClassification(lowerCamelCase   )
         model.to(lowerCamelCase   )
         model.eval()
         __a					  =     model(lowerCamelCase			, labels=lowerCamelCase   )
         self.parent.assertEqual(result.logits.shape			, (self.batch_size, self.num_labels)   )




      def 			__UpperCamelCase				(	self			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     self.num_labels
         __a					  =     MobileViTVaForSemanticSegmentation(lowerCamelCase   )
         model.to(lowerCamelCase   )
         model.eval()
         __a					  =     model(lowerCamelCase   )
         self.parent.assertEqual(
             result.logits.shape			, (
                 self.batch_size,
                 self.num_labels,
                 self.image_size // self.output_stride,
                 self.image_size // self.output_stride,
             )			, )
         __a					  =     model(lowerCamelCase			, labels=lowerCamelCase   )
         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   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     self.prepare_config_and_inputs()
         __a  ,      __a  ,      __a  ,      __a					  =     config_and_inputs
         __a					  =     {'pixel_values': pixel_values}
         return config, inputs_dict







@require_torch
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase   ,   _lowerCAmelCase   ,   unittest.TestCase  ):
      __a	       =(
          (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
          if is_torch_available()
          else ()
      )

      __a	       =(
          {
              "feature-extraction": MobileViTVaModel,
              "image-classification": MobileViTVaForImageClassification,
              "image-segmentation": MobileViTVaForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      __a	       =False
      __a	       =False
      __a	       =False
      __a	       =False




      def 			__UpperCamelCase				(	self   )				->Dict:



         '''simple docstring'''
         __a					  =     MobileViTVaModelTester(self   )
         __a					  =     MobileViTVaConfigTester(self			, config_class=lowerCamelCase			, has_text_modality=lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         self.config_tester.run_common_tests()




      @unittest.skip(reason='MobileViTV2 does not use inputs_embeds'   )
      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         pass




      @unittest.skip(reason='MobileViTV2 does not support input and output embeddings'   )
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         pass




      @unittest.skip(reason='MobileViTV2 does not output attentions'   )
      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         pass




      @require_torch_multi_gpu
      @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.'   )
      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         pass




      @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




      def 			__UpperCamelCase				(	self   )				->Dict:



         '''simple docstring'''
         __a  ,      __a					  =     self.model_tester.prepare_config_and_inputs_for_common()

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

            __a					  =     ['pixel_values']
            self.assertListEqual(arg_names[:1]			, lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         __a					  =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Optional[Any]:



         '''simple docstring'''
         def check_hidden_states_output(lowerCamelCase			, lowerCamelCase			, lowerCamelCase   ):
            __a					  =     model_class(lowerCamelCase   )
            model.to(lowerCamelCase   )
            model.eval()

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

            __a					  =     outputs.hidden_states

            __a					  =     5
            self.assertEqual(len(lowerCamelCase   )			, lowerCamelCase   )

            # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
            # with the width and height being successively divided by 2.
            __a					  =     2
            for i in range(len(lowerCamelCase   )   ):
               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   )

         __a  ,      __a					  =     self.model_tester.prepare_config_and_inputs_for_common()

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

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

            check_hidden_states_output(lowerCamelCase			, lowerCamelCase			, lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Optional[int]:



         '''simple docstring'''
         __a					  =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*lowerCamelCase   )




      def 			__UpperCamelCase				(	self   )				->Dict:



         '''simple docstring'''
         __a					  =     self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase   )






      @slow
      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            __a					  =     MobileViTVaModel.from_pretrained(lowerCamelCase   )
            self.assertIsNotNone(lowerCamelCase   )







def  __UpperCAmelCase						(					)	->      List[Any]:

   """simple docstring"""
   __a					  =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
   return image



@require_torch
@require_vision
class 				__SCREAMING_SNAKE_CASE							(				unittest.TestCase  ):




      @cached_property
      def 			__UpperCamelCase				(	self   )				->int:



         '''simple docstring'''
         return (
             MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256'   )
             if is_vision_available()
             else None
         )




      @slow
      def 			__UpperCamelCase				(	self   )				->List[Any]:



         '''simple docstring'''
         __a					  =     MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256'   ).to(
             lowerCamelCase   )

         __a					  =     self.default_image_processor
         __a					  =     prepare_img()
         __a					  =     image_processor(images=lowerCamelCase			, return_tensors='pt'   ).to(lowerCamelCase   )

         # forward pass
         with torch.no_grad():
            __a					  =     model(**lowerCamelCase   )

         # verify the logits
         __a					  =     torch.Size((1, 1000)   )
         self.assertEqual(outputs.logits.shape			, lowerCamelCase   )

         __a					  =     torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]   ).to(lowerCamelCase   )

         self.assertTrue(torch.allclose(outputs.logits[0, :3]			, lowerCamelCase			, atol=1e-4   )   )




      @slow
      def 			__UpperCamelCase				(	self   )				->List[str]:



         '''simple docstring'''
         __a					  =     MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )
         __a					  =     model.to(lowerCamelCase   )

         __a					  =     MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )

         __a					  =     prepare_img()
         __a					  =     image_processor(images=lowerCamelCase			, return_tensors='pt'   ).to(lowerCamelCase   )

         # forward pass
         with torch.no_grad():
            __a					  =     model(**lowerCamelCase   )
         __a					  =     outputs.logits

         # verify the logits
         __a					  =     torch.Size((1, 21, 32, 32)   )
         self.assertEqual(logits.shape			, lowerCamelCase   )

         __a					  =     torch.tensor(
             [
                 [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
                 [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
                 [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
             ]			, device=lowerCamelCase			, )

         self.assertTrue(torch.allclose(logits[0, :3, :3, :3]			, lowerCamelCase			, atol=1e-4   )   )






      @slow
      def 			__UpperCamelCase				(	self   )				->Union[str, Any]:



         '''simple docstring'''
         __a					  =     MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )
         __a					  =     model.to(lowerCamelCase   )

         __a					  =     MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3'   )

         __a					  =     prepare_img()
         __a					  =     image_processor(images=lowerCamelCase			, return_tensors='pt'   ).to(lowerCamelCase   )

         # forward pass
         with torch.no_grad():
            __a					  =     model(**lowerCamelCase   )

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

         __a					  =     image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase			, target_sizes=[(50, 60)]   )
         __a					  =     torch.Size((50, 60)   )
         self.assertEqual(segmentation[0].shape			, lowerCamelCase   )

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