


from ..utils import DummyObject, requires_backends







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    Union[str, Any]          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :Union[str, Any]			,*__snake_case   :Tuple			,**__snake_case   :Dict      )					->    str:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :Any			,*__snake_case   :Tuple			,**__snake_case   :str      )					->    Optional[int]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :List[str]			,*__snake_case   :Tuple			,**__snake_case   :List[Any]      )					->    List[Any]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    Optional[int]          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :Dict			,*__snake_case   :Union[str, Any]			,**__snake_case   :Any      )					->    Optional[int]:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :Tuple			,*__snake_case   :Dict			,**__snake_case   :List[str]      )					->    Tuple:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :Optional[int]			,*__snake_case   :Optional[Any]			,**__snake_case   :List[str]      )					->    Any:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    Optional[Any]          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :List[str]			,*__snake_case   :Dict			,**__snake_case   :int      )					->    List[Any]:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :Optional[int]			,*__snake_case   :Optional[int]			,**__snake_case   :Dict      )					->    List[Any]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :List[Any]			,*__snake_case   :List[Any]			,**__snake_case   :List[Any]      )					->    List[Any]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    Optional[Any]          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :Tuple			,*__snake_case   :int			,**__snake_case   :List[str]      )					->    Any:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :Optional[Any]			,*__snake_case   :Dict			,**__snake_case   :List[Any]      )					->    Optional[Any]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :str			,*__snake_case   :List[Any]			,**__snake_case   :Any      )					->    List[Any]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    Optional[Any]          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :Optional[int]			,*__snake_case   :List[Any]			,**__snake_case   :Tuple      )					->    int:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :int			,*__snake_case   :List[str]			,**__snake_case   :List[str]      )					->    Tuple:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :Optional[int]			,*__snake_case   :int			,**__snake_case   :List[str]      )					->    Optional[int]:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )







class        snake_case_   (metaclass=lowerCamelCase_      ):
					UpperCAmelCase__					:    str          =			['''torch''', '''transformers''', '''onnx''']
					def __init__(      self   :str			,*__snake_case   :Any			,**__snake_case   :Optional[Any]      )					->    Dict:
												requires_backends(self			,['torch', 'transformers', 'onnx']      )
					@classmethod
					def  lowerCamelCase__(      cls   :List[str]			,*__snake_case   :Union[str, Any]			,**__snake_case   :Optional[Any]      )					->    Tuple:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )



					@classmethod
					def  lowerCamelCase__(      cls   :Dict			,*__snake_case   :Dict			,**__snake_case   :int      )					->    Dict:
												requires_backends(cls			,['torch', 'transformers', 'onnx']      )








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 							__lowercase   ( __lowerCAmelCase							:				str					,    __lowerCAmelCase							:				Any					,    __lowerCAmelCase							:				int   ):
							# Construct model
							if gpta_config_file == "":
														a__             =     GPTaConfig()
							else:
														a__             =     GPTaConfig.from_json_file(__lowerCAmelCase   )
							a__             =     GPTaModel(__lowerCAmelCase   )

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

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


if __name__ == "__main__":
						snake_case							:       List[Any]     			=      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.'''
						    ),
						)
						snake_case							:       Any     			=      parser.parse_args()
						convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)




