


'''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       )       )



"""simple docstring"""







import inspect
import json
import os
import tempfile
import unittest

from transformers.models.speech_to_text_a import SpeechaTextaTokenizer
from transformers.models.speech_to_text_a.tokenization_speech_to_text_a import VOCAB_FILES_NAMES

from ...test_tokenization_common import TokenizerTesterMixin
class 				lowerCamelCase							(      __SCREAMING_SNAKE_CASE					,       unittest.TestCase			):


							"""simple docstring"""
							SCREAMING_SNAKE_CASE              =   SpeechaTextaTokenizer
							SCREAMING_SNAKE_CASE              =   False






							def        lowerCAmelCase  (    self			:  Dict					):
													super().setUp()

													UpperCAmelCase__												=     '''<s> <pad> </s> <unk> here@@ a couple of@@ words for the he@@ re@@ vocab'''.split(''' '''					)
													UpperCAmelCase__												=     ['''he re</w> 123''', '''here a 1456''']
													UpperCAmelCase__												=     dict(zip(lowerCamelCase_		,			range(len(lowerCamelCase_					)					)					)					)

													UpperCAmelCase__												=     {'''pad_token''': '''<pad>''', '''unk_token''': '''<unk>''', '''bos_token''': '''<s>''', '''eos_token''': '''</s>'''}

													UpperCAmelCase__												=     tempfile.mkdtemp()
													UpperCAmelCase__												=     os.path.join(self.tmpdirname		,			VOCAB_FILES_NAMES['''vocab_file''']					)
													UpperCAmelCase__												=     os.path.join(self.tmpdirname		,			VOCAB_FILES_NAMES['''merges_file''']					)

													with open(self.vocab_file		,			'''w'''		,			encoding='''utf-8'''					) as fp:
																			fp.write(json.dumps(lowerCamelCase_					) + '''\n'''					)

													with open(self.merges_file		,			'''w'''					) as fp:
																			fp.write('''\n'''.join(lowerCamelCase_					)					)






							def        lowerCAmelCase  (    self			:  Union[str, Any]					):
													UpperCAmelCase__												=     list(self.get_tokenizer().get_vocab().keys()					)

													self.assertEqual(vocab_keys[0]		,			'''<s>'''					)
													self.assertEqual(vocab_keys[1]		,			'''<pad>'''					)
													self.assertEqual(vocab_keys[-1]		,			'''vocab'''					)
													self.assertEqual(len(lowerCamelCase_					)		,			14					)






							def        lowerCAmelCase  (    self			:  Optional[Any]					):
													self.assertEqual(self.get_tokenizer().vocab_size		,			14					)






							def        lowerCAmelCase  (    self			:  Any					):
													UpperCAmelCase__												=     SpeechaTextaTokenizer.from_pretrained(self.tmpdirname					)

													# make sure @@ is correctly concatenated
													UpperCAmelCase__												=     [4, 6, 8, 7, 10]  # ["here@@", "couple", "words", "of@@", "the"]
													UpperCAmelCase__												=     tokenizer.decode(lowerCamelCase_					)

													self.assertTrue(output_string == '''herecouple words ofthe'''					)






							def        lowerCAmelCase  (    self			:  int					):
													UpperCAmelCase__												=     SpeechaTextaTokenizer.from_pretrained(self.tmpdirname					)

													with tempfile.TemporaryDirectory() as tmp_dirname:
																			tokenizer.save_pretrained(lowerCamelCase_					)
																			os.remove(os.path.join(lowerCamelCase_		,			'''merges.txt'''					)					)

																			# load tokenizer without merges file should not throw an error
																			UpperCAmelCase__												=     SpeechaTextaTokenizer.from_pretrained(lowerCamelCase_					)

													with tempfile.TemporaryDirectory() as tmp_dirname:
																			# save tokenizer and load again
																			tokenizer.save_pretrained(lowerCamelCase_					)
																			UpperCAmelCase__												=     SpeechaTextaTokenizer.from_pretrained(lowerCamelCase_					)

													self.assertIsNotNone(lowerCamelCase_					)






							def        lowerCAmelCase  (    self			:  int					):
													if not self.test_slow_tokenizer:
																			return

													UpperCAmelCase__												=     inspect.signature(self.tokenizer_class.__init__					)
													UpperCAmelCase__												=     self.get_tokenizer()

													for parameter_name, parameter in signature.parameters.items():
																			if parameter.default != inspect.Parameter.empty and parameter_name != "merges_file":
																									self.assertIn(lowerCamelCase_		,			tokenizer.init_kwargs					)