



"""simple docstring"""
import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp

def       _snake_case						(						):
 UpperCAmelCase	:					Union[str, Any]	=	ArgumentParser(
     description=(
         """PyTorch TPU distributed training launch """
         """helper utility that will spawn up """
         """multiple distributed processes"""
     )						)

 # Optional arguments for the launch helper
 parser.add_argument("""--num_cores"""			,		type=UpperCamelCase			,		default=1			,		help="""Number of TPU cores to use (1 or 8)."""						)

 # positional
 parser.add_argument(
     """training_script"""			,		type=UpperCamelCase			,		help=(
         """The full path to the single TPU training """
         """program/script to be launched in parallel, """
         """followed by all the arguments for the """
         """training script"""
     )			,		)

 # rest from the training program
 parser.add_argument("""training_script_args"""			,		nargs=UpperCamelCase						)

 return parser.parse_args()

def       _snake_case						(						):
 UpperCAmelCase	:					List[str]	=	parse_args()

 # Import training_script as a module.
 UpperCAmelCase	:					int	=	Path(args.training_script						)
 sys.path.append(str(script_fpath.parent.resolve()						)						)
 UpperCAmelCase	:					Union[str, Any]	=	script_fpath.stem
 UpperCAmelCase	:					Any	=	importlib.import_module(UpperCamelCase						)

 # Patch sys.argv
 UpperCAmelCase	:					Dict	=	[args.training_script] + args.training_script_args + ["""--tpu_num_cores""", str(args.num_cores						)]
 xmp.spawn(mod._mp_fn			,		args=()			,		nprocs=args.num_cores						)


if __name__ == "__main__":
      main()



"""simple docstring"""


import argparse

import torch

from transformers import GPTaConfig, GPTaModel, load_tf_weights_in_gpta
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()






def     a__    (    __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE )	->	Optional[int]:
		# Construct model
		if gpta_config_file == "":
				__lowerCAmelCase:       Optional[int]          =			GPTaConfig()
		else:
				__lowerCAmelCase:       List[str]          =			GPTaConfig.from_json_file(__SCREAMING_SNAKE_CASE )
		__lowerCAmelCase:       Optional[int]          =			GPTaModel(__SCREAMING_SNAKE_CASE )

		# Load weights from numpy
		load_tf_weights_in_gpta(__SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE					, __SCREAMING_SNAKE_CASE )

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


if __name__ == "__main__":
			__A						   =			argparse.ArgumentParser()
			# Required parameters
			parser.add_argument(
			    "--gpt2_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
			)
			parser.add_argument(
			    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
			)
			parser.add_argument(
			    "--gpt2_config_file",
			    default="",
			    type=str,
			    help=(
			        "An optional config json file corresponding to the pre-trained OpenAI model. \n"
			        "This specifies the model architecture."
			    ),
			)
			__A						   =			parser.parse_args()
			convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)


