




'''simple docstring'''



from sklearn.metrics import accuracy_score

import datasets


lowerCamelCase_	 =		'\nAccuracy is the proportion of correct predictions among the total number of cases processed. It can be computed with:\nAccuracy = (TP + TN) / (TP + TN + FP + FN)\n Where:\nTP: True positive\nTN: True negative\nFP: False positive\nFN: False negative\n'


lowerCamelCase_	 =		'\nArgs:\n    predictions (`list` of `int`): Predicted labels.\n    references (`list` of `int`): Ground truth labels.\n    normalize (`boolean`): If set to False, returns the number of correctly classified samples. Otherwise, returns the fraction of correctly classified samples. Defaults to True.\n    sample_weight (`list` of `float`): Sample weights Defaults to None.\n\nReturns:\n    accuracy (`float` or `int`): Accuracy score. Minimum possible value is 0. Maximum possible value is 1.0, or the number of examples input, if `normalize` is set to `True`.. A higher score means higher accuracy.\n\nExamples:\n\n    Example 1-A simple example\n        >>> accuracy_metric = datasets.load_metric("accuracy")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0])\n        >>> print(results)\n        {\'accuracy\': 0.5}\n\n    Example 2-The same as Example 1, except with `normalize` set to `False`.\n        >>> accuracy_metric = datasets.load_metric("accuracy")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], normalize=False)\n        >>> print(results)\n        {\'accuracy\': 3.0}\n\n    Example 3-The same as Example 1, except with `sample_weight` set.\n        >>> accuracy_metric = datasets.load_metric("accuracy")\n        >>> results = accuracy_metric.compute(references=[0, 1, 2, 0, 1, 2], predictions=[0, 1, 1, 2, 1, 0], sample_weight=[0.5, 2, 0.7, 0.5, 9, 0.4])\n        >>> print(results)\n        {\'accuracy\': 0.8778625954198473}\n'


lowerCamelCase_	 =		'\n@article{scikit-learn,\n  title={Scikit-learn: Machine Learning in {P}ython},\n  author={Pedregosa, F. and Varoquaux, G. and Gramfort, A. and Michel, V.\n         and Thirion, B. and Grisel, O. and Blondel, M. and Prettenhofer, P.\n         and Weiss, R. and Dubourg, V. and Vanderplas, J. and Passos, A. and\n         Cournapeau, D. and Brucher, M. and Perrot, M. and Duchesnay, E.},\n  journal={Journal of Machine Learning Research},\n  volume={12},\n  pages={2825--2830},\n  year={2011}\n}\n'







@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,						_KWARGS_DESCRIPTION     )
class 	lowercase_					(				datasets.Metric     ):


   """simple docstring"""

   def 							lowerCAmelCase_    (					self      :			Any					):

      """simple docstring"""
      return datasets.MetricInfo(
          description=_DESCRIPTION						,   citation=_CITATION						,   inputs_description=_KWARGS_DESCRIPTION						,   features=datasets.Features(
              {
                  "predictions": datasets.Sequence(datasets.Value("int32"					)					),
                  "references": datasets.Sequence(datasets.Value("int32"					)					),
              }
              if self.config_name == "multilabel"
              else {
                  "predictions": datasets.Value("int32"					),
                  "references": datasets.Value("int32"					),
              }					)						,   reference_urls=["https://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html"]						,   )



   def 							lowerCAmelCase_    (					self      :			List[str]						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Optional[Any]						,   __lowerCamelCase      :			Dict=True						,   __lowerCamelCase      :			int=None					):

      """simple docstring"""
      return {
          "accuracy": float(
              accuracy_score(__lowerCamelCase						,   __lowerCamelCase						,   normalize=__lowerCamelCase						,   sample_weight=__lowerCamelCase					)					)
      }







