






"""simple docstring"""




import math
from timeit import timeit





def 						UpperCAmelCase__		(					_UpperCAmelCase ):






  """simple docstring"""





  A_  :	int    						=  0
  A_  :	Tuple    						=  abs(_A )
  while True:
    A_  :	Tuple    						=  n // 10
    digits += 1
    if n == 0:
      break
  return digits





def 						UpperCAmelCase__		(					_UpperCAmelCase ):






  """simple docstring"""





  return 1 if n == 0 else math.floor(math.log(abs(_A )			, 10 ) + 1 )





def 						UpperCAmelCase__		(					_UpperCAmelCase ):






  """simple docstring"""





  return len(str(abs(_A ) ) )





def 						UpperCAmelCase__		(					):






  """simple docstring"""





  from collections.abc import Callable

  def benchmark_a_function(_UpperCAmelCase			, _UpperCAmelCase ) -> None:
    A_  :	Union[str, Any]    						=  f"""{func.__name__}({value})"""
    A_  :	int    						=  timeit(f"""__main__.{call}"""			, setup='import __main__' )
    print(f"""{call}: {func(_A )} -- {timing} seconds""" )

  for value in (262144, 1125899906842624, 1267650600228229401496703205376):
    for func in (num_digits, num_digits_fast, num_digits_faster):
      benchmark_a_function(_A			, _A )
    print()


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   benchmark()






"""simple docstring"""




from collections import OrderedDict
from typing import Mapping

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


lowerCamelCase_					:						List[str]      = logging.get_logger(__name__)

lowerCamelCase_					:						Optional[int]      = {
    'google/electra-small-generator': 'https://huggingface.co/google/electra-small-generator/resolve/main/config.json',
    'google/electra-base-generator': 'https://huggingface.co/google/electra-base-generator/resolve/main/config.json',
    'google/electra-large-generator': 'https://huggingface.co/google/electra-large-generator/resolve/main/config.json',
    'google/electra-small-discriminator': (
        'https://huggingface.co/google/electra-small-discriminator/resolve/main/config.json'
    ),
    'google/electra-base-discriminator': (
        'https://huggingface.co/google/electra-base-discriminator/resolve/main/config.json'
    ),
    'google/electra-large-discriminator': (
        'https://huggingface.co/google/electra-large-discriminator/resolve/main/config.json'
    ),
}

class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''
      lowercase_				:			Tuple        =       """electra"""

      def __init__(					self ,				snake_case_=3_0_5_2_2 ,				snake_case_=1_2_8 ,				snake_case_=2_5_6 ,				snake_case_=1_2 ,				snake_case_=4 ,				snake_case_=1_0_2_4 ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=5_1_2 ,				snake_case_=2 ,				snake_case_=0.02 ,				snake_case_=1E-12 ,				snake_case_="first" ,				snake_case_=True ,				snake_case_="gelu" ,				snake_case_=0.1 ,				snake_case_=0 ,				snake_case_="absolute" ,				snake_case_=True ,				snake_case_=None ,				**snake_case_ ,				):

        """simple docstring"""

        super().__init__(pad_token_id=snake_case_ ,				**snake_case_  )

        A_  :	Optional[Any]    						=  vocab_size
        A_  :	Any    						=  embedding_size
        A_  :	Optional[int]    						=  hidden_size
        A_  :	Tuple    						=  num_hidden_layers
        A_  :	Tuple    						=  num_attention_heads
        A_  :	List[Any]    						=  intermediate_size
        A_  :	Any    						=  hidden_act
        A_  :	str    						=  hidden_dropout_prob
        A_  :	Any    						=  attention_probs_dropout_prob
        A_  :	str    						=  max_position_embeddings
        A_  :	Optional[Any]    						=  type_vocab_size
        A_  :	Dict    						=  initializer_range
        A_  :	Optional[int]    						=  layer_norm_eps

        A_  :	int    						=  summary_type
        A_  :	List[str]    						=  summary_use_proj
        A_  :	Optional[Any]    						=  summary_activation
        A_  :	Optional[Any]    						=  summary_last_dropout
        A_  :	List[Any]    						=  position_embedding_type
        A_  :	Union[str, Any]    						=  use_cache
        A_  :	Tuple    						=  classifier_dropout


class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

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