


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

 def __init__(			self			:						List[Any],       a_			:						int,       a_			:						Dict=13,       a_			:						List[str]=7,       a_			:						List[str]=True,       a_			:						List[Any]=True,       a_			:						List[str]=True,       a_			:						str=True,       a_			:						str=99,       a_			:						Optional[int]=32,       a_			:						Any=5,       a_			:						Dict=4,       a_			:						Union[str, Any]=37,       a_			:						Optional[Any]="gelu",       a_			:						Dict=0.1,       a_			:						Optional[int]=0.1,       a_			:						Union[str, Any]=512,       a_			:						str=16,       a_			:						Optional[int]=2,       a_			:						List[Any]=0.02,       a_			:						Optional[Any]=3,       a_			:						Union[str, Any]=4,       a_			:						str=None,       ):





    """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 		lowercase_    (			self			:						Union[str, Any]       ):





    """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__			    =    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 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Optional[int]       ):





    """simple docstring"""



    (
        (
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        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 		lowercase_    (			self			:						List[str],       a_			:						Optional[int],       a_			:						Union[str, Any],       a_			:						List[str],       a_			:						Dict,       a_			:						Dict,       a_			:						List[Any],       a_			:						List[Any],       a_			:						List[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Tuple,       a_			:						Optional[int],       a_			:						Union[str, Any],       a_			:						Union[str, Any],       a_			:						int,       a_			:						Optional[int],       a_			:						Tuple,       a_			:						Tuple,       a_			:						Optional[int],       a_			:						List[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Any,       a_			:						List[str],       a_			:						Optional[int],       a_			:						Tuple,       a_			:						List[str],       a_			:						Union[str, Any],       a_			:						List[str],       a_			:						Optional[int],       a_			:						Optional[int],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Any,       a_			:						Dict,       a_			:						Optional[Any],       a_			:						List[str],       a_			:						str,       a_			:						List[str],       a_			:						Dict,       a_			:						Dict,       a_			:						Union[str, Any],       a_			:						Optional[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Tuple,       a_			:						Tuple,       a_			:						Tuple,       a_			:						Optional[Any],       a_			:						Any,       a_			:						Optional[Any],       a_			:						Dict,       a_			:						Optional[Any],       a_			:						Optional[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Any,       a_			:						List[str],       a_			:						Optional[Any],       a_			:						Tuple,       a_			:						int,       a_			:						List[Any],       a_			:						str,       a_			:						List[str],       a_			:						List[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						List[Any],       a_			:						Optional[Any],       a_			:						Union[str, Any],       a_			:						Dict,       a_			:						int,       a_			:						List[str],       a_			:						str,       a_			:						List[str],       a_			:						Union[str, Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						Tuple,       a_			:						str,       a_			:						str,       a_			:						List[str],       a_			:						Optional[int],       a_			:						Any,       a_			:						Optional[int],       a_			:						List[str],       a_			:						List[Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						List[Any],       a_			:						List[Any],       a_			:						Any,       a_			:						List[Any],       a_			:						List[str],       a_			:						Dict,       a_			:						Dict,       a_			:						List[str],       a_			:						Union[str, Any],       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						int       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.prepare_config_and_inputs()
    (
        (
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        UpperCamelCase__
    )    ,		(
        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 			UpperCAmelCase			(							SCREAMING_SNAKE_CASE__		,      SCREAMING_SNAKE_CASE__		,      unittest.TestCase):
 _lowerCamelCase			:       Any            =       (
     (
         ElectraModel,
         ElectraForPreTraining,
         ElectraForMaskedLM,
         ElectraForCausalLM,
         ElectraForMultipleChoice,
         ElectraForTokenClassification,
         ElectraForSequenceClassification,
         ElectraForQuestionAnswering,
     )
     if is_torch_available()
     else ()
 )
 _lowerCamelCase			:       List[Any]            =       (
     {
         '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 {}
 )
 _lowerCamelCase			:       Union[str, Any]            =       True

 def 		lowercase_    (			self			:						Union[str, Any],       a_			:						List[Any],       a_			:						List[Any],       a_			:						List[Any]=False       ):





    """simple docstring"""



    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 		lowercase_    (			self			:						str       ):





    """simple docstring"""



    UpperCamelCase__			    =    ElectraModelTester(self       )
    UpperCamelCase__			    =    ConfigTester(self,       config_class=a_,       hidden_size=37       )

 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    self.config_tester.run_common_tests()

 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_model(*a_       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_decoder()
    self.model_tester.create_and_check_electra_model_as_decoder(*a_       )

 def 		lowercase_    (			self			:						List[Any]       ):





    """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_electra_model(*a_       )

 def 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_masked_lm(*a_       )

 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_token_classification(*a_       )

 def 		lowercase_    (			self			:						List[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_pretraining(*a_       )

 def 		lowercase_    (			self			:						Optional[Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_sequence_classification(*a_       )

 def 		lowercase_    (			self			:						Union[str, Any]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_question_answering(*a_       )

 def 		lowercase_    (			self			:						List[str]       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_electra_for_multiple_choice(*a_       )

 @slow
 def 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



    for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCamelCase__			    =    ElectraModel.from_pretrained(a_       )
       self.assertIsNotNone(a_       )

 def 		lowercase_    (			self			:						Dict       ):





    """simple docstring"""



    UpperCamelCase__			    =    self.model_tester.prepare_config_and_inputs_for_decoder()
    self.model_tester.create_and_check_electra_for_causal_lm(*a_       )







@require_torch
class 			UpperCAmelCase			(							unittest.TestCase):

 @slow
 def 		lowercase_    (			self			:						Tuple       ):





    """simple docstring"""



    UpperCamelCase__			    =    ElectraModel.from_pretrained("google/electra-small-discriminator"       )
    UpperCamelCase__			    =    torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 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, 256)       )
    self.assertEqual(output.shape,       a_       )
    UpperCamelCase__			    =    torch.tensor(
        [[[0.4_471, 0.6_821, -0.3_265], [0.4_627, 0.5_255, -0.3_668], [0.4_532, 0.3_313, -0.4_344]]]       )

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

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


_UpperCAmelCase   :					int    =			{"configuration_levit": ["LEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP", "LevitConfig", "LevitOnnxConfig"]}

try:
					if not is_vision_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase   :					Optional[Any]    =			["LevitFeatureExtractor"]
					_UpperCAmelCase   :					Optional[int]    =			["LevitImageProcessor"]

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_UpperCAmelCase   :					Optional[int]    =			[
					    "LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "LevitForImageClassification",
					    "LevitForImageClassificationWithTeacher",
					    "LevitModel",
					    "LevitPreTrainedModel",
					]


if TYPE_CHECKING:
					from .configuration_levit import LEVIT_PRETRAINED_CONFIG_ARCHIVE_MAP, LevitConfig, LevitOnnxConfig

					try:
										if not is_vision_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .feature_extraction_levit import LevitFeatureExtractor
										from .image_processing_levit import LevitImageProcessor

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_levit import (
										    LEVIT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    LevitForImageClassification,
										    LevitForImageClassificationWithTeacher,
										    LevitModel,
										    LevitPreTrainedModel,
										)
else:
					import sys

					_UpperCAmelCase   :					Optional[Any]    =			_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
