

"""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 					_lowerCAmelCase  (	lowercase   ):







 """simple docstring"""







 def 					_lowercase (			self							:			Dict	):
    __lowercase								=						self.config_class(**self.inputs_dict	)
    self.parent.assertTrue(hasattr(UpperCAmelCase__,					"hidden_sizes"	)	)
    self.parent.assertTrue(hasattr(UpperCAmelCase__,					"num_attention_heads"	)	)
    self.parent.assertTrue(hasattr(UpperCAmelCase__,					"num_encoder_blocks"	)	)







class 					_lowerCAmelCase  :







 """simple docstring"""







 def __init__(			self							:			Union[str, Any],					UpperCAmelCase__							:			str,					UpperCAmelCase__							:			Optional[int]=1_3,					UpperCAmelCase__							:			Tuple=6_4,					UpperCAmelCase__							:			Union[str, Any]=3,					UpperCAmelCase__							:			Tuple=4,					UpperCAmelCase__							:			List[Any]=[2, 2, 2, 2],					UpperCAmelCase__							:			Tuple=[8, 4, 2, 1],					UpperCAmelCase__							:			Dict=[1_6, 3_2, 6_4, 1_2_8],					UpperCAmelCase__							:			Optional[Any]=[1, 4, 8, 1_6],					UpperCAmelCase__							:			List[str]=[1, 2, 4, 8],					UpperCAmelCase__							:			List[Any]=True,					UpperCAmelCase__							:			List[Any]=True,					UpperCAmelCase__							:			Dict="gelu",					UpperCAmelCase__							:			int=0.1,					UpperCAmelCase__							:			Optional[int]=0.1,					UpperCAmelCase__							:			Dict=0.02,					UpperCAmelCase__							:			str=3,					UpperCAmelCase__							:			Union[str, Any]=None,					):
    __lowercase								=						parent
    __lowercase								=						batch_size
    __lowercase								=						image_size
    __lowercase								=						num_channels
    __lowercase								=						num_encoder_blocks
    __lowercase								=						sr_ratios
    __lowercase								=						depths
    __lowercase								=						hidden_sizes
    __lowercase								=						downsampling_rates
    __lowercase								=						num_attention_heads
    __lowercase								=						is_training
    __lowercase								=						use_labels
    __lowercase								=						hidden_act
    __lowercase								=						hidden_dropout_prob
    __lowercase								=						attention_probs_dropout_prob
    __lowercase								=						initializer_range
    __lowercase								=						num_labels
    __lowercase								=						scope


 def 					_lowercase (			self							:			List[Any]	):
    __lowercase								=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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


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



 def 					_lowercase (			self							:			Optional[Any]	):
    __lowercase								=						self.prepare_config_and_inputs()
    __lowercase		,__lowercase		,__lowercase								=						config_and_inputs
    __lowercase								=						{"pixel_values": pixel_values}
    return config, inputs_dict







@require_torch
class 					_lowerCAmelCase  (	lowercase     ,lowercase     ,unittest.TestCase   ):







 """simple docstring"""







 __UpperCAmelCase	:					Optional[int]   		=	(
     (
         SegformerModel,
         SegformerForSemanticSegmentation,
         SegformerForImageClassification,
     )
     if is_torch_available()
     else ()
 )
 __UpperCAmelCase	:					Tuple   		=	(
     {
         "feature-extraction": SegformerModel,
         "image-classification": SegformerForImageClassification,
         "image-segmentation": SegformerForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 __UpperCAmelCase	:					Tuple   		=	True
 __UpperCAmelCase	:					str   		=	False
 __UpperCAmelCase	:					Union[str, Any]   		=	False
 __UpperCAmelCase	:					Dict   		=	False


 def 					_lowercase (			self							:			Any	):
    __lowercase								=						SegformerModelTester(self	)
    __lowercase								=						SegformerConfigTester(self,					config_class=UpperCAmelCase__	)


 def 					_lowercase (			self							:			Dict	):
    self.config_tester.run_common_tests()


 def 					_lowercase (			self							:			Any	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			int	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_binary_image_segmentation(*UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[Any]	):
    __lowercase								=						self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_image_segmentation(*UpperCAmelCase__	)


 @unittest.skip("SegFormer does not use inputs_embeds"	)
 def 					_lowercase (			self							:			Optional[int]	):
    pass


 @unittest.skip("SegFormer does not have get_input_embeddings method and get_output_embeddings methods"	)
 def 					_lowercase (			self							:			int	):
    pass


 def 					_lowercase (			self							:			List[Any]	):
    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()

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

       __lowercase								=						["pixel_values"]
       self.assertListEqual(arg_names[:1],					UpperCAmelCase__	)


 def 					_lowercase (			self							:			Optional[int]	):
    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()
    __lowercase								=						True

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

       __lowercase								=						sum(self.model_tester.depths	)
       self.assertEqual(len(UpperCAmelCase__	),					UpperCAmelCase__	)

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

       self.assertEqual(len(UpperCAmelCase__	),					UpperCAmelCase__	)

       # verify the first attentions (first block, first layer)
       __lowercase								=						(self.model_tester.image_size // 4) ** 2
       __lowercase								=						(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)
       __lowercase								=						(self.model_tester.image_size // 3_2) ** 2
       __lowercase								=						(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],					)
       __lowercase								=						len(UpperCAmelCase__	)

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

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

       __lowercase								=						outputs.attentions

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

       with torch.no_grad():
          __lowercase								=						model(**self._prepare_for_class(UpperCAmelCase__,					UpperCAmelCase__	)	)

       __lowercase								=						outputs.hidden_states

       __lowercase								=						self.model_tester.num_encoder_blocks
       self.assertEqual(len(UpperCAmelCase__	),					UpperCAmelCase__	)

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

    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       __lowercase								=						True
       check_hidden_states_output(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)

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

       check_hidden_states_output(UpperCAmelCase__,					UpperCAmelCase__,					UpperCAmelCase__	)


 def 					_lowercase (			self							:			List[Any]	):
    if not self.model_tester.is_training:
       return

    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()
    __lowercase								=						True

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

       __lowercase								=						model_class(UpperCAmelCase__	)
       model.to(UpperCAmelCase__	)
       model.train()
       __lowercase								=						self._prepare_for_class(UpperCAmelCase__,					UpperCAmelCase__,					return_labels=UpperCAmelCase__	)
       __lowercase								=						model(**UpperCAmelCase__	).loss
       loss.backward()


 @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."	)
 def 					_lowercase (			self							:			Optional[int]	):
    pass



 @slow
 def 					_lowercase (			self							:			Tuple	):
    for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       __lowercase								=						SegformerModel.from_pretrained(UpperCAmelCase__	)
       self.assertIsNotNone(UpperCAmelCase__	)







def   _A  (  )	->						Tuple:
   '''simple docstring'''


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




@require_torch
class 					_lowerCAmelCase  (	unittest.TestCase   ):







 """simple docstring"""







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

    __lowercase								=						prepare_img()
    __lowercase								=						image_processor(images=UpperCAmelCase__,					return_tensors="pt"	)
    __lowercase								=						encoded_inputs.pixel_values.to(UpperCAmelCase__	)

    with torch.no_grad():
       __lowercase								=						model(UpperCAmelCase__	)

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

    __lowercase								=						torch.tensor(
        [
            [[-4.6_310, -5.5_232, -6.2_356], [-5.1_921, -6.1_444, -6.5_996], [-5.4_424, -6.2_790, -6.7_574]],
            [[-12.1_391, -13.3_122, -13.9_554], [-12.8_732, -13.9_352, -14.3_563], [-12.9_438, -13.8_226, -14.2_513]],
            [[-12.5_134, -13.4_686, -14.4_915], [-12.8_669, -14.4_343, -14.7_758], [-13.2_523, -14.5_819, -15.0_694]],
        ]	).to(UpperCAmelCase__	)
    self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3],					UpperCAmelCase__,					atol=1E-4	)	)


 @slow
 def 					_lowercase (			self							:			Tuple	):
    # only resize + normalize
    __lowercase								=						SegformerImageProcessor(
        image_scale=(5_1_2, 5_1_2),					keep_ratio=UpperCAmelCase__,					align=UpperCAmelCase__,					do_random_crop=UpperCAmelCase__	)
    __lowercase								=						SegformerForSemanticSegmentation.from_pretrained(
        "nvidia/segformer-b1-finetuned-cityscapes-1024-1024"	).to(UpperCAmelCase__	)

    __lowercase								=						prepare_img()
    __lowercase								=						image_processor(images=UpperCAmelCase__,					return_tensors="pt"	)
    __lowercase								=						encoded_inputs.pixel_values.to(UpperCAmelCase__	)

    with torch.no_grad():
       __lowercase								=						model(UpperCAmelCase__	)

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

    __lowercase								=						torch.tensor(
        [
            [[-13.5_748, -13.9_111, -12.6_500], [-14.3_500, -15.3_683, -14.2_328], [-14.7_532, -16.0_424, -15.6_087]],
            [[-17.1_651, -15.8_725, -12.9_653], [-17.2_580, -17.3_718, -14.8_223], [-16.6_058, -16.8_783, -16.7_452]],
            [[-3.6_456, -3.0_209, -1.4_203], [-3.0_797, -3.1_959, -2.0_000], [-1.8_757, -1.9_217, -1.6_997]],
        ]	).to(UpperCAmelCase__	)
    self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3],					UpperCAmelCase__,					atol=1E-1	)	)



 @slow
 def 					_lowercase (			self							:			Union[str, Any]	):
    # only resize + normalize
    __lowercase								=						SegformerImageProcessor(
        image_scale=(5_1_2, 5_1_2),					keep_ratio=UpperCAmelCase__,					align=UpperCAmelCase__,					do_random_crop=UpperCAmelCase__	)
    __lowercase								=						SegformerForSemanticSegmentation.from_pretrained("nvidia/segformer-b0-finetuned-ade-512-512"	).to(
        UpperCAmelCase__	)

    __lowercase								=						prepare_img()
    __lowercase								=						image_processor(images=UpperCAmelCase__,					return_tensors="pt"	)
    __lowercase								=						encoded_inputs.pixel_values.to(UpperCAmelCase__	)

    with torch.no_grad():
       __lowercase								=						model(UpperCAmelCase__	)

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

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

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







"""simple docstring"""





def   _A  (  UpperCamelCase_     :       list[int])	->						float:
   '''simple docstring'''


   if not nums:  # Makes sure that the list is not empty
      raise ValueError("List is empty")

   __lowercase								=						sum(UpperCamelCase_) / len(UpperCamelCase_)  # Calculate the average
   return sum(abs(x - average) for x in nums) / len(UpperCamelCase_)


if __name__ == "__main__":
   import doctest

   doctest.testmod()




