



"""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__		(      UpperCamelCase     ):



		def 					A_		( self  :    Union[str, Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					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      UpperCAmelCase__		:



		def __init__( self  :    Optional[int]      ,							snake_case  :    List[str]      ,							snake_case  :    str=13      ,							snake_case  :    Optional[int]=64      ,							snake_case  :    Union[str, Any]=3      ,							snake_case  :    Optional[int]=4      ,							snake_case  :    Optional[Any]=[2, 2, 2, 2]      ,							snake_case  :    Optional[Any]=[8, 4, 2, 1]      ,							snake_case  :    int=[16, 32, 64, 128]      ,							snake_case  :    Union[str, Any]=[1, 4, 8, 16]      ,							snake_case  :    int=[1, 2, 4, 8]      ,							snake_case  :    List[Any]=True      ,							snake_case  :    List[str]=True      ,							snake_case  :    Optional[Any]="gelu"      ,							snake_case  :    Union[str, Any]=0.1      ,							snake_case  :    Tuple=0.1      ,							snake_case  :    Tuple=0.02      ,							snake_case  :    Dict=3      ,							snake_case  :    Optional[Any]=None      ,							)			->						Dict:






									'''simple docstring'''

									A         =					parent
									A         =					batch_size
									A         =					image_size
									A         =					num_channels
									A         =					num_encoder_blocks
									A         =					sr_ratios
									A         =					depths
									A         =					hidden_sizes
									A         =					downsampling_rates
									A         =					num_attention_heads
									A         =					is_training
									A         =					use_labels
									A         =					hidden_act
									A         =					hidden_dropout_prob
									A         =					attention_probs_dropout_prob
									A         =					initializer_range
									A         =					num_labels
									A         =					scope



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






									'''simple docstring'''

									A         =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

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



		def 					A_		( self  :    Tuple				)			->						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  :    Any      ,							snake_case  :    Optional[int]      ,							snake_case  :    Union[str, Any]      ,							snake_case  :    Optional[Any]				)			->						str:






									'''simple docstring'''

									A         =					SegformerModel(config=snake_case				)
									model.to(snake_case				)
									model.eval()
									A         =					model(snake_case				)
									A         =					A         =					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  :    Any      ,							snake_case  :    Dict      ,							snake_case  :    Dict      ,							snake_case  :    List[str]				)			->						str:






									'''simple docstring'''

									A         =					self.num_labels
									A         =					SegformerForSemanticSegmentation(snake_case				)
									model.to(snake_case				)
									model.eval()
									A         =					model(snake_case				)
									self.parent.assertEqual(
									    result.logits.shape      ,							(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)				)
									A         =					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  :    Optional[Any]      ,							snake_case  :    Tuple      ,							snake_case  :    Optional[int]      ,							snake_case  :    Union[str, Any]				)			->						Optional[Any]:






									'''simple docstring'''

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



		def 					A_		( self  :    List[str]				)			->						Any:






									'''simple docstring'''

									A         =					self.prepare_config_and_inputs()
									A      ,  A      ,  A         =					config_and_inputs
									A         =					{'pixel_values': pixel_values}
									return config, inputs_dict






@require_torch
class      UpperCAmelCase__		(      UpperCamelCase   ,UpperCamelCase   ,unittest.TestCase     ):
		lowerCAmelCase_       :	Optional[int] 							=     (
		    (
		        SegformerModel,
		        SegformerForSemanticSegmentation,
		        SegformerForImageClassification,
		    )
		    if is_torch_available()
		    else ()
		)
		lowerCAmelCase_       :	Union[str, Any] 							=     (
		    {
		        """feature-extraction""": SegformerModel,
		        """image-classification""": SegformerForImageClassification,
		        """image-segmentation""": SegformerForSemanticSegmentation,
		    }
		    if is_torch_available()
		    else {}
		)

		lowerCAmelCase_       :	Union[str, Any] 							=     True
		lowerCAmelCase_       :	List[str] 							=     False
		lowerCAmelCase_       :	Optional[Any] 							=     False
		lowerCAmelCase_       :	Dict 							=     False



		def 					A_		( self  :    Optional[int]				)			->						List[str]:






									'''simple docstring'''

									A         =					SegformerModelTester(self				)
									A         =					SegformerConfigTester(self      ,							config_class=snake_case				)



		def 					A_		( self  :    Optional[Any]				)			->						str:






									'''simple docstring'''

									self.config_tester.run_common_tests()



		def 					A_		( self  :    Dict				)			->						Any:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case				)



		def 					A_		( self  :    int				)			->						List[str]:






									'''simple docstring'''

									A         =					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_binary_image_segmentation(*snake_case				)



		def 					A_		( self  :    Optional[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					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  :    str				)			->						List[Any]:






									'''simple docstring'''

									pass



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






									'''simple docstring'''

									pass



		def 					A_		( self  :    List[str]				)			->						List[str]:






									'''simple docstring'''

									A      ,  A         =					self.model_tester.prepare_config_and_inputs_for_common()

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

																A         =					['pixel_values']
																self.assertListEqual(arg_names[:1]      ,							snake_case				)



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






									'''simple docstring'''

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

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

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

																self.assertEqual(len(snake_case				)      ,							snake_case				)

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

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

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

																A         =					outputs.attentions

																self.assertEqual(len(snake_case				)      ,							snake_case				)
																# verify the first attentions (first block, first layer)
																A         =					(self.model_tester.image_size // 4) ** 2
																A         =					(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  :    int				)			->						Optional[Any]:






									'''simple docstring'''

									def check_hidden_states_output(snake_case  :    Union[str, Any]      ,							snake_case  :    Dict      ,							snake_case  :    List[str]				):
																A         =					model_class(snake_case				)
																model.to(snake_case				)
																model.eval()

																with torch.no_grad():
																							A         =					model(**self._prepare_for_class(snake_case      ,							snake_case				)				)

																A         =					outputs.hidden_states

																A         =					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      ,  A         =					self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																A         =					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         =					True

																check_hidden_states_output(snake_case      ,							snake_case      ,							snake_case				)



		def 					A_		( self  :    Optional[int]				)			->						List[Any]:






									'''simple docstring'''

									if not self.model_tester.is_training:
																return

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

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

																A         =					model_class(snake_case				)
																model.to(snake_case				)
																model.train()
																A         =					self._prepare_for_class(snake_case      ,							snake_case      ,							return_labels=snake_case				)
																A         =					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  :    Dict				)			->						List[Any]:






									'''simple docstring'''

									pass



		@slow
		def 					A_		( self  :    str				)			->						str:






									'''simple docstring'''

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



def   lowerCAmelCase__			(     ) ->							List[Any]:
							A         =					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
							return image






@require_torch
class      UpperCAmelCase__		(      unittest.TestCase     ):



		@slow
		def 					A_		( self  :    List[Any]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					SegformerImageProcessor(
									    image_scale=(512, 512)      ,							keep_ratio=snake_case      ,							align=snake_case      ,							do_random_crop=snake_case				)
									A         =					SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'				).to(
									    snake_case				)

									A         =					prepare_img()
									A         =					image_processor(images=snake_case      ,							return_tensors='pt'				)
									A         =					encoded_inputs.pixel_values.to(snake_case				)

									with torch.no_grad():
																A         =					model(snake_case				)

									A         =					torch.Size((1, model.config.num_labels, 128, 128)				)
									self.assertEqual(outputs.logits.shape      ,							snake_case				)

									A         =					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 					A_		( self  :    Optional[int]				)			->						Optional[int]:






									'''simple docstring'''

									A         =					SegformerImageProcessor(
									    image_scale=(512, 512)      ,							keep_ratio=snake_case      ,							align=snake_case      ,							do_random_crop=snake_case				)
									A         =					SegformerForSemanticSegmentation.from_pretrained(
									    'nvidia/segformer-b1-finetuned-cityscapes-1024-1024'				).to(snake_case				)

									A         =					prepare_img()
									A         =					image_processor(images=snake_case      ,							return_tensors='pt'				)
									A         =					encoded_inputs.pixel_values.to(snake_case				)

									with torch.no_grad():
																A         =					model(snake_case				)

									A         =					torch.Size((1, model.config.num_labels, 128, 128)				)
									self.assertEqual(outputs.logits.shape      ,							snake_case				)

									A         =					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 					A_		( self  :    List[Any]				)			->						Dict:






									'''simple docstring'''

									A         =					SegformerImageProcessor(
									    image_scale=(512, 512)      ,							keep_ratio=snake_case      ,							align=snake_case      ,							do_random_crop=snake_case				)
									A         =					SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'				).to(
									    snake_case				)

									A         =					prepare_img()
									A         =					image_processor(images=snake_case      ,							return_tensors='pt'				)
									A         =					encoded_inputs.pixel_values.to(snake_case				)

									with torch.no_grad():
																A         =					model(snake_case				)

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

									A         =					image_processor.post_process_semantic_segmentation(outputs=snake_case      ,							target_sizes=[(500, 300)]				)
									A         =					torch.Size((500, 300)				)
									self.assertEqual(segmentation[0].shape      ,							snake_case				)

									A         =					image_processor.post_process_semantic_segmentation(outputs=snake_case				)
									A         =					torch.Size((128, 128)				)
									self.assertEqual(segmentation[0].shape      ,							snake_case				)








"""simple docstring"""







def   lowerCAmelCase__			(     lowerCamelCase__			) ->							int:

							if not isinstance(lowerCamelCase__				,      lowerCamelCase__			):
														raise ValueError('multiplicative_persistence() only accepts integral values'			)
							if num < 0:
														raise ValueError('multiplicative_persistence() does not accept negative values'			)

							A         =					0
							A         =					str(lowerCamelCase__			)

							while len(lowerCamelCase__			) != 1:
														A         =					[int(lowerCamelCase__			) for i in num_string]

														A         =					1
														for i in range(0				,      len(lowerCamelCase__			)			):
																					total *= numbers[i]

														A         =					str(lowerCamelCase__			)

														steps += 1
							return steps

def   lowerCAmelCase__			(     lowerCamelCase__			) ->							int:

							if not isinstance(lowerCamelCase__				,      lowerCamelCase__			):
														raise ValueError('additive_persistence() only accepts integral values'			)
							if num < 0:
														raise ValueError('additive_persistence() does not accept negative values'			)

							A         =					0
							A         =					str(lowerCamelCase__			)

							while len(lowerCamelCase__			) != 1:
														A         =					[int(lowerCamelCase__			) for i in num_string]

														A         =					0
														for i in range(0				,      len(lowerCamelCase__			)			):
																					total += numbers[i]

														A         =					str(lowerCamelCase__			)

														steps += 1
							return steps


if __name__ == "__main__":
							import doctest

							doctest.testmod()



