






from typing import TYPE_CHECKING

from ...utils import _LazyModule


UpperCAmelCase_ :						Optional[int]      =      {'''tokenization_wav2vec2_phoneme''': ['''Wav2Vec2PhonemeCTCTokenizer''']}


if TYPE_CHECKING:
	from .tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizer
else:
	import sys

	UpperCAmelCase_ :						Any      =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)





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 				__snake_case						:




							def __init__(       self     :       Tuple				,				A_     :       Any				,				A_     :       Tuple=1_3				,				A_     :       str=7				,				A_     :       Any=True				,				A_     :       Union[str, Any]=True				,				A_     :       int=False				,				A_     :       int=True				,				A_     :       List[Any]=9_9				,				A_     :       Dict=6_4				,				A_     :       int=5				,				A_     :       List[Any]=4				,				A_     :       Optional[Any]=6_4				,				A_     :       str="gelu"				,				A_     :       Union[str, Any]=0.1				,				A_     :       List[Any]=0.1				,				A_     :       Any=5_1_2				,				A_     :       Union[str, Any]=1_6				,				A_     :       str=2				,				A_     :       Any=0.02				,				A_     :       str=3				,				A_     :       Optional[int]=4				,				A_     :       int=None				,				):
									lowerCAmelCase_			:     List[Any]									= parent
									lowerCAmelCase_			:     List[Any]									= batch_size
									lowerCAmelCase_			:     List[Any]									= seq_length
									lowerCAmelCase_			:     int									= is_training
									lowerCAmelCase_			:     Union[str, Any]									= use_input_mask
									lowerCAmelCase_			:     Tuple									= use_token_type_ids
									lowerCAmelCase_			:     List[Any]									= use_labels
									lowerCAmelCase_			:     int									= vocab_size
									lowerCAmelCase_			:     Union[str, Any]									= hidden_size
									lowerCAmelCase_			:     Optional[Any]									= num_hidden_layers
									lowerCAmelCase_			:     List[str]									= num_attention_heads
									lowerCAmelCase_			:     List[str]									= intermediate_size
									lowerCAmelCase_			:     int									= hidden_act
									lowerCAmelCase_			:     List[str]									= hidden_dropout_prob
									lowerCAmelCase_			:     Optional[int]									= attention_probs_dropout_prob
									lowerCAmelCase_			:     Optional[Any]									= max_position_embeddings
									lowerCAmelCase_			:     Union[str, Any]									= type_vocab_size
									lowerCAmelCase_			:     Any									= type_sequence_label_size
									lowerCAmelCase_			:     Optional[int]									= initializer_range
									lowerCAmelCase_			:     str									= num_labels
									lowerCAmelCase_			:     List[str]									= num_choices
									lowerCAmelCase_			:     Optional[Any]									= scope




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




							def    UpperCAmelCase__			(       self     :       int):
									lowerCAmelCase_			:     Union[str, Any]									= ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size)

									lowerCAmelCase_			:     int									= None
									if self.use_input_mask:
											lowerCAmelCase_			:     List[str]									= random_attention_mask([self.batch_size, self.seq_length])

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

									lowerCAmelCase_			:     List[str]									= self.get_config()
									return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels




							def    UpperCAmelCase__			(       self     :       Any):
									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    UpperCAmelCase__			(       self     :       Dict				,				A_     :       Dict				,				A_     :       int				,				A_     :       Tuple				,				A_     :       List[str]				,				A_     :       str				,				A_     :       List[Any]):
									lowerCAmelCase_			:     int									= MPNetModel(config=A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     Any									= model(A_				,				A_)
									lowerCAmelCase_			:     Union[str, Any]									= model(A_)
									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    UpperCAmelCase__			(       self     :       List[str]				,				A_     :       Union[str, Any]				,				A_     :       List[Any]				,				A_     :       Optional[int]				,				A_     :       Optional[Any]				,				A_     :       Optional[int]				,				A_     :       Any):
									lowerCAmelCase_			:     Any									= MPNetForQuestionAnswering(config=A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     int									= model(
									    A_				,				attention_mask=A_				,				start_positions=A_				,				end_positions=A_				,				)
									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    UpperCAmelCase__			(       self     :       Optional[Any]				,				A_     :       Tuple				,				A_     :       List[str]				,				A_     :       Optional[Any]				,				A_     :       Dict				,				A_     :       Union[str, Any]				,				A_     :       Tuple):
									lowerCAmelCase_			:     Tuple									= self.num_labels
									lowerCAmelCase_			:     Any									= MPNetForSequenceClassification(A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     Dict									= model(A_				,				attention_mask=A_				,				labels=A_)
									self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_labels))




							def    UpperCAmelCase__			(       self     :       Union[str, Any]				,				A_     :       Tuple				,				A_     :       Dict				,				A_     :       Tuple				,				A_     :       Dict				,				A_     :       List[str]				,				A_     :       List[Any]):
									lowerCAmelCase_			:     int									= self.num_choices
									lowerCAmelCase_			:     List[str]									= MPNetForMultipleChoice(config=A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     Optional[Any]									= input_ids.unsqueeze(1).expand(-1				,				self.num_choices				,				-1).contiguous()
									lowerCAmelCase_			:     int									= input_mask.unsqueeze(1).expand(-1				,				self.num_choices				,				-1).contiguous()
									lowerCAmelCase_			:     Optional[int]									= model(
									    A_				,				attention_mask=A_				,				labels=A_				,				)
									self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_choices))




							def    UpperCAmelCase__			(       self     :       Optional[Any]				,				A_     :       Any				,				A_     :       int				,				A_     :       Any				,				A_     :       List[Any]				,				A_     :       Any				,				A_     :       Union[str, Any]):
									lowerCAmelCase_			:     int									= self.num_labels
									lowerCAmelCase_			:     Tuple									= MPNetForTokenClassification(config=A_)
									model.to(A_)
									model.eval()
									lowerCAmelCase_			:     Optional[int]									= model(A_				,				attention_mask=A_				,				labels=A_)
									self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.num_labels))







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





