
"""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      _UpperCAmelCase				(					_snake_case):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   self.config_class(**self.inputs_dict     )
      self.parent.assertTrue(hasattr(_lowerCAmelCase						,    "hidden_sizes"     )     )
      self.parent.assertTrue(hasattr(_lowerCAmelCase						,    "num_attention_heads"     )     )
      self.parent.assertTrue(hasattr(_lowerCAmelCase						,    "num_encoder_blocks"     )     )






class      _UpperCAmelCase				:
    def __init__(    self						,    snake_case_						,    snake_case_=13						,    snake_case_=64						,    snake_case_=3						,    snake_case_=4						,    snake_case_=[2, 2, 2, 2]						,    snake_case_=[8, 4, 2, 1]						,    snake_case_=[16, 32, 64, 1_28]						,    snake_case_=[1, 4, 8, 16]						,    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     :						List[Any]						=   parent
      _snake_case     :						Tuple						=   batch_size
      _snake_case     :						Union[str, Any]						=   image_size
      _snake_case     :						List[Any]						=   num_channels
      _snake_case     :						List[Any]						=   num_encoder_blocks
      _snake_case     :						Tuple						=   sr_ratios
      _snake_case     :						int						=   depths
      _snake_case     :						Tuple						=   hidden_sizes
      _snake_case     :						Optional[Any]						=   downsampling_rates
      _snake_case     :						Tuple						=   num_attention_heads
      _snake_case     :						int						=   is_training
      _snake_case     :						List[Any]						=   use_labels
      _snake_case     :						Dict						=   hidden_act
      _snake_case     :						Dict						=   hidden_dropout_prob
      _snake_case     :						str						=   attention_probs_dropout_prob
      _snake_case     :						List[Any]						=   initializer_range
      _snake_case     :						int						=   num_labels
      _snake_case     :						List[Any]						=   scope
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

      _snake_case     :						List[str]						=   None
      if self.use_labels:
        _snake_case     :						Tuple						=   ids_tensor([self.batch_size, self.image_size, self.image_size]						,    self.num_labels     )

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


    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   self.prepare_config_and_inputs()
      _snake_case			,					_snake_case			,					_snake_case     :						Tuple						=   config_and_inputs
      _snake_case     :						Tuple						=   {"pixel_values": pixel_values}
      return config, inputs_dict






@require_torch
class      _UpperCAmelCase				(					_snake_case		,					_snake_case		,					unittest.TestCase):
    __lowercase							: Optional[int]  =					(
        (
            SegformerModel,
            SegformerForSemanticSegmentation,
            SegformerForImageClassification,
        )
        if is_torch_available()
        else ()
    )
    __lowercase							: List[Any]  =					(
        {
            """feature-extraction""": SegformerModel,
            """image-classification""": SegformerForImageClassification,
            """image-segmentation""": SegformerForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    __lowercase							: Any  =					True
    __lowercase							: Any  =					False
    __lowercase							: Dict  =					False
    __lowercase							: Union[str, Any]  =					False
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   SegformerModelTester(self     )
      _snake_case     :						Tuple						=   SegformerConfigTester(self						,    config_class=_lowerCAmelCase     )
    def 					lowerCamelCase__	(    self     ):
      self.config_tester.run_common_tests()
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCAmelCase     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[Any]						=   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_binary_image_segmentation(*_lowerCAmelCase     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_segmentation(*_lowerCAmelCase     )
    @unittest.skip("SegFormer does not use inputs_embeds"     )
    def 					lowerCamelCase__	(    self     ):
      pass
    @unittest.skip("SegFormer does not have get_input_embeddings method and get_output_embeddings methods"     )
    def 					lowerCamelCase__	(    self     ):
      pass
    def 					lowerCamelCase__	(    self     ):
      _snake_case			,					_snake_case     :						int						=   self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        _snake_case     :						Optional[int]						=   model_class(_lowerCAmelCase     )
        _snake_case     :						Union[str, Any]						=   inspect.signature(model.forward     )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        _snake_case     :						str						=   [*signature.parameters.keys()]

        _snake_case     :						Union[str, Any]						=   ["pixel_values"]
        self.assertListEqual(arg_names[:1]						,    _lowerCAmelCase     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case			,					_snake_case     :						str						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						Optional[int]						=   True

      for model_class in self.all_model_classes:
        _snake_case     :						List[Any]						=   True
        _snake_case     :						Union[str, Any]						=   False
        _snake_case     :						Dict						=   True
        _snake_case     :						Tuple						=   model_class(_lowerCAmelCase     )
        model.to(_lowerCAmelCase     )
        model.eval()
        with torch.no_grad():
          _snake_case     :						Dict						=   model(**self._prepare_for_class(_lowerCAmelCase						,    _lowerCAmelCase     )     )
        _snake_case     :						Union[str, Any]						=   outputs.attentions

        _snake_case     :						int						=   sum(self.model_tester.depths     )
        self.assertEqual(len(_lowerCAmelCase     )						,    _lowerCAmelCase     )

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        _snake_case     :						List[Any]						=   True
        _snake_case     :						int						=   model_class(_lowerCAmelCase     )
        model.to(_lowerCAmelCase     )
        model.eval()
        with torch.no_grad():
          _snake_case     :						Dict						=   model(**self._prepare_for_class(_lowerCAmelCase						,    _lowerCAmelCase     )     )
        _snake_case     :						List[str]						=   outputs.attentions

        self.assertEqual(len(_lowerCAmelCase     )						,    _lowerCAmelCase     )

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

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

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

        _snake_case     :						Tuple						=   outputs.attentions

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

        with torch.no_grad():
          _snake_case     :						List[str]						=   model(**self._prepare_for_class(_lowerCAmelCase						,    _lowerCAmelCase     )     )

        _snake_case     :						Tuple						=   outputs.hidden_states

        _snake_case     :						int						=   self.model_tester.num_encoder_blocks
        self.assertEqual(len(_lowerCAmelCase     )						,    _lowerCAmelCase     )

        # verify the first hidden states (first block)
        self.assertListEqual(
            list(hidden_states[0].shape[-3:]     )						,    [
                self.model_tester.hidden_sizes[0],
                self.model_tester.image_size // 4,
                self.model_tester.image_size // 4,
            ]						,    )

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

      for model_class in self.all_model_classes:
        _snake_case     :						List[Any]						=   True
        check_hidden_states_output(_lowerCAmelCase						,    _lowerCAmelCase						,    _lowerCAmelCase     )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        _snake_case     :						List[Any]						=   True

        check_hidden_states_output(_lowerCAmelCase						,    _lowerCAmelCase						,    _lowerCAmelCase     )
    def 					lowerCamelCase__	(    self     ):
      if not self.model_tester.is_training:
        return

      _snake_case			,					_snake_case     :						List[Any]						=   self.model_tester.prepare_config_and_inputs_for_common()
      _snake_case     :						str						=   True

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

        _snake_case     :						Optional[Any]						=   model_class(_lowerCAmelCase     )
        model.to(_lowerCAmelCase     )
        model.train()
        _snake_case     :						Any						=   self._prepare_for_class(_lowerCAmelCase						,    _lowerCAmelCase						,    return_labels=_lowerCAmelCase     )
        _snake_case     :						List[Any]						=   model(**_lowerCAmelCase     ).loss
        loss.backward()
    @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."     )
    def 					lowerCamelCase__	(    self     ):
      pass


    @slow
    def 					lowerCamelCase__	(    self     ):
      for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        _snake_case     :						List[Any]						=   SegformerModel.from_pretrained(_lowerCAmelCase     )
        self.assertIsNotNone(_lowerCAmelCase     )


def 				a__   (   ):

  """simple docstring"""







  _snake_case     :						Optional[Any]						=   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
  return image






@require_torch
class      _UpperCAmelCase				(					unittest.TestCase):
    @slow
    def 					lowerCamelCase__	(    self     ):
      # only resize + normalize
      _snake_case     :						Optional[int]						=   SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,    keep_ratio=_lowerCAmelCase						,    align=_lowerCAmelCase						,    do_random_crop=_lowerCAmelCase     )
      _snake_case     :						Optional[int]						=   SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512"     ).to(
          _lowerCAmelCase     )

      _snake_case     :						str						=   prepare_img()
      _snake_case     :						str						=   image_processor(images=_lowerCAmelCase						,    return_tensors="pt"     )
      _snake_case     :						Union[str, Any]						=   encoded_inputs.pixel_values.to(_lowerCAmelCase     )

      with torch.no_grad():
        _snake_case     :						Optional[Any]						=   model(_lowerCAmelCase     )

      _snake_case     :						Tuple						=   torch.Size((1, model.config.num_labels, 1_28, 1_28)     )
      self.assertEqual(outputs.logits.shape						,    _lowerCAmelCase     )

      _snake_case     :						Tuple						=   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(_lowerCAmelCase     )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3]						,    _lowerCAmelCase						,    atol=1E-4     )     )
    @slow
    def 					lowerCamelCase__	(    self     ):
      # only resize + normalize
      _snake_case     :						Tuple						=   SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,    keep_ratio=_lowerCAmelCase						,    align=_lowerCAmelCase						,    do_random_crop=_lowerCAmelCase     )
      _snake_case     :						str						=   SegformerForSemanticSegmentation.from_pretrained(
          "nvidia/segformer-b1-finetuned-cityscapes-1024-1024"     ).to(_lowerCAmelCase     )

      _snake_case     :						Any						=   prepare_img()
      _snake_case     :						Any						=   image_processor(images=_lowerCAmelCase						,    return_tensors="pt"     )
      _snake_case     :						int						=   encoded_inputs.pixel_values.to(_lowerCAmelCase     )

      with torch.no_grad():
        _snake_case     :						Optional[Any]						=   model(_lowerCAmelCase     )

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

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


    @slow
    def 					lowerCamelCase__	(    self     ):
      # only resize + normalize
      _snake_case     :						Optional[Any]						=   SegformerImageProcessor(
          image_scale=(5_12, 5_12)						,    keep_ratio=_lowerCAmelCase						,    align=_lowerCAmelCase						,    do_random_crop=_lowerCAmelCase     )
      _snake_case     :						List[Any]						=   SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512"     ).to(
          _lowerCAmelCase     )

      _snake_case     :						Optional[int]						=   prepare_img()
      _snake_case     :						List[str]						=   image_processor(images=_lowerCAmelCase						,    return_tensors="pt"     )
      _snake_case     :						Optional[Any]						=   encoded_inputs.pixel_values.to(_lowerCAmelCase     )

      with torch.no_grad():
        _snake_case     :						Optional[Any]						=   model(_lowerCAmelCase     )

      _snake_case     :						Any						=   outputs.logits.detach().cpu()

      _snake_case     :						str						=   image_processor.post_process_semantic_segmentation(outputs=_lowerCAmelCase						,    target_sizes=[(5_00, 3_00)]     )
      _snake_case     :						Optional[int]						=   torch.Size((5_00, 3_00)     )
      self.assertEqual(segmentation[0].shape						,    _lowerCAmelCase     )

      _snake_case     :						Dict						=   image_processor.post_process_semantic_segmentation(outputs=_lowerCAmelCase     )
      _snake_case     :						List[str]						=   torch.Size((1_28, 1_28)     )
      self.assertEqual(segmentation[0].shape						,    _lowerCAmelCase     )



"""simple docstring"""
from ...configuration_utils import PretrainedConfig
from ...utils import logging


_a      :			Optional[int]					=							logging.get_logger(__name__)

_a      :			str					=							{"""openai-gpt""": """https://huggingface.co/openai-gpt/resolve/main/config.json"""}






