




"""simple docstring"""






import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()





def 							UpperCAmelCase		(		snake_case			:					Any      ,       snake_case			:					List[str]      ,       snake_case			:					str    ):
					# Construct model
					if openai_config_file == "":
										_lowerCAmelCase:List[Any]									=  OpenAIGPTConfig()
					else:
										_lowerCAmelCase:int									=  OpenAIGPTConfig.from_json_file(snake_case    )
					_lowerCAmelCase:int									=  OpenAIGPTModel(snake_case    )

					# Load weights from numpy
					load_tf_weights_in_openai_gpt(snake_case      ,       snake_case      ,       snake_case    )

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


if __name__ == "__main__":
				UpperCamelCase__						=							argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--openai_checkpoint_folder_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(
				    '''--openai_config_file''',
				    default='''''',
				    type=str,
				    help=(
				        '''An optional config json file corresponding to the pre-trained OpenAI model. \n'''
				        '''This specifies the model architecture.'''
				    ),
				)
				UpperCamelCase__						=							parser.parse_args()
				convert_openai_checkpoint_to_pytorch(
				    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
				)












"""simple docstring"""






import importlib
import sys
from argparse import REMAINDER, ArgumentParser
from pathlib import Path

import torch_xla.distributed.xla_multiprocessing as xmp





def 							UpperCAmelCase		(		):
					_lowerCAmelCase:Optional[int]									=  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=snake_case      ,       default=1      ,       help='''Number of TPU cores to use (1 or 8).'''    )

					# positional
					parser.add_argument(
					    '''training_script'''      ,       type=snake_case      ,       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=snake_case    )

					return parser.parse_args()





def 							UpperCAmelCase		(		):
					_lowerCAmelCase:int									=  parse_args()

					# Import training_script as a module.
					_lowerCAmelCase:Optional[int]									=  Path(args.training_script    )
					sys.path.append(str(script_fpath.parent.resolve()    )    )
					_lowerCAmelCase:Optional[int]									=  script_fpath.stem
					_lowerCAmelCase:Any									=  importlib.import_module(snake_case    )

					# Patch sys.argv
					_lowerCAmelCase: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()






