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


   def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase=13,				_UpperCAmelCase=7,				_UpperCAmelCase=True,				_UpperCAmelCase=True,				_UpperCAmelCase=False,				_UpperCAmelCase=True,				_UpperCAmelCase=99,				_UpperCAmelCase=64,				_UpperCAmelCase=5,				_UpperCAmelCase=4,				_UpperCAmelCase=64,				_UpperCAmelCase="gelu",				_UpperCAmelCase=0.1,				_UpperCAmelCase=0.1,				_UpperCAmelCase=512,				_UpperCAmelCase=16,				_UpperCAmelCase=2,				_UpperCAmelCase=0.02,				_UpperCAmelCase=3,				_UpperCAmelCase=4,				_UpperCAmelCase=None,				):
        '''simple docstring'''



        lowercase__				 =							parent
        lowercase__				 =							batch_size
        lowercase__				 =							seq_length
        lowercase__				 =							is_training
        lowercase__				 =							use_input_mask
        lowercase__				 =							use_token_type_ids
        lowercase__				 =							use_labels
        lowercase__				 =							vocab_size
        lowercase__				 =							hidden_size
        lowercase__				 =							num_hidden_layers
        lowercase__				 =							num_attention_heads
        lowercase__				 =							intermediate_size
        lowercase__				 =							hidden_act
        lowercase__				 =							hidden_dropout_prob
        lowercase__				 =							attention_probs_dropout_prob
        lowercase__				 =							max_position_embeddings
        lowercase__				 =							type_vocab_size
        lowercase__				 =							type_sequence_label_size
        lowercase__				 =							initializer_range
        lowercase__				 =							num_labels
        lowercase__				 =							num_choices
        lowercase__				 =							scope


   def 	snake_case__	(     self  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							ids_tensor([self.batch_size, self.seq_length],				self.vocab_size  )

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

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

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


   def 	snake_case__	(     self  ):
        '''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 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							MPNetModel(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							model(_UpperCAmelCase,				_UpperCAmelCase  )
        lowercase__				 =							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 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							MPNetForQuestionAnswering(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							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 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



        lowercase__				 =							self.num_choices
        lowercase__				 =							MPNetForMultipleChoice(config=_UpperCAmelCase  )
        model.to(_UpperCAmelCase  )
        model.eval()
        lowercase__				 =							input_ids.unsqueeze(1  ).expand(-1,				self.num_choices,				-1  ).contiguous()
        lowercase__				 =							input_mask.unsqueeze(1  ).expand(-1,				self.num_choices,				-1  ).contiguous()
        lowercase__				 =							model(
            _UpperCAmelCase,				attention_mask=_UpperCAmelCase,				labels=_UpperCAmelCase,				)
        self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.num_choices)  )


   def 	snake_case__	(     self,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase,				_UpperCAmelCase  ):
        '''simple docstring'''



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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.prepare_config_and_inputs()
        ((lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__) ,						(lowercase__))				 =							config_and_inputs
        lowercase__				 =							{"input_ids": input_ids, "attention_mask": input_mask}
        return config, inputs_dict






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


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							MPNetModelTester(self  )
        lowercase__				 =							ConfigTester(self,				config_class=_UpperCAmelCase,				hidden_size=37  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        self.config_tester.run_common_tests()


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mpnet_model(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mpnet_for_sequence_classification(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mpnet_for_multiple_choice(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mpnet_for_token_classification(*_UpperCAmelCase  )


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_mpnet_for_question_answering(*_UpperCAmelCase  )






@require_torch
class    a__    (   unittest.TestCase	):


   @slow
   def 	snake_case__	(     self  ):
        '''simple docstring'''



        lowercase__				 =							MPNetModel.from_pretrained("microsoft/mpnet-base"  )
        lowercase__				 =							torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]  )
        lowercase__				 =							model(_UpperCAmelCase  )[0]
        lowercase__				 =							torch.Size((1, 11, 768)  )
        self.assertEqual(output.shape,				_UpperCAmelCase  )
        lowercase__				 =							torch.tensor(
            [[[-0.0_550, 0.1_943, -0.0_740], [-0.0_562, 0.2_211, -0.0_579], [-0.0_437, 0.3_337, -0.0_641]]]  )
        # compare the actual values for a slice.
        self.assertTrue(torch.allclose(output[:, :3, :3],				_UpperCAmelCase,				atol=1E-4  )  )





"""simple docstring"""


from typing import Optional

from .. import Features, NamedSplit
from ..packaged_modules.text.text import Text
from ..utils.typing import NestedDataStructureLike, PathLike
from .abc import AbstractDatasetReader






class    a__    (   _a	):


   def __init__(     self,				_UpperCAmelCase,				_UpperCAmelCase = None,				_UpperCAmelCase = None,				_UpperCAmelCase = None,				_UpperCAmelCase = False,				_UpperCAmelCase = False,				_UpperCAmelCase = None,				**_UpperCAmelCase,				):
        '''simple docstring'''



        super().__init__(
            _UpperCAmelCase,				split=_UpperCAmelCase,				features=_UpperCAmelCase,				cache_dir=_UpperCAmelCase,				keep_in_memory=_UpperCAmelCase,				streaming=_UpperCAmelCase,				num_proc=_UpperCAmelCase,				**_UpperCAmelCase,				)
        lowercase__				 =							path_or_paths if isinstance(_UpperCAmelCase,				_UpperCAmelCase  ) else {self.split: path_or_paths}
        lowercase__				 =							Text(
            cache_dir=_UpperCAmelCase,				data_files=_UpperCAmelCase,				features=_UpperCAmelCase,				**_UpperCAmelCase,				)


   def 	snake_case__	(     self  ):
        '''simple docstring'''



        if self.streaming:
             lowercase__				 =							self.builder.as_streaming_dataset(split=self.split  )
        # Build regular (map-style) dataset
        else:
             lowercase__				 =							None
             lowercase__				 =							None
             lowercase__				 =							None
             lowercase__				 =							None

             self.builder.download_and_prepare(
                 download_config=_UpperCAmelCase,				download_mode=_UpperCAmelCase,				verification_mode=_UpperCAmelCase,				base_path=_UpperCAmelCase,				num_proc=self.num_proc,				)
             lowercase__				 =							self.builder.as_dataset(
                 split=self.split,				verification_mode=_UpperCAmelCase,				in_memory=self.keep_in_memory  )
        return dataset