class      _UpperCAmelCase				(					_snake_case):
    __lowercase							: Optional[Any]  =					"""openai-gpt"""
    __lowercase							: Dict  =					{
        """max_position_embeddings""": """n_positions""",
        """hidden_size""": """n_embd""",
        """num_attention_heads""": """n_head""",
        """num_hidden_layers""": """n_layer""",
    }
    def __init__(    self						,    snake_case_=4_04_78						,    snake_case_=5_12						,    snake_case_=7_68						,    snake_case_=12						,    snake_case_=12						,    snake_case_="gelu"						,    snake_case_=0.1						,    snake_case_=0.1						,    snake_case_=0.1						,    snake_case_=1E-5						,    snake_case_=0.02						,    snake_case_="cls_index"						,    snake_case_=True						,    snake_case_=None						,    snake_case_=True						,    snake_case_=0.1						,    **snake_case_						,    ):
      _snake_case     :						Tuple						=   vocab_size
      _snake_case     :						Dict						=   n_positions
      _snake_case     :						Any						=   n_embd
      _snake_case     :						Any						=   n_layer
      _snake_case     :						Optional[int]						=   n_head
      _snake_case     :						Union[str, Any]						=   afn
      _snake_case     :						Dict						=   resid_pdrop
      _snake_case     :						str						=   embd_pdrop
      _snake_case     :						Union[str, Any]						=   attn_pdrop
      _snake_case     :						str						=   layer_norm_epsilon
      _snake_case     :						Union[str, Any]						=   initializer_range
      _snake_case     :						Any						=   summary_type
      _snake_case     :						List[str]						=   summary_use_proj
      _snake_case     :						Optional[int]						=   summary_activation
      _snake_case     :						Union[str, Any]						=   summary_first_dropout
      _snake_case     :						Optional[int]						=   summary_proj_to_labels
      super().__init__(**snake_case_     )

