




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  :      Union[str, Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      List[str]=13				,       snake_case__  :      Dict=7				,       snake_case__  :      Any=True				,       snake_case__  :      List[str]=True				,       snake_case__  :      List[Any]=True				,       snake_case__  :      Any=True				,       snake_case__  :      List[str]=99				,       snake_case__  :      int=32				,       snake_case__  :      int=5				,       snake_case__  :      Any=4				,       snake_case__  :      List[str]=37				,       snake_case__  :      Dict="gelu"				,       snake_case__  :      str=0.1				,       snake_case__  :      Tuple=0.1				,       snake_case__  :      Any=5_12				,       snake_case__  :      Any=16				,       snake_case__  :      Tuple=2				,       snake_case__  :      Dict=0.02				,       snake_case__  :      Optional[Any]=3				,       snake_case__  :      List[Any]=4				,       snake_case__  :      int=None				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       parent
								SCREAMING_SNAKE_CASE_							=       batch_size
								SCREAMING_SNAKE_CASE_							=       seq_length
								SCREAMING_SNAKE_CASE_							=       is_training
								SCREAMING_SNAKE_CASE_							=       use_input_mask
								SCREAMING_SNAKE_CASE_							=       use_token_type_ids
								SCREAMING_SNAKE_CASE_							=       use_labels
								SCREAMING_SNAKE_CASE_							=       vocab_size
								SCREAMING_SNAKE_CASE_							=       hidden_size
								SCREAMING_SNAKE_CASE_							=       num_hidden_layers
								SCREAMING_SNAKE_CASE_							=       num_attention_heads
								SCREAMING_SNAKE_CASE_							=       intermediate_size
								SCREAMING_SNAKE_CASE_							=       hidden_act
								SCREAMING_SNAKE_CASE_							=       hidden_dropout_prob
								SCREAMING_SNAKE_CASE_							=       attention_probs_dropout_prob
								SCREAMING_SNAKE_CASE_							=       max_position_embeddings
								SCREAMING_SNAKE_CASE_							=       type_vocab_size
								SCREAMING_SNAKE_CASE_							=       type_sequence_label_size
								SCREAMING_SNAKE_CASE_							=       initializer_range
								SCREAMING_SNAKE_CASE_							=       num_labels
								SCREAMING_SNAKE_CASE_							=       num_choices
								SCREAMING_SNAKE_CASE_							=       scope



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size, self.seq_length]				,       self.vocab_size     )

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

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

								SCREAMING_SNAKE_CASE_							=       None
								SCREAMING_SNAKE_CASE_							=       None
								SCREAMING_SNAKE_CASE_							=       None
								if self.use_labels:
										SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size]				,       self.type_sequence_label_size     )
										SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size, self.seq_length]				,       self.num_labels     )
										SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size]				,       self.num_choices     )
										SCREAMING_SNAKE_CASE_							=       ids_tensor([self.batch_size, self.seq_length]				,       1     )

								SCREAMING_SNAKE_CASE_							=       self.get_config()

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



						def   __a				( self  :      Optional[Any]     ):

								"""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=snake_case__				,       initializer_range=self.initializer_range				,       )



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								(
								    (
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							
								)							=       self.prepare_config_and_inputs()

								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
								SCREAMING_SNAKE_CASE_							=       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  :      Any				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[int]				,       snake_case__  :      str				,       snake_case__  :      Optional[Any]				,       snake_case__  :      List[str]				,       snake_case__  :      List[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      List[str]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraModel(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       token_type_ids=snake_case__     )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__     )
								self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)     )



						def   __a				( self  :      Tuple				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Tuple				,       snake_case__  :      Any				,       snake_case__  :      str				,       snake_case__  :      Tuple				,       snake_case__  :      Tuple				,       snake_case__  :      str				,       snake_case__  :      Dict				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       True
								SCREAMING_SNAKE_CASE_							=       ElectraModel(snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       encoder_hidden_states=snake_case__				,       encoder_attention_mask=snake_case__				,       )
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       encoder_hidden_states=snake_case__				,       )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__     )
								self.parent.assertEqual(result.last_hidden_state.shape				,       (self.batch_size, self.seq_length, self.hidden_size)     )



						def   __a				( self  :      List[str]				,       snake_case__  :      Optional[int]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      List[Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      List[str]				,       snake_case__  :      Any				,       snake_case__  :      Tuple				,       snake_case__  :      List[Any]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraForMaskedLM(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



						def   __a				( self  :      Union[str, Any]				,       snake_case__  :      List[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      int				,       snake_case__  :      str				,       snake_case__  :      List[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      List[str]				,       snake_case__  :      Optional[int]				,       snake_case__  :      Union[str, Any]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraForCausalLM(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.vocab_size)     )



						def   __a				( self  :      str				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[int]				,       snake_case__  :      int				,       snake_case__  :      int				,       snake_case__  :      Dict				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[int]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_labels
								SCREAMING_SNAKE_CASE_							=       ElectraForTokenClassification(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length, self.num_labels)     )



						def   __a				( self  :      Union[str, Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Any				,       snake_case__  :      str				,       snake_case__  :      int				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      str				,       snake_case__  :      Any				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_labels
								SCREAMING_SNAKE_CASE_							=       ElectraForPreTraining(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.seq_length)     )



						def   __a				( self  :      int				,       snake_case__  :      Any				,       snake_case__  :      Tuple				,       snake_case__  :      Optional[int]				,       snake_case__  :      Optional[int]				,       snake_case__  :      Dict				,       snake_case__  :      str				,       snake_case__  :      Any				,       snake_case__  :      Optional[Any]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_labels
								SCREAMING_SNAKE_CASE_							=       ElectraForSequenceClassification(snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__     )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_labels)     )



						def   __a				( self  :      Optional[Any]				,       snake_case__  :      Any				,       snake_case__  :      Any				,       snake_case__  :      Dict				,       snake_case__  :      str				,       snake_case__  :      List[str]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Any				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraForQuestionAnswering(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       start_positions=snake_case__				,       end_positions=snake_case__				,       )
								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  :      str				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Optional[Any]				,       snake_case__  :      Tuple				,       snake_case__  :      Union[str, Any]				,       snake_case__  :      Dict				,       snake_case__  :      Union[str, Any]				,       ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.num_choices
								SCREAMING_SNAKE_CASE_							=       ElectraForMultipleChoice(config=snake_case__     )
								model.to(snake_case__     )
								model.eval()
								SCREAMING_SNAKE_CASE_							=       input_ids.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       token_type_ids.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       input_mask.unsqueeze(1     ).expand(-1				,       self.num_choices				,       -1     ).contiguous()
								SCREAMING_SNAKE_CASE_							=       model(
								    snake_case__				,       attention_mask=snake_case__				,       token_type_ids=snake_case__				,       labels=snake_case__				,       )
								self.parent.assertEqual(result.logits.shape				,       (self.batch_size, self.num_choices)     )






						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.prepare_config_and_inputs()
								(
								    (
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							(
								    SCREAMING_SNAKE_CASE_
								)			,							
								)							=       config_and_inputs
								SCREAMING_SNAKE_CASE_							=       {'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict



@require_torch
class       lowercase_		(SCREAMING_SNAKE_CASE__       ,  SCREAMING_SNAKE_CASE__       ,  unittest.TestCase   ):
						lowerCAmelCase__ 			=(
						    (
						        ElectraModel,
						        ElectraForPreTraining,
						        ElectraForMaskedLM,
						        ElectraForCausalLM,
						        ElectraForMultipleChoice,
						        ElectraForTokenClassification,
						        ElectraForSequenceClassification,
						        ElectraForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__ 			=(
						    {
						        "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__ 			=True



						def   __a				( self  :      Optional[int]				,       snake_case__  :      Tuple				,       snake_case__  :      List[str]				,       snake_case__  :      List[Any]=False     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       super()._prepare_for_class(snake_case__				,       snake_case__				,       return_labels=snake_case__     )

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



						def   __a				( self  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraModelTester(self     )
								SCREAMING_SNAKE_CASE_							=       ConfigTester(self				,       config_class=snake_case__				,       hidden_size=37     )



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								self.config_tester.run_common_tests()



						def   __a				( self  :      Optional[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_model(*snake_case__     )



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_electra_model_as_decoder(*snake_case__     )



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								for type in ["absolute", "relative_key", "relative_key_query"]:
										SCREAMING_SNAKE_CASE_							=       type
										self.model_tester.create_and_check_electra_model(*snake_case__     )



						def   __a				( self  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_masked_lm(*snake_case__     )



						def   __a				( self  :      Optional[int]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_token_classification(*snake_case__     )



						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_pretraining(*snake_case__     )



						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_sequence_classification(*snake_case__     )



						def   __a				( self  :      List[str]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_question_answering(*snake_case__     )



						def   __a				( self  :      List[Any]     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_electra_for_multiple_choice(*snake_case__     )



						@slow
						def   __a				( self  :      Union[str, Any]     ):

								"""simple docstring"""

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






						def   __a				( self  :      Tuple     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       self.model_tester.prepare_config_and_inputs_for_decoder()
								self.model_tester.create_and_check_electra_for_causal_lm(*snake_case__     )



@require_torch
class       lowercase_		(unittest.TestCase   ):



						@slow
						def   __a				( self  :      str     ):

								"""simple docstring"""

								SCREAMING_SNAKE_CASE_							=       ElectraModel.from_pretrained('google/electra-small-discriminator'     )
								SCREAMING_SNAKE_CASE_							=       torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]     )
								SCREAMING_SNAKE_CASE_							=       torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]     )
								SCREAMING_SNAKE_CASE_							=       model(snake_case__				,       attention_mask=snake_case__     )[0]
								SCREAMING_SNAKE_CASE_							=       torch.Size((1, 11, 2_56)     )
								self.assertEqual(output.shape				,       snake_case__     )
								SCREAMING_SNAKE_CASE_							=       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]				,       snake_case__				,       atol=1e-4     )     )





from __future__ import annotations

import sys


def 				_a       (				lowerCAmelCase   )->  int:
		if n < 0:
				raise ValueError('Negative arguments are not supported'   )
		return _fib(lowerCAmelCase   )[0]


def 				_a       (				lowerCAmelCase   )->  tuple[int, int]:
		if n == 0:  # (F(0), F(1))
				return (0, 1)

		# F(2n) = F(n)[2F(n+1) − F(n)]
		# F(2n+1) = F(n+1)^2+F(n)^2
		SCREAMING_SNAKE_CASE_			,							SCREAMING_SNAKE_CASE_							=       _fib(n // 2   )
		SCREAMING_SNAKE_CASE_							=       a * (b * 2 - a)
		SCREAMING_SNAKE_CASE_							=       a * a + b * b
		return (d, c + d) if n % 2 else (c, d)


if __name__ == "__main__":
						SCREAMING_SNAKE_CASE:    Optional[int]											=   int(sys.argv[1])
						print(f"""fibonacci({n}) is {fibonacci(n)}""")