

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    A__:
						"""simple docstring"""






						def __init__(  self       ,     _lowercase       ,     _lowercase=13       ,     _lowercase=7       ,     _lowercase=True       ,     _lowercase=True       ,     _lowercase=True       ,     _lowercase=True       ,     _lowercase=99       ,     _lowercase=32       ,     _lowercase=5       ,     _lowercase=4       ,     _lowercase=37       ,     _lowercase="gelu"       ,     _lowercase=0.1       ,     _lowercase=0.1       ,     _lowercase=512       ,     _lowercase=16       ,     _lowercase=2       ,     _lowercase=0.0_2       ,     _lowercase=3       ,     _lowercase=4       ,     _lowercase=None       ,     )      ->				str:
									a_		:		Dict				    =				parent
									a_		:		Tuple				    =				batch_size
									a_		:		Tuple				    =				seq_length
									a_		:		Union[str, Any]				    =				is_training
									a_		:		int				    =				use_input_mask
									a_		:		Optional[int]				    =				use_token_type_ids
									a_		:		List[Any]				    =				use_labels
									a_		:		Optional[int]				    =				vocab_size
									a_		:		int				    =				hidden_size
									a_		:		List[str]				    =				num_hidden_layers
									a_		:		List[Any]				    =				num_attention_heads
									a_		:		Optional[Any]				    =				intermediate_size
									a_		:		Any				    =				hidden_act
									a_		:		Any				    =				hidden_dropout_prob
									a_		:		List[Any]				    =				attention_probs_dropout_prob
									a_		:		str				    =				max_position_embeddings
									a_		:		Optional[Any]				    =				type_vocab_size
									a_		:		str				    =				type_sequence_label_size
									a_		:		str				    =				initializer_range
									a_		:		Dict				    =				num_labels
									a_		:		Any				    =				num_choices
									a_		:		Optional[Any]				    =				scope





						def 	UpperCamelCase__			(  self  )      ->				Optional[int]:
									a_		:		List[str]				    =				ids_tensor([self.batch_size, self.seq_length]       ,     self.vocab_size  )

									a_		:		List[Any]				    =				None
									if self.use_input_mask:
												a_		:		str				    =				random_attention_mask([self.batch_size, self.seq_length]  )

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

									a_		:		Union[str, Any]				    =				None
									a_		:		Dict				    =				None
									a_		:		Union[str, Any]				    =				None
									if self.use_labels:
												a_		:		Dict				    =				ids_tensor([self.batch_size]       ,     self.type_sequence_label_size  )
												a_		:		Optional[Any]				    =				ids_tensor([self.batch_size, self.seq_length]       ,     self.num_labels  )
												a_		:		int				    =				ids_tensor([self.batch_size]       ,     self.num_choices  )
												a_		:		Dict				    =				ids_tensor([self.batch_size, self.seq_length]       ,     1  )

									a_		:		List[Any]				    =				self.get_config()

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





						def 	UpperCamelCase__			(  self  )      ->				str:
									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=_lowercase       ,     initializer_range=self.initializer_range       ,     )





						def 	UpperCamelCase__			(  self  )      ->				Optional[Any]:
									(
									    (
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			
									)		:		Any				    =				self.prepare_config_and_inputs()

									a_		:		Any				    =				True
									a_		:		str				    =				floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
									a_		:		Optional[Any]				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				Dict:
									a_		:		Optional[int]				    =				ElectraModel(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Tuple				    =				model(_lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase  )
									a_		:		str				    =				model(_lowercase       ,     token_type_ids=_lowercase  )
									a_		:		Tuple				    =				model(_lowercase  )
									self.parent.assertEqual(result.last_hidden_state.shape       ,     (self.batch_size, self.seq_length, self.hidden_size)  )





						def 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				Tuple:
									a_		:		List[Any]				    =				True
									a_		:		List[str]				    =				ElectraModel(_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Optional[int]				    =				model(
									    _lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase       ,     encoder_hidden_states=_lowercase       ,     encoder_attention_mask=_lowercase       ,     )
									a_		:		Optional[Any]				    =				model(
									    _lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase       ,     encoder_hidden_states=_lowercase       ,     )
									a_		:		str				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				Union[str, Any]:
									a_		:		Optional[int]				    =				ElectraForMaskedLM(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		List[str]				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				List[Any]:
									a_		:		Tuple				    =				ElectraForCausalLM(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Dict				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				List[Any]:
									a_		:		List[str]				    =				self.num_labels
									a_		:		Tuple				    =				ElectraForTokenClassification(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		List[Any]				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				Dict:
									a_		:		List[str]				    =				self.num_labels
									a_		:		Optional[int]				    =				ElectraForPreTraining(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Optional[Any]				    =				model(_lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase       ,     labels=_lowercase  )
									self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.seq_length)  )





						def 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				List[str]:
									a_		:		Optional[int]				    =				self.num_labels
									a_		:		Union[str, Any]				    =				ElectraForSequenceClassification(_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Tuple				    =				model(_lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase       ,     labels=_lowercase  )
									self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.num_labels)  )





						def 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				List[Any]:
									a_		:		Any				    =				ElectraForQuestionAnswering(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Any				    =				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 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     _lowercase       ,     )      ->				List[Any]:
									a_		:		Any				    =				self.num_choices
									a_		:		List[str]				    =				ElectraForMultipleChoice(config=_lowercase  )
									model.to(_lowercase  )
									model.eval()
									a_		:		Union[str, Any]				    =				input_ids.unsqueeze(1  ).expand(-1       ,     self.num_choices       ,     -1  ).contiguous()
									a_		:		Tuple				    =				token_type_ids.unsqueeze(1  ).expand(-1       ,     self.num_choices       ,     -1  ).contiguous()
									a_		:		Any				    =				input_mask.unsqueeze(1  ).expand(-1       ,     self.num_choices       ,     -1  ).contiguous()
									a_		:		Any				    =				model(
									    _lowercase       ,     attention_mask=_lowercase       ,     token_type_ids=_lowercase       ,     labels=_lowercase       ,     )
									self.parent.assertEqual(result.logits.shape       ,     (self.batch_size, self.num_choices)  )





						def 	UpperCamelCase__			(  self  )      ->				int:
									a_		:		Dict				    =				self.prepare_config_and_inputs()
									(
									    (
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			(
									    a_
									)    ,			
									)		:		Any				    =				config_and_inputs
									a_		:		int				    =				{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": input_mask}
									return config, inputs_dict







@require_torch
class    A__(a_,       a_,       unittest.TestCase    ):
						"""simple docstring"""






						_A  :							Optional[int]   			=	(
						    (
						        ElectraModel,
						        ElectraForPreTraining,
						        ElectraForMaskedLM,
						        ElectraForCausalLM,
						        ElectraForMultipleChoice,
						        ElectraForTokenClassification,
						        ElectraForSequenceClassification,
						        ElectraForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						_A  :							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 {}
						)
						_A  :							Union[str, Any]   			=	True





						def 	UpperCamelCase__			(  self       ,     _lowercase       ,     _lowercase       ,     _lowercase=False  )      ->				List[Any]:
									a_		:		Optional[int]				    =				super()._prepare_for_class(_lowercase       ,     _lowercase       ,     return_labels=_lowercase  )

									if return_labels:
												if model_class in get_values(_lowercase  ):
															a_		:		List[Any]				    =				torch.zeros(
															    (self.model_tester.batch_size, self.model_tester.seq_length)       ,     dtype=torch.long       ,     device=_lowercase  )
									return inputs_dict





						def 	UpperCamelCase__			(  self  )      ->				List[Any]:
									a_		:		int				    =				ElectraModelTester(self  )
									a_		:		Union[str, Any]				    =				ConfigTester(self       ,     config_class=_lowercase       ,     hidden_size=37  )





						def 	UpperCamelCase__			(  self  )      ->				Tuple:
									self.config_tester.run_common_tests()





						def 	UpperCamelCase__			(  self  )      ->				Optional[int]:
									a_		:		Optional[int]				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_model(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				str:
									a_		:		Dict				    =				self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_electra_model_as_decoder(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				Dict:
									a_		:		Dict				    =				self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
												a_		:		Dict				    =				type
												self.model_tester.create_and_check_electra_model(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				Optional[int]:
									a_		:		str				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_masked_lm(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				Dict:
									a_		:		Optional[int]				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_token_classification(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				str:
									a_		:		int				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_pretraining(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				List[str]:
									a_		:		Dict				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_sequence_classification(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				List[str]:
									a_		:		int				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_question_answering(*_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				Dict:
									a_		:		Optional[Any]				    =				self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_multiple_choice(*_lowercase  )





						@slow
						def 	UpperCamelCase__			(  self  )      ->				str:
									for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												a_		:		List[str]				    =				ElectraModel.from_pretrained(_lowercase  )
												self.assertIsNotNone(_lowercase  )





						def 	UpperCamelCase__			(  self  )      ->				Any:
									a_		:		List[str]				    =				self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_electra_for_causal_lm(*_lowercase  )







@require_torch
class    A__(unittest.TestCase    ):
						"""simple docstring"""






						@slow
						def 	UpperCamelCase__			(  self  )      ->				List[Any]:
									a_		:		List[str]				    =				ElectraModel.from_pretrained("""google/electra-small-discriminator"""  )
									a_		:		Union[str, Any]				    =				torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]  )
									a_		:		List[str]				    =				torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
									a_		:		Any				    =				model(_lowercase       ,     attention_mask=_lowercase  )[0]
									a_		:		Dict				    =				torch.Size((1, 11, 256)  )
									self.assertEqual(output.shape       ,     _lowercase  )
									a_		:		Tuple				    =				torch.tensor(
									    [[[0.4_4_7_1, 0.6_8_2_1, -0.3_2_6_5], [0.4_6_2_7, 0.5_2_5_5, -0.3_6_6_8], [0.4_5_3_2, 0.3_3_1_3, -0.4_3_4_4]]]  )

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





from collections import namedtuple

__snake_case							:     Optional[Any] 						=	namedtuple("""from_to""", """from_ to""")

__snake_case							:     Tuple 						=	{
    """millimeter""": """mm""",
    """centimeter""": """cm""",
    """meter""": """m""",
    """kilometer""": """km""",
    """inch""": """in""",
    """inche""": """in""",  # Trailing 's' has been stripped off
    """feet""": """ft""",
    """foot""": """ft""",
    """yard""": """yd""",
    """mile""": """mi""",
}

__snake_case							:     Optional[int] 						=	{
    """mm""": from_to(0.001, 10_00),
    """cm""": from_to(0.01, 1_00),
    """m""": from_to(1, 1),
    """km""": from_to(10_00, 0.001),
    """in""": from_to(0.0254, 39.3701),
    """ft""": from_to(0.3048, 3.2_8084),
    """yd""": from_to(0.9144, 1.0_9361),
    """mi""": from_to(1609.34, 0.0_0062_1371),
}


def 			_UpperCAmelCase							(		a__       ,					a__       ,					a__):

			'''simple docstring'''



			a_		:		List[str]				    =				from_type.lower().rstrip("""s""")
			a_		:		Union[str, Any]				    =				TYPE_CONVERSION.get(a__       ,					a__)
			a_		:		Optional[int]				    =				to_type.lower().rstrip("""s""")
			a_		:		Optional[int]				    =				TYPE_CONVERSION.get(a__       ,					a__)
			if new_from not in METRIC_CONVERSION:
						a_		:		Any				    =				(
						    f'''Invalid \'from_type\' value: {from_type!r}.\n'''
						    f'''Conversion abbreviations are: {", ".join(a__)}'''
						)
						raise ValueError(a__)
			if new_to not in METRIC_CONVERSION:
						a_		:		Union[str, Any]				    =				(
						    f'''Invalid \'to_type\' value: {to_type!r}.\n'''
						    f'''Conversion abbreviations are: {", ".join(a__)}'''
						)
						raise ValueError(a__)
			return value * METRIC_CONVERSION[new_from].from_ * METRIC_CONVERSION[new_to].to


if __name__ == "__main__":
	import doctest

	doctest.testmod()


