




import unittest

from transformers import 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      RemBertConfig,
      RemBertForCausalLM,
      RemBertForMaskedLM,
      RemBertForMultipleChoice,
      RemBertForQuestionAnswering,
      RemBertForSequenceClassification,
      RemBertForTokenClassification,
      RemBertModel,
  )
  from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST
class 							__lowercase   :



     def __init__(  self   :							str      ,		lowercase__   :							Dict      ,		lowercase__   :							Dict=1_3      ,		lowercase__   :							List[str]=7      ,		lowercase__   :							Optional[int]=True      ,		lowercase__   :							str=True      ,		lowercase__   :							Tuple=True      ,		lowercase__   :							Optional[Any]=True      ,		lowercase__   :							str=9_9      ,		lowercase__   :							str=3_2      ,		lowercase__   :							str=1_8      ,		lowercase__   :							List[str]=4_3      ,		lowercase__   :							Optional[int]=5      ,		lowercase__   :							List[str]=4      ,		lowercase__   :							List[Any]=3_7      ,		lowercase__   :							Optional[int]="gelu"      ,		lowercase__   :							Any=0.1      ,		lowercase__   :							List[str]=0.1      ,		lowercase__   :							Dict=5_1_2      ,		lowercase__   :							str=1_6      ,		lowercase__   :							str=2      ,		lowercase__   :							str=0.02      ,		lowercase__   :							str=3      ,		lowercase__   :							Tuple=4      ,		lowercase__   :							Any=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_		    =  input_embedding_size
       a_		    =  output_embedding_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 				__magic_name__		(  self   :							Tuple       ):
       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_		    =  RemBertConfig(
           vocab_size=self.vocab_size      ,		hidden_size=self.hidden_size      ,		input_embedding_size=self.input_embedding_size      ,		output_embedding_size=self.output_embedding_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      ,		)

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



     def 				__magic_name__		(  self   :							Optional[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 				__magic_name__		(  self   :							Tuple      ,		lowercase__   :							int      ,		lowercase__   :							int      ,		lowercase__   :							Any      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Dict      ,		lowercase__   :							List[str]       ):
       a_		    =  RemBertModel(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  model(lowercase__      ,		attention_mask=lowercase__      ,		token_type_ids=lowercase__       )
       a_		    =  model(lowercase__      ,		token_type_ids=lowercase__       )
       a_		    =  model(lowercase__       )
       self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)       )



     def 				__magic_name__		(  self   :							str      ,		lowercase__   :							Any      ,		lowercase__   :							List[Any]      ,		lowercase__   :							List[str]      ,		lowercase__   :							List[Any]      ,		lowercase__   :							Any      ,		lowercase__   :							Union[str, Any]      ,		lowercase__   :							Any      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Union[str, Any]      ,		):
       a_		    =  True
       a_		    =  RemBertModel(lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  model(
           lowercase__      ,		attention_mask=lowercase__      ,		token_type_ids=lowercase__      ,		encoder_hidden_states=lowercase__      ,		encoder_attention_mask=lowercase__      ,		)
       a_		    =  model(
           lowercase__      ,		attention_mask=lowercase__      ,		token_type_ids=lowercase__      ,		encoder_hidden_states=lowercase__      ,		)
       a_		    =  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 				__magic_name__		(  self   :							Optional[int]      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							List[str]      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							Dict      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							List[str]      ,		lowercase__   :							List[Any]      ,		):
       a_		    =  RemBertForCausalLM(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  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 				__magic_name__		(  self   :							Optional[int]      ,		lowercase__   :							Tuple      ,		lowercase__   :							Dict      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							Union[str, Any]      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Dict      ,		lowercase__   :							Any       ):
       a_		    =  RemBertForMaskedLM(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  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 				__magic_name__		(  self   :							Optional[int]      ,		lowercase__   :							List[str]      ,		lowercase__   :							int      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							Dict      ,		lowercase__   :							int      ,		lowercase__   :							Union[str, Any]      ,		lowercase__   :							str      ,		lowercase__   :							str      ,		):
       a_		    =  True
       a_		    =  True
       a_		    =  RemBertForCausalLM(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()

       # first forward pass
       a_		    =  model(
           lowercase__      ,		attention_mask=lowercase__      ,		encoder_hidden_states=lowercase__      ,		encoder_attention_mask=lowercase__      ,		use_cache=lowercase__      ,		)
       a_		    =  outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       a_		    =  ids_tensor((self.batch_size, 3)      ,		config.vocab_size       )
       a_		    =  ids_tensor((self.batch_size, 3)      ,		vocab_size=2       )

       # append to next input_ids and
       a_		    =  torch.cat([input_ids, next_tokens]      ,		dim=-1       )
       a_		    =  torch.cat([input_mask, next_mask]      ,		dim=-1       )

       a_		    =  model(
           lowercase__      ,		attention_mask=lowercase__      ,		encoder_hidden_states=lowercase__      ,		encoder_attention_mask=lowercase__      ,		output_hidden_states=lowercase__      ,		)['''hidden_states'''][0]
       a_		    =  model(
           lowercase__      ,		attention_mask=lowercase__      ,		encoder_hidden_states=lowercase__      ,		encoder_attention_mask=lowercase__      ,		past_key_values=lowercase__      ,		output_hidden_states=lowercase__      ,		)['''hidden_states'''][0]

       # select random slice
       a_		    =  ids_tensor((1,)      ,		output_from_past.shape[-1]       ).item()
       a_		    =  output_from_no_past[:, -3:, random_slice_idx].detach()
       a_		    =  output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]       )

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(lowercase__      ,		lowercase__      ,		atol=1e-3       )       )



     def 				__magic_name__		(  self   :							Union[str, Any]      ,		lowercase__   :							Tuple      ,		lowercase__   :							int      ,		lowercase__   :							List[str]      ,		lowercase__   :							str      ,		lowercase__   :							Any      ,		lowercase__   :							int      ,		lowercase__   :							Any       ):
       a_		    =  RemBertForQuestionAnswering(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  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 				__magic_name__		(  self   :							Union[str, Any]      ,		lowercase__   :							Dict      ,		lowercase__   :							str      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							List[Any]      ,		lowercase__   :							Any      ,		lowercase__   :							List[str]      ,		lowercase__   :							Dict       ):
       a_		    =  self.num_labels
       a_		    =  RemBertForSequenceClassification(lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  model(lowercase__      ,		attention_mask=lowercase__      ,		token_type_ids=lowercase__      ,		labels=lowercase__       )
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_labels)       )



     def 				__magic_name__		(  self   :							Optional[int]      ,		lowercase__   :							Optional[Any]      ,		lowercase__   :							str      ,		lowercase__   :							Optional[int]      ,		lowercase__   :							Union[str, Any]      ,		lowercase__   :							int      ,		lowercase__   :							Any      ,		lowercase__   :							Optional[Any]       ):
       a_		    =  self.num_labels
       a_		    =  RemBertForTokenClassification(config=lowercase__       )
       model.to(lowercase__       )
       model.eval()
       a_		    =  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 				__magic_name__		(  self   :							Any      ,		lowercase__   :							Union[str, Any]      ,		lowercase__   :							List[str]      ,		lowercase__   :							List[Any]      ,		lowercase__   :							str      ,		lowercase__   :							str      ,		lowercase__   :							Any      ,		lowercase__   :							List[str]       ):
       a_		    =  self.num_choices
       a_		    =  RemBertForMultipleChoice(config=lowercase__       )
       model.to(lowercase__       )
       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(
           lowercase__      ,		attention_mask=lowercase__      ,		token_type_ids=lowercase__      ,		labels=lowercase__      ,		)
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_choices)       )



     def 				__magic_name__		(  self   :							List[str]       ):
       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 							__lowercase   (			a__	,		a__	,		unittest.TestCase    ):
     _lowerCAmelCase		       =						(
         (
             RemBertModel,
             RemBertForMaskedLM,
             RemBertForCausalLM,
             RemBertForMultipleChoice,
             RemBertForQuestionAnswering,
             RemBertForSequenceClassification,
             RemBertForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     _lowerCAmelCase		       =						(RemBertForCausalLM,) if is_torch_available() else ()
     _lowerCAmelCase		       =						(
         {
             "feature-extraction": RemBertModel,
             "fill-mask": RemBertForMaskedLM,
             "question-answering": RemBertForQuestionAnswering,
             "text-classification": RemBertForSequenceClassification,
             "text-generation": RemBertForCausalLM,
             "token-classification": RemBertForTokenClassification,
             "zero-shot": RemBertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )



     def 				__magic_name__		(  self   :							str       ):
       a_		    =  RemBertModelTester(self       )
       a_		    =  ConfigTester(self      ,		config_class=lowercase__      ,		hidden_size=3_7       )



     def 				__magic_name__		(  self   :							Optional[Any]       ):
       self.config_tester.run_common_tests()



     def 				__magic_name__		(  self   :							int       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowercase__       )



     def 				__magic_name__		(  self   :							Union[str, Any]       ):
       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(*lowercase__       )



     def 				__magic_name__		(  self   :							Dict       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*lowercase__       )



     def 				__magic_name__		(  self   :							Any       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*lowercase__       )



     def 				__magic_name__		(  self   :							Optional[Any]       ):
       a_		    =  self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*lowercase__       )



     def 				__magic_name__		(  self   :							List[Any]       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*lowercase__       )



     def 				__magic_name__		(  self   :							List[Any]       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*lowercase__       )



     def 				__magic_name__		(  self   :							Optional[int]       ):
       a_		    =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*lowercase__       )



     def 				__magic_name__		(  self   :							Optional[int]       ):
       a_		    =  self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*lowercase__       )



     def 				__magic_name__		(  self   :							str       ):
       # This regression test was failing with PyTorch < 1.3
       (
           (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , (
           a_
       )    , 
       )		    =  self.model_tester.prepare_config_and_inputs_for_decoder()

       a_		    =  None

       self.model_tester.create_and_check_model_as_decoder(
           lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		lowercase__      ,		)



     @slow
     def 				__magic_name__		(  self   :							Optional[Any]       ):
       for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         a_		    =  RemBertModel.from_pretrained(lowercase__       )
         self.assertIsNotNone(lowercase__       )



@require_torch
class 							__lowercase   (			unittest.TestCase    ):



     @slow
     def 				__magic_name__		(  self   :							Dict       ):
       # Test exact values at the last hidden layer
       a_		    =  RemBertModel.from_pretrained('''google/rembert'''       )
       a_		    =  torch.tensor([[3_1_2, 5_6_4_9_8, 3_1_3, 2_1_2_5, 3_1_3]]       )
       a_		    =  torch.tensor([[0, 0, 0, 1, 1]]       )
       with torch.no_grad():
         a_		    =  model(lowercase__      ,		token_type_ids=lowercase__      ,		output_hidden_states=lowercase__       )

       a_		    =  1_1_5_2

       a_		    =  torch.Size((1, 5, hidden_size)       )
       self.assertEqual(output['''last_hidden_state'''].shape      ,		lowercase__       )

       a_		    =  torch.tensor(
           [
               [
                   [0.0754, -0.2022, 0.1904],
                   [-0.3354, -0.3692, -0.4791],
                   [-0.2314, -0.6729, -0.0749],
                   [-0.0396, -0.3105, -0.4234],
                   [-0.1571, -0.0525, 0.5353],
               ]
           ]       )

       # Running on the original tf implementation gives slightly different results here.
       # Not clear why this variations is present
       # TODO: Find reason for discrepancy
       # expected_original_implementation = [[
       #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
       #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
       #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
       #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
       #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
       # ]]

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






def 				UpperCAmelCase__  (							_A      ,      _A			):






  """simple docstring"""


  if not root or root not in binary_tree_mirror_dictionary:
    return
  a_    , a_		    =  binary_tree_mirror_dictionary[root][:2]
  a_		    =  [right_child, left_child]
  binary_tree_mirror_dict(_A      ,      _A			)
  binary_tree_mirror_dict(_A      ,      _A			)






def 				UpperCAmelCase__  (							_A      ,      _A = 1			):






  """simple docstring"""


  if not binary_tree:
    raise ValueError('''binary tree cannot be empty'''			)
  if root not in binary_tree:
    a_		    =  f"root {root} is not present in the binary_tree"
    raise ValueError(_A			)
  a_		    =  dict(_A			)
  binary_tree_mirror_dict(_A      ,      _A			)
  return binary_tree_mirror_dictionary


if __name__ == "__main__":
  UpperCamelCase__       				=	{1: [2, 3], 2: [4, 5], 3: [6, 7], 7: [8, 9]}
  print(F"""Binary tree: {binary_tree}""")
  UpperCamelCase__       				=	binary_tree_mirror(binary_tree, 5)
  print(F"""Binary tree mirror: {binary_tree_mirror_dictionary}""")
