



"""simple docstring"""





import unittest

from transformers import MraConfig, 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, floats_tensor, ids_tensor, random_attention_mask


if is_torch_available():
  import torch

  from transformers import (
      MraForMaskedLM,
      MraForMultipleChoice,
      MraForQuestionAnswering,
      MraForSequenceClassification,
      MraForTokenClassification,
      MraModel,
  )
  from transformers.models.mra.modeling_mra import MRA_PRETRAINED_MODEL_ARCHIVE_LIST
class  lowercase__  :







       '''simple docstring'''


       def __init__(				self     :    List[Any]						,							_UpperCAmelCase     :    Optional[int]						,							_UpperCAmelCase     :    Tuple=2						,							_UpperCAmelCase     :    Union[str, Any]=8						,							_UpperCAmelCase     :    Union[str, Any]=True						,							_UpperCAmelCase     :    Optional[int]=True						,							_UpperCAmelCase     :    Tuple=True						,							_UpperCAmelCase     :    Any=True						,							_UpperCAmelCase     :    Optional[int]=99						,							_UpperCAmelCase     :    Tuple=16						,							_UpperCAmelCase     :    Union[str, Any]=5						,							_UpperCAmelCase     :    Optional[Any]=2						,							_UpperCAmelCase     :    Dict=36						,							_UpperCAmelCase     :    List[str]="gelu"						,							_UpperCAmelCase     :    Optional[int]=0.0						,							_UpperCAmelCase     :    Dict=0.0						,							_UpperCAmelCase     :    Tuple=512						,							_UpperCAmelCase     :    Optional[int]=16						,							_UpperCAmelCase     :    List[Any]=2						,							_UpperCAmelCase     :    str=0.02						,							_UpperCAmelCase     :    Dict=3						,							_UpperCAmelCase     :    List[str]=4						,							_UpperCAmelCase     :    Optional[Any]=None						,							)					->		Optional[Any]:


             '''simple docstring'''




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



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


             '''simple docstring'''




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

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

             UpperCAmelCase_     					=				None
             if self.use_token_type_ids:
                   UpperCAmelCase_     					=				ids_tensor([self.batch_size, self.seq_length]						,							self.type_vocab_size       )

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

             UpperCAmelCase_     					=				self.get_config()

             return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



       def 	lowercase__							(				self     :    int       )					->		Dict:


             '''simple docstring'''




             return MraConfig(
                 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						,							type_vocab_size=self.type_vocab_size						,							is_decoder=_UpperCAmelCase						,							initializer_range=self.initializer_range						,							)



       def 	lowercase__							(				self     :    Dict       )					->		str:


             '''simple docstring'''




             UpperCAmelCase_     					=				self.get_config()
             UpperCAmelCase_     					=				300
             return config



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


             '''simple docstring'''




             (
                 (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       (
                 UpperCAmelCase_
             )					,       
             )     					=				self.prepare_config_and_inputs()

             UpperCAmelCase_     					=				True
             UpperCAmelCase_     					=				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]       )
             UpperCAmelCase_     					=				ids_tensor([self.batch_size, self.seq_length]						,							vocab_size=2       )

             return (
                 config,
                 input_ids,
                 token_type_ids,
                 input_mask,
                 sequence_labels,
                 token_labels,
                 choice_labels,
                 encoder_hidden_states,
                 encoder_attention_mask,
             )



       def 	lowercase__							(				self     :    int						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Tuple       )					->		Any:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraModel(config=_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             UpperCAmelCase_     					=				model(_UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase       )
             UpperCAmelCase_     					=				model(_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase       )
             UpperCAmelCase_     					=				model(_UpperCAmelCase       )
             self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, self.seq_length, self.hidden_size)       )



       def 	lowercase__							(				self     :    int						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Dict						,							_UpperCAmelCase     :    Dict						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    List[str]						,							_UpperCAmelCase     :    Dict						,							_UpperCAmelCase     :    Optional[int]						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Optional[int]						,							)					->		int:


             '''simple docstring'''




             UpperCAmelCase_     					=				True
             UpperCAmelCase_     					=				MraModel(_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             UpperCAmelCase_     					=				model(
                 _UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase						,							encoder_hidden_states=_UpperCAmelCase						,							encoder_attention_mask=_UpperCAmelCase						,							)
             UpperCAmelCase_     					=				model(
                 _UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase						,							encoder_hidden_states=_UpperCAmelCase						,							)
             UpperCAmelCase_     					=				model(_UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase       )
             self.parent.assertEqual(result.last_hidden_state.shape						,							(self.batch_size, self.seq_length, self.hidden_size)       )



       def 	lowercase__							(				self     :    List[Any]						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    List[str]						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    Optional[int]       )					->		Tuple:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraForMaskedLM(config=_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             UpperCAmelCase_     					=				model(_UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase						,							labels=_UpperCAmelCase       )
             self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.seq_length, self.vocab_size)       )



       def 	lowercase__							(				self     :    str						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    Optional[int]						,							_UpperCAmelCase     :    Tuple       )					->		Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraForQuestionAnswering(config=_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             UpperCAmelCase_     					=				model(
                 _UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_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 	lowercase__							(				self     :    Any						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Optional[Any]						,							_UpperCAmelCase     :    str						,							_UpperCAmelCase     :    int						,							_UpperCAmelCase     :    List[str]						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    Dict       )					->		Any:


             '''simple docstring'''




             UpperCAmelCase_     					=				self.num_labels
             UpperCAmelCase_     					=				MraForSequenceClassification(_UpperCAmelCase       )
             model.to(_UpperCAmelCase       )
             model.eval()
             UpperCAmelCase_     					=				model(_UpperCAmelCase						,							attention_mask=_UpperCAmelCase						,							token_type_ids=_UpperCAmelCase						,							labels=_UpperCAmelCase       )
             self.parent.assertEqual(result.logits.shape						,							(self.batch_size, self.num_labels)       )



       def 	lowercase__							(				self     :    Dict						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    List[str]						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    List[Any]       )					->		int:


             '''simple docstring'''




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



       def 	lowercase__							(				self     :    Optional[int]						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    Tuple						,							_UpperCAmelCase     :    Union[str, Any]						,							_UpperCAmelCase     :    int						,							_UpperCAmelCase     :    List[Any]						,							_UpperCAmelCase     :    Any						,							_UpperCAmelCase     :    List[str]       )					->		str:


             '''simple docstring'''




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







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


             '''simple docstring'''




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



@require_torch
class  lowercase__  (       SCREAMING_SNAKE_CASE							,   unittest.TestCase ):







       '''simple docstring'''


       UpperCamelCase		=	(
           (
               MraModel,
               MraForMaskedLM,
               MraForMultipleChoice,
               MraForQuestionAnswering,
               MraForSequenceClassification,
               MraForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       UpperCamelCase		=	False
       UpperCamelCase		=	False
       UpperCamelCase		=	False
       UpperCamelCase		=	False

       UpperCamelCase		=	()



       def 	lowercase__							(				self     :    Optional[int]       )					->		Tuple:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraModelTester(self       )
             UpperCAmelCase_     					=				ConfigTester(self						,							config_class=_UpperCAmelCase						,							hidden_size=37       )



       def 	lowercase__							(				self     :    Optional[int]       )					->		Dict:


             '''simple docstring'''




             self.config_tester.run_common_tests()



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


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*_UpperCAmelCase       )



       def 	lowercase__							(				self     :    Tuple       )					->		Tuple:


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             for type in ["absolute", "relative_key", "relative_key_query"]:
                   UpperCAmelCase_     					=				type
                   self.model_tester.create_and_check_model(*_UpperCAmelCase       )



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


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase       )



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


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_multiple_choice(*_UpperCAmelCase       )



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


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase       )



       def 	lowercase__							(				self     :    Optional[int]       )					->		str:


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase       )



       def 	lowercase__							(				self     :    str       )					->		Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_token_classification(*_UpperCAmelCase       )



       @slow
       def 	lowercase__							(				self     :    Union[str, Any]       )					->		Tuple:


             '''simple docstring'''




             for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   UpperCAmelCase_     					=				MraModel.from_pretrained(_UpperCAmelCase       )
                   self.assertIsNotNone(_UpperCAmelCase       )







       @unittest.skip(reason="MRA does not output attentions"       )
       def 	lowercase__							(				self     :    Optional[Any]       )					->		Any:


             '''simple docstring'''




             return



@require_torch
class  lowercase__  (       unittest.TestCase ):







       '''simple docstring'''


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


             '''simple docstring'''




             UpperCAmelCase_     					=				MraModel.from_pretrained("uw-madison/mra-base-512-4"       )
             UpperCAmelCase_     					=				torch.arange(256       ).unsqueeze(0       )

             with torch.no_grad():
                   UpperCAmelCase_     					=				model(_UpperCAmelCase       )[0]

             UpperCAmelCase_     					=				torch.Size((1, 256, 768)       )
             self.assertEqual(output.shape						,							_UpperCAmelCase       )

             UpperCAmelCase_     					=				torch.tensor(
                 [[[-0.0140, 0.0830, -0.0381], [0.1546, 0.1402, 0.0220], [0.1162, 0.0851, 0.0165]]]       )

             self.assertTrue(torch.allclose(output[:, :3, :3]						,							_UpperCAmelCase						,							atol=1e-4       )       )



       @slow
       def 	lowercase__							(				self     :    Union[str, Any]       )					->		Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraForMaskedLM.from_pretrained("uw-madison/mra-base-512-4"       )
             UpperCAmelCase_     					=				torch.arange(256       ).unsqueeze(0       )

             with torch.no_grad():
                   UpperCAmelCase_     					=				model(_UpperCAmelCase       )[0]

             UpperCAmelCase_     					=				50265

             UpperCAmelCase_     					=				torch.Size((1, 256, vocab_size)       )
             self.assertEqual(output.shape						,							_UpperCAmelCase       )

             UpperCAmelCase_     					=				torch.tensor(
                 [[[9.2595, -3.6038, 11.8819], [9.3869, -3.2693, 11.0956], [11.8524, -3.4938, 13.1210]]]       )

             self.assertTrue(torch.allclose(output[:, :3, :3]						,							_UpperCAmelCase						,							atol=1e-4       )       )







       @slow
       def 	lowercase__							(				self     :    Tuple       )					->		Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_     					=				MraForMaskedLM.from_pretrained("uw-madison/mra-base-4096-8-d3"       )
             UpperCAmelCase_     					=				torch.arange(4096       ).unsqueeze(0       )

             with torch.no_grad():
                   UpperCAmelCase_     					=				model(_UpperCAmelCase       )[0]

             UpperCAmelCase_     					=				50265

             UpperCAmelCase_     					=				torch.Size((1, 4096, vocab_size)       )
             self.assertEqual(output.shape						,							_UpperCAmelCase       )

             UpperCAmelCase_     					=				torch.tensor(
                 [[[5.4789, -2.3564, 7.5064], [7.9067, -1.3369, 9.9668], [9.0712, -1.8106, 7.0380]]]       )

             self.assertTrue(torch.allclose(output[:, :3, :3]						,							_UpperCAmelCase						,							atol=1e-4       )       )










'''simple docstring'''


def 						lowerCamelCase__   (				a							):
						assert (
						    isinstance(a    ,	a							) and number_of_steps > 0
						), f'number_of_steps needs to be positive integer, your input {number_of_steps}'
						if number_of_steps == 1:
												return 1
						__snake_case ,       __snake_case						 =   1, 1
						for _ in range(number_of_steps - 1							):
												__snake_case ,       __snake_case						 =   current + previous, current
						return current


if __name__ == "__main__":
	import doctest

	doctest.testmod()

