


'''simple docstring'''

import unittest

from transformers import MPNetConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MPNetForMaskedLM,
	    MPNetForMultipleChoice,
	    MPNetForQuestionAnswering,
	    MPNetForSequenceClassification,
	    MPNetForTokenClassification,
	    MPNetModel,
	)


class       a__				:







				"""simple docstring"""



				def __init__(self       ,			__lowercase       ,			__lowercase=13       ,			__lowercase=7       ,			__lowercase=True       ,			__lowercase=True       ,			__lowercase=False       ,			__lowercase=True       ,			__lowercase=99       ,			__lowercase=64       ,			__lowercase=5       ,			__lowercase=4       ,			__lowercase=64       ,			__lowercase="gelu"       ,			__lowercase=0.1       ,			__lowercase=0.1       ,			__lowercase=5_12       ,			__lowercase=16       ,			__lowercase=2       ,			__lowercase=0.0_2       ,			__lowercase=3       ,			__lowercase=4       ,			__lowercase=None       ,			):
										__lowerCAmelCase							       =				parent
										__lowerCAmelCase							       =				batch_size
										__lowerCAmelCase							       =				seq_length
										__lowerCAmelCase							       =				is_training
										__lowerCAmelCase							       =				use_input_mask
										__lowerCAmelCase							       =				use_token_type_ids
										__lowerCAmelCase							       =				use_labels
										__lowerCAmelCase							       =				vocab_size
										__lowerCAmelCase							       =				hidden_size
										__lowerCAmelCase							       =				num_hidden_layers
										__lowerCAmelCase							       =				num_attention_heads
										__lowerCAmelCase							       =				intermediate_size
										__lowerCAmelCase							       =				hidden_act
										__lowerCAmelCase							       =				hidden_dropout_prob
										__lowerCAmelCase							       =				attention_probs_dropout_prob
										__lowerCAmelCase							       =				max_position_embeddings
										__lowerCAmelCase							       =				type_vocab_size
										__lowerCAmelCase							       =				type_sequence_label_size
										__lowerCAmelCase							       =				initializer_range
										__lowerCAmelCase							       =				num_labels
										__lowerCAmelCase							       =				num_choices
										__lowerCAmelCase							       =				scope




				def 					_snake_case  (self		):
										return MPNetConfig.from_pretrained('''microsoft/mpnet-base'''		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				ids_tensor([self.batch_size, self.seq_length]       ,			self.vocab_size		)

										__lowerCAmelCase							       =				None
										if self.use_input_mask:
																__lowerCAmelCase							       =				random_attention_mask([self.batch_size, self.seq_length]		)

										__lowerCAmelCase							       =				None
										__lowerCAmelCase							       =				None
										__lowerCAmelCase							       =				None
										if self.use_labels:
																__lowerCAmelCase							       =				ids_tensor([self.batch_size]       ,			self.type_sequence_label_size		)
																__lowerCAmelCase							       =				ids_tensor([self.batch_size, self.seq_length]       ,			self.num_labels		)
																__lowerCAmelCase							       =				ids_tensor([self.batch_size]       ,			self.num_choices		)

										__lowerCAmelCase							       =				self.get_config()
										return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels




				def 					_snake_case  (self		):
										return MPNetConfig(
										    vocab_size=self.vocab_size       ,			hidden_size=self.hidden_size       ,			num_hidden_layers=self.num_hidden_layers       ,			num_attention_heads=self.num_attention_heads       ,			intermediate_size=self.intermediate_size       ,			hidden_act=self.hidden_act       ,			hidden_dropout_prob=self.hidden_dropout_prob       ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,			max_position_embeddings=self.max_position_embeddings       ,			initializer_range=self.initializer_range       ,			)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				MPNetModel(config=__lowercase		)
										model.to(__lowercase		)
										model.eval()
										__lowerCAmelCase							       =				model(__lowercase       ,			__lowercase		)
										__lowerCAmelCase							       =				model(__lowercase		)
										self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.seq_length, self.hidden_size)		)
										self.parent.assertEqual(result.pooler_output.shape       ,			(self.batch_size, self.hidden_size)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				MPNetForQuestionAnswering(config=__lowercase		)
										model.to(__lowercase		)
										model.eval()
										__lowerCAmelCase							       =				model(
										    __lowercase       ,			attention_mask=__lowercase       ,			start_positions=__lowercase       ,			end_positions=__lowercase       ,			)
										self.parent.assertEqual(result.start_logits.shape       ,			(self.batch_size, self.seq_length)		)
										self.parent.assertEqual(result.end_logits.shape       ,			(self.batch_size, self.seq_length)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				self.num_labels
										__lowerCAmelCase							       =				MPNetForSequenceClassification(__lowercase		)
										model.to(__lowercase		)
										model.eval()
										__lowerCAmelCase							       =				model(__lowercase       ,			attention_mask=__lowercase       ,			labels=__lowercase		)
										self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_labels)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				self.num_choices
										__lowerCAmelCase							       =				MPNetForMultipleChoice(config=__lowercase		)
										model.to(__lowercase		)
										model.eval()
										__lowerCAmelCase							       =				input_ids.unsqueeze(1		).expand(-1       ,			self.num_choices       ,			-1		).contiguous()
										__lowerCAmelCase							       =				input_mask.unsqueeze(1		).expand(-1       ,			self.num_choices       ,			-1		).contiguous()
										__lowerCAmelCase							       =				model(
										    __lowercase       ,			attention_mask=__lowercase       ,			labels=__lowercase       ,			)
										self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_choices)		)




				def 					_snake_case  (self       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase       ,			__lowercase		):
										__lowerCAmelCase							       =				self.num_labels
										__lowerCAmelCase							       =				MPNetForTokenClassification(config=__lowercase		)
										model.to(__lowercase		)
										model.eval()
										__lowerCAmelCase							       =				model(__lowercase       ,			attention_mask=__lowercase       ,			labels=__lowercase		)
										self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.num_labels)		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.prepare_config_and_inputs()
										((__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase)       ,					(__lowerCAmelCase))							       =				config_and_inputs
										__lowerCAmelCase							       =				{'''input_ids''': input_ids, '''attention_mask''': input_mask}
										return config, inputs_dict


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







				"""simple docstring"""



				__UpperCamelCase    :		Optional[int]	=	(
				    (
				        MPNetForMaskedLM,
				        MPNetForMultipleChoice,
				        MPNetForQuestionAnswering,
				        MPNetForSequenceClassification,
				        MPNetForTokenClassification,
				        MPNetModel,
				    )
				    if is_torch_available()
				    else ()
				)
				__UpperCamelCase    :		int	=	(
				    {
				        'feature-extraction': MPNetModel,
				        'fill-mask': MPNetForMaskedLM,
				        'question-answering': MPNetForQuestionAnswering,
				        'text-classification': MPNetForSequenceClassification,
				        'token-classification': MPNetForTokenClassification,
				        'zero-shot': MPNetForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				__UpperCamelCase    :		Tuple	=	False
				__UpperCamelCase    :		Union[str, Any]	=	True




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				MPNetModelTester(self		)
										__lowerCAmelCase							       =				ConfigTester(self       ,			config_class=__lowercase       ,			hidden_size=37		)




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




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_mpnet_model(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_mpnet_for_sequence_classification(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_mpnet_for_multiple_choice(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_mpnet_for_token_classification(*__lowercase		)




				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_mpnet_for_question_answering(*__lowercase		)


@require_torch
class       a__				( unittest.TestCase      ):







				"""simple docstring"""



				@slow
				def 					_snake_case  (self		):
										__lowerCAmelCase							       =				MPNetModel.from_pretrained('''microsoft/mpnet-base'''		)
										__lowerCAmelCase							       =				torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]		)
										__lowerCAmelCase							       =				model(__lowercase		)[0]
										__lowerCAmelCase							       =				torch.Size((1, 11, 7_68)		)
										self.assertEqual(output.shape       ,			__lowercase		)
										__lowerCAmelCase							       =				torch.tensor(
										    [[[-0.0_5_5_0, 0.1_9_4_3, -0.0_7_4_0], [-0.0_5_6_2, 0.2_2_1_1, -0.0_5_7_9], [-0.0_4_3_7, 0.3_3_3_7, -0.0_6_4_1]]]		)
										# compare the actual values for a slice.
										self.assertTrue(torch.allclose(output[:, :3, :3]       ,			__lowercase       ,			atol=1e-4		)		)





'''simple docstring'''

def 							__magic_name__(						):
						return [
						    a * b * (1_0_0_0 - a - b)
						    for a in range(1,				9_9_9)
						    for b in range(lowerCamelCase,				9_9_9)
						    if (a * a + b * b == (1_0_0_0 - a - b) ** 2)
						][0]


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

