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





       """simple docstring"""




       def        UpperCamelCase				(							self      )    ->			int:
          _SCREAMING_SNAKE_CASE      =				self.config_class(**self.inputs_dict      )
          self.parent.assertTrue(hasattr(A__       ,							"""hidden_sizes"""      )      )
          self.parent.assertTrue(hasattr(A__       ,							"""num_attention_heads"""      )      )
          self.parent.assertTrue(hasattr(A__       ,							"""num_encoder_blocks"""      )      )






class    _a				:





       """simple docstring"""




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






       def        UpperCamelCase				(							self      )    ->			Tuple:
          _SCREAMING_SNAKE_CASE      =				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

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






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






       def        UpperCamelCase				(							self      )    ->			Optional[int]:
          _SCREAMING_SNAKE_CASE      =				self.prepare_config_and_inputs()
          _SCREAMING_SNAKE_CASE      =				config_and_inputs
          _SCREAMING_SNAKE_CASE      =				{"pixel_values": pixel_values}
          return config, inputs_dict






@require_torch
class    _a				(_UpperCamelCase  ,					_UpperCamelCase  ,					unittest.TestCase):





       """simple docstring"""




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

       SCREAMING_SNAKE_CASE      =  True
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False
       SCREAMING_SNAKE_CASE      =  False






       def        UpperCamelCase				(							self      )    ->			List[Any]:
          _SCREAMING_SNAKE_CASE      =				SegformerModelTester(self      )
          _SCREAMING_SNAKE_CASE      =				SegformerConfigTester(self       ,							config_class=A__      )






       def        UpperCamelCase				(							self      )    ->			Tuple:
          self.config_tester.run_common_tests()






       def        UpperCamelCase				(							self      )    ->			str:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A__      )






       def        UpperCamelCase				(							self      )    ->			Any:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_binary_image_segmentation(*A__      )






       def        UpperCamelCase				(							self      )    ->			List[str]:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_segmentation(*A__      )






       @unittest.skip("""SegFormer does not use inputs_embeds"""      )
       def        UpperCamelCase				(							self      )    ->			List[str]:
          pass






       @unittest.skip("""SegFormer does not have get_input_embeddings method and get_output_embeddings methods"""      )
       def        UpperCamelCase				(							self      )    ->			Optional[Any]:
          pass






       def        UpperCamelCase				(							self      )    ->			Union[str, Any]:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()

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

             _SCREAMING_SNAKE_CASE      =				["pixel_values"]
             self.assertListEqual(arg_names[:1]       ,							A__      )






       def        UpperCamelCase				(							self      )    ->			Tuple:
          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()
          _SCREAMING_SNAKE_CASE      =				True

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

             _SCREAMING_SNAKE_CASE      =				sum(self.model_tester.depths      )
             self.assertEqual(len(A__      )       ,							A__      )

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

             self.assertEqual(len(A__      )       ,							A__      )

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

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

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

             _SCREAMING_SNAKE_CASE      =				outputs.attentions

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

             with torch.no_grad():
                _SCREAMING_SNAKE_CASE      =				model(**self._prepare_for_class(A__       ,							A__      )      )

             _SCREAMING_SNAKE_CASE      =				outputs.hidden_states

             _SCREAMING_SNAKE_CASE      =				self.model_tester.num_encoder_blocks
             self.assertEqual(len(A__      )       ,							A__      )

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

          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             _SCREAMING_SNAKE_CASE      =				True
             check_hidden_states_output(A__       ,							A__       ,							A__      )

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

             check_hidden_states_output(A__       ,							A__       ,							A__      )






       def        UpperCamelCase				(							self      )    ->			Dict:
          if not self.model_tester.is_training:
             return

          _SCREAMING_SNAKE_CASE      =				self.model_tester.prepare_config_and_inputs_for_common()
          _SCREAMING_SNAKE_CASE      =				True

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

             _SCREAMING_SNAKE_CASE      =				model_class(A__      )
             model.to(A__      )
             model.train()
             _SCREAMING_SNAKE_CASE      =				self._prepare_for_class(A__       ,							A__       ,							return_labels=A__      )
             _SCREAMING_SNAKE_CASE      =				model(**A__      ).loss
             loss.backward()






       @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""      )
       def        UpperCamelCase				(							self      )    ->			str:
          pass






       @slow
       def        UpperCamelCase				(							self      )    ->			Dict:
          for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _SCREAMING_SNAKE_CASE      =				SegformerModel.from_pretrained(A__      )
             self.assertIsNotNone(A__      )






