



'''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    lowerCamelCase__ (		_A				,    _A				,    _A       ):
  # Construct model
  if gpta_config_file == "":
    a		:      Optional[Any]       =  GPTaConfig()
  else:
    a		:      Optional[Any]       =  GPTaConfig.from_json_file(_A       )
  a		:      Optional[int]       =  GPTaModel(_A       )

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

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


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




'''simple docstring'''






from ..utils import DummyObject, requires_backends

class 							a__(      metaclass=lowerCamelCase__			):
    lowercase__				=					["""torch""", """torchsde"""]







    def __init__(   self				:						Any		,    *__snake_case				:						List[str]		,    **__snake_case				:						Tuple			):
      requires_backends(self		,    ['torch', 'torchsde']			)







    @classmethod
    def     lowercase_ (   cls				:						List[Any]		,    *__snake_case				:						str		,    **__snake_case				:						List[Any]			):
      requires_backends(cls		,    ['torch', 'torchsde']			)







    @classmethod
    def     lowercase_ (   cls				:						Dict		,    *__snake_case				:						Optional[Any]		,    **__snake_case				:						str			):
      requires_backends(cls		,    ['torch', 'torchsde']			)