
"""simple docstring"""

from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_			    =  logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_			    =  {
    '''flaubert/flaubert_small_cased''': '''https://huggingface.co/flaubert/flaubert_small_cased/resolve/main/config.json''',
    '''flaubert/flaubert_base_uncased''': '''https://huggingface.co/flaubert/flaubert_base_uncased/resolve/main/config.json''',
    '''flaubert/flaubert_base_cased''': '''https://huggingface.co/flaubert/flaubert_base_cased/resolve/main/config.json''',
    '''flaubert/flaubert_large_cased''': '''https://huggingface.co/flaubert/flaubert_large_cased/resolve/main/config.json''',
}
class    _UpperCAmelCase							(						_lowerCAmelCase							):
      __SCREAMING_SNAKE_CASE      :							str												=		"flaubert"
      __SCREAMING_SNAKE_CASE      :							Dict												=		{
          "hidden_size": "emb_dim",
          "num_attention_heads": "n_heads",
          "num_hidden_layers": "n_layers",
          "n_words": "vocab_size",  # For backward compatibility
      }




      def __init__(							self      ,				lowercase_=False      ,				lowercase_=0.0      ,				lowercase_=3_0_1_4_5      ,				lowercase_=2_0_4_8      ,				lowercase_=1_2      ,				lowercase_=1_6      ,				lowercase_=0.1      ,				lowercase_=0.1      ,				lowercase_=True      ,				lowercase_=False      ,				lowercase_=False      ,				lowercase_=False      ,				lowercase_=1      ,				lowercase_=True      ,				lowercase_=5_1_2      ,				lowercase_=2_0_4_8**-0.5      ,				lowercase_=1E-12      ,				lowercase_=0.0_2      ,				lowercase_=0      ,				lowercase_=1      ,				lowercase_=2      ,				lowercase_=3      ,				lowercase_=5      ,				lowercase_=True      ,				lowercase_="first"      ,				lowercase_=True      ,				lowercase_=None      ,				lowercase_=True      ,				lowercase_=0.1      ,				lowercase_=5      ,				lowercase_=5      ,				lowercase_=0      ,				lowercase_=0      ,				lowercase_=2      ,				lowercase_=0      ,				**lowercase_      ,				)  ->    Union[str, Any]:
          UpperCAmelCase  	=    pre_norm
          UpperCAmelCase  	=    layerdrop
          UpperCAmelCase  	=    vocab_size
          UpperCAmelCase  	=    emb_dim
          UpperCAmelCase  	=    n_layers
          UpperCAmelCase  	=    n_heads
          UpperCAmelCase  	=    dropout
          UpperCAmelCase  	=    attention_dropout
          UpperCAmelCase  	=    gelu_activation
          UpperCAmelCase  	=    sinusoidal_embeddings
          UpperCAmelCase  	=    causal
          UpperCAmelCase  	=    asm
          UpperCAmelCase  	=    n_langs
          UpperCAmelCase  	=    use_lang_emb
          UpperCAmelCase  	=    layer_norm_eps
          UpperCAmelCase  	=    bos_index
          UpperCAmelCase  	=    eos_index
          UpperCAmelCase  	=    pad_index
          UpperCAmelCase  	=    unk_index
          UpperCAmelCase  	=    mask_index
          UpperCAmelCase  	=    is_encoder
          UpperCAmelCase  	=    max_position_embeddings
          UpperCAmelCase  	=    embed_init_std
          UpperCAmelCase  	=    init_std
          UpperCAmelCase  	=    summary_type
          UpperCAmelCase  	=    summary_use_proj
          UpperCAmelCase  	=    summary_activation
          UpperCAmelCase  	=    summary_proj_to_labels
          UpperCAmelCase  	=    summary_first_dropout
          UpperCAmelCase  	=    start_n_top
          UpperCAmelCase  	=    end_n_top
          UpperCAmelCase  	=    mask_token_id
          UpperCAmelCase  	=    lang_id

          if "n_words" in kwargs:
              UpperCAmelCase  	=    kwargs['''n_words''']

          super().__init__(pad_token_id=lowerCAmelCase__      ,				bos_token_id=lowerCAmelCase__      ,				**lowerCAmelCase__							)

class    _UpperCAmelCase							(						_lowerCAmelCase							):




      @property
      def 			a_					(							self							)  ->    Mapping[str, Mapping[int, str]]:



          if self.task == "multiple-choice":
              UpperCAmelCase  	=    {0: '''batch''', 1: '''choice''', 2: '''sequence'''}
          else:
              UpperCAmelCase  	=    {0: '''batch''', 1: '''sequence'''}
          return OrderedDict(
              [
                  ('input_ids', dynamic_axis),
                  ('attention_mask', dynamic_axis),
              ]							)










"""simple docstring"""




import unittest

import numpy as np

from transformers import ElectraConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
						from transformers.models.electra.modeling_flax_electra import (
						    FlaxElectraForCausalLM,
						    FlaxElectraForMaskedLM,
						    FlaxElectraForMultipleChoice,
						    FlaxElectraForPreTraining,
						    FlaxElectraForQuestionAnswering,
						    FlaxElectraForSequenceClassification,
						    FlaxElectraForTokenClassification,
						    FlaxElectraModel,
						)




