

"""simple docstring"""





import argparse

import torch

from transformers import ImageGPTConfig, ImageGPTForCausalLM, load_tf_weights_in_imagegpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()




def     _A    (    UpperCamelCase_	:			Union[str, Any],     UpperCamelCase_	:			List[str],     UpperCamelCase_	:			Union[str, Any])      ->		Optional[int]:
   '''simple docstring'''


   __lowercase								=		{"small": (512, 8, 24), "medium": (1024, 8, 36), "large": (1536, 16, 48)}
   __lowercase						,__lowercase						,__lowercase								=		MODELS[model_size]  # set model hyperparameters
   __lowercase								=		ImageGPTConfig(n_embd=UpperCamelCase_,     n_layer=UpperCamelCase_,     n_head=UpperCamelCase_)
   __lowercase								=		ImageGPTForCausalLM(UpperCamelCase_)

   # Load weights from numpy
   load_tf_weights_in_imagegpt(UpperCamelCase_,     UpperCamelCase_,     UpperCamelCase_)

   # Save pytorch-model
   __lowercase								=		pytorch_dump_folder_path + "/" + WEIGHTS_NAME
   __lowercase								=		pytorch_dump_folder_path + "/" + CONFIG_NAME
   print(F"""Save PyTorch model to {pytorch_weights_dump_path}""")
   torch.save(model.state_dict(),     UpperCamelCase_)
   print(F"""Save configuration file to {pytorch_config_dump_path}""")
   with open(UpperCamelCase_,     "w",     encoding="utf-8") as f:
      f.write(config.to_json_string())


if __name__ == "__main__":
   _a					 =				argparse.ArgumentParser()
   # Required parameters
   parser.add_argument(
       '--imagegpt_checkpoint_path',
       default=None,
       type=str,
       required=True,
       help='Path to the TensorFlow checkpoint path.',
   )
   parser.add_argument(
       '--model_size',
       default=None,
       type=str,
       required=True,
       help='Size of the model (can be either \'small\', \'medium\' or \'large\').',
   )
   parser.add_argument(
       '--pytorch_dump_folder_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
   )
   _a					 =				parser.parse_args()
   convert_imagegpt_checkpoint_to_pytorch(
       args.imagegpt_checkpoint_path, args.model_size, args.pytorch_dump_folder_path
   )







"""simple docstring"""





def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int = 1000)      ->		str:
   '''simple docstring'''


   if (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (digit_position <= 0):
      raise ValueError("Digit position must be a positive integer")
   elif (not isinstance(UpperCamelCase_,     UpperCamelCase_)) or (precision < 0):
      raise ValueError("Precision must be a nonnegative integer")

   # compute an approximation of (16 ** (n - 1)) * pi whose fractional part is mostly
   # accurate
   __lowercase								=		(
       4 * _subsum(UpperCamelCase_,     1,     UpperCamelCase_)
       - 2 * _subsum(UpperCamelCase_,     4,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     5,     UpperCamelCase_)
       - _subsum(UpperCamelCase_,     6,     UpperCamelCase_)
   )

   # return the first hex digit of the fractional part of the result
   return hex(int((sum_result % 1) * 16))[2:]




def     _A    (    UpperCamelCase_	:			int,     UpperCamelCase_	:			int,     UpperCamelCase_	:			int)      ->		float:
   '''simple docstring'''


   __lowercase								=		0.0
   for sum_index in range(digit_pos_to_extract + precision):
      __lowercase								=		8 * sum_index + denominator_addend
      if sum_index < digit_pos_to_extract:
         # if the exponential term is an integer and we mod it by the denominator
         # before dividing, only the integer part of the sum will change;
         # the fractional part will not
         __lowercase								=		pow(
             16,     digit_pos_to_extract - 1 - sum_index,     UpperCamelCase_)
      else:
         __lowercase								=		pow(16,     digit_pos_to_extract - 1 - sum_index)
      total += exponential_term / denominator
   return total


if __name__ == "__main__":
   import doctest

   doctest.testmod()




