
'''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=1_3     ,				A=7     ,				A=True     ,				A=True     ,				A=True     ,				A=True     ,				A=9_9     ,				A=3_2     ,				A=5     ,				A=4     ,				A=3_7     ,				A="gelu"     ,				A=0.1     ,				A=0.1     ,				A=5_1_2     ,				A=1_6     ,				A=2     ,				A=0.02     ,				A=3     ,				A=4     ,				A=None     ,				):
								lowerCamelCase_   : Tuple       =						parent
								lowerCamelCase_   : Any       =						batch_size
								lowerCamelCase_   : List[str]       =						seq_length
								lowerCamelCase_   : Union[str, Any]       =						is_training
								lowerCamelCase_   : List[Any]       =						use_input_mask
								lowerCamelCase_   : List[str]       =						use_token_type_ids
								lowerCamelCase_   : Optional[int]       =						use_labels
								lowerCamelCase_   : List[Any]       =						vocab_size
								lowerCamelCase_   : Dict       =						hidden_size
								lowerCamelCase_   : str       =						num_hidden_layers
								lowerCamelCase_   : List[str]       =						num_attention_heads
								lowerCamelCase_   : Dict       =						intermediate_size
								lowerCamelCase_   : Union[str, Any]       =						hidden_act
								lowerCamelCase_   : Optional[int]       =						hidden_dropout_prob
								lowerCamelCase_   : Tuple       =						attention_probs_dropout_prob
								lowerCamelCase_   : Optional[int]       =						max_position_embeddings
								lowerCamelCase_   : Union[str, Any]       =						type_vocab_size
								lowerCamelCase_   : Optional[Any]       =						type_sequence_label_size
								lowerCamelCase_   : Dict       =						initializer_range
								lowerCamelCase_   : Dict       =						num_labels
								lowerCamelCase_   : List[Any]       =						num_choices
								lowerCamelCase_   : Union[str, Any]       =						scope

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : str       =						ids_tensor([self.batch_size, self.seq_length]     ,				self.vocab_size )

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

								lowerCamelCase_   : List[Any]       =						None
								if self.use_token_type_ids:
													lowerCamelCase_   : Optional[Any]       =						ids_tensor([self.batch_size, self.seq_length]     ,				self.type_vocab_size )

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

								lowerCamelCase_   : Tuple       =						self.get_config()

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

			def     UpperCAmelCase__	(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     UpperCAmelCase__	(self ):
								(
								    lowerCamelCase_ 
								)   : Optional[Any]       =						self.prepare_config_and_inputs()

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

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

			def     UpperCAmelCase__	(self     ,				A     ,				A     ,				A     ,				A     ,				A     ,				A     ,				A     ,				A     ,				):
								lowerCamelCase_   : Dict       =						self.num_labels
								lowerCamelCase_   : Any       =						ElectraForSequenceClassification(A )
								model.to(A )
								model.eval()
								lowerCamelCase_   : Optional[Any]       =						model(A     ,				attention_mask=A     ,				token_type_ids=A     ,				labels=A )
								self.parent.assertEqual(result.logits.shape     ,				(self.batch_size, self.num_labels) )

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






			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : List[Any]       =						self.prepare_config_and_inputs()
								(
								    lowerCamelCase_ 
								)   : List[str]       =						config_and_inputs
								lowerCamelCase_   : Optional[Any]       =						{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
								return config, inputs_dict

@require_torch
class 		__lowercase			(					_lowercase ,       _lowercase ,       unittest.TestCase      ):
			lowerCamelCase     :						str		 =     (
			    (
			        ElectraModel,
			        ElectraForPreTraining,
			        ElectraForMaskedLM,
			        ElectraForCausalLM,
			        ElectraForMultipleChoice,
			        ElectraForTokenClassification,
			        ElectraForSequenceClassification,
			        ElectraForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			lowerCamelCase     :						Tuple		 =     (
			    {
			        "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     :						List[Any]		 =     True

			def     UpperCAmelCase__	(self     ,				A     ,				A     ,				A=False ):
								lowerCamelCase_   : Optional[Any]       =						super()._prepare_for_class(A     ,				A     ,				return_labels=A )

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

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Any       =						ElectraModelTester(self )
								lowerCamelCase_   : Optional[int]       =						ConfigTester(self     ,				config_class=A     ,				hidden_size=3_7 )

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

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_model(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : str       =						self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_electra_model_as_decoder(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
													lowerCamelCase_   : List[Any]       =						type
													self.model_tester.create_and_check_electra_model(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : List[Any]       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_masked_lm(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Tuple       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_token_classification(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Optional[int]       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_pretraining(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_sequence_classification(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_question_answering(*A )

			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Tuple       =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_multiple_choice(*A )

			@slow
			def     UpperCAmelCase__	(self ):
								for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCamelCase_   : Union[str, Any]       =						ElectraModel.from_pretrained(A )
													self.assertIsNotNone(A )






			def     UpperCAmelCase__	(self ):
								lowerCamelCase_   : Any       =						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     UpperCAmelCase__	(self ):
								lowerCamelCase_   : int       =						ElectraModel.from_pretrained('''google/electra-small-discriminator''' )
								lowerCamelCase_   : int       =						torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]] )
								lowerCamelCase_   : Tuple       =						torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
								lowerCamelCase_   : Any       =						model(A     ,				attention_mask=A )[0]
								lowerCamelCase_   : Optional[Any]       =						torch.Size((1, 1_1, 2_5_6) )
								self.assertEqual(output.shape     ,				A )
								lowerCamelCase_   : Any       =						torch.tensor(
								    [[[0.44_71, 0.68_21, -0.32_65], [0.46_27, 0.52_55, -0.36_68], [0.45_32, 0.33_13, -0.43_44]]] )

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




'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__lowercase							:				Any					=       {
    '''configuration_camembert''': ['''CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CamembertConfig''', '''CamembertOnnxConfig'''],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				Any					=       ['''CamembertTokenizer''']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				str					=       ['''CamembertTokenizerFast''']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				List[Any]					=       [
					    '''CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''CamembertForCausalLM''',
					    '''CamembertForMaskedLM''',
					    '''CamembertForMultipleChoice''',
					    '''CamembertForQuestionAnswering''',
					    '''CamembertForSequenceClassification''',
					    '''CamembertForTokenClassification''',
					    '''CamembertModel''',
					    '''CamembertPreTrainedModel''',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					__lowercase							:				Any					=       [
					    '''TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TFCamembertForCausalLM''',
					    '''TFCamembertForMaskedLM''',
					    '''TFCamembertForMultipleChoice''',
					    '''TFCamembertForQuestionAnswering''',
					    '''TFCamembertForSequenceClassification''',
					    '''TFCamembertForTokenClassification''',
					    '''TFCamembertModel''',
					    '''TFCamembertPreTrainedModel''',
					]


if TYPE_CHECKING:
					from .configuration_camembert import CAMEMBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, CamembertConfig, CamembertOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_camembert import CamembertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_camembert_fast import CamembertTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_camembert import (
										    CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    CamembertForCausalLM,
										    CamembertForMaskedLM,
										    CamembertForMultipleChoice,
										    CamembertForQuestionAnswering,
										    CamembertForSequenceClassification,
										    CamembertForTokenClassification,
										    CamembertModel,
										    CamembertPreTrainedModel,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_camembert import (
										    TF_CAMEMBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFCamembertForCausalLM,
										    TFCamembertForMaskedLM,
										    TFCamembertForMultipleChoice,
										    TFCamembertForQuestionAnswering,
										    TFCamembertForSequenceClassification,
										    TFCamembertForTokenClassification,
										    TFCamembertModel,
										    TFCamembertPreTrainedModel,
										)

else:
					import sys

					__lowercase							:				Union[str, Any]					=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