'''simple docstring'''



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_					:


   """simple docstring"""

   def __init__(					self      :			Any						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			Union[str, Any]=1_3						,   __lowerCamelCase      :			str=7						,   __lowerCamelCase      :			Any=True						,   __lowerCamelCase      :			List[Any]=True						,   __lowerCamelCase      :			str=True						,   __lowerCamelCase      :			Union[str, Any]=True						,   __lowerCamelCase      :			List[Any]=9_9						,   __lowerCamelCase      :			List[str]=3_2						,   __lowerCamelCase      :			List[Any]=1_8						,   __lowerCamelCase      :			List[Any]=4_3						,   __lowerCamelCase      :			int=5						,   __lowerCamelCase      :			Any=4						,   __lowerCamelCase      :			List[str]=3_7						,   __lowerCamelCase      :			Any="gelu"						,   __lowerCamelCase      :			List[str]=0.1						,   __lowerCamelCase      :			List[Any]=0.1						,   __lowerCamelCase      :			Union[str, Any]=5_1_2						,   __lowerCamelCase      :			int=1_6						,   __lowerCamelCase      :			str=2						,   __lowerCamelCase      :			Optional[int]=0.0_2						,   __lowerCamelCase      :			Dict=3						,   __lowerCamelCase      :			str=4						,   __lowerCamelCase      :			Union[str, Any]=None						,   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   parent
      _SCREAMING_SNAKE_CASE =   batch_size
      _SCREAMING_SNAKE_CASE =   seq_length
      _SCREAMING_SNAKE_CASE =   is_training
      _SCREAMING_SNAKE_CASE =   use_input_mask
      _SCREAMING_SNAKE_CASE =   use_token_type_ids
      _SCREAMING_SNAKE_CASE =   use_labels
      _SCREAMING_SNAKE_CASE =   vocab_size
      _SCREAMING_SNAKE_CASE =   hidden_size
      _SCREAMING_SNAKE_CASE =   input_embedding_size
      _SCREAMING_SNAKE_CASE =   output_embedding_size
      _SCREAMING_SNAKE_CASE =   num_hidden_layers
      _SCREAMING_SNAKE_CASE =   num_attention_heads
      _SCREAMING_SNAKE_CASE =   intermediate_size
      _SCREAMING_SNAKE_CASE =   hidden_act
      _SCREAMING_SNAKE_CASE =   hidden_dropout_prob
      _SCREAMING_SNAKE_CASE =   attention_probs_dropout_prob
      _SCREAMING_SNAKE_CASE =   max_position_embeddings
      _SCREAMING_SNAKE_CASE =   type_vocab_size
      _SCREAMING_SNAKE_CASE =   type_sequence_label_size
      _SCREAMING_SNAKE_CASE =   initializer_range
      _SCREAMING_SNAKE_CASE =   num_labels
      _SCREAMING_SNAKE_CASE =   num_choices
      _SCREAMING_SNAKE_CASE =   scope



   def 							lowerCAmelCase_    (					self      :			int					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   ids_tensor([self.batch_size, self.seq_length]						,   self.vocab_size					)

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

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

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

      _SCREAMING_SNAKE_CASE =   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=__lowerCamelCase						,   initializer_range=self.initializer_range						,   )

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



   def 							lowerCAmelCase_    (					self      :			List[str]					):

      """simple docstring"""
      (
          (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), 
      ) =   self.prepare_config_and_inputs()

      _SCREAMING_SNAKE_CASE =   True
      _SCREAMING_SNAKE_CASE =   floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
      _SCREAMING_SNAKE_CASE =   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 							lowerCAmelCase_    (					self      :			int						,   __lowerCamelCase      :			List[str]						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			List[str]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Dict					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   RemBertModel(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase					)
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   token_type_ids=__lowerCamelCase					)
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase					)
      self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, self.seq_length, self.hidden_size)					)



   def 							lowerCAmelCase_    (					self      :			List[str]						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			Tuple						,   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   True
      _SCREAMING_SNAKE_CASE =   RemBertModel(__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   encoder_hidden_states=__lowerCamelCase						,   encoder_attention_mask=__lowerCamelCase						,   )
      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   encoder_hidden_states=__lowerCamelCase						,   )
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase					)
      self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, self.seq_length, self.hidden_size)					)



   def 							lowerCAmelCase_    (					self      :			List[str]						,   __lowerCamelCase      :			List[str]						,   __lowerCamelCase      :			Optional[Any]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Union[str, Any]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Dict						,   __lowerCamelCase      :			List[str]						,   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   RemBertForCausalLM(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   labels=__lowerCamelCase					)
      self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.vocab_size)					)



   def 							lowerCAmelCase_    (					self      :			Tuple						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			List[str]						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			Any					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   RemBertForMaskedLM(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   labels=__lowerCamelCase					)
      self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.vocab_size)					)



   def 							lowerCAmelCase_    (					self      :			Tuple						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			Union[str, Any]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			Optional[Any]						,   __lowerCamelCase      :			Union[str, Any]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Optional[int]						,   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   True
      _SCREAMING_SNAKE_CASE =   True
      _SCREAMING_SNAKE_CASE =   RemBertForCausalLM(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()

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

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

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

      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   encoder_hidden_states=__lowerCamelCase						,   encoder_attention_mask=__lowerCamelCase						,   output_hidden_states=__lowerCamelCase						,   )["hidden_states"][0]
      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   encoder_hidden_states=__lowerCamelCase						,   encoder_attention_mask=__lowerCamelCase						,   past_key_values=__lowerCamelCase						,   output_hidden_states=__lowerCamelCase						,   )["hidden_states"][0]

      # select random slice
      _SCREAMING_SNAKE_CASE =   ids_tensor((1,)						,   output_from_past.shape[-1]					).item()
      _SCREAMING_SNAKE_CASE =   output_from_no_past[:, -3:, random_slice_idx].detach()
      _SCREAMING_SNAKE_CASE =   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(__lowerCamelCase						,   __lowerCamelCase						,   atol=1e-3					)					)



   def 							lowerCAmelCase_    (					self      :			List[Any]						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			Optional[Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   RemBertForQuestionAnswering(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   start_positions=__lowerCamelCase						,   end_positions=__lowerCamelCase						,   )
      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 							lowerCAmelCase_    (					self      :			Optional[int]						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			int						,   __lowerCamelCase      :			Optional[Any]						,   __lowerCamelCase      :			Dict					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.num_labels
      _SCREAMING_SNAKE_CASE =   RemBertForSequenceClassification(__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   labels=__lowerCamelCase					)
      self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.num_labels)					)



   def 							lowerCAmelCase_    (					self      :			Tuple						,   __lowerCamelCase      :			List[str]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			Any						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			List[Any]						,   __lowerCamelCase      :			Union[str, Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.num_labels
      _SCREAMING_SNAKE_CASE =   RemBertForTokenClassification(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   labels=__lowerCamelCase					)
      self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.seq_length, self.num_labels)					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]						,   __lowerCamelCase      :			Dict						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			Optional[int]						,   __lowerCamelCase      :			str						,   __lowerCamelCase      :			Union[str, Any]						,   __lowerCamelCase      :			Tuple						,   __lowerCamelCase      :			int					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.num_choices
      _SCREAMING_SNAKE_CASE =   RemBertForMultipleChoice(config=__lowerCamelCase					)
      model.to(__lowerCamelCase					)
      model.eval()
      _SCREAMING_SNAKE_CASE =   input_ids.unsqueeze(1					).expand(-1						,   self.num_choices						,   -1					).contiguous()
      _SCREAMING_SNAKE_CASE =   token_type_ids.unsqueeze(1					).expand(-1						,   self.num_choices						,   -1					).contiguous()
      _SCREAMING_SNAKE_CASE =   input_mask.unsqueeze(1					).expand(-1						,   self.num_choices						,   -1					).contiguous()
      _SCREAMING_SNAKE_CASE =   model(
          __lowerCamelCase						,   attention_mask=__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   labels=__lowerCamelCase						,   )
      self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.num_choices)					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.prepare_config_and_inputs()
      (
          (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), 
      ) =   config_and_inputs
      _SCREAMING_SNAKE_CASE =   {"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     ):


   """simple docstring"""

   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 							lowerCAmelCase_    (					self      :			Any					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   RemBertModelTester(self					)
      _SCREAMING_SNAKE_CASE =   ConfigTester(self						,   config_class=__lowerCamelCase						,   hidden_size=3_7					)



   def 							lowerCAmelCase_    (					self      :			int					):

      """simple docstring"""
      self.config_tester.run_common_tests()



   def 							lowerCAmelCase_    (					self      :			Dict					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Optional[Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      for type in ["absolute", "relative_key", "relative_key_query"]:
         _SCREAMING_SNAKE_CASE =   type
         self.model_tester.create_and_check_model(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Dict					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_multiple_choice(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			List[Any]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_decoder_model_past_large_inputs(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Dict					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Tuple					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Optional[int]					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Any					):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE =   self.model_tester.prepare_config_and_inputs_for_decoder()
      self.model_tester.create_and_check_model_as_decoder(*__lowerCamelCase					)



   def 							lowerCAmelCase_    (					self      :			Tuple					):

      """simple docstring"""
      # This regression test was failing with PyTorch < 1.3
      (
          (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), (
          _SCREAMING_SNAKE_CASE
      ), 
      ) =   self.model_tester.prepare_config_and_inputs_for_decoder()

      _SCREAMING_SNAKE_CASE =   None

      self.model_tester.create_and_check_model_as_decoder(
          __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   __lowerCamelCase						,   )



   @slow
   def 							lowerCAmelCase_    (					self      :			Optional[Any]					):

      """simple docstring"""
      for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _SCREAMING_SNAKE_CASE =   RemBertModel.from_pretrained(__lowerCamelCase					)
         self.assertIsNotNone(__lowerCamelCase					)







@require_torch
class 	lowercase_					(				unittest.TestCase     ):


   """simple docstring"""

   @slow
   def 							lowerCAmelCase_    (					self      :			List[Any]					):

      """simple docstring"""
      # Test exact values at the last hidden layer
      _SCREAMING_SNAKE_CASE =   RemBertModel.from_pretrained("google/rembert"					)
      _SCREAMING_SNAKE_CASE =   torch.tensor([[3_1_2, 5_6_4_9_8, 3_1_3, 2_1_2_5, 3_1_3]]					)
      _SCREAMING_SNAKE_CASE =   torch.tensor([[0, 0, 0, 1, 1]]					)
      with torch.no_grad():
         _SCREAMING_SNAKE_CASE =   model(__lowerCamelCase						,   token_type_ids=__lowerCamelCase						,   output_hidden_states=__lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   1_1_5_2

      _SCREAMING_SNAKE_CASE =   torch.Size((1, 5, hidden_size)					)
      self.assertEqual(output["last_hidden_state"].shape						,   __lowerCamelCase					)

      _SCREAMING_SNAKE_CASE =   torch.tensor(
          [
              [
                  [0.0_7_5_4, -0.2_0_2_2, 0.1_9_0_4],
                  [-0.3_3_5_4, -0.3_6_9_2, -0.4_7_9_1],
                  [-0.2_3_1_4, -0.6_7_2_9, -0.0_7_4_9],
                  [-0.0_3_9_6, -0.3_1_0_5, -0.4_2_3_4],
                  [-0.1_5_7_1, -0.0_5_2_5, 0.5_3_5_3],
              ]
          ]					)

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

