


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







   """simple docstring"""




   def __init__(		self				:List[Any]					,	UpperCamelCase__				:Any					,	UpperCamelCase__				:Optional[int]=2					,	UpperCamelCase__				:Tuple=8					,	UpperCamelCase__				:int=True					,	UpperCamelCase__				:Dict=True					,	UpperCamelCase__				:Dict=True					,	UpperCamelCase__				:Optional[Any]=True					,	UpperCamelCase__				:str=99					,	UpperCamelCase__				:Any=16					,	UpperCamelCase__				:Any=5					,	UpperCamelCase__				:List[Any]=2					,	UpperCamelCase__				:int=36					,	UpperCamelCase__				:List[Any]="gelu"					,	UpperCamelCase__				:List[str]=0.0					,	UpperCamelCase__				:str=0.0					,	UpperCamelCase__				:Any=512					,	UpperCamelCase__				:int=16					,	UpperCamelCase__				:Tuple=2					,	UpperCamelCase__				:int=0.02					,	UpperCamelCase__				:Dict=3					,	UpperCamelCase__				:Union[str, Any]=4					,	UpperCamelCase__				:Optional[int]=None					,	):
          _a							 =					parent
          _a							 =					batch_size
          _a							 =					seq_length
          _a							 =					is_training
          _a							 =					use_input_mask
          _a							 =					use_token_type_ids
          _a							 =					use_labels
          _a							 =					vocab_size
          _a							 =					hidden_size
          _a							 =					num_hidden_layers
          _a							 =					num_attention_heads
          _a							 =					intermediate_size
          _a							 =					hidden_act
          _a							 =					hidden_dropout_prob
          _a							 =					attention_probs_dropout_prob
          _a							 =					max_position_embeddings
          _a							 =					type_vocab_size
          _a							 =					type_sequence_label_size
          _a							 =					initializer_range
          _a							 =					num_labels
          _a							 =					num_choices
          _a							 =					scope




   def SCREAMING_SNAKE_CASE_   (		self				:Dict							):
          _a							 =					ids_tensor([self.batch_size, self.seq_length]					,	self.vocab_size							)

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

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

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

          _a							 =					self.get_config()

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




   def SCREAMING_SNAKE_CASE_   (		self				:Optional[int]							):
          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=snake_case_					,	initializer_range=self.initializer_range					,	)




   def SCREAMING_SNAKE_CASE_   (		self				:int							):
          _a							 =					self.get_config()
          _a							 =					300
          return config




   def SCREAMING_SNAKE_CASE_   (		self				:List[Any]							):
          (
              (
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,						
          )							 =					self.prepare_config_and_inputs()

          _a							 =					True
          _a							 =					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]							)
          _a							 =					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 SCREAMING_SNAKE_CASE_   (		self				:Dict					,	UpperCamelCase__				:List[str]					,	UpperCamelCase__				:int					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Any					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:int							):
          _a							 =					MraModel(config=snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_							)
          _a							 =					model(snake_case_					,	token_type_ids=snake_case_							)
          _a							 =					model(snake_case_							)
          self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)							)




   def SCREAMING_SNAKE_CASE_   (		self				:str					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:int					,	UpperCamelCase__				:int					,	UpperCamelCase__				:Union[str, Any]					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Optional[Any]					,	UpperCamelCase__				:Union[str, Any]					,	):
          _a							 =					True
          _a							 =					MraModel(snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(
              snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	encoder_hidden_states=snake_case_					,	encoder_attention_mask=snake_case_					,	)
          _a							 =					model(
              snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	encoder_hidden_states=snake_case_					,	)
          _a							 =					model(snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_							)
          self.parent.assertEqual(result.last_hidden_state.shape					,	(self.batch_size, self.seq_length, self.hidden_size)							)




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:Tuple					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:int					,	UpperCamelCase__				:str							):
          _a							 =					MraForMaskedLM(config=snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	labels=snake_case_							)
          self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.vocab_size)							)




   def SCREAMING_SNAKE_CASE_   (		self				:int					,	UpperCamelCase__				:str					,	UpperCamelCase__				:int					,	UpperCamelCase__				:Tuple					,	UpperCamelCase__				:int					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:Tuple							):
          _a							 =					MraForQuestionAnswering(config=snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(
              snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	start_positions=snake_case_					,	end_positions=snake_case_					,	)
          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 SCREAMING_SNAKE_CASE_   (		self				:Optional[Any]					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:Union[str, Any]					,	UpperCamelCase__				:str					,	UpperCamelCase__				:Any					,	UpperCamelCase__				:str					,	UpperCamelCase__				:List[str]							):
          _a							 =					self.num_labels
          _a							 =					MraForSequenceClassification(snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	labels=snake_case_							)
          self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_labels)							)




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Optional[Any]					,	UpperCamelCase__				:Union[str, Any]					,	UpperCamelCase__				:Union[str, Any]					,	UpperCamelCase__				:List[Any]					,	UpperCamelCase__				:List[str]							):
          _a							 =					self.num_labels
          _a							 =					MraForTokenClassification(config=snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					model(snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	labels=snake_case_							)
          self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.seq_length, self.num_labels)							)




   def SCREAMING_SNAKE_CASE_   (		self				:str					,	UpperCamelCase__				:Optional[Any]					,	UpperCamelCase__				:int					,	UpperCamelCase__				:List[str]					,	UpperCamelCase__				:Optional[int]					,	UpperCamelCase__				:Tuple					,	UpperCamelCase__				:Dict					,	UpperCamelCase__				:Dict							):
          _a							 =					self.num_choices
          _a							 =					MraForMultipleChoice(config=snake_case_							)
          model.to(snake_case_							)
          model.eval()
          _a							 =					input_ids.unsqueeze(1							).expand(-1					,	self.num_choices					,	-1							).contiguous()
          _a							 =					token_type_ids.unsqueeze(1							).expand(-1					,	self.num_choices					,	-1							).contiguous()
          _a							 =					input_mask.unsqueeze(1							).expand(-1					,	self.num_choices					,	-1							).contiguous()
          _a							 =					model(
              snake_case_					,	attention_mask=snake_case_					,	token_type_ids=snake_case_					,	labels=snake_case_					,	)
          self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_choices)							)




   def SCREAMING_SNAKE_CASE_   (		self				:Union[str, Any]							):
          _a							 =					self.prepare_config_and_inputs()
          (
              (
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,			(
              _a			
          ) ,						
          )							 =					config_and_inputs
          _a							 =					{"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
          return config, inputs_dict






@require_torch
class __snake_case		(       __snake_case					,							unittest.TestCase   ):







   """simple docstring"""




   lowerCAmelCase_					: Optional[int]  						=      (
       (
           MraModel,
           MraForMaskedLM,
           MraForMultipleChoice,
           MraForQuestionAnswering,
           MraForSequenceClassification,
           MraForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   lowerCAmelCase_					: Union[str, Any]  						=      False
   lowerCAmelCase_					: Tuple  						=      False
   lowerCAmelCase_					: Optional[int]  						=      False
   lowerCAmelCase_					: Any  						=      False

   lowerCAmelCase_					: Optional[int]  						=      ()




   def SCREAMING_SNAKE_CASE_   (		self				:Dict							):
          _a							 =					MraModelTester(self							)
          _a							 =					ConfigTester(self					,	config_class=snake_case_					,	hidden_size=37							)




   def SCREAMING_SNAKE_CASE_   (		self				:int							):
          self.config_tester.run_common_tests()




   def SCREAMING_SNAKE_CASE_   (		self				:Optional[int]							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          for type in ["absolute", "relative_key", "relative_key_query"]:
                 _a							 =					type
                 self.model_tester.create_and_check_model(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:List[str]							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_lm(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:List[Any]							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_multiple_choice(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_question_answering(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_sequence_classification(*snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:Dict							):
          _a							 =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_token_classification(*snake_case_							)




   @slow
   def SCREAMING_SNAKE_CASE_   (		self				:Optional[int]							):
          for model_name in MRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 _a							 =					MraModel.from_pretrained(snake_case_							)
                 self.assertIsNotNone(snake_case_							)




   @unittest.skip(reason="MRA does not output attentions"							)
   def SCREAMING_SNAKE_CASE_   (		self				:List[str]							):
          return






@require_torch
class __snake_case		(       unittest.TestCase   ):







   """simple docstring"""




   @slow
   def SCREAMING_SNAKE_CASE_   (		self				:Optional[Any]							):
          _a							 =					MraModel.from_pretrained("uw-madison/mra-base-512-4"							)
          _a							 =					torch.arange(256							).unsqueeze(0							)

          with torch.no_grad():
                 _a							 =					model(snake_case_							)[0]

          _a							 =					torch.Size((1, 256, 768)							)
          self.assertEqual(output.shape					,	snake_case_							)

          _a							 =					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]					,	snake_case_					,	atol=1E-4							)							)




   @slow
   def SCREAMING_SNAKE_CASE_   (		self				:Dict							):
          _a							 =					MraForMaskedLM.from_pretrained("uw-madison/mra-base-512-4"							)
          _a							 =					torch.arange(256							).unsqueeze(0							)

          with torch.no_grad():
                 _a							 =					model(snake_case_							)[0]

          _a							 =					50_265

          _a							 =					torch.Size((1, 256, vocab_size)							)
          self.assertEqual(output.shape					,	snake_case_							)

          _a							 =					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]					,	snake_case_					,	atol=1E-4							)							)




   @slow
   def SCREAMING_SNAKE_CASE_   (		self				:Optional[int]							):
          _a							 =					MraForMaskedLM.from_pretrained("uw-madison/mra-base-4096-8-d3"							)
          _a							 =					torch.arange(4_096							).unsqueeze(0							)

          with torch.no_grad():
                 _a							 =					model(snake_case_							)[0]

          _a							 =					50_265

          _a							 =					torch.Size((1, 4_096, vocab_size)							)
          self.assertEqual(output.shape					,	snake_case_							)

          _a							 =					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]					,	snake_case_					,	atol=1E-4							)							)







def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> int:




    """simple docstring"""




    return int((input_a, input_a).count(0				) != 0				)





def 				__lowerCAmelCase(       )							-> None:




    """simple docstring"""




    assert nand_gate(0							,     0				) == 1
    assert nand_gate(0							,     1				) == 1
    assert nand_gate(1							,     0				) == 1
    assert nand_gate(1							,     1				) == 0


if __name__ == "__main__":
 print(nand_gate(0, 0))
 print(nand_gate(0, 1))
 print(nand_gate(1, 0))
 print(nand_gate(1, 1))





