


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_       (				lowerCAmelCase__				):



					'''simple docstring'''







					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   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 	lowerCamelCase_       :



					'''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.0_2 ,       snake_case_=3 ,       snake_case_=None ,       )   ->			Optional[int]:







								'''simple docstring'''

								__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 A      (				self						)   ->			Union[str, Any]:







								'''simple docstring'''

								__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 A      (				self						)   ->			int:







								'''simple docstring'''

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







								'''simple docstring'''

								__lowercase 					=   SegformerModel(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_						)
								__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 A      (				self ,       snake_case_ ,       snake_case_ ,       snake_case_						)   ->			str:







								'''simple docstring'''

								__lowercase 					=   self.num_labels
								__lowercase 					=   SegformerForSemanticSegmentation(snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   model(snake_case_						)
								self.parent.assertEqual(
								    result.logits.shape ,       (self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)						)
								__lowercase 					=   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_						)   ->			int:







								'''simple docstring'''

								__lowercase 					=   1
								__lowercase 					=   SegformerForSemanticSegmentation(config=snake_case_						)
								model.to(snake_case_						)
								model.eval()
								__lowercase 					=   torch.randint(0 ,       1 ,       (self.batch_size, self.image_size, self.image_size)						).to(snake_case_						)
								__lowercase 					=   model(snake_case_ ,       labels=snake_case_						)
								self.parent.assertGreater(result.loss ,       0.0						)






					def A      (				self						)   ->			Tuple:







								'''simple docstring'''

								__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_       (				lowerCAmelCase__     ,     lowerCAmelCase__     ,     unittest.TestCase				):



					'''simple docstring'''







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

					__UpperCAmelCase            =				True
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False
					__UpperCAmelCase            =				False






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase 					=   SegformerModelTester(self						)
								__lowercase 					=   SegformerConfigTester(self ,       config_class=snake_case_						)






					def A      (				self						)   ->			str:







								'''simple docstring'''

								self.config_tester.run_common_tests()






					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_						)






					def A      (				self						)   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_binary_image_segmentation(*snake_case_						)






					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   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						)   ->			Union[str, Any]:







								'''simple docstring'''

								pass






					@unittest.skip('''SegFormer does not have get_input_embeddings method and get_output_embeddings methods'''						)
					def A      (				self						)   ->			List[str]:







								'''simple docstring'''

								pass






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__lowercase					, __lowercase 					=   self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											__lowercase 					=   model_class(snake_case_						)
											__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] ,       snake_case_						)






					def A      (				self						)   ->			Any:







								'''simple docstring'''

								__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(snake_case_						)
											model.to(snake_case_						)
											model.eval()
											with torch.no_grad():
														__lowercase 					=   model(**self._prepare_for_class(snake_case_ ,       snake_case_						)						)
											__lowercase 					=   outputs.attentions

											__lowercase 					=   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"]
											__lowercase 					=   True
											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.eval()
											with torch.no_grad():
														__lowercase 					=   model(**self._prepare_for_class(snake_case_ ,       snake_case_						)						)
											__lowercase 					=   outputs.attentions

											self.assertEqual(len(snake_case_						) ,       snake_case_						)

											# 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(snake_case_						)

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

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

											__lowercase 					=   outputs.attentions

											self.assertEqual(len(snake_case_						) ,       snake_case_						)
											# 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 A      (				self						)   ->			Dict:







								'''simple docstring'''

								def check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						):
											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.eval()

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

											__lowercase 					=   outputs.hidden_states

											__lowercase 					=   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,
											    ] ,       )

								__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(snake_case_ ,       snake_case_ ,       snake_case_						)

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

											check_hidden_states_output(snake_case_ ,       snake_case_ ,       snake_case_						)






					def A      (				self						)   ->			str:







								'''simple docstring'''

								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(snake_case_						):
														continue

											__lowercase 					=   model_class(snake_case_						)
											model.to(snake_case_						)
											model.train()
											__lowercase 					=   self._prepare_for_class(snake_case_ ,       snake_case_ ,       return_labels=snake_case_						)
											__lowercase 					=   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						)   ->			str:







								'''simple docstring'''

								pass






					@slow
					def A      (				self						)   ->			Union[str, Any]:







								'''simple docstring'''

								for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase 					=   SegformerModel.from_pretrained(snake_case_						)
											self.assertIsNotNone(snake_case_						)




def 		lowercase_  (     ):


			'''simple docstring'''







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





@require_torch
class 	lowerCamelCase_       (				unittest.TestCase				):



					'''simple docstring'''







					@slow
					def A      (				self						)   ->			Dict:







								'''simple docstring'''

								__lowercase 					=   SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2) ,       keep_ratio=snake_case_ ,       align=snake_case_ ,       do_random_crop=snake_case_						)
								__lowercase 					=   SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''						).to(
								    snake_case_						)

								__lowercase 					=   prepare_img()
								__lowercase 					=   image_processor(images=snake_case_ ,       return_tensors='''pt'''						)
								__lowercase 					=   encoded_inputs.pixel_values.to(snake_case_						)

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

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

								__lowercase 					=   torch.tensor(
								    [
								        [[-4.6_3_1_0, -5.5_2_3_2, -6.2_3_5_6], [-5.1_9_2_1, -6.1_4_4_4, -6.5_9_9_6], [-5.4_4_2_4, -6.2_7_9_0, -6.7_5_7_4]],
								        [[-1_2.1_3_9_1, -1_3.3_1_2_2, -1_3.9_5_5_4], [-1_2.8_7_3_2, -1_3.9_3_5_2, -1_4.3_5_6_3], [-1_2.9_4_3_8, -1_3.8_2_2_6, -1_4.2_5_1_3]],
								        [[-1_2.5_1_3_4, -1_3.4_6_8_6, -1_4.4_9_1_5], [-1_2.8_6_6_9, -1_4.4_3_4_3, -1_4.7_7_5_8], [-1_3.2_5_2_3, -1_4.5_8_1_9, -1_5.0_6_9_4]],
								    ]						).to(snake_case_						)
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,       snake_case_ ,       atol=1e-4						)						)






					@slow
					def A      (				self						)   ->			Optional[Any]:







								'''simple docstring'''

								__lowercase 					=   SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2) ,       keep_ratio=snake_case_ ,       align=snake_case_ ,       do_random_crop=snake_case_						)
								__lowercase 					=   SegformerForSemanticSegmentation.from_pretrained(
								    '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''						).to(snake_case_						)

								__lowercase 					=   prepare_img()
								__lowercase 					=   image_processor(images=snake_case_ ,       return_tensors='''pt'''						)
								__lowercase 					=   encoded_inputs.pixel_values.to(snake_case_						)

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

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

								__lowercase 					=   torch.tensor(
								    [
								        [[-1_3.5_7_4_8, -1_3.9_1_1_1, -1_2.6_5_0_0], [-1_4.3_5_0_0, -1_5.3_6_8_3, -1_4.2_3_2_8], [-1_4.7_5_3_2, -1_6.0_4_2_4, -1_5.6_0_8_7]],
								        [[-1_7.1_6_5_1, -1_5.8_7_2_5, -1_2.9_6_5_3], [-1_7.2_5_8_0, -1_7.3_7_1_8, -1_4.8_2_2_3], [-1_6.6_0_5_8, -1_6.8_7_8_3, -1_6.7_4_5_2]],
								        [[-3.6_4_5_6, -3.0_2_0_9, -1.4_2_0_3], [-3.0_7_9_7, -3.1_9_5_9, -2.0_0_0_0], [-1.8_7_5_7, -1.9_2_1_7, -1.6_9_9_7]],
								    ]						).to(snake_case_						)
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3, :3] ,       snake_case_ ,       atol=1e-1						)						)






					@slow
					def A      (				self						)   ->			Union[str, Any]:







								'''simple docstring'''

								__lowercase 					=   SegformerImageProcessor(
								    image_scale=(5_1_2, 5_1_2) ,       keep_ratio=snake_case_ ,       align=snake_case_ ,       do_random_crop=snake_case_						)
								__lowercase 					=   SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''						).to(
								    snake_case_						)

								__lowercase 					=   prepare_img()
								__lowercase 					=   image_processor(images=snake_case_ ,       return_tensors='''pt'''						)
								__lowercase 					=   encoded_inputs.pixel_values.to(snake_case_						)

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

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

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

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






from ..utils import DummyObject, requires_backends
class 	lowerCamelCase_       (				metaclass=lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				["speech"]






					def __init__(				self ,       *snake_case_ ,       **snake_case_						)   ->			List[str]:







								'''simple docstring'''

								requires_backends(self ,       ['''speech''']						)




class 	lowerCamelCase_       (				metaclass=lowerCAmelCase__				):



					'''simple docstring'''







					__UpperCAmelCase            =				["speech"]






					def __init__(				self ,       *snake_case_ ,       **snake_case_						)   ->			Tuple:







								'''simple docstring'''

								requires_backends(self ,       ['''speech''']						)


