



'''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__(					__UpperCAmelCase	):







    def 			lowercase_       (      self :  Any	):
      a						:					Dict        =     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__:







    def __init__(      self :  Optional[int]						,			__snake_case :  Union[str, Any]						,			__snake_case :  int=13						,			__snake_case :  Dict=64						,			__snake_case :  int=3						,			__snake_case :  Optional[Any]=4						,			__snake_case :  Tuple=[2, 2, 2, 2]						,			__snake_case :  Tuple=[8, 4, 2, 1]						,			__snake_case :  List[str]=[16, 32, 64, 1_28]						,			__snake_case :  Tuple=[1, 4, 8, 16]						,			__snake_case :  Union[str, Any]=[1, 2, 4, 8]						,			__snake_case :  Tuple=True						,			__snake_case :  Optional[Any]=True						,			__snake_case :  Tuple="gelu"						,			__snake_case :  List[Any]=0.1						,			__snake_case :  List[Any]=0.1						,			__snake_case :  List[Any]=0.02						,			__snake_case :  int=3						,			__snake_case :  Any=None						,			):
      a						:					Optional[Any]        =     parent
      a						:					int        =     batch_size
      a						:					Tuple        =     image_size
      a						:					Union[str, Any]        =     num_channels
      a						:					str        =     num_encoder_blocks
      a						:					Dict        =     sr_ratios
      a						:					Dict        =     depths
      a						:					Union[str, Any]        =     hidden_sizes
      a						:					str        =     downsampling_rates
      a						:					Tuple        =     num_attention_heads
      a						:					Optional[Any]        =     is_training
      a						:					Union[str, Any]        =     use_labels
      a						:					Any        =     hidden_act
      a						:					Optional[int]        =     hidden_dropout_prob
      a						:					int        =     attention_probs_dropout_prob
      a						:					Optional[Any]        =     initializer_range
      a						:					Tuple        =     num_labels
      a						:					Union[str, Any]        =     scope







    def 			lowercase_       (      self :  int	):
      a						:					Optional[int]        =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

      a						:					Any        =     self.get_config()
      return config, pixel_values, labels







    def 			lowercase_       (      self :  Optional[Any]	):
      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 			lowercase_       (      self :  List[Any]						,			__snake_case :  Optional[int]						,			__snake_case :  Optional[Any]						,			__snake_case :  int	):
      a						:					Dict        =     SegformerModel(config=__snake_case	)
      model.to(__snake_case	)
      model.eval()
      a						:					Optional[Any]        =     model(__snake_case	)
      a						:					Optional[Any]        =     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 			lowercase_       (      self :  Optional[int]						,			__snake_case :  Tuple						,			__snake_case :  List[Any]						,			__snake_case :  Dict	):
      a						:					Optional[Any]        =     self.num_labels
      a						:					List[str]        =     SegformerForSemanticSegmentation(__snake_case	)
      model.to(__snake_case	)
      model.eval()
      a						:					List[str]        =     model(__snake_case	)
      self.parent.assertEqual(
          result.logits.shape						,			(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)	)
      a						:					int        =     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 			lowercase_       (      self :  List[Any]						,			__snake_case :  str						,			__snake_case :  Optional[Any]						,			__snake_case :  Tuple	):
      a						:					Union[str, Any]        =     1
      a						:					Optional[int]        =     SegformerForSemanticSegmentation(config=__snake_case	)
      model.to(__snake_case	)
      model.eval()
      a						:					Union[str, Any]        =     torch.randint(0						,			1						,			(self.batch_size, self.image_size, self.image_size)	).to(__snake_case	)
      a						:					Optional[Any]        =     model(__snake_case						,			labels=__snake_case	)
      self.parent.assertGreater(result.loss						,			0.0	)







    def 			lowercase_       (      self :  List[str]	):
      a						:					Any        =     self.prepare_config_and_inputs()
      a						:					str        =     config_and_inputs
      a						:					Optional[int]        =     {'pixel_values': pixel_values}
      return config, inputs_dict

@require_torch
class 							a__(					__UpperCAmelCase		, __UpperCAmelCase		, unittest.TestCase	):
    lowercase__ =    (
        (
            SegformerModel,
            SegformerForSemanticSegmentation,
            SegformerForImageClassification,
        )
        if is_torch_available()
        else ()
    )
    lowercase__ =    (
        {
            '''feature-extraction''': SegformerModel,
            '''image-classification''': SegformerForImageClassification,
            '''image-segmentation''': SegformerForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    lowercase__ =    True
    lowercase__ =    False
    lowercase__ =    False
    lowercase__ =    False







    def 			lowercase_       (      self :  Tuple	):
      a						:					Union[str, Any]        =     SegformerModelTester(self	)
      a						:					Optional[Any]        =     SegformerConfigTester(self						,			config_class=__snake_case	)







    def 			lowercase_       (      self :  Tuple	):
      self.config_tester.run_common_tests()







    def 			lowercase_       (      self :  int	):
      a						:					Dict        =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__snake_case	)







    def 			lowercase_       (      self :  Optional[Any]	):
      a						:					Union[str, Any]        =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*__snake_case	)







    def 			lowercase_       (      self :  Any	):
      a						:					int        =     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 			lowercase_       (      self :  Dict	):
      pass







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







    def 			lowercase_       (      self :  Tuple	):
      a						:					Union[str, Any]        =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a						:					List[str]        =     model_class(__snake_case	)
        a						:					Dict        =     inspect.signature(model.forward	)
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        a						:					Optional[int]        =     [*signature.parameters.keys()]

        a						:					Union[str, Any]        =     ['pixel_values']
        self.assertListEqual(arg_names[:1]						,			__snake_case	)







    def 			lowercase_       (      self :  List[Any]	):
      a						:					Dict        =     self.model_tester.prepare_config_and_inputs_for_common()
      a						:					Tuple        =     True

      for model_class in self.all_model_classes:
        a						:					str        =     True
        a						:					List[str]        =     False
        a						:					int        =     True
        a						:					List[Any]        =     model_class(__snake_case	)
        model.to(__snake_case	)
        model.eval()
        with torch.no_grad():
          a						:					Optional[Any]        =     model(**self._prepare_for_class(__snake_case						,			__snake_case	)	)
        a						:					Optional[Any]        =     outputs.attentions

        a						:					Dict        =     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"]
        a						:					Dict        =     True
        a						:					int        =     model_class(__snake_case	)
        model.to(__snake_case	)
        model.eval()
        with torch.no_grad():
          a						:					Optional[int]        =     model(**self._prepare_for_class(__snake_case						,			__snake_case	)	)
        a						:					Optional[Any]        =     outputs.attentions

        self.assertEqual(len(__snake_case	)						,			__snake_case	)

        # verify the first attentions (first block, first layer)
        a						:					Tuple        =     (self.model_tester.image_size // 4) ** 2
        a						:					List[str]        =     (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)
        a						:					str        =     (self.model_tester.image_size // 32) ** 2
        a						:					Optional[int]        =     (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]						,			)
        a						:					Dict        =     len(__snake_case	)

        # Check attention is always last and order is fine
        a						:					List[Any]        =     True
        a						:					Any        =     True
        a						:					Dict        =     model_class(__snake_case	)
        model.to(__snake_case	)
        model.eval()
        with torch.no_grad():
          a						:					int        =     model(**self._prepare_for_class(__snake_case						,			__snake_case	)	)

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

        a						:					int        =     outputs.attentions

        self.assertEqual(len(__snake_case	)						,			__snake_case	)
        # verify the first attentions (first block, first layer)
        a						:					List[Any]        =     (self.model_tester.image_size // 4) ** 2
        a						:					Union[str, Any]        =     (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 			lowercase_       (      self :  List[str]	):

      def check_hidden_states_output(__snake_case :  Tuple						,			__snake_case :  Any						,			__snake_case :  Optional[Any]	):
        a						:					Optional[Any]        =     model_class(__snake_case	)
        model.to(__snake_case	)
        model.eval()

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

        a						:					Union[str, Any]        =     outputs.hidden_states

        a						:					Any        =     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,
            ]						,			)

      a						:					Union[str, Any]        =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a						:					List[str]        =     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"]
        a						:					int        =     True

        check_hidden_states_output(__snake_case						,			__snake_case						,			__snake_case	)







    def 			lowercase_       (      self :  Any	):

      if not self.model_tester.is_training:
        return

      a						:					Optional[Any]        =     self.model_tester.prepare_config_and_inputs_for_common()
      a						:					Tuple        =     True

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

        a						:					Dict        =     model_class(__snake_case	)
        model.to(__snake_case	)
        model.train()
        a						:					str        =     self._prepare_for_class(__snake_case						,			__snake_case						,			return_labels=__snake_case	)
        a						:					Optional[int]        =     model(**__snake_case	).loss
        loss.backward()







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







    @slow
    def 			lowercase_       (      self :  List[Any]	):

      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a						:					Optional[Any]        =     SegformerModel.from_pretrained(__snake_case	)
        self.assertIsNotNone(__snake_case	)
def       lowerCamelCase__       (						):
  a						:					str        =     Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
  return image

@require_torch
class 							a__(					unittest.TestCase	):







    @slow
    def 			lowercase_       (      self :  Any	):
      a						:					Dict        =     SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,			keep_ratio=__snake_case						,			align=__snake_case						,			do_random_crop=__snake_case	)
      a						:					int        =     SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'	).to(
          __snake_case	)

      a						:					Optional[int]        =     prepare_img()
      a						:					Optional[int]        =     image_processor(images=__snake_case						,			return_tensors='pt'	)
      a						:					List[str]        =     encoded_inputs.pixel_values.to(__snake_case	)

      with torch.no_grad():
        a						:					Optional[int]        =     model(__snake_case	)

      a						:					Union[str, Any]        =     torch.Size((1, model.config.num_labels, 1_28, 1_28)	)
      self.assertEqual(outputs.logits.shape						,			__snake_case	)

      a						:					Dict        =     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 			lowercase_       (      self :  Tuple	):
      a						:					Dict        =     SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,			keep_ratio=__snake_case						,			align=__snake_case						,			do_random_crop=__snake_case	)
      a						:					List[str]        =     SegformerForSemanticSegmentation.from_pretrained(
          'nvidia/segformer-b1-finetuned-cityscapes-1024-1024'	).to(__snake_case	)

      a						:					Dict        =     prepare_img()
      a						:					Optional[int]        =     image_processor(images=__snake_case						,			return_tensors='pt'	)
      a						:					List[str]        =     encoded_inputs.pixel_values.to(__snake_case	)

      with torch.no_grad():
        a						:					Optional[Any]        =     model(__snake_case	)

      a						:					List[Any]        =     torch.Size((1, model.config.num_labels, 1_28, 1_28)	)
      self.assertEqual(outputs.logits.shape						,			__snake_case	)

      a						:					Optional[Any]        =     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 			lowercase_       (      self :  int	):
      a						:					List[str]        =     SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,			keep_ratio=__snake_case						,			align=__snake_case						,			do_random_crop=__snake_case	)
      a						:					List[str]        =     SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'	).to(
          __snake_case	)

      a						:					Any        =     prepare_img()
      a						:					Optional[Any]        =     image_processor(images=__snake_case						,			return_tensors='pt'	)
      a						:					Optional[int]        =     encoded_inputs.pixel_values.to(__snake_case	)

      with torch.no_grad():
        a						:					Union[str, Any]        =     model(__snake_case	)

      a						:					int        =     outputs.logits.detach().cpu()

      a						:					List[str]        =     image_processor.post_process_semantic_segmentation(outputs=__snake_case						,			target_sizes=[(5_00, 3_00)]	)
      a						:					Optional[Any]        =     torch.Size((5_00, 3_00)	)
      self.assertEqual(segmentation[0].shape						,			__snake_case	)

      a						:					Any        =     image_processor.post_process_semantic_segmentation(outputs=__snake_case	)
      a						:					Union[str, Any]        =     torch.Size((1_28, 1_28)	)
      self.assertEqual(segmentation[0].shape						,			__snake_case	)






from collections.abc import Iterable
from typing import Generic, TypeVar

lowercase      :       Any									=  TypeVar("""_T""")





class  A__    (							Generic[_T]	):




   """simple docstring"""



   def __init__(					self					,  lowercase = None)			->						None:







          '''simple docstring'''

          a__						:	list[_T] =				list(iterable or [])
          a__						:	list[_T] =				[]

   def __len__(					self)			->						int:







          '''simple docstring'''

          return len(self._stacka) + len(self._stacka)

   def __repr__(					self)			->						str:







          '''simple docstring'''

          return F'Queue({tuple(self._stacka[::-1] + self._stacka)})'

   def 							__lowercase		(					self					,  lowercase)			->						None:







          '''simple docstring'''

          self._stacka.append(lowercase)

   def 							__lowercase		(					self)			->						_T:







          '''simple docstring'''

          a__						:	List[str] =				self._stacka.pop
          a__						:	Optional[int] =				self._stacka.append

          if not self._stacka:
                 while self._stacka:
                        stacka_append(stacka_pop())

          if not self._stacka:
                 raise IndexError('Queue is empty')
          return self._stacka.pop()


if __name__ == "__main__":
    from doctest import testmod

    testmod()


