


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

import torch_xla.distributed.xla_multiprocessing as xmp







def 	_UpperCamelCase   (    )  ->   str:

						"""simple docstring"""



						lowerCAmelCase__    						=						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=UpperCamelCase_    ,       default=1    ,       help='Number of TPU cores to use (1 or 8).'		)

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

						return parser.parse_args()







def 	_UpperCamelCase   (    )  ->   List[Any]:

						"""simple docstring"""



						lowerCAmelCase__    						=						parse_args()

						# Import training_script as a module.
						lowerCAmelCase__    						=						Path(args.training_script		)
						sys.path.append(str(script_fpath.parent.resolve()		)		)
						lowerCAmelCase__    						=						script_fpath.stem
						lowerCAmelCase__    						=						importlib.import_module(UpperCamelCase_		)

						# Patch sys.argv
						lowerCAmelCase__    						=						[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()













import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()







def 	_UpperCamelCase   (    UpperCamelCase_       :					Dict    ,       UpperCamelCase_       :					str    ,       UpperCamelCase_       :					Optional[Any]		)  ->   Any:

						"""simple docstring"""



						lowerCAmelCase__    						=						BertConfig.from_json_file(UpperCamelCase_		)
						print(F"Building PyTorch model from configuration: {config}"		)
						lowerCAmelCase__    						=						BertForPreTraining(UpperCamelCase_		)

						# Load weights from tf checkpoint
						load_tf_weights_in_bert(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_		)

						# Save pytorch-model
						print(F"Save PyTorch model to {pytorch_dump_path}"		)
						torch.save(model.state_dict()    ,       UpperCamelCase_		)


if __name__ == "__main__":
					__snake_case    :    Union[str, Any]         =     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
					)
					parser.add_argument(
					    """--bert_config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help=(
					        """The config json file corresponding to the pre-trained BERT model. \n"""
					        """This specifies the model architecture."""
					    ),
					)
					parser.add_argument(
					    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
					)
					__snake_case    :    List[str]         =     parser.parse_args()
					convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





