



"""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 			lowercase__			(      A    ):
							'''simple docstring'''







							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		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 			lowercase__			:
							'''simple docstring'''







							def __init__(  self	,       snake_case	,       snake_case=13	,       snake_case=64	,       snake_case=3	,       snake_case=4	,       snake_case=[2, 2, 2, 2]	,       snake_case=[8, 4, 2, 1]	,       snake_case=[16, 32, 64, 128]	,       snake_case=[1, 4, 8, 16]	,       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.02	,       snake_case=3	,       snake_case=None	,       )			->							List[str]:
									_UpperCAmelCase							 =		parent
									_UpperCAmelCase							 =		batch_size
									_UpperCAmelCase							 =		image_size
									_UpperCAmelCase							 =		num_channels
									_UpperCAmelCase							 =		num_encoder_blocks
									_UpperCAmelCase							 =		sr_ratios
									_UpperCAmelCase							 =		depths
									_UpperCAmelCase							 =		hidden_sizes
									_UpperCAmelCase							 =		downsampling_rates
									_UpperCAmelCase							 =		num_attention_heads
									_UpperCAmelCase							 =		is_training
									_UpperCAmelCase							 =		use_labels
									_UpperCAmelCase							 =		hidden_act
									_UpperCAmelCase							 =		hidden_dropout_prob
									_UpperCAmelCase							 =		attention_probs_dropout_prob
									_UpperCAmelCase							 =		initializer_range
									_UpperCAmelCase							 =		num_labels
									_UpperCAmelCase							 =		scope






							def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

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






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






							def        lowerCamelCase_   (  self						)			->							Any:
									_UpperCAmelCase							 =		self.prepare_config_and_inputs()
									_UpperCAmelCase ,					_UpperCAmelCase ,					_UpperCAmelCase							 =		config_and_inputs
									_UpperCAmelCase							 =		{'pixel_values': pixel_values}
									return config, inputs_dict







@require_torch
class 			lowercase__			(      A,					A,					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        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									_UpperCAmelCase							 =		SegformerModelTester(self						)
									_UpperCAmelCase							 =		SegformerConfigTester(self	,       config_class=snake_case						)






							def        lowerCamelCase_   (  self						)			->							Optional[Any]:
									self.config_tester.run_common_tests()






							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case						)






							def        lowerCamelCase_   (  self						)			->							Any:
									_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_binary_image_segmentation(*snake_case						)






							def        lowerCamelCase_   (  self						)			->							List[str]:
									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									pass






							@unittest.skip('SegFormer does not have get_input_embeddings method and get_output_embeddings methods'						)
							def        lowerCamelCase_   (  self						)			->							str:
									pass






							def        lowerCamelCase_   (  self						)			->							int:
									_UpperCAmelCase ,					_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs_for_common()

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

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






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

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

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

											self.assertEqual(len(snake_case						)	,       snake_case						)

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

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

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

											_UpperCAmelCase							 =		outputs.attentions

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

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

											_UpperCAmelCase							 =		outputs.hidden_states

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

									_UpperCAmelCase ,					_UpperCAmelCase							 =		self.model_tester.prepare_config_and_inputs_for_common()

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

											check_hidden_states_output(snake_case	,       snake_case	,       snake_case						)






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

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

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

											_UpperCAmelCase							 =		model_class(snake_case						)
											model.to(snake_case						)
											model.train()
											_UpperCAmelCase							 =		self._prepare_for_class(snake_case	,       snake_case	,       return_labels=snake_case						)
											_UpperCAmelCase							 =		model(**snake_case						).loss
											loss.backward()






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






							@slow
							def        lowerCamelCase_   (  self						)			->							Union[str, Any]:
									for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											_UpperCAmelCase							 =		SegformerModel.from_pretrained(snake_case						)
											self.assertIsNotNone(snake_case						)







def 	UpperCAmelCase     (		):

		'''simple docstring'''


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






@require_torch
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







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

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

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

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

									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							int:
									# only resize + normalize
									_UpperCAmelCase							 =		SegformerImageProcessor(
									    image_scale=(512, 512)	,       keep_ratio=snake_case	,       align=snake_case	,       do_random_crop=snake_case						)
									_UpperCAmelCase							 =		SegformerForSemanticSegmentation.from_pretrained(
									    'nvidia/segformer-b1-finetuned-cityscapes-1024-1024'						).to(snake_case						)

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

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

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

									_UpperCAmelCase							 =		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        lowerCamelCase_   (  self						)			->							Any:
									# only resize + normalize
									_UpperCAmelCase							 =		SegformerImageProcessor(
									    image_scale=(512, 512)	,       keep_ratio=snake_case	,       align=snake_case	,       do_random_crop=snake_case						)
									_UpperCAmelCase							 =		SegformerForSemanticSegmentation.from_pretrained('nvidia/segformer-b0-finetuned-ade-512-512'						).to(
									    snake_case						)

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

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

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

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

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







"""simple docstring"""





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase  							=					{
    '''configuration_roberta''': ['''ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''RobertaConfig''', '''RobertaOnnxConfig'''],
    '''tokenization_roberta''': ['''RobertaTokenizer'''],
}

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					['''RobertaTokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					[
					    '''ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''RobertaForCausalLM''',
					    '''RobertaForMaskedLM''',
					    '''RobertaForMultipleChoice''',
					    '''RobertaForQuestionAnswering''',
					    '''RobertaForSequenceClassification''',
					    '''RobertaForTokenClassification''',
					    '''RobertaModel''',
					    '''RobertaPreTrainedModel''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					[
					    '''TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFRobertaForCausalLM''',
					    '''TFRobertaForMaskedLM''',
					    '''TFRobertaForMultipleChoice''',
					    '''TFRobertaForQuestionAnswering''',
					    '''TFRobertaForSequenceClassification''',
					    '''TFRobertaForTokenClassification''',
					    '''TFRobertaMainLayer''',
					    '''TFRobertaModel''',
					    '''TFRobertaPreTrainedModel''',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase  							=					[
					    '''FlaxRobertaForCausalLM''',
					    '''FlaxRobertaForMaskedLM''',
					    '''FlaxRobertaForMultipleChoice''',
					    '''FlaxRobertaForQuestionAnswering''',
					    '''FlaxRobertaForSequenceClassification''',
					    '''FlaxRobertaForTokenClassification''',
					    '''FlaxRobertaModel''',
					    '''FlaxRobertaPreTrainedModel''',
					]


if TYPE_CHECKING:
					from .configuration_roberta import ROBERTA_PRETRAINED_CONFIG_ARCHIVE_MAP, RobertaConfig, RobertaOnnxConfig
					from .tokenization_roberta import RobertaTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_roberta_fast import RobertaTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_roberta import (
										    ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
										    RobertaForCausalLM,
										    RobertaForMaskedLM,
										    RobertaForMultipleChoice,
										    RobertaForQuestionAnswering,
										    RobertaForSequenceClassification,
										    RobertaForTokenClassification,
										    RobertaModel,
										    RobertaPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_roberta import (
										    TF_ROBERTA_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFRobertaForCausalLM,
										    TFRobertaForMaskedLM,
										    TFRobertaForMultipleChoice,
										    TFRobertaForQuestionAnswering,
										    TFRobertaForSequenceClassification,
										    TFRobertaForTokenClassification,
										    TFRobertaMainLayer,
										    TFRobertaModel,
										    TFRobertaPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_roberta import (
										    FlaxRobertaForCausalLM,
										    FlaxRobertaForMaskedLM,
										    FlaxRobertaForMultipleChoice,
										    FlaxRobertaForQuestionAnswering,
										    FlaxRobertaForSequenceClassification,
										    FlaxRobertaForTokenClassification,
										    FlaxRobertaModel,
										    FlaxRobertaPreTrainedModel,
										)

else:
					import sys

					lowercase  							=					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


