




"""simple docstring"""






import os
import unittest

from transformers import MobileBertTokenizer, MobileBertTokenizerFast
from transformers.models.bert.tokenization_bert import (
    VOCAB_FILES_NAMES,
    BasicTokenizer,
    WordpieceTokenizer,
    _is_control,
    _is_punctuation,
    _is_whitespace,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english






@require_tokenizers
class lowerCAmelCase__      (	lowercase,      unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__ =     MobileBertTokenizer
			lowerCamelCase__ =     MobileBertTokenizerFast
			lowerCamelCase__ =     True
			lowerCamelCase__ =     True
			lowerCamelCase__ =     filter_non_english
			lowerCamelCase__ =     """google/mobilebert-uncased"""
			def    A_       (    self    ):
							super().setUp()

							_lowerCamelCase	:     Optional[int]       =       [
							    '[UNK]',
							    '[CLS]',
							    '[SEP]',
							    '[PAD]',
							    '[MASK]',
							    'want',
							    '##want',
							    '##ed',
							    'wa',
							    'un',
							    'runn',
							    '##ing',
							    ',',
							    'low',
							    'lowest',
							]
							_lowerCamelCase	:     Union[str, Any]       =       os.path.join(self.tmpdirname    , VOCAB_FILES_NAMES['vocab_file']    )
							with open(self.vocab_file    , 'w'    , encoding='utf-8'    ) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]    )    )

							_lowerCamelCase	:     Any       =       [
							    (tokenizer_def[0], self.pre_trained_model_path, tokenizer_def[2])  # else the 'google/' prefix is stripped
							    for tokenizer_def in self.tokenizers_list
							]
			def    A_       (    self    , lowercase    ):
							_lowerCamelCase	:     Union[str, Any]       =       'UNwant\u00E9d,running'
							_lowerCamelCase	:     List[Any]       =       'unwanted, running'
							return input_text, output_text
			def    A_       (    self    ):
							_lowerCamelCase	:     Dict       =       self.tokenizer_class(self.vocab_file    )

							_lowerCamelCase	:     Union[str, Any]       =       tokenizer.tokenize('UNwant\u00E9d,running'    )
							self.assertListEqual(lowercase    , ['un', '##want', '##ed', ',', 'runn', '##ing']    )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase    )    , [9, 6, 7, 12, 10, 11]    )
			def    A_       (    self    ):
							if not self.test_rust_tokenizer:
											return

							_lowerCamelCase	:     Any       =       self.get_tokenizer()
							_lowerCamelCase	:     Any       =       self.get_rust_tokenizer()

							_lowerCamelCase	:     int       =       'UNwant\u00E9d,running'

							_lowerCamelCase	:     Union[str, Any]       =       tokenizer.tokenize(lowercase    )
							_lowerCamelCase	:     List[Any]       =       rust_tokenizer.tokenize(lowercase    )
							self.assertListEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     Dict       =       tokenizer.encode(lowercase    , add_special_tokens=lowercase    )
							_lowerCamelCase	:     Dict       =       rust_tokenizer.encode(lowercase    , add_special_tokens=lowercase    )
							self.assertListEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     Optional[Any]       =       self.get_rust_tokenizer()
							_lowerCamelCase	:     Optional[int]       =       tokenizer.encode(lowercase    )
							_lowerCamelCase	:     List[str]       =       rust_tokenizer.encode(lowercase    )
							self.assertListEqual(lowercase    , lowercase    )

							# With lower casing
							_lowerCamelCase	:     List[Any]       =       self.get_tokenizer(do_lower_case=lowercase    )
							_lowerCamelCase	:     int       =       self.get_rust_tokenizer(do_lower_case=lowercase    )

							_lowerCamelCase	:     Optional[Any]       =       'UNwant\u00E9d,running'

							_lowerCamelCase	:     Dict       =       tokenizer.tokenize(lowercase    )
							_lowerCamelCase	:     int       =       rust_tokenizer.tokenize(lowercase    )
							self.assertListEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     Dict       =       tokenizer.encode(lowercase    , add_special_tokens=lowercase    )
							_lowerCamelCase	:     Dict       =       rust_tokenizer.encode(lowercase    , add_special_tokens=lowercase    )
							self.assertListEqual(lowercase    , lowercase    )

							_lowerCamelCase	:     Any       =       self.get_rust_tokenizer()
							_lowerCamelCase	:     Union[str, Any]       =       tokenizer.encode(lowercase    )
							_lowerCamelCase	:     Dict       =       rust_tokenizer.encode(lowercase    )
							self.assertListEqual(lowercase    , lowercase    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Dict       =       BasicTokenizer()

							self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'    )    , ['ah', '\u535A', '\u63A8', 'zz']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Optional[Any]       =       BasicTokenizer(do_lower_case=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )    , ['hello', '!', 'how', 'are', 'you', '?']    )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )    , ['hello']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[str]       =       BasicTokenizer(do_lower_case=lowercase    , strip_accents=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )    , ['hällo', '!', 'how', 'are', 'you', '?']    )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )    , ['h\u00E9llo']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[Any]       =       BasicTokenizer(do_lower_case=lowercase    , strip_accents=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )    , ['hallo', '!', 'how', 'are', 'you', '?']    )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )    , ['hello']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     int       =       BasicTokenizer(do_lower_case=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )    , ['hallo', '!', 'how', 'are', 'you', '?']    )
							self.assertListEqual(tokenizer.tokenize('H\u00E9llo'    )    , ['hello']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[str]       =       BasicTokenizer(do_lower_case=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '    )    , ['HeLLo', '!', 'how', 'Are', 'yoU', '?']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       BasicTokenizer(do_lower_case=lowercase    , strip_accents=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )    , ['HäLLo', '!', 'how', 'Are', 'yoU', '?']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       BasicTokenizer(do_lower_case=lowercase    , strip_accents=lowercase    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '    )    , ['HaLLo', '!', 'how', 'Are', 'yoU', '?']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     int       =       BasicTokenizer(do_lower_case=lowercase    , never_split=['[UNK]']    )

							self.assertListEqual(
							    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'    )    , ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

							_lowerCamelCase	:     Tuple       =       {}
							for i, token in enumerate(lowercase    ):
											_lowerCamelCase	:     Union[str, Any]       =       i
							_lowerCamelCase	:     str       =       WordpieceTokenizer(vocab=lowercase    , unk_token='[UNK]'    )

							self.assertListEqual(tokenizer.tokenize(''    )    , []    )

							self.assertListEqual(tokenizer.tokenize('unwanted running'    )    , ['un', '##want', '##ed', 'runn', '##ing']    )

							self.assertListEqual(tokenizer.tokenize('unwantedX running'    )    , ['[UNK]', 'runn', '##ing']    )
			def    A_       (    self    ):
							self.assertTrue(_is_whitespace(' '    )    )
							self.assertTrue(_is_whitespace('\t'    )    )
							self.assertTrue(_is_whitespace('\r'    )    )
							self.assertTrue(_is_whitespace('\n'    )    )
							self.assertTrue(_is_whitespace('\u00A0'    )    )

							self.assertFalse(_is_whitespace('A'    )    )
							self.assertFalse(_is_whitespace('-'    )    )
			def    A_       (    self    ):
							self.assertTrue(_is_control('\u0005'    )    )

							self.assertFalse(_is_control('A'    )    )
							self.assertFalse(_is_control(' '    )    )
							self.assertFalse(_is_control('\t'    )    )
							self.assertFalse(_is_control('\r'    )    )
			def    A_       (    self    ):
							self.assertTrue(_is_punctuation('-'    )    )
							self.assertTrue(_is_punctuation('$'    )    )
							self.assertTrue(_is_punctuation('`'    )    )
							self.assertTrue(_is_punctuation('.'    )    )

							self.assertFalse(_is_punctuation('A'    )    )
							self.assertFalse(_is_punctuation(' '    )    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[Any]       =       self.get_tokenizer()
							_lowerCamelCase	:     Union[str, Any]       =       self.get_rust_tokenizer()

							# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
							self.assertListEqual([tokenizer.tokenize(lowercase    ) for t in ['Test', '\xad', 'test']]    , [['[UNK]'], [], ['[UNK]']]    )

							self.assertListEqual(
							    [rust_tokenizer.tokenize(lowercase    ) for t in ['Test', '\xad', 'test']]    , [['[UNK]'], [], ['[UNK]']]    )
			@slow
			def    A_       (    self    ):
							_lowerCamelCase	:     Optional[Any]       =       self.tokenizer_class.from_pretrained('google/mobilebert-uncased'    )

							_lowerCamelCase	:     List[str]       =       tokenizer.encode('sequence builders'    , add_special_tokens=lowercase    )
							_lowerCamelCase	:     Dict       =       tokenizer.encode('multi-sequence build'    , add_special_tokens=lowercase    )

							_lowerCamelCase	:     Optional[int]       =       tokenizer.build_inputs_with_special_tokens(lowercase    )
							_lowerCamelCase	:     List[Any]       =       tokenizer.build_inputs_with_special_tokens(lowercase    , lowercase    )

							assert encoded_sentence == [101] + text + [102]
							assert encoded_pair == [101] + text + [102] + text_a + [102]
			def    A_       (    self    ):
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															_lowerCamelCase	:     int       =       self.rust_tokenizer_class.from_pretrained(lowercase    , **lowercase    )

															_lowerCamelCase	:     int       =       F'''A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'''
															_lowerCamelCase	:     int       =       tokenizer_r.encode_plus(
															    lowercase    , return_attention_mask=lowercase    , return_token_type_ids=lowercase    , return_offsets_mapping=lowercase    , add_special_tokens=lowercase    , )

															_lowerCamelCase	:     Tuple       =       tokenizer_r.do_lower_case if hasattr(lowercase    , 'do_lower_case'    ) else False
															_lowerCamelCase	:     Dict       =       (
															    [
															        ((0, 0), tokenizer_r.cls_token),
															        ((0, 1), 'A'),
															        ((1, 2), ','),
															        ((3, 5), 'na'),
															        ((5, 6), '##ï'),
															        ((6, 8), '##ve'),
															        ((9, 15), tokenizer_r.mask_token),
															        ((16, 21), 'Allen'),
															        ((21, 23), '##NL'),
															        ((23, 24), '##P'),
															        ((25, 33), 'sentence'),
															        ((33, 34), '.'),
															        ((0, 0), tokenizer_r.sep_token),
															    ]
															    if not do_lower_case
															    else [
															        ((0, 0), tokenizer_r.cls_token),
															        ((0, 1), 'a'),
															        ((1, 2), ','),
															        ((3, 8), 'naive'),
															        ((9, 15), tokenizer_r.mask_token),
															        ((16, 21), 'allen'),
															        ((21, 23), '##nl'),
															        ((23, 24), '##p'),
															        ((25, 33), 'sentence'),
															        ((33, 34), '.'),
															        ((0, 0), tokenizer_r.sep_token),
															    ]
															)

															self.assertEqual(
															    [e[1] for e in expected_results]    , tokenizer_r.convert_ids_to_tokens(tokens['input_ids']    )    )
															self.assertEqual([e[0] for e in expected_results]    , tokens['offset_mapping']    )






			def    A_       (    self    ):
							_lowerCamelCase	:     Tuple       =       ['的', '人', '有']
							_lowerCamelCase	:     Optional[Any]       =       ''.join(lowercase    )
							for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''    ):
															_lowerCamelCase	:     int       =       True
															_lowerCamelCase	:     Any       =       self.tokenizer_class.from_pretrained(lowercase    , **lowercase    )
															_lowerCamelCase	:     Dict       =       self.rust_tokenizer_class.from_pretrained(lowercase    , **lowercase    )

															_lowerCamelCase	:     List[str]       =       tokenizer_p.encode(lowercase    , add_special_tokens=lowercase    )
															_lowerCamelCase	:     List[Any]       =       tokenizer_r.encode(lowercase    , add_special_tokens=lowercase    )

															_lowerCamelCase	:     Any       =       tokenizer_r.convert_ids_to_tokens(lowercase    )
															_lowerCamelCase	:     Dict       =       tokenizer_p.convert_ids_to_tokens(lowercase    )

															# it is expected that each Chinese character is not preceded by "##"
															self.assertListEqual(lowercase    , lowercase    )
															self.assertListEqual(lowercase    , lowercase    )

															_lowerCamelCase	:     Optional[Any]       =       False
															_lowerCamelCase	:     Dict       =       self.rust_tokenizer_class.from_pretrained(lowercase    , **lowercase    )
															_lowerCamelCase	:     Optional[int]       =       self.tokenizer_class.from_pretrained(lowercase    , **lowercase    )

															_lowerCamelCase	:     Optional[Any]       =       tokenizer_r.encode(lowercase    , add_special_tokens=lowercase    )
															_lowerCamelCase	:     str       =       tokenizer_p.encode(lowercase    , add_special_tokens=lowercase    )

															_lowerCamelCase	:     List[Any]       =       tokenizer_r.convert_ids_to_tokens(lowercase    )
															_lowerCamelCase	:     Dict       =       tokenizer_p.convert_ids_to_tokens(lowercase    )

															# it is expected that only the first Chinese character is not preceded by "##".
															_lowerCamelCase	:     List[str]       =       [
															    F'''##{token}''' if idx != 0 else token for idx, token in enumerate(lowercase    )
															]
															self.assertListEqual(lowercase    , lowercase    )
															self.assertListEqual(lowercase    , lowercase    )





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






			'''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=512    , lowercase=16    , lowercase=2    , lowercase=0.02    , lowercase=3    , lowercase=4    , lowercase=None    , ):
							_lowerCamelCase	:     List[str]       =       parent
							_lowerCamelCase	:     List[str]       =       batch_size
							_lowerCamelCase	:     Tuple       =       seq_length
							_lowerCamelCase	:     List[Any]       =       is_training
							_lowerCamelCase	:     int       =       use_input_mask
							_lowerCamelCase	:     Optional[Any]       =       use_token_type_ids
							_lowerCamelCase	:     List[Any]       =       use_labels
							_lowerCamelCase	:     str       =       vocab_size
							_lowerCamelCase	:     Optional[int]       =       hidden_size
							_lowerCamelCase	:     List[str]       =       num_hidden_layers
							_lowerCamelCase	:     Optional[int]       =       num_attention_heads
							_lowerCamelCase	:     List[str]       =       intermediate_size
							_lowerCamelCase	:     int       =       hidden_act
							_lowerCamelCase	:     Optional[int]       =       hidden_dropout_prob
							_lowerCamelCase	:     List[Any]       =       attention_probs_dropout_prob
							_lowerCamelCase	:     List[str]       =       max_position_embeddings
							_lowerCamelCase	:     List[Any]       =       type_vocab_size
							_lowerCamelCase	:     Optional[int]       =       type_sequence_label_size
							_lowerCamelCase	:     Union[str, Any]       =       initializer_range
							_lowerCamelCase	:     Tuple       =       num_labels
							_lowerCamelCase	:     int       =       num_choices
							_lowerCamelCase	:     int       =       scope
			def    A_       (    self    ):
							return MPNetConfig.from_pretrained('microsoft/mpnet-base'    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Tuple       =       ids_tensor([self.batch_size, self.seq_length]    , self.vocab_size    )

							_lowerCamelCase	:     Dict       =       None
							if self.use_input_mask:
											_lowerCamelCase	:     Optional[int]       =       random_attention_mask([self.batch_size, self.seq_length]    )

							_lowerCamelCase	:     int       =       None
							_lowerCamelCase	:     List[str]       =       None
							_lowerCamelCase	:     Any       =       None
							if self.use_labels:
											_lowerCamelCase	:     List[str]       =       ids_tensor([self.batch_size]    , self.type_sequence_label_size    )
											_lowerCamelCase	:     str       =       ids_tensor([self.batch_size, self.seq_length]    , self.num_labels    )
											_lowerCamelCase	:     Dict       =       ids_tensor([self.batch_size]    , self.num_choices    )

							_lowerCamelCase	:     int       =       self.get_config()
							return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
			def    A_       (    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    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Optional[Any]       =       MPNetModel(config=lowercase    )
							model.to(lowercase    )
							model.eval()
							_lowerCamelCase	:     Tuple       =       model(lowercase    , lowercase    )
							_lowerCamelCase	:     Tuple       =       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    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    ):
							_lowerCamelCase	:     str       =       MPNetForQuestionAnswering(config=lowercase    )
							model.to(lowercase    )
							model.eval()
							_lowerCamelCase	:     str       =       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    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Optional[int]       =       self.num_labels
							_lowerCamelCase	:     int       =       MPNetForSequenceClassification(lowercase    )
							model.to(lowercase    )
							model.eval()
							_lowerCamelCase	:     Optional[Any]       =       model(lowercase    , attention_mask=lowercase    , labels=lowercase    )
							self.parent.assertEqual(result.logits.shape    , (self.batch_size, self.num_labels)    )
			def    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    ):
							_lowerCamelCase	:     List[str]       =       self.num_choices
							_lowerCamelCase	:     List[str]       =       MPNetForMultipleChoice(config=lowercase    )
							model.to(lowercase    )
							model.eval()
							_lowerCamelCase	:     Union[str, Any]       =       input_ids.unsqueeze(1    ).expand(-1    , self.num_choices    , -1    ).contiguous()
							_lowerCamelCase	:     List[str]       =       input_mask.unsqueeze(1    ).expand(-1    , self.num_choices    , -1    ).contiguous()
							_lowerCamelCase	:     Any       =       model(
							    lowercase    , attention_mask=lowercase    , labels=lowercase    , )
							self.parent.assertEqual(result.logits.shape    , (self.batch_size, self.num_choices)    )
			def    A_       (    self    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    , lowercase    ):
							_lowerCamelCase	:     Any       =       self.num_labels
							_lowerCamelCase	:     Union[str, Any]       =       MPNetForTokenClassification(config=lowercase    )
							model.to(lowercase    )
							model.eval()
							_lowerCamelCase	:     Union[str, Any]       =       model(lowercase    , attention_mask=lowercase    , labels=lowercase    )
							self.parent.assertEqual(result.logits.shape    , (self.batch_size, self.seq_length, self.num_labels)    )






			def    A_       (    self    ):
							_lowerCamelCase	:     Dict       =       self.prepare_config_and_inputs()
							((_lowerCamelCase),					(_lowerCamelCase),					(_lowerCamelCase),					(_lowerCamelCase),					(_lowerCamelCase),					(_lowerCamelCase))	:     List[Any]       =       config_and_inputs
							_lowerCamelCase	:     str       =       {'input_ids': input_ids, 'attention_mask': input_mask}
							return config, inputs_dict






@require_torch
class lowerCAmelCase__      (	lowercase,      lowercase,      unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__ =     (
			    (
			        MPNetForMaskedLM,
			        MPNetForMultipleChoice,
			        MPNetForQuestionAnswering,
			        MPNetForSequenceClassification,
			        MPNetForTokenClassification,
			        MPNetModel,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase__ =     (
			    {
			        """feature-extraction""": MPNetModel,
			        """fill-mask""": MPNetForMaskedLM,
			        """question-answering""": MPNetForQuestionAnswering,
			        """text-classification""": MPNetForSequenceClassification,
			        """token-classification""": MPNetForTokenClassification,
			        """zero-shot""": MPNetForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			lowerCamelCase__ =     False
			lowerCamelCase__ =     True
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       MPNetModelTester(self    )
							_lowerCamelCase	:     List[Any]       =       ConfigTester(self    , config_class=lowercase    , hidden_size=37    )
			def    A_       (    self    ):
							self.config_tester.run_common_tests()
			def    A_       (    self    ):
							_lowerCamelCase	:     Union[str, Any]       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_mpnet_model(*lowercase    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[Any]       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_mpnet_for_sequence_classification(*lowercase    )
			def    A_       (    self    ):
							_lowerCamelCase	:     Optional[Any]       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_mpnet_for_multiple_choice(*lowercase    )
			def    A_       (    self    ):
							_lowerCamelCase	:     List[Any]       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_mpnet_for_token_classification(*lowercase    )






			def    A_       (    self    ):
							_lowerCamelCase	:     str       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_mpnet_for_question_answering(*lowercase    )






@require_torch
class lowerCAmelCase__      (	unittest.TestCase		):






			'''simple docstring'''



			@slow
			def    A_       (    self    ):
							_lowerCamelCase	:     Optional[Any]       =       MPNetModel.from_pretrained('microsoft/mpnet-base'    )
							_lowerCamelCase	:     Optional[Any]       =       torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]    )
							_lowerCamelCase	:     Any       =       model(lowercase    )[0]
							_lowerCamelCase	:     Dict       =       torch.Size((1, 11, 768)    )
							self.assertEqual(output.shape    , lowercase    )
							_lowerCamelCase	:     List[Any]       =       torch.tensor(
							    [[[-0.05_50, 0.19_43, -0.07_40], [-0.05_62, 0.22_11, -0.05_79], [-0.04_37, 0.33_37, -0.06_41]]]    )
							# compare the actual values for a slice.
							self.assertTrue(torch.allclose(output[:, :3, :3]    , lowercase    , atol=1E-4    )    )