

import os
import sys
import tempfile

import torch

from .state import AcceleratorState
from .utils import PrecisionType, PrepareForLaunch, is_mps_available, patch_environment






def        UpperCamelCase_(							_snake_case   :  Optional[int]       ,     _snake_case   :  Dict=()       ,     _snake_case   :  Dict=None       ,     _snake_case   :  Dict="no"       ,     _snake_case   :  Any="29500"	):




			"""simple docstring"""






			__a        =False
			__a        =False
			if any(key.startswith('KAGGLE'	) for key in os.environ.keys()	):
						__a        =True
			elif "IPython" in sys.modules:
						__a        ='google.colab' in str(sys.modules['IPython'].get_ipython()	)

			try:
						__a        =PrecisionType(mixed_precision.lower()	)
			except ValueError:
						raise ValueError(
						    F'Unknown mixed_precision mode: {args.mixed_precision.lower()}. Choose between {PrecisionType.list()}.'	)

			if (in_colab or in_kaggle) and (os.environ.get('TPU_NAME'       ,     _snake_case	) is not None):
						# TPU launch
						import torch_xla.distributed.xla_multiprocessing as xmp

						if len(AcceleratorState._shared_state	) > 0:
									raise ValueError(
									    'To train on TPU in Colab or Kaggle Kernel, the `Accelerator` should only be initialized inside '
									    'your training function. Restart your notebook and make sure no cells initializes an '
									    '`Accelerator`.'	)
						if num_processes is None:
									__a        =8

						__a        =PrepareForLaunch(_snake_case       ,     distributed_type='TPU'	)
						print(F'Launching a training on {num_processes} TPU cores.'	)
						xmp.spawn(_snake_case       ,     args=_snake_case       ,     nprocs=_snake_case       ,     start_method='fork'	)
			elif in_colab:
						# No need for a distributed launch otherwise as it's either CPU or one GPU.
						if torch.cuda.is_available():
									print('Launching training on one GPU.'	)
						else:
									print('Launching training on one CPU.'	)
						function(*_snake_case	)
			else:
						if num_processes is None:
									raise ValueError(
									    'You have to specify the number of GPUs you would like to use, add `num_processes=...` to your call.'	)

						if num_processes > 1:
									# Multi-GPU launch
									from torch.multiprocessing import start_processes
									from torch.multiprocessing.spawn import ProcessRaisedException

									if len(AcceleratorState._shared_state	) > 0:
												raise ValueError(
												    'To launch a multi-GPU training from your notebook, the `Accelerator` should only be initialized '
												    'inside your training function. Restart your notebook and make sure no cells initializes an '
												    '`Accelerator`.'	)

									if torch.cuda.is_initialized():
												raise ValueError(
												    'To launch a multi-GPU training from your notebook, you need to avoid running any instruction '
												    'using `torch.cuda` in any cell. Restart your notebook and make sure no cells use any CUDA '
												    'function.'	)

									# torch.distributed will expect a few environment variable to be here. We set the ones common to each
									# process here (the other ones will be set be the launcher).
									with patch_environment(
									    world_size=_snake_case       ,     master_addr='127.0.01'       ,     master_port=_snake_case       ,     mixed_precision=_snake_case	):
												__a        =PrepareForLaunch(_snake_case       ,     distributed_type='MULTI_GPU'	)
												print(F'Launching training on {num_processes} GPUs.'	)
												try:
															start_processes(_snake_case       ,     args=_snake_case       ,     nprocs=_snake_case       ,     start_method='fork'	)
												except ProcessRaisedException as e:
															if "Cannot re-initialize CUDA in forked subprocess" in e.args[0]:
																		raise RuntimeError(
																		    'CUDA has been initialized before the `notebook_launcher` could create a forked subprocess. '
																		    'This likely stems from an outside import causing issues once the `notebook_launcher()` is called. '
																		    'Please review your imports and test them when running the `notebook_launcher()` to identify '
																		    'which one is problematic.'	) from e

						else:
									# No need for a distributed launch otherwise as it's either CPU, GPU or MPS.
									if is_mps_available():
												__a        ='1'
												print('Launching training on MPS.'	)
									elif torch.cuda.is_available():
												print('Launching training on one GPU.'	)
									else:
												print('Launching training on CPU.'	)
									function(*_snake_case	)






def        UpperCamelCase_(							_snake_case   :  Dict       ,     _snake_case   :  List[str]=()       ,     _snake_case   :  Any=2	):




			"""simple docstring"""






			from torch.multiprocessing import start_processes

			with tempfile.NamedTemporaryFile() as tmp_file:
						# torch.distributed will expect a few environment variable to be here. We set the ones common to each
						# process here (the other ones will be set be the launcher).
						with patch_environment(
						    world_size=_snake_case       ,     master_addr='127.0.01'       ,     master_port='29500'       ,     accelerate_mixed_precision='no'       ,     accelerate_debug_rdv_file=tmp_file.name       ,     accelerate_use_cpu='yes'       ,     ):
									__a        =PrepareForLaunch(_snake_case       ,     debug=_snake_case	)
									start_processes(_snake_case       ,     args=_snake_case       ,     nprocs=_snake_case       ,     start_method='fork'	)









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   :  Dict       ,     _snake_case   :  Optional[int]       ,     _snake_case   :  str	):




			"""simple docstring"""






			if openai_config_file == "":
						__a        =OpenAIGPTConfig()
			else:
						__a        =OpenAIGPTConfig.from_json_file(_snake_case	)
			__a        =OpenAIGPTModel(_snake_case	)

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

			# 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()       ,     _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__":
						_lowerCAmelCase					:			Tuple  				=			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."
						    ),
						)
						_lowerCAmelCase					:			int  				=			parser.parse_args()
						convert_openai_checkpoint_to_pytorch(
						    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
						)






