code: 
  
  
  from collections import OrderedDict
  from typing import Any, List, Mapping, Optional
  
  from ... import PreTrainedTokenizer, TensorType, is_torch_available
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfigWithPast, PatchingSpec
  from ...utils import logging
  
  
  __a   				=      logging.get_logger(__name__)
  
  __a   				=      {
      '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/config.json''',
      '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/config.json''',
      '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/config.json''',
      '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/config.json''',
      '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/config.json''',
  }
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   (			A__   ):
        A				:							str    							=     'gpt2'
        A				:							Optional[int]    							=     ['past_key_values']
        A				:							List[Any]    							=     {
            'hidden_size': 'n_embd',
            'max_position_embeddings': 'n_positions',
            'num_attention_heads': 'n_head',
            'num_hidden_layers': 'n_layer',
        }
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__=50257							,						SCREAMING_SNAKE_CASE__=1024							,						SCREAMING_SNAKE_CASE__=768							,						SCREAMING_SNAKE_CASE__=12							,						SCREAMING_SNAKE_CASE__=12							,						SCREAMING_SNAKE_CASE__=None							,						SCREAMING_SNAKE_CASE__="gelu_new"							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=1E-5							,						SCREAMING_SNAKE_CASE__=0.02							,						SCREAMING_SNAKE_CASE__="cls_index"							,						SCREAMING_SNAKE_CASE__=True							,						SCREAMING_SNAKE_CASE__=None							,						SCREAMING_SNAKE_CASE__=True							,						SCREAMING_SNAKE_CASE__=0.1							,						SCREAMING_SNAKE_CASE__=True							,						SCREAMING_SNAKE_CASE__=True							,						SCREAMING_SNAKE_CASE__=50256							,						SCREAMING_SNAKE_CASE__=50256							,						SCREAMING_SNAKE_CASE__=False							,						SCREAMING_SNAKE_CASE__=False							,						**SCREAMING_SNAKE_CASE__							,						):
              lowercase			:   Dict					   =		vocab_size
              lowercase			:   Union[str, Any]					   =		n_positions
              lowercase			:   Tuple					   =		n_embd
              lowercase			:   Union[str, Any]					   =		n_layer
              lowercase			:   Dict					   =		n_head
              lowercase			:   str					   =		n_inner
              lowercase			:   Union[str, Any]					   =		activation_function
              lowercase			:   List[str]					   =		resid_pdrop
              lowercase			:   Dict					   =		embd_pdrop
              lowercase			:   int					   =		attn_pdrop
              lowercase			:   Optional[Any]					   =		layer_norm_epsilon
              lowercase			:   int					   =		initializer_range
              lowercase			:   List[Any]					   =		summary_type
              lowercase			:   Dict					   =		summary_use_proj
              lowercase			:   Tuple					   =		summary_activation
              lowercase			:   Union[str, Any]					   =		summary_first_dropout
              lowercase			:   Union[str, Any]					   =		summary_proj_to_labels
              lowercase			:   List[str]					   =		scale_attn_weights
              lowercase			:   Optional[int]					   =		use_cache
              lowercase			:   Optional[int]					   =		scale_attn_by_inverse_layer_idx
              lowercase			:   Union[str, Any]					   =		reorder_and_upcast_attn
  
              lowercase			:   Union[str, Any]					   =		bos_token_id
              lowercase			:   Optional[int]					   =		eos_token_id
  
              super().__init__(bos_token_id=SCREAMING_SNAKE_CASE__							,						eos_token_id=SCREAMING_SNAKE_CASE__							,						**SCREAMING_SNAKE_CASE__		)
  
  
  
  
  
  
  
  class 				__SCREAMING_SNAKE_CASE   (			A__   ):
  
  
        def __init__(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__ = "default"							,						SCREAMING_SNAKE_CASE__ = None							,						SCREAMING_SNAKE_CASE__ = False							,						):
              super().__init__(SCREAMING_SNAKE_CASE__							,						task=SCREAMING_SNAKE_CASE__							,						patching_specs=SCREAMING_SNAKE_CASE__							,						use_past=SCREAMING_SNAKE_CASE__		)
              if not getattr(self._config							,						'''pad_token_id'''							,						SCREAMING_SNAKE_CASE__		):
                    # TODO: how to do that better?
                    lowercase			:   Tuple					   =		0
  
  
        @property
        def        __lowerCamelCase			(							self		):
              lowercase			:   int					   =		OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}}		)
              if self.use_past:
                    self.fill_with_past_key_values_(SCREAMING_SNAKE_CASE__							,						direction='''inputs'''		)
                    lowercase			:   List[Any]					   =		{0: '''batch''', 1: '''past_sequence + sequence'''}
              else:
                    lowercase			:   Any					   =		{0: '''batch''', 1: '''sequence'''}
  
              return common_inputs
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return self._config.n_layer
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return self._config.n_head
  
  
        def        __lowerCamelCase			(							self							,						SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__ = -1							,						SCREAMING_SNAKE_CASE__ = -1							,						SCREAMING_SNAKE_CASE__ = False							,						SCREAMING_SNAKE_CASE__ = None							,						):
              lowercase			:   List[str]					   =		super(SCREAMING_SNAKE_CASE__							,						self		).generate_dummy_inputs(
                  SCREAMING_SNAKE_CASE__							,						batch_size=SCREAMING_SNAKE_CASE__							,						seq_length=SCREAMING_SNAKE_CASE__							,						is_pair=SCREAMING_SNAKE_CASE__							,						framework=SCREAMING_SNAKE_CASE__		)
  
              # We need to order the input in the way they appears in the forward()
              lowercase			:   Union[str, Any]					   =		OrderedDict({'''input_ids''': common_inputs['''input_ids''']}		)
  
              # Need to add the past_keys
              if self.use_past:
                    if not is_torch_available():
                          raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''		)
                    else:
                          import torch
  
                          lowercase   ,			lowercase			:   List[Any]					   =		common_inputs['''input_ids'''].shape
                          # Not using the same length for past_key_values
                          lowercase			:   int					   =		seqlen + 2
                          lowercase			:   int					   =		(
                              batch,
                              self.num_attention_heads,
                              past_key_values_length,
                              self._config.hidden_size // self.num_attention_heads,
                          )
                          lowercase			:   Any					   =		[
                              (torch.zeros(SCREAMING_SNAKE_CASE__		), torch.zeros(SCREAMING_SNAKE_CASE__		)) for _ in range(self.num_layers		)
                          ]
  
              lowercase			:   str					   =		common_inputs['''attention_mask''']
              if self.use_past:
                    lowercase			:   Dict					   =		ordered_inputs['''attention_mask'''].dtype
                    lowercase			:   Tuple					   =		torch.cat(
                        [ordered_inputs['''attention_mask'''], torch.ones(SCREAMING_SNAKE_CASE__							,						SCREAMING_SNAKE_CASE__							,						dtype=SCREAMING_SNAKE_CASE__		)]							,						dim=1		)
  
              return ordered_inputs
  
  
  
  
  
  
        @property
        def        __lowerCamelCase			(							self		):
              return 13
  
  
style_context: 
  
  
  import math
  
  
  
  
  def 			__lowercase	(						_UpperCamelCase     )    ->Union[str, Any]:
  
  
  
  
  
  
  
        """simple docstring"""
  
        lowercase			:   List[Any]					   =		0
        if n % 2 == 0:
              count += 1
              while n % 2 == 0:
                    lowercase			:   Any					   =		int(n / 2     )
      # the n input value must be odd so that
      # we can skip one element (ie i += 2)
  
        lowercase			:   Optional[int]					   =		3
  
        while i <= int(math.sqrt(_UpperCamelCase     )     ):
              if n % i == 0:
                    count += 1
                    while n % i == 0:
                          lowercase			:   Optional[Any]					   =		int(n / i     )
              lowercase			:   str					   =		i + 2
  
        # this condition checks the prime
        # number n is greater than 2
  
        if n > 2:
              count += 1
        return count
  
  
  if __name__ == "__main__":
    __a   				=      51_24_21_83
    print(F'''The number of distinct prime factors is/are {exact_prime_factor_count(n)}''')
    print(F'''The value of log(log(n)) is {math.log(math.log(n)):.4f}''')
  
  