





'''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     __lowerCAmelCase					:






       """simple docstring"""





       def __init__(							self       :		str	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		Union[str, Any]=2	,			lowerCAmelCase__       :		List[Any]=8	,			lowerCAmelCase__       :		Union[str, Any]=True	,			lowerCAmelCase__       :		Optional[int]=True	,			lowerCAmelCase__       :		Union[str, Any]=True	,			lowerCAmelCase__       :		List[Any]=True	,			lowerCAmelCase__       :		Tuple=99	,			lowerCAmelCase__       :		List[Any]=16	,			lowerCAmelCase__       :		Tuple=5	,			lowerCAmelCase__       :		List[Any]=2	,			lowerCAmelCase__       :		Any=36	,			lowerCAmelCase__       :		int="gelu"	,			lowerCAmelCase__       :		List[str]=0.0	,			lowerCAmelCase__       :		Dict=0.0	,			lowerCAmelCase__       :		List[str]=512	,			lowerCAmelCase__       :		int=16	,			lowerCAmelCase__       :		str=2	,			lowerCAmelCase__       :		Tuple=0.02	,			lowerCAmelCase__       :		List[Any]=3	,			lowerCAmelCase__       :		Tuple=4	,			lowerCAmelCase__       :		Dict=None	,			)   ->					List[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 snake_case__						(							self       :		Optional[int]					)   ->					Optional[int]:

            '''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 snake_case__						(							self       :		Any					)   ->					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=lowercase_	,			initializer_range=self.initializer_range	,			)





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

            '''simple docstring'''




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





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

            '''simple docstring'''




            (
                _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 snake_case__						(							self       :		Optional[Any]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Optional[int]					)   ->					Optional[int]:

            '''simple docstring'''




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





       def snake_case__						(							self       :		Any	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Union[str, Any]	,			)   ->					List[str]:

            '''simple docstring'''




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





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

            '''simple docstring'''




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





       def snake_case__						(							self       :		str	,			lowerCAmelCase__       :		Tuple	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Optional[Any]					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	MraForQuestionAnswering(config=lowercase_					)
            model.to(lowercase_					)
            model.eval()
            _UpperCamelCase       =	model(
                lowercase_	,			attention_mask=lowercase_	,			token_type_ids=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 snake_case__						(							self       :		int	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		int	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Any	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		Tuple					)   ->					str:

            '''simple docstring'''




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





       def snake_case__						(							self       :		Dict	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		str	,			lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		Union[str, Any]	,			lowerCAmelCase__       :		List[str]	,			lowerCAmelCase__       :		Tuple					)   ->					List[Any]:

            '''simple docstring'''




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





       def snake_case__						(							self       :		Any	,			lowerCAmelCase__       :		Dict	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		List[Any]	,			lowerCAmelCase__       :		Optional[int]	,			lowerCAmelCase__       :		Optional[Any]	,			lowerCAmelCase__       :		Optional[int]					)   ->					List[Any]:

            '''simple docstring'''




            _UpperCamelCase       =	self.num_choices
            _UpperCamelCase       =	MraForMultipleChoice(config=lowercase_					)
            model.to(lowercase_					)
            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(
                lowercase_	,			attention_mask=lowercase_	,			token_type_ids=lowercase_	,			labels=lowercase_	,			)
            self.parent.assertEqual(result.logits.shape	,			(self.batch_size, self.num_choices)					)







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

            '''simple docstring'''




            _UpperCamelCase       =	self.prepare_config_and_inputs()
            (
                _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     __lowerCAmelCase					(   lowercase__						,						unittest.TestCase			):






       """simple docstring"""
       _snake_case     :					Union[str, Any]						    =   (
           (
               MraModel,
               MraForMaskedLM,
               MraForMultipleChoice,
               MraForQuestionAnswering,
               MraForSequenceClassification,
               MraForTokenClassification,
           )
           if is_torch_available()
           else ()
       )
       _snake_case     :					Union[str, Any]						    =   False
       _snake_case     :					Dict						    =   False
       _snake_case     :					int						    =   False
       _snake_case     :					Any						    =   False

       _snake_case     :					Optional[int]						    =   ()





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

            '''simple docstring'''




            _UpperCamelCase       =	MraModelTester(self					)
            _UpperCamelCase       =	ConfigTester(self	,			config_class=lowercase_	,			hidden_size=37					)





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

            '''simple docstring'''




            self.config_tester.run_common_tests()





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

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*lowercase_					)





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

            '''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(*lowercase_					)





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

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*lowercase_					)





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

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_multiple_choice(*lowercase_					)





       def snake_case__						(							self       :		Tuple					)   ->					str:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*lowercase_					)





       def snake_case__						(							self       :		Any					)   ->					Dict:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*lowercase_					)





       def snake_case__						(							self       :		Any					)   ->					Any:

            '''simple docstring'''




            _UpperCamelCase       =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*lowercase_					)





       @slow
       def snake_case__						(							self       :		int					)   ->					List[str]:

            '''simple docstring'''




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







       @unittest.skip(reason='''MRA does not output attentions'''					)
       def snake_case__						(							self       :		Optional[int]					)   ->					int:

            '''simple docstring'''




            return

@require_torch
class     __lowerCAmelCase					(   unittest.TestCase			):






       """simple docstring"""





       @slow
       def snake_case__						(							self       :		Optional[Any]					)   ->					Optional[int]:

            '''simple docstring'''




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

            with torch.no_grad():
                 _UpperCamelCase       =	model(lowercase_					)[0]

            _UpperCamelCase       =	torch.Size((1, 256, 768)					)
            self.assertEqual(output.shape	,			lowercase_					)

            _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]	,			lowercase_	,			atol=1e-4					)					)





       @slow
       def snake_case__						(							self       :		Dict					)   ->					Dict:

            '''simple docstring'''




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

            with torch.no_grad():
                 _UpperCamelCase       =	model(lowercase_					)[0]

            _UpperCamelCase       =	50265

            _UpperCamelCase       =	torch.Size((1, 256, vocab_size)					)
            self.assertEqual(output.shape	,			lowercase_					)

            _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]	,			lowercase_	,			atol=1e-4					)					)







       @slow
       def snake_case__						(							self       :		int					)   ->					Dict:

            '''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(lowercase_					)[0]

            _UpperCamelCase       =	50265

            _UpperCamelCase       =	torch.Size((1, 4096, vocab_size)					)
            self.assertEqual(output.shape	,			lowercase_					)

            _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]	,			lowercase_	,			atol=1e-4					)					)










'''simple docstring'''

from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase__						:      Optional[Any]	=    {
    'configuration_autoformer': [
        'AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AutoformerConfig',
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowercase__						:      List[Any]	=    [
       'AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
       'AutoformerForPrediction',
       'AutoformerModel',
       'AutoformerPreTrainedModel',
   ]


if TYPE_CHECKING:
   from .configuration_autoformer import (
       AUTOFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       AutoformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_autoformer import (
          AUTOFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          AutoformerForPrediction,
          AutoformerModel,
          AutoformerPreTrainedModel,
      )

else:
   import sys

   lowercase__						:      Tuple	=    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



