


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__     ):







    """simple docstring"""

    def 		a_      (	self   ):
         snake_case					=    self.config_class(**self.inputs_dict   )
         self.parent.assertTrue(hasattr(__snake_case      , '''hidden_sizes'''   )   )
         self.parent.assertTrue(hasattr(__snake_case      , '''num_attention_heads'''   )   )
         self.parent.assertTrue(hasattr(__snake_case      , '''num_encoder_blocks'''   )   )






class   A__ :







    """simple docstring"""

    def __init__(	self      , __snake_case      , __snake_case=1_3      , __snake_case=6_4      , __snake_case=3      , __snake_case=4      , __snake_case=[2, 2, 2, 2]      , __snake_case=[8, 4, 2, 1]      , __snake_case=[1_6, 3_2, 6_4, 1_2_8]      , __snake_case=[1, 4, 8, 1_6]      , __snake_case=[1, 2, 4, 8]      , __snake_case=True      , __snake_case=True      , __snake_case="gelu"      , __snake_case=0.1      , __snake_case=0.1      , __snake_case=0.02      , __snake_case=3      , __snake_case=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 		a_      (	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 		a_      (	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 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    SegformerModel(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )
         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 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    self.num_labels
         snake_case					=    SegformerForSemanticSegmentation(__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    model(__snake_case   )
         self.parent.assertEqual(
             result.logits.shape      , (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)   )
         snake_case					=    model(__snake_case      , labels=__snake_case   )
         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 		a_      (	self      , __snake_case      , __snake_case      , __snake_case   ):
         snake_case					=    1
         snake_case					=    SegformerForSemanticSegmentation(config=__snake_case   )
         model.to(__snake_case   )
         model.eval()
         snake_case					=    torch.randint(0      , 1      , (self.batch_size, self.image_size, self.image_size)   ).to(__snake_case   )
         snake_case					=    model(__snake_case      , labels=__snake_case   )
         self.parent.assertGreater(result.loss      , 0.0   )




    def 		a_      (	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   A__ (   snake_case__	, snake_case__	, unittest.TestCase     ):







    """simple docstring"""

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

    __magic_name__        =		True
    __magic_name__        =		False
    __magic_name__        =		False
    __magic_name__        =		False
    def 		a_      (	self   ):
         snake_case					=    SegformerModelTester(self   )
         snake_case					=    SegformerConfigTester(self      , config_class=__snake_case   )
    def 		a_      (	self   ):
         self.config_tester.run_common_tests()
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_binary_image_segmentation(*__snake_case   )
    def 		a_      (	self   ):
         snake_case					=    self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_segmentation(*__snake_case   )
    @unittest.skip('''SegFormer does not use inputs_embeds'''   )
    def 		a_      (	self   ):
         pass
    @unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''   )
    def 		a_      (	self   ):
         pass
    def 		a_      (	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(__snake_case   )
              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]      , __snake_case   )
    def 		a_      (	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(__snake_case   )
              model.to(__snake_case   )
              model.eval()
              with torch.no_grad():
                   snake_case					=    model(**self._prepare_for_class(__snake_case      , __snake_case   )   )
              snake_case					=    outputs.attentions

              snake_case					=    sum(self.model_tester.depths   )
              self.assertEqual(len(__snake_case   )      , __snake_case   )

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

              self.assertEqual(len(__snake_case   )      , __snake_case   )

              # 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 // 3_2) ** 2
              snake_case					=    (self.model_tester.image_size // (3_2 * 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(__snake_case   )

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

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

              snake_case					=    outputs.attentions

              self.assertEqual(len(__snake_case   )      , __snake_case   )
              # 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 		a_      (	self   ):
         def check_hidden_states_output(__snake_case      , __snake_case      , __snake_case   ):
              snake_case					=    model_class(__snake_case   )
              model.to(__snake_case   )
              model.eval()

              with torch.no_grad():
                   snake_case					=    model(**self._prepare_for_class(__snake_case      , __snake_case   )   )

              snake_case					=    outputs.hidden_states

              snake_case					=    self.model_tester.num_encoder_blocks
              self.assertEqual(len(__snake_case   )      , __snake_case   )

              # 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(__snake_case      , __snake_case      , __snake_case   )

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

              check_hidden_states_output(__snake_case      , __snake_case      , __snake_case   )
    def 		a_      (	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(__snake_case   ):
                   continue

              snake_case					=    model_class(__snake_case   )
              model.to(__snake_case   )
              model.train()
              snake_case					=    self._prepare_for_class(__snake_case      , __snake_case      , return_labels=__snake_case   )
              snake_case					=    model(**__snake_case   ).loss
              loss.backward()
    @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''   )
    def 		a_      (	self   ):
         pass




    @slow
    def 		a_      (	self   ):
         for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case					=    SegformerModel.from_pretrained(__snake_case   )
              self.assertIsNotNone(__snake_case   )






def       UpperCAmelCase__						():



     """simple docstring"""






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

@require_torch
class   A__ (   unittest.TestCase     ):







    """simple docstring"""

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

         snake_case					=    prepare_img()
         snake_case					=    image_processor(images=__snake_case      , return_tensors='''pt'''   )
         snake_case					=    encoded_inputs.pixel_values.to(__snake_case   )

         with torch.no_grad():
              snake_case					=    model(__snake_case   )

         snake_case					=    torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8)   )
         self.assertEqual(outputs.logits.shape      , __snake_case   )

         snake_case					=    torch.tensor(
             [
                 [[-4.6310, -5.5232, -6.2356], [-5.1921, -6.1444, -6.5996], [-5.4424, -6.2790, -6.7574]],
                 [[-12.1391, -13.3122, -13.9554], [-12.8732, -13.9352, -14.3563], [-12.9438, -13.8226, -14.2513]],
                 [[-12.5134, -13.4686, -14.4915], [-12.8669, -14.4343, -14.7758], [-13.2523, -14.5819, -15.0694]],
             ]   ).to(__snake_case   )
         self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      , __snake_case      , atol=1E-4   )   )
    @slow
    def 		a_      (	self   ):
         # only resize + normalize
         snake_case					=    SegformerImageProcessor(
             image_scale=(5_1_2, 5_1_2)      , keep_ratio=__snake_case      , align=__snake_case      , do_random_crop=__snake_case   )
         snake_case					=    SegformerForSemanticSegmentation.from_pretrained(
             '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''   ).to(__snake_case   )

         snake_case					=    prepare_img()
         snake_case					=    image_processor(images=__snake_case      , return_tensors='''pt'''   )
         snake_case					=    encoded_inputs.pixel_values.to(__snake_case   )

         with torch.no_grad():
              snake_case					=    model(__snake_case   )

         snake_case					=    torch.Size((1, model.config.num_labels, 1_2_8, 1_2_8)   )
         self.assertEqual(outputs.logits.shape      , __snake_case   )

         snake_case					=    torch.tensor(
             [
                 [[-13.5748, -13.9111, -12.6500], [-14.3500, -15.3683, -14.2328], [-14.7532, -16.0424, -15.6087]],
                 [[-17.1651, -15.8725, -12.9653], [-17.2580, -17.3718, -14.8223], [-16.6058, -16.8783, -16.7452]],
                 [[-3.6456, -3.0209, -1.4203], [-3.0797, -3.1959, -2.0000], [-1.8757, -1.9217, -1.6997]],
             ]   ).to(__snake_case   )
         self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]      , __snake_case      , atol=1E-1   )   )




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

         snake_case					=    prepare_img()
         snake_case					=    image_processor(images=__snake_case      , return_tensors='''pt'''   )
         snake_case					=    encoded_inputs.pixel_values.to(__snake_case   )

         with torch.no_grad():
              snake_case					=    model(__snake_case   )

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

         snake_case					=    image_processor.post_process_semantic_segmentation(outputs=__snake_case      , target_sizes=[(5_0_0, 3_0_0)]   )
         snake_case					=    torch.Size((5_0_0, 3_0_0)   )
         self.assertEqual(segmentation[0].shape      , __snake_case   )

         snake_case					=    image_processor.post_process_semantic_segmentation(outputs=__snake_case   )
         snake_case					=    torch.Size((1_2_8, 1_2_8)   )
         self.assertEqual(segmentation[0].shape      , __snake_case   )








import re

from filelock import FileLock


try:
 import nltk

 _SCREAMING_SNAKE_CASE      :			Union[str, Any]      				=   True
except (ImportError, ModuleNotFoundError):
 _SCREAMING_SNAKE_CASE      :			Optional[Any]      				=   False

if NLTK_AVAILABLE:
 with FileLock(".lock") as lock:
  nltk.download("punkt", quiet=True)
def       UpperCAmelCase__						(UpperCamelCase_    ):



     """simple docstring"""






     re.sub('''<n>'''							,''''''							,UpperCamelCase_    )  # remove pegasus newline char
     assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)"
     return "\n".join(nltk.sent_tokenize(UpperCamelCase_    )    )