@require_torch
class 				__snake_case						(     UpperCamelCase_						,UpperCamelCase_						,unittest.TestCase						):
							_a			      = (
							    (
							        MPNetForMaskedLM,
							        MPNetForMultipleChoice,
							        MPNetForQuestionAnswering,
							        MPNetForSequenceClassification,
							        MPNetForTokenClassification,
							        MPNetModel,
							    )
							    if is_torch_available()
							    else ()
							)
							_a			      = (
							    {
							        '''feature-extraction''': MPNetModel,
							        '''fill-mask''': MPNetForMaskedLM,
							        '''question-answering''': MPNetForQuestionAnswering,
							        '''text-classification''': MPNetForSequenceClassification,
							        '''token-classification''': MPNetForTokenClassification,
							        '''zero-shot''': MPNetForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							_a			      = False
							_a			      = True




							def    UpperCAmelCase__			(       self     :       Union[str, Any]):
									lowerCAmelCase_			:     List[Any]									= MPNetModelTester(self)
									lowerCAmelCase_			:     Optional[Any]									= ConfigTester(self				,				config_class=A_				,				hidden_size=3_7)




							def    UpperCAmelCase__			(       self     :       Any):
									self.config_tester.run_common_tests()




							def    UpperCAmelCase__			(       self     :       List[Any]):
									lowerCAmelCase_			:     int									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_mpnet_model(*A_)




							def    UpperCAmelCase__			(       self     :       Tuple):
									lowerCAmelCase_			:     Optional[int]									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_mpnet_for_sequence_classification(*A_)




							def    UpperCAmelCase__			(       self     :       str):
									lowerCAmelCase_			:     Dict									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_mpnet_for_multiple_choice(*A_)




							def    UpperCAmelCase__			(       self     :       int):
									lowerCAmelCase_			:     Dict									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_mpnet_for_token_classification(*A_)







							def    UpperCAmelCase__			(       self     :       str):
									lowerCAmelCase_			:     Any									= self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_mpnet_for_question_answering(*A_)





@require_torch
class 				__snake_case						(     unittest.TestCase						):




							@slow
							def    UpperCAmelCase__			(       self     :       Tuple):
									lowerCAmelCase_			:     Union[str, Any]									= MPNetModel.from_pretrained('''microsoft/mpnet-base''')
									lowerCAmelCase_			:     Optional[Any]									= torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]])
									lowerCAmelCase_			:     Union[str, Any]									= model(A_)[0]
									lowerCAmelCase_			:     Optional[int]									= torch.Size((1, 1_1, 7_6_8))
									self.assertEqual(output.shape				,				A_)
									lowerCAmelCase_			:     Tuple									= 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]				,				A_				,				atol=1e-4))





