





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        UpperCamelCase__				(		lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase  ):





      """simple docstring"""


      if gpta_config_file == "":
            _lowerCAmelCase												=							GPTaConfig()
      else:
            _lowerCAmelCase												=							GPTaConfig.from_json_file(__snake_case  )
      _lowerCAmelCase												=							GPTaModel(__snake_case  )

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

      # Save pytorch-model
      _lowerCAmelCase												=							pytorch_dump_folder_path + """/""" + WEIGHTS_NAME
      _lowerCAmelCase												=							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__":
      A__    :       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.'''
          ),
      )
      A__    :       List[Any]              =parser.parse_args()
      convert_gpta_checkpoint_to_pytorch(args.gpta_checkpoint_path, args.gpta_config_file, args.pytorch_dump_folder_path)













'''simple docstring'''






import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_huggingface_suite,
    require_multi_gpu,
    require_single_gpu,
)
from accelerate.utils import patch_environment




@require_huggingface_suite
class 			UpperCAmelCase					(      unittest.TestCase       ):




      def     lowercase__   (      self      :			int  )    ->				Union[str, Any]:
            _lowerCAmelCase												=							inspect.getfile(accelerate.test_utils  )
            _lowerCAmelCase												=							os.path.sep.join(
                mod_file.split(os.path.sep  )[:-1] + ["""scripts""", """external_deps""", """test_metrics.py"""]  )

            from accelerate.test_utils.scripts.external_deps import test_metrics  # noqa: F401

            _lowerCAmelCase												=							test_metrics




      @require_cpu
      def     lowercase__   (      self      :			Optional[Any]  )    ->				Optional[Any]:
            debug_launcher(self.test_metrics.main      ,      num_processes=1  )




      @require_cpu
      def     lowercase__   (      self      :			Tuple  )    ->				Tuple:
            debug_launcher(self.test_metrics.main  )




      @require_single_gpu
      def     lowercase__   (      self      :			Union[str, Any]  )    ->				str:
            self.test_metrics.main()




      @require_multi_gpu
      def     lowercase__   (      self      :			str  )    ->				List[str]:
            print(f"Found {torch.cuda.device_count()} devices."  )
            _lowerCAmelCase												=							["""torchrun""", f"--nproc_per_node={torch.cuda.device_count()}", self.test_file_path]
            with patch_environment(omp_num_threads=1  ):
                  execute_subprocess_async(__snake_case      ,      env=os.environ.copy()  )