def    lowerCAmelCase_	(				)     ->     Optional[int]:




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







@require_torch
class    _a				(unittest.TestCase):





       """simple docstring"""




       @slow
       def        UpperCamelCase				(							self      )    ->			Any:
          # only resize + normalize
          _SCREAMING_SNAKE_CASE      =				SegformerImageProcessor(
              image_scale=(5_12, 5_12)       ,							keep_ratio=A__       ,							align=A__       ,							do_random_crop=A__      )
          _SCREAMING_SNAKE_CASE      =				SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""      ).to(
              A__      )

          _SCREAMING_SNAKE_CASE      =				prepare_img()
          _SCREAMING_SNAKE_CASE      =				image_processor(images=A__       ,							return_tensors="""pt"""      )
          _SCREAMING_SNAKE_CASE      =				encoded_inputs.pixel_values.to(A__      )

          with torch.no_grad():
             _SCREAMING_SNAKE_CASE      =				model(A__      )

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

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






       @slow
       def        UpperCamelCase				(							self      )    ->			Any:
          # only resize + normalize
          _SCREAMING_SNAKE_CASE      =				SegformerImageProcessor(
              image_scale=(5_12, 5_12)       ,							keep_ratio=A__       ,							align=A__       ,							do_random_crop=A__      )
          _SCREAMING_SNAKE_CASE      =				SegformerForSemanticSegmentation.from_pretrained(
              """nvidia/segformer-b1-finetuned-cityscapes-1024-1024"""      ).to(A__      )

          _SCREAMING_SNAKE_CASE      =				prepare_img()
          _SCREAMING_SNAKE_CASE      =				image_processor(images=A__       ,							return_tensors="""pt"""      )
          _SCREAMING_SNAKE_CASE      =				encoded_inputs.pixel_values.to(A__      )

          with torch.no_grad():
             _SCREAMING_SNAKE_CASE      =				model(A__      )

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

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






       @slow
       def        UpperCamelCase				(							self      )    ->			int:
          # only resize + normalize
          _SCREAMING_SNAKE_CASE      =				SegformerImageProcessor(
              image_scale=(5_12, 5_12)       ,							keep_ratio=A__       ,							align=A__       ,							do_random_crop=A__      )
          _SCREAMING_SNAKE_CASE      =				SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""      ).to(
              A__      )

          _SCREAMING_SNAKE_CASE      =				prepare_img()
          _SCREAMING_SNAKE_CASE      =				image_processor(images=A__       ,							return_tensors="""pt"""      )
          _SCREAMING_SNAKE_CASE      =				encoded_inputs.pixel_values.to(A__      )

          with torch.no_grad():
             _SCREAMING_SNAKE_CASE      =				model(A__      )

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

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

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








'''simple docstring'''



def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     str:




   """simple docstring"""
   return "".join([hex(SCREAMING_SNAKE_CASE_						)[2:].zfill(2						).upper() for byte in list(SCREAMING_SNAKE_CASE_						)]						)
def    lowerCAmelCase_	(				SCREAMING_SNAKE_CASE_						)     ->     bytes:




   """simple docstring"""
   # Check data validity, following RFC3548
   # https://www.ietf.org/rfc/rfc3548.txt
   if (len(SCREAMING_SNAKE_CASE_						) % 2) != 0:
      raise ValueError(
          """Base16 encoded data is invalid:
Data does not have an even number of hex digits."""						)
   # Check the character set - the standard base16 alphabet
   # is uppercase according to RFC3548 section 6
   if not set(SCREAMING_SNAKE_CASE_						) <= set("""0123456789ABCDEF"""						):
      raise ValueError(
          """Base16 encoded data is invalid:
Data is not uppercase hex or it contains invalid characters."""						)
   # For every two hexadecimal digits (= a byte), turn it into an integer.
   # Then, string the result together into bytes, and return it.
   return bytes(int(data[i] + data[i + 1]    ,      16						) for i in range(0    ,      len(SCREAMING_SNAKE_CASE_						)    ,      2						)						)


if __name__ == "__main__":
     import doctest

     doctest.testmod()






