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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__        =   self.config_class(**self.inputs_dict     )
							self.parent.assertTrue(hasattr(lowercase_  ,						"""hidden_sizes"""     )     )
							self.parent.assertTrue(hasattr(lowercase_  ,						"""num_attention_heads"""     )     )
							self.parent.assertTrue(hasattr(lowercase_  ,						"""num_encoder_blocks"""     )     )

class       a_      :




					def __init__(	self						:     Optional[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple=13  ,						snake_case__						:     List[Any]=64  ,						snake_case__						:     List[Any]=3  ,						snake_case__						:     Optional[Any]=4  ,						snake_case__						:     Dict=[2, 2, 2, 2]  ,						snake_case__						:     Optional[Any]=[8, 4, 2, 1]  ,						snake_case__						:     str=[16, 32, 64, 128]  ,						snake_case__						:     Optional[Any]=[1, 4, 8, 16]  ,						snake_case__						:     Tuple=[1, 2, 4, 8]  ,						snake_case__						:     List[str]=True  ,						snake_case__						:     int=True  ,						snake_case__						:     Optional[int]="gelu"  ,						snake_case__						:     Dict=0.1  ,						snake_case__						:     List[Any]=0.1  ,						snake_case__						:     str=0.02  ,						snake_case__						:     Optional[int]=3  ,						snake_case__						:     List[str]=None  ,						):
							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						:     Any     ):
							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						:     Dict     ):
							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						:     Any  ,						snake_case__						:     Dict  ,						snake_case__						:     List[str]  ,						snake_case__						:     str     ):
							lowerCAmelCase__        =   SegformerModel(config=lowercase_     )
							model.to(lowercase_     )
							model.eval()
							lowerCAmelCase__        =   model(lowercase_     )
							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						:     List[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     Tuple  ,						snake_case__						:     Dict     ):
							lowerCAmelCase__        =   self.num_labels
							lowerCAmelCase__        =   SegformerForSemanticSegmentation(lowercase_     )
							model.to(lowercase_     )
							model.eval()
							lowerCAmelCase__        =   model(lowercase_     )
							self.parent.assertEqual(
							    result.logits.shape  ,						(self.batch_size, self.num_labels, self.image_size // 4, self.image_size // 4)     )
							lowerCAmelCase__        =   model(lowercase_  ,						labels=lowercase_     )
							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						:     Optional[int]  ,						snake_case__						:     str  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     int     ):
							lowerCAmelCase__        =   1
							lowerCAmelCase__        =   SegformerForSemanticSegmentation(config=lowercase_     )
							model.to(lowercase_     )
							model.eval()
							lowerCAmelCase__        =   torch.randint(0  ,						1  ,						(self.batch_size, self.image_size, self.image_size)     ).to(lowercase_     )
							lowerCAmelCase__        =   model(lowercase_  ,						labels=lowercase_     )
							self.parent.assertGreater(result.loss  ,						0.0     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							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_      (     __UpperCamelCase ,		__UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	List[str]			=    (
					    (
					        SegformerModel,
					        SegformerForSemanticSegmentation,
					        SegformerForImageClassification,
					    )
					    if is_torch_available()
					    else ()
					)
					UpperCamelCase_ :	Tuple			=    (
					    {
					        "feature-extraction": SegformerModel,
					        "image-classification": SegformerForImageClassification,
					        "image-segmentation": SegformerForSemanticSegmentation,
					    }
					    if is_torch_available()
					    else {}
					)

					UpperCamelCase_ :	int			=    True
					UpperCamelCase_ :	int			=    False
					UpperCamelCase_ :	Tuple			=    False
					UpperCamelCase_ :	Optional[Any]			=    False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   SegformerModelTester(self     )
							lowerCAmelCase__        =   SegformerConfigTester(self  ,						config_class=lowercase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							self.config_tester.run_common_tests()




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowercase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_binary_image_segmentation(*lowercase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_segmentation(*lowercase_     )




					@unittest.skip("""SegFormer does not use inputs_embeds"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							pass




					@unittest.skip("""SegFormer does not have get_input_embeddings method and get_output_embeddings methods"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							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(lowercase_     )
									model.to(lowercase_     )
									model.eval()
									with torch.no_grad():
											lowerCAmelCase__        =   model(**self._prepare_for_class(lowercase_  ,						lowercase_     )     )
									lowerCAmelCase__        =   outputs.attentions

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

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

									self.assertEqual(len(lowercase_     )  ,						lowercase_     )

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

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

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

									lowerCAmelCase__        =   outputs.attentions

									self.assertEqual(len(lowercase_     )  ,						lowercase_     )
									# 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						:     List[Any]     ):







							def check_hidden_states_output(snake_case__						:     Union[str, Any]  ,						snake_case__						:     Dict  ,						snake_case__						:     Optional[int]     ):
									lowerCAmelCase__        =   model_class(lowercase_     )
									model.to(lowercase_     )
									model.eval()

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

									lowerCAmelCase__        =   outputs.hidden_states

									lowerCAmelCase__        =   self.model_tester.num_encoder_blocks
									self.assertEqual(len(lowercase_     )  ,						lowercase_     )

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

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

									check_hidden_states_output(lowercase_  ,						lowercase_  ,						lowercase_     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):







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

									lowerCAmelCase__        =   model_class(lowercase_     )
									model.to(lowercase_     )
									model.train()
									lowerCAmelCase__        =   self._prepare_for_class(lowercase_  ,						lowercase_  ,						return_labels=lowercase_     )
									lowerCAmelCase__        =   model(**lowercase_     ).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						:     Any     ):
							pass




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):







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







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		lowerCAmelCase__        =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
		return image






@require_torch
class       a_      (     unittest.TestCase			):




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   SegformerImageProcessor(
							    image_scale=(512, 512)  ,						keep_ratio=lowercase_  ,						align=lowercase_  ,						do_random_crop=lowercase_     )
							lowerCAmelCase__        =   SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
							    lowercase_     )

							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(images=lowercase_  ,						return_tensors="""pt"""     )
							lowerCAmelCase__        =   encoded_inputs.pixel_values.to(lowercase_     )

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

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

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




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							lowerCAmelCase__        =   SegformerImageProcessor(
							    image_scale=(512, 512)  ,						keep_ratio=lowercase_  ,						align=lowercase_  ,						do_random_crop=lowercase_     )
							lowerCAmelCase__        =   SegformerForSemanticSegmentation.from_pretrained(
							    """nvidia/segformer-b1-finetuned-cityscapes-1024-1024"""     ).to(lowercase_     )

							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(images=lowercase_  ,						return_tensors="""pt"""     )
							lowerCAmelCase__        =   encoded_inputs.pixel_values.to(lowercase_     )

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

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

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




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							lowerCAmelCase__        =   SegformerImageProcessor(
							    image_scale=(512, 512)  ,						keep_ratio=lowercase_  ,						align=lowercase_  ,						do_random_crop=lowercase_     )
							lowerCAmelCase__        =   SegformerForSemanticSegmentation.from_pretrained("""nvidia/segformer-b0-finetuned-ade-512-512"""     ).to(
							    lowercase_     )

							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(images=lowercase_  ,						return_tensors="""pt"""     )
							lowerCAmelCase__        =   encoded_inputs.pixel_values.to(lowercase_     )

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

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

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

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





"""simple docstring"""




import io
import json
import unittest

from parameterized import parameterized

from transformers import FSMTForConditionalGeneration, FSMTTokenizer
from transformers.testing_utils import get_tests_dir, require_torch, slow, torch_device
from utils import calculate_bleu


__lowerCAmelCase    :							Union[str, Any]													=						get_tests_dir() + "/test_data/fsmt/fsmt_val_data.json"
with io.open(filename, "r", encoding="utf-8") as f:
			__lowerCAmelCase    :							Optional[int]													=						json.load(f)

@require_torch
class       a_      (     unittest.TestCase			):




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]  ,						snake_case__						:     Dict     ):
							return FSMTTokenizer.from_pretrained(snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]  ,						snake_case__						:     Any     ):
							lowerCAmelCase__        =   FSMTForConditionalGeneration.from_pretrained(snake_case__     ).to(snake_case__     )
							if torch_device == "cuda":
									model.half()
							return model




					@parameterized.expand(
					    [
					        ["""en-ru""", 26.0],
					        ["""ru-en""", 22.0],
					        ["""en-de""", 22.0],
					        ["""de-en""", 29.0],
					    ]     )
					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict  ,						snake_case__						:     Any  ,						snake_case__						:     int     ):
							# note: this test is not testing the best performance since it only evals a small batch
							# but it should be enough to detect a regression in the output quality
							lowerCAmelCase__        =   F"""facebook/wmt19-{pair}"""
							lowerCAmelCase__        =   self.get_tokenizer(snake_case__     )
							lowerCAmelCase__        =   self.get_model(snake_case__     )

							lowerCAmelCase__        =   bleu_data[pair]["""src"""]
							lowerCAmelCase__        =   bleu_data[pair]["""tgt"""]

							lowerCAmelCase__        =   tokenizer(snake_case__  ,						return_tensors="""pt"""  ,						truncation=snake_case__  ,						padding="""longest"""     ).to(snake_case__     )
							lowerCAmelCase__        =   model.generate(
							    input_ids=batch.input_ids  ,						num_beams=8  ,						)
							lowerCAmelCase__        =   tokenizer.batch_decode(
							    snake_case__  ,						skip_special_tokens=snake_case__  ,						clean_up_tokenization_spaces=snake_case__     )
							lowerCAmelCase__        =   calculate_bleu(snake_case__  ,						snake_case__     )
							print(snake_case__     )
							self.assertGreaterEqual(scores["""bleu"""]  ,						snake_case__     )




