


'''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 		a__    (							a__  ):





							'''simple docstring'''






							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__	       =     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 		a__    :





							'''simple docstring'''






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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

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







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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														lowerCAmelCase__	       =     self.prepare_config_and_inputs()
														lowerCAmelCase__       , lowerCAmelCase__       , lowerCAmelCase__	       =     config_and_inputs
														lowerCAmelCase__	       =     {'''pixel_values''': pixel_values}
														return config, inputs_dict




@require_torch
class 		a__    (							a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






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

							lowercase__      :       str     						=				True
							lowercase__      :       str     						=				False
							lowercase__      :       str     						=				False
							lowercase__      :       Any     						=				False







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														lowerCAmelCase__	       =     SegformerModelTester(self       )
														lowerCAmelCase__	       =     SegformerConfigTester(self ,   config_class=lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														self.config_tester.run_common_tests()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_binary_image_segmentation(*lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														lowerCAmelCase__	       =     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   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														pass







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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs_for_common()

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

																					lowerCAmelCase__	       =     ['''pixel_values''']
																					self.assertListEqual(arg_names[:1] ,   lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs_for_common()
														lowerCAmelCase__	       =     True

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

																					lowerCAmelCase__	       =     sum(self.model_tester.depths       )
																					self.assertEqual(len(lowerCamelCase_       ) ,   lowerCamelCase_       )

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

																					self.assertEqual(len(lowerCamelCase_       ) ,   lowerCamelCase_       )

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

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

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

																					lowerCAmelCase__	       =     outputs.attentions

																					self.assertEqual(len(lowerCamelCase_       ) ,   lowerCamelCase_       )
																					# verify the first attentions (first block, first layer)
																					lowerCAmelCase__	       =     (self.model_tester.image_size // 4) ** 2
																					lowerCAmelCase__	       =     (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   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														def check_hidden_states_output(lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       ):
																					lowerCAmelCase__	       =     model_class(lowerCamelCase_       )
																					model.to(lowerCamelCase_       )
																					model.eval()

																					with torch.no_grad():
																												lowerCAmelCase__	       =     model(**self._prepare_for_class(lowerCamelCase_ ,   lowerCamelCase_       )       )

																					lowerCAmelCase__	       =     outputs.hidden_states

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

														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					lowerCAmelCase__	       =     True
																					check_hidden_states_output(lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )

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

																					check_hidden_states_output(lowerCamelCase_ ,   lowerCamelCase_ ,   lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														if not self.model_tester.is_training:
																					return

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

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

																					lowerCAmelCase__	       =     model_class(lowerCamelCase_       )
																					model.to(lowerCamelCase_       )
																					model.train()
																					lowerCAmelCase__	       =     self._prepare_for_class(lowerCamelCase_ ,   lowerCamelCase_ ,   return_labels=lowerCamelCase_       )
																					lowerCAmelCase__	       =     model(**lowerCamelCase_       ).loss
																					loss.backward()







							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''       )
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														pass







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__	       =     SegformerModel.from_pretrained(lowerCamelCase_       )
																					self.assertIsNotNone(lowerCamelCase_       )


def  _snake_case       (					)						->   str:
							lowerCAmelCase__	       =     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
							return image






@require_torch
class 		a__    (							unittest.TestCase  ):





							'''simple docstring'''






							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														# only resize + normalize
														lowerCAmelCase__	       =     SegformerImageProcessor(
														    image_scale=(5_12, 5_12) ,   keep_ratio=lowerCamelCase_ ,   align=lowerCamelCase_ ,   do_random_crop=lowerCamelCase_       )
														lowerCAmelCase__	       =     SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''       ).to(
														    lowerCamelCase_       )

														lowerCAmelCase__	       =     prepare_img()
														lowerCAmelCase__	       =     image_processor(images=lowerCamelCase_ ,   return_tensors='''pt'''       )
														lowerCAmelCase__	       =     encoded_inputs.pixel_values.to(lowerCamelCase_       )

														with torch.no_grad():
																					lowerCAmelCase__	       =     model(lowerCamelCase_       )

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

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







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							str:
														# only resize + normalize
														lowerCAmelCase__	       =     SegformerImageProcessor(
														    image_scale=(5_12, 5_12) ,   keep_ratio=lowerCamelCase_ ,   align=lowerCamelCase_ ,   do_random_crop=lowerCamelCase_       )
														lowerCAmelCase__	       =     SegformerForSemanticSegmentation.from_pretrained(
														    '''nvidia/segformer-b1-finetuned-cityscapes-1024-1024'''       ).to(lowerCamelCase_       )

														lowerCAmelCase__	       =     prepare_img()
														lowerCAmelCase__	       =     image_processor(images=lowerCamelCase_ ,   return_tensors='''pt'''       )
														lowerCAmelCase__	       =     encoded_inputs.pixel_values.to(lowerCamelCase_       )

														with torch.no_grad():
																					lowerCAmelCase__	       =     model(lowerCamelCase_       )

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

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







							@slow
							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														# only resize + normalize
														lowerCAmelCase__	       =     SegformerImageProcessor(
														    image_scale=(5_12, 5_12) ,   keep_ratio=lowerCamelCase_ ,   align=lowerCamelCase_ ,   do_random_crop=lowerCamelCase_       )
														lowerCAmelCase__	       =     SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512'''       ).to(
														    lowerCamelCase_       )

														lowerCAmelCase__	       =     prepare_img()
														lowerCAmelCase__	       =     image_processor(images=lowerCamelCase_ ,   return_tensors='''pt'''       )
														lowerCAmelCase__	       =     encoded_inputs.pixel_values.to(lowerCamelCase_       )

														with torch.no_grad():
																					lowerCAmelCase__	       =     model(lowerCamelCase_       )

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

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

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



'''simple docstring'''






def  _snake_case       (					A = 10			,   A = 22	)						->   int:
							lowerCAmelCase__	       =     range(1			,   A	)
							lowerCAmelCase__	       =     range(1			,   A	)
							return sum(
							    1 for power in powers for base in bases if len(str(base**power	)	) == power	)


if __name__ == "__main__":
		print(f"""{solution(10, 22) = }""")