
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	(      SCREAMING_SNAKE_CASE__	):




							def 				A__   (       self):
												lowercase					=		self.config_class(**self.inputs_dict)
												self.parent.assertTrue(hasattr(A__     ,'''hidden_sizes'''))
												self.parent.assertTrue(hasattr(A__     ,'''num_attention_heads'''))
												self.parent.assertTrue(hasattr(A__     ,'''num_encoder_blocks'''))







class        lowercase	:




							def __init__(       self     ,A__     ,A__=1_3     ,A__=6_4     ,A__=3     ,A__=4     ,A__=[2, 2, 2, 2]     ,A__=[8, 4, 2, 1]     ,A__=[1_6, 3_2, 6_4, 1_2_8]     ,A__=[1, 4, 8, 1_6]     ,A__=[1, 2, 4, 8]     ,A__=True     ,A__=True     ,A__="gelu"     ,A__=0.1     ,A__=0.1     ,A__=0.02     ,A__=3     ,A__=None     ,):
												lowercase					=		parent
												lowercase					=		batch_size
												lowercase					=		image_size
												lowercase					=		num_channels
												lowercase					=		num_encoder_blocks
												lowercase					=		sr_ratios
												lowercase					=		depths
												lowercase					=		hidden_sizes
												lowercase					=		downsampling_rates
												lowercase					=		num_attention_heads
												lowercase					=		is_training
												lowercase					=		use_labels
												lowercase					=		hidden_act
												lowercase					=		hidden_dropout_prob
												lowercase					=		attention_probs_dropout_prob
												lowercase					=		initializer_range
												lowercase					=		num_labels
												lowercase					=		scope




							def 				A__   (       self):
												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):
												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     ,A__     ,A__     ,A__):
												lowercase					=		SegformerModel(config=A__)
												model.to(A__)
												model.eval()
												lowercase					=		model(A__)
												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     ,A__     ,A__     ,A__):
												lowercase					=		self.num_labels
												lowercase					=		SegformerForSemanticSegmentation(A__)
												model.to(A__)
												model.eval()
												lowercase					=		model(A__)
												self.parent.assertEqual(
												    result.logits.shape     ,(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4))
												lowercase					=		model(A__     ,labels=A__)
												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     ,A__     ,A__     ,A__):
												lowercase					=		1
												lowercase					=		SegformerForSemanticSegmentation(config=A__)
												model.to(A__)
												model.eval()
												lowercase					=		torch.randint(0     ,1     ,(self.batch_size, self.image_size, self.image_size)).to(A__)
												lowercase					=		model(A__     ,labels=A__)
												self.parent.assertGreater(result.loss     ,0.0)





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







@require_torch
class        lowercase	(      SCREAMING_SNAKE_CASE__ ,						SCREAMING_SNAKE_CASE__ ,						unittest.TestCase	):
							lowercase_ : Optional[int]       =(
							    (
							        SegformerModel,
							        SegformerForSemanticSegmentation,
							        SegformerForImageClassification,
							    )
							    if is_torch_available()
							    else ()
							)
							lowercase_ : Optional[int]       =(
							    {
							        '''feature-extraction''': SegformerModel,
							        '''image-classification''': SegformerForImageClassification,
							        '''image-segmentation''': SegformerForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							lowercase_ : Optional[int]       =True
							lowercase_ : Any       =False
							lowercase_ : Any       =False
							lowercase_ : Union[str, Any]       =False




							def 				A__   (       self):
												lowercase					=		SegformerModelTester(self)
												lowercase					=		SegformerConfigTester(self     ,config_class=A__)




							def 				A__   (       self):
												self.config_tester.run_common_tests()




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_binary_image_segmentation(*A__)




							def 				A__   (       self):
												lowercase					=		self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_segmentation(*A__)




							@unittest.skip('''SegFormer does not use inputs_embeds''')
							def 				A__   (       self):
												pass




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




							def 				A__   (       self):
												lowercase			,		lowercase					=		self.model_tester.prepare_config_and_inputs_for_common()

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




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

																	lowercase					=		sum(self.model_tester.depths)
																	self.assertEqual(len(A__)     ,A__)

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

																	self.assertEqual(len(A__)     ,A__)

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

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

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

																	lowercase					=		outputs.attentions

																	self.assertEqual(len(A__)     ,A__)
																	# 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):
												def check_hidden_states_output(A__     ,A__     ,A__):
																	lowercase					=		model_class(A__)
																	model.to(A__)
																	model.eval()

																	with torch.no_grad():
																						lowercase					=		model(**self._prepare_for_class(A__     ,A__))

																	lowercase					=		outputs.hidden_states

																	lowercase					=		self.model_tester.num_encoder_blocks
																	self.assertEqual(len(A__)     ,A__)

																	# 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(A__     ,A__     ,A__)

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

																	check_hidden_states_output(A__     ,A__     ,A__)




							def 				A__   (       self):
												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(A__):
																						continue

																	lowercase					=		model_class(A__)
																	model.to(A__)
																	model.train()
																	lowercase					=		self._prepare_for_class(A__     ,A__     ,return_labels=A__)
																	lowercase					=		model(**A__).loss
																	loss.backward()




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





							@slow
							def 				A__   (       self):
												for model_name in SEGFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	lowercase					=		SegformerModel.from_pretrained(A__)
																	self.assertIsNotNone(A__)



def  UpperCamelCase					(							):
					'''simple docstring'''
					lowercase					=		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
					return image







@require_torch
class        lowercase	(      unittest.TestCase	):




							@slow
							def 				A__   (       self):
												# only resize + normalize
												lowercase					=		SegformerImageProcessor(
												    image_scale=(5_1_2, 5_1_2)     ,keep_ratio=A__     ,align=A__     ,do_random_crop=A__)
												lowercase					=		SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512''').to(
												    A__)

												lowercase					=		prepare_img()
												lowercase					=		image_processor(images=A__     ,return_tensors='''pt''')
												lowercase					=		encoded_inputs.pixel_values.to(A__)

												with torch.no_grad():
																	lowercase					=		model(A__)

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

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




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

												lowercase					=		prepare_img()
												lowercase					=		image_processor(images=A__     ,return_tensors='''pt''')
												lowercase					=		encoded_inputs.pixel_values.to(A__)

												with torch.no_grad():
																	lowercase					=		model(A__)

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

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





							@slow
							def 				A__   (       self):
												# only resize + normalize
												lowercase					=		SegformerImageProcessor(
												    image_scale=(5_1_2, 5_1_2)     ,keep_ratio=A__     ,align=A__     ,do_random_crop=A__)
												lowercase					=		SegformerForSemanticSegmentation.from_pretrained('''nvidia/segformer-b0-finetuned-ade-512-512''').to(
												    A__)

												lowercase					=		prepare_img()
												lowercase					=		image_processor(images=A__     ,return_tensors='''pt''')
												lowercase					=		encoded_inputs.pixel_values.to(A__)

												with torch.no_grad():
																	lowercase					=		model(A__)

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

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

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






def  UpperCamelCase					(							lowerCAmelCase__				,    lowerCAmelCase__	):
					'''simple docstring'''
					return int((input_a, input_a).count(0	) == 0	)



def  UpperCamelCase					(							):
					'''simple docstring'''
					assert and_gate(0				,    0	) == 0
					assert and_gate(0				,    1	) == 0
					assert and_gate(1				,    0	) == 0
					assert and_gate(1				,    1	) == 1


if __name__ == "__main__":
							test_and_gate()
							print(and_gate(1, 0))
							print(and_gate(0, 0))
							print(and_gate(0, 1))
							print(and_gate(1, 1))