class  _a						(      unittest.TestCase				):






				def __init__( self		:    str, lowerCAmelCase__		:    Tuple, lowerCAmelCase__		:    List[str]=1_3, lowerCAmelCase__		:    Optional[int]=7, lowerCAmelCase__		:    Optional[Any]=True, lowerCAmelCase__		:    Optional[int]=True, lowerCAmelCase__		:    Any=True, lowerCAmelCase__		:    str=True, lowerCAmelCase__		:    Any=9_9, lowerCAmelCase__		:    Union[str, Any]=2_4, lowerCAmelCase__		:    Optional[Any]=3_2, lowerCAmelCase__		:    Tuple=5, lowerCAmelCase__		:    int=4, lowerCAmelCase__		:    List[Any]=3_7, lowerCAmelCase__		:    Dict="gelu", lowerCAmelCase__		:    Any=0.1, lowerCAmelCase__		:    Any=0.1, lowerCAmelCase__		:    str=5_1_2, lowerCAmelCase__		:    Tuple=1_6, lowerCAmelCase__		:    int=2, lowerCAmelCase__		:    int=0.02, lowerCAmelCase__		:    Optional[int]=4, )	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    parent
										_UpperCamelCase			:					Tuple     =    batch_size
										_UpperCamelCase			:					str     =    seq_length
										_UpperCamelCase			:					Any     =    is_training
										_UpperCamelCase			:					Union[str, Any]     =    use_attention_mask
										_UpperCamelCase			:					List[Any]     =    use_token_type_ids
										_UpperCamelCase			:					str     =    use_labels
										_UpperCamelCase			:					Union[str, Any]     =    vocab_size
										_UpperCamelCase			:					int     =    hidden_size
										_UpperCamelCase			:					Optional[int]     =    embedding_size
										_UpperCamelCase			:					int     =    num_hidden_layers
										_UpperCamelCase			:					int     =    num_attention_heads
										_UpperCamelCase			:					Tuple     =    intermediate_size
										_UpperCamelCase			:					Optional[int]     =    hidden_act
										_UpperCamelCase			:					Any     =    hidden_dropout_prob
										_UpperCamelCase			:					Union[str, Any]     =    attention_probs_dropout_prob
										_UpperCamelCase			:					Any     =    max_position_embeddings
										_UpperCamelCase			:					List[str]     =    type_vocab_size
										_UpperCamelCase			:					Union[str, Any]     =    type_sequence_label_size
										_UpperCamelCase			:					str     =    initializer_range
										_UpperCamelCase			:					Union[str, Any]     =    num_choices






				def 				snake_case	( self		:    Optional[Any]							)	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Optional[Any]     =    ids_tensor([self.batch_size, self.seq_length], self.vocab_size							)

										_UpperCamelCase			:					Dict     =    None
										if self.use_attention_mask:
																_UpperCamelCase			:					Union[str, Any]     =    random_attention_mask([self.batch_size, self.seq_length]							)

										_UpperCamelCase			:					Optional[Any]     =    None
										if self.use_token_type_ids:
																_UpperCamelCase			:					Union[str, Any]     =    ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size							)

										_UpperCamelCase			:					Optional[Any]     =    ElectraConfig(
										    vocab_size=self.vocab_size, hidden_size=self.hidden_size, embedding_size=self.embedding_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, initializer_range=self.initializer_range, )

										return config, input_ids, token_type_ids, attention_mask






				def 				snake_case	( self		:    Any							)	->      Optional[int]:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    self.prepare_config_and_inputs()
										_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase			:					Tuple     =    config_and_inputs
										_UpperCamelCase			:					List[Any]     =    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
										return config, inputs_dict




@require_flax
class  _a						(      _lowerCAmelCase	,				unittest.TestCase				):
				UpperCamelCase								=    True

				UpperCamelCase								=    (
				    (
				        FlaxElectraModel,
				        FlaxElectraForCausalLM,
				        FlaxElectraForMaskedLM,
				        FlaxElectraForPreTraining,
				        FlaxElectraForTokenClassification,
				        FlaxElectraForQuestionAnswering,
				        FlaxElectraForMultipleChoice,
				        FlaxElectraForSequenceClassification,
				    )
				    if is_flax_available()
				    else ()
				)






				def 				snake_case	( self		:    Union[str, Any]							)	->      Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase			:					List[Any]     =    FlaxElectraModelTester(self							)






				@slow
				def 				snake_case	( self		:    Optional[Any]							)	->      str:




										'''simple docstring'''



										for model_class_name in self.all_model_classes:
																if model_class_name == FlaxElectraForMaskedLM:
																						_UpperCamelCase			:					int     =    model_class_name.from_pretrained('''google/electra-small-generator'''							)
																else:
																						_UpperCamelCase			:					Any     =    model_class_name.from_pretrained('''google/electra-small-discriminator'''							)
																_UpperCamelCase			:					List[str]     =    model(np.ones((1, 1)							)							)
																self.assertIsNotNone(lowerCAmelCase__							)



