
"""simple docstring"""



import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_snake_case          =						get_tests_dir('''fixtures/test_sentencepiece.model''')
@require_sentencepiece
@require_tokenizers
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							int							=					XLNetTokenizer
				SCREAMING_SNAKE_CASE_:							Dict							=					XLNetTokenizerFast
				SCREAMING_SNAKE_CASE_:							Tuple							=					True
				SCREAMING_SNAKE_CASE_:							int							=					True


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  List[Any]:







											"""simple docstring"""




											super().setUp()

											# We have a SentencePiece fixture for testing
											_lowerCAmelCase  	=			XLNetTokenizer(UpperCAmelCase_				,     keep_accents=UpperCAmelCase_  )
											tokenizer.sanitize_special_tokens()
											tokenizer.save_pretrained(self.tmpdirname  )


				def 				__lowerCamelCase	(					self	:			Tuple  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			'<s>'
											_lowerCAmelCase  	=			1

											self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCAmelCase_  )				,     UpperCAmelCase_  )
											self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCAmelCase_  )				,     UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			str  )		->  Tuple:







											"""simple docstring"""




											_lowerCAmelCase  	=			list(self.get_tokenizer().get_vocab().keys()  )

											self.assertEqual(vocab_keys[0]				,     '<unk>'  )
											self.assertEqual(vocab_keys[1]				,     '<s>'  )
											self.assertEqual(vocab_keys[-1]				,     '<eod>'  )
											self.assertEqual(len(UpperCAmelCase_  )				,     1_006  )


				def 				__lowerCamelCase	(					self	:			int  )		->  Optional[Any]:







											"""simple docstring"""




											self.assertEqual(self.get_tokenizer().vocab_size				,     1_000  )


				def 				__lowerCamelCase	(					self	:			int  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			XLNetTokenizer(UpperCAmelCase_				,     keep_accents=UpperCAmelCase_  )

											_lowerCAmelCase  	=			tokenizer.tokenize('This is a test'  )
											self.assertListEqual(UpperCAmelCase_				,     ['▁This', '▁is', '▁a', '▁t', 'est']  )

											self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase_  )				,     [285, 46, 10, 170, 382]  )

											_lowerCAmelCase  	=			tokenizer.tokenize('I was born in 92000, and this is falsé.'  )
											self.assertListEqual(
											    UpperCAmelCase_				,     [
											        SPIECE_UNDERLINE + 'I',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '9',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        's',
											        'é',
											        '.',
											    ]				,     )
											_lowerCAmelCase  	=			tokenizer.convert_tokens_to_ids(UpperCAmelCase_  )
											self.assertListEqual(UpperCAmelCase_				,     [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]  )

											_lowerCAmelCase  	=			tokenizer.convert_ids_to_tokens(UpperCAmelCase_  )
											self.assertListEqual(
											    UpperCAmelCase_				,     [
											        SPIECE_UNDERLINE + 'I',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '<unk>',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        's',
											        '<unk>',
											        '.',
											    ]				,     )


				def 				__lowerCamelCase	(					self	:			str  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			XLNetTokenizer(UpperCAmelCase_				,     do_lower_case=UpperCAmelCase_  )
											_lowerCAmelCase  	=			tokenizer.tokenize('I was born in 92000, and this is falsé.'  )
											self.assertListEqual(
											    UpperCAmelCase_				,     [
											        SPIECE_UNDERLINE + '',
											        'i',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '9',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        'se',
											        '.',
											    ]				,     )
											self.assertListEqual(tokenizer.tokenize('H\u00E9llo'  )				,     ['▁he', 'll', 'o']  )


				def 				__lowerCamelCase	(					self	:			Tuple  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			XLNetTokenizer(UpperCAmelCase_				,     do_lower_case=UpperCAmelCase_  )
											_lowerCAmelCase  	=			tokenizer.tokenize('I was born in 92000, and this is falsé.'  )
											self.assertListEqual(
											    UpperCAmelCase_				,     [
											        SPIECE_UNDERLINE + 'I',
											        SPIECE_UNDERLINE + 'was',
											        SPIECE_UNDERLINE + 'b',
											        'or',
											        'n',
											        SPIECE_UNDERLINE + 'in',
											        SPIECE_UNDERLINE + '',
											        '9',
											        '2',
											        '0',
											        '0',
											        '0',
											        ',',
											        SPIECE_UNDERLINE + 'and',
											        SPIECE_UNDERLINE + 'this',
											        SPIECE_UNDERLINE + 'is',
											        SPIECE_UNDERLINE + 'f',
											        'al',
											        'se',
											        '.',
											    ]				,     )


				@slow
				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			XLNetTokenizer.from_pretrained('xlnet-base-cased'  )

											_lowerCAmelCase  	=			tokenizer.encode('sequence builders'				,     add_special_tokens=UpperCAmelCase_  )
											_lowerCAmelCase  	=			tokenizer.encode('multi-sequence build'				,     add_special_tokens=UpperCAmelCase_  )

											_lowerCAmelCase  	=			tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_  )
											_lowerCAmelCase  	=			tokenizer.build_inputs_with_special_tokens(UpperCAmelCase_				,     UpperCAmelCase_  )

											assert encoded_sentence == text + [4, 3]
											assert encoded_pair == text + [4] + text_a + [4, 3]







				@slow
				def 				__lowerCamelCase	(					self	:			int  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			{'input_ids': [[17, 21_442, 270, 17, 10, 14_645, 318, 34, 17, 4_546, 3_145, 787, 13, 7_752, 22_018, 23, 21, 17, 4_546, 3_145, 787, 13, 3_352, 14_431, 13, 5_500, 11, 1_176, 580, 13, 16_819, 4_797, 23, 17, 10, 17_135, 658, 19, 457, 7_932, 13, 184, 19, 3_154, 17_135, 6_468, 19, 1_404, 12_269, 19, 4_229, 5_356, 16_264, 46, 19, 17, 20_545, 10_395, 9, 9, 9, 11, 28, 6_421, 9_531, 20_729, 17, 10, 353, 17_022, 11, 21, 6_421, 9_531, 16_949, 17, 10, 11_509, 753, 11, 33, 95, 2_421, 7_385, 956, 14_431, 2_626, 25, 842, 7_385, 4_836, 21, 1_429, 2_272, 9_855, 3_120, 161, 24_738, 19, 13_203, 658, 218, 787, 21, 430, 18_482, 847, 2_637, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 322, 22_178, 27, 1_064, 22, 956, 13, 11_101, 1_429, 5_854, 24_313, 18_953, 40, 422, 24_366, 68, 1_758, 37, 10_483, 14_257, 31, 207, 263, 21, 203, 3_773, 25, 71, 9_735, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 2_049, 3_442, 17, 13_894, 3_380, 23, 95, 18, 17_634, 2_288, 9, 4, 3]], 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
											# fmt: on

											self.tokenizer_integration_test_util(
											    expected_encoding=UpperCAmelCase_				,     model_name='xlnet-base-cased'				,     revision='c841166438c31ec7ca9a106dee7bb312b73ae511'				,     )








"""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        _SCREAMING_SNAKE_CASE  :






				'''simple docstring'''



				def __init__(					self	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			str=13				,     UpperCAmelCase_	:			Dict=7				,     UpperCAmelCase_	:			Tuple=True				,     UpperCAmelCase_	:			Any=True				,     UpperCAmelCase_	:			Optional[int]=False				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Optional[Any]=99				,     UpperCAmelCase_	:			int=64				,     UpperCAmelCase_	:			Union[str, Any]=5				,     UpperCAmelCase_	:			Union[str, Any]=4				,     UpperCAmelCase_	:			List[Any]=64				,     UpperCAmelCase_	:			List[str]="gelu"				,     UpperCAmelCase_	:			Optional[Any]=0.1				,     UpperCAmelCase_	:			Dict=0.1				,     UpperCAmelCase_	:			Tuple=512				,     UpperCAmelCase_	:			Optional[Any]=16				,     UpperCAmelCase_	:			str=2				,     UpperCAmelCase_	:			int=0.02				,     UpperCAmelCase_	:			List[str]=3				,     UpperCAmelCase_	:			int=4				,     UpperCAmelCase_	:			Tuple=None				,     )		->  Optional[int]:







											"""simple docstring"""




											_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 				__lowerCamelCase	(					self	:			List[str]  )		->  Any:







											"""simple docstring"""




											return MPNetConfig.from_pretrained('microsoft/mpnet-base'  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Tuple:







											"""simple docstring"""




											_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 				__lowerCamelCase	(					self	:			Any  )		->  Tuple:







											"""simple docstring"""




											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 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[int]  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModel(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     UpperCAmelCase_  )
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )
											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 				__lowerCamelCase	(					self	:			List[str]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[Any]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			int  )		->  Optional[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetForQuestionAnswering(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(
											    UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     start_positions=UpperCAmelCase_				,     end_positions=UpperCAmelCase_				,     )
											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 				__lowerCamelCase	(					self	:			Dict				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Union[str, Any]				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Union[str, Any]  )		->  Any:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			MPNetForSequenceClassification(UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_labels)  )


				def 				__lowerCamelCase	(					self	:			int				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			Optional[int]				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Any				,     UpperCAmelCase_	:			List[Any]  )		->  Dict:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_choices
											_lowerCAmelCase  	=			MPNetForMultipleChoice(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											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(
											    UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_				,     )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.num_choices)  )


				def 				__lowerCamelCase	(					self	:			Tuple				,     UpperCAmelCase_	:			Tuple				,     UpperCAmelCase_	:			Optional[Any]				,     UpperCAmelCase_	:			Dict				,     UpperCAmelCase_	:			List[str]				,     UpperCAmelCase_	:			str				,     UpperCAmelCase_	:			List[str]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.num_labels
											_lowerCAmelCase  	=			MPNetForTokenClassification(config=UpperCAmelCase_  )
											model.to(UpperCAmelCase_  )
											model.eval()
											_lowerCAmelCase  	=			model(UpperCAmelCase_				,     attention_mask=UpperCAmelCase_				,     labels=UpperCAmelCase_  )
											self.parent.assertEqual(result.logits.shape				,     (self.batch_size, self.seq_length, self.num_labels)  )







				def 				__lowerCamelCase	(					self	:			str  )		->  List[str]:







											"""simple docstring"""




											_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        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase      ,				UpperCAmelCase      ,				unittest.TestCase							):






				'''simple docstring'''



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


				def 				__lowerCamelCase	(					self	:			str  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModelTester(self  )
											_lowerCAmelCase  	=			ConfigTester(self				,     config_class=UpperCAmelCase_				,     hidden_size=37  )


				def 				__lowerCamelCase	(					self	:			Dict  )		->  Dict:







											"""simple docstring"""




											self.config_tester.run_common_tests()


				def 				__lowerCamelCase	(					self	:			Tuple  )		->  str:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_model(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_sequence_classification(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Optional[int]  )		->  int:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_multiple_choice(*UpperCAmelCase_  )


				def 				__lowerCamelCase	(					self	:			Any  )		->  List[str]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_token_classification(*UpperCAmelCase_  )







				def 				__lowerCamelCase	(					self	:			Any  )		->  Union[str, Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_mpnet_for_question_answering(*UpperCAmelCase_  )






@require_torch
class        _SCREAMING_SNAKE_CASE  (  unittest.TestCase							):






				'''simple docstring'''



				@slow
				def 				__lowerCamelCase	(					self	:			List[Any]  )		->  List[Any]:







											"""simple docstring"""




											_lowerCAmelCase  	=			MPNetModel.from_pretrained('microsoft/mpnet-base'  )
											_lowerCAmelCase  	=			torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]  )
											_lowerCAmelCase  	=			model(UpperCAmelCase_  )[0]
											_lowerCAmelCase  	=			torch.Size((1, 11, 768)  )
											self.assertEqual(output.shape				,     UpperCAmelCase_  )
											_lowerCAmelCase  	=			torch.tensor(
											    [[[-0.0550, 0.1943, -0.0740], [-0.0562, 0.2211, -0.0579], [-0.0437, 0.3337, -0.0641]]]  )
											# compare the actual values for a slice.
											self.assertTrue(torch.allclose(output[:, :3, :3]				,     UpperCAmelCase_				,     atol=1E-4  )  )






