



"""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_    (     _lowercase,   _lowercase,   _lowercase      ):







						'''simple docstring'''


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

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

						# Save pytorch-model
						snake_case_					:int		=     pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
						snake_case_					:Optional[int]		=     pytorch_dump_folder_path + """/""" + CONFIG_NAME
						print(f"""Save PyTorch model to {pytorch_weights_dump_path}"""      )
						torch.save(model.state_dict(),   _lowercase      )
						print(f"""Save configuration file to {pytorch_config_dump_path}"""      )
						with open(_lowercase,   """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()




