


'''simple docstring'''







import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
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 (
      MODEL_FOR_PRETRAINING_MAPPING,
      ElectraForCausalLM,
      ElectraForMaskedLM,
      ElectraForMultipleChoice,
      ElectraForPreTraining,
      ElectraForQuestionAnswering,
      ElectraForSequenceClassification,
      ElectraForTokenClassification,
      ElectraModel,
  )
  from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST
class    lowercase_	:


    def __init__(	self    ,   a    ,   a=13    ,   a=7    ,   a=True    ,   a=True    ,   a=True    ,   a=True    ,   a=99    ,   a=32    ,   a=5    ,   a=4    ,   a=37    ,   a="gelu"    ,   a=0.1    ,   a=0.1    ,   a=5_12    ,   a=16    ,   a=2    ,   a=0.02    ,   a=3    ,   a=4    ,   a=None    ,   ):
          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   __a				(	self       ):
          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__      =							ids_tensor([self.batch_size, self.seq_length]    ,   1       )

          UpperCamelCase__      =							self.get_config()

          return (
              config,
              input_ids,
              token_type_ids,
              input_mask,
              sequence_labels,
              token_labels,
              choice_labels,
              fake_token_labels,
          )


    def   __a				(	self       ):
          return ElectraConfig(
              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=_a    ,   initializer_range=self.initializer_range    ,   )


    def   __a				(	self       ):
          (
              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   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							ElectraModel(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a       )
          UpperCamelCase__      =							model(_a    ,   token_type_ids=_a       )
          UpperCamelCase__      =							model(_a       )
          self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							True
          UpperCamelCase__      =							ElectraModel(_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(
              _a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   encoder_hidden_states=_a    ,   encoder_attention_mask=_a    ,   )
          UpperCamelCase__      =							model(
              _a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   encoder_hidden_states=_a    ,   )
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a       )
          self.parent.assertEqual(result.last_hidden_state.shape    ,   (self.batch_size, self.seq_length, self.hidden_size)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							ElectraForMaskedLM(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							ElectraForCausalLM(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.vocab_size)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							self.num_labels
          UpperCamelCase__      =							ElectraForTokenClassification(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length, self.num_labels)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							self.num_labels
          UpperCamelCase__      =							ElectraForPreTraining(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.seq_length)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							self.num_labels
          UpperCamelCase__      =							ElectraForSequenceClassification(_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a       )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_labels)       )


    def   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							ElectraForQuestionAnswering(config=_a       )
          model.to(_a       )
          model.eval()
          UpperCamelCase__      =							model(
              _a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   start_positions=_a    ,   end_positions=_a    ,   )
          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   __a				(	self    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   a    ,   ):
          UpperCamelCase__      =							self.num_choices
          UpperCamelCase__      =							ElectraForMultipleChoice(config=_a       )
          model.to(_a       )
          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(
              _a    ,   attention_mask=_a    ,   token_type_ids=_a    ,   labels=_a    ,   )
          self.parent.assertEqual(result.logits.shape    ,   (self.batch_size, self.num_choices)       )


    def   __a				(	self       ):
          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    lowercase_	(       _snake_case    ,		_snake_case    ,		unittest.TestCase  ):
    __UpperCAmelCase       =      (
        (
            ElectraModel,
            ElectraForPreTraining,
            ElectraForMaskedLM,
            ElectraForCausalLM,
            ElectraForMultipleChoice,
            ElectraForTokenClassification,
            ElectraForSequenceClassification,
            ElectraForQuestionAnswering,
        )
        if is_torch_available()
        else ()
    )
    __UpperCAmelCase       =      (
        {
            '''feature-extraction''': ElectraModel,
            '''fill-mask''': ElectraForMaskedLM,
            '''question-answering''': ElectraForQuestionAnswering,
            '''text-classification''': ElectraForSequenceClassification,
            '''text-generation''': ElectraForCausalLM,
            '''token-classification''': ElectraForTokenClassification,
            '''zero-shot''': ElectraForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )
    __UpperCAmelCase       =      True


    def   __a				(	self    ,   a    ,   a    ,   a=False       ):
          UpperCamelCase__      =							super()._prepare_for_class(_a    ,   _a    ,   return_labels=_a       )

          if return_labels:
                if model_class in get_values(_a       ):
                      UpperCamelCase__      =							torch.zeros(
                          (self.model_tester.batch_size, self.model_tester.seq_length)    ,   dtype=torch.long    ,   device=_a       )
          return inputs_dict


    def   __a				(	self       ):
          UpperCamelCase__      =							ElectraModelTester(self       )
          UpperCamelCase__      =							ConfigTester(self    ,   config_class=_a    ,   hidden_size=37       )


    def   __a				(	self       ):
          self.config_tester.run_common_tests()


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_model(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_electra_model_as_decoder(*_a       )


    def   __a				(	self       ):
          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_electra_model(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_masked_lm(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_token_classification(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_pretraining(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_sequence_classification(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_question_answering(*_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_electra_for_multiple_choice(*_a       )


    @slow
    def   __a				(	self       ):
          for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase__      =							ElectraModel.from_pretrained(_a       )
                self.assertIsNotNone(_a       )


    def   __a				(	self       ):
          UpperCamelCase__      =							self.model_tester.prepare_config_and_inputs_for_decoder()
          self.model_tester.create_and_check_electra_for_causal_lm(*_a       )

@require_torch
class    lowercase_	(       unittest.TestCase  ):


    @slow
    def   __a				(	self       ):
          UpperCamelCase__      =							ElectraModel.from_pretrained("google/electra-small-discriminator"       )
          UpperCamelCase__      =							torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]       )
          UpperCamelCase__      =							torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]       )
          UpperCamelCase__      =							model(_a    ,   attention_mask=_a       )[0]
          UpperCamelCase__      =							torch.Size((1, 11, 2_56)       )
          self.assertEqual(output.shape    ,   _a       )
          UpperCamelCase__      =							torch.tensor(
              [[[0.4471, 0.6821, -0.3265], [0.4627, 0.5255, -0.3668], [0.4532, 0.3313, -0.4344]]]       )

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






'''simple docstring'''




def _UpperCamelCase (							SCREAMING_SNAKE_CASE_				):
     return " ".join([word[::-1] for word in input_str.split()]				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()




