code: 
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_flax_available,
      is_keras_nlp_available,
      is_tensorflow_text_available,
      is_tf_available,
      is_tokenizers_available,
      is_torch_available,
  )
  
  
  A_    :					Union[str, Any]             ={
      '''configuration_gpt2''': ['''GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''GPT2Config''', '''GPT2OnnxConfig'''],
      '''tokenization_gpt2''': ['''GPT2Tokenizer'''],
  }
  
  try:
  	if not is_tokenizers_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	A_    :					Dict             =['''GPT2TokenizerFast''']
  
  try:
  	if not is_torch_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	A_    :					int             =[
  	    '''GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
  	    '''GPT2DoubleHeadsModel''',
  	    '''GPT2ForQuestionAnswering''',
  	    '''GPT2ForSequenceClassification''',
  	    '''GPT2ForTokenClassification''',
  	    '''GPT2LMHeadModel''',
  	    '''GPT2Model''',
  	    '''GPT2PreTrainedModel''',
  	    '''load_tf_weights_in_gpt2''',
  	]
  
  try:
  	if not is_tf_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	A_    :					List[str]             =[
  	    '''TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST''',
  	    '''TFGPT2DoubleHeadsModel''',
  	    '''TFGPT2ForSequenceClassification''',
  	    '''TFGPT2LMHeadModel''',
  	    '''TFGPT2MainLayer''',
  	    '''TFGPT2Model''',
  	    '''TFGPT2PreTrainedModel''',
  	]
  
  try:
  	if not is_keras_nlp_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	A_    :					List[str]             =['''TFGPT2Tokenizer''']
  
  try:
  	if not is_flax_available():
  		raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  	pass
  else:
  	A_    :					Any             =['''FlaxGPT2LMHeadModel''', '''FlaxGPT2Model''', '''FlaxGPT2PreTrainedModel''']
  
  if TYPE_CHECKING:
  	from .configuration_gpta import GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTaConfig, GPTaOnnxConfig
  	from .tokenization_gpta import GPTaTokenizer
  
  	try:
  		if not is_tokenizers_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .tokenization_gpta_fast import GPTaTokenizerFast
  
  	try:
  		if not is_torch_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .modeling_gpta import (
  		    GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
  		    GPTaDoubleHeadsModel,
  		    GPTaForQuestionAnswering,
  		    GPTaForSequenceClassification,
  		    GPTaForTokenClassification,
  		    GPTaLMHeadModel,
  		    GPTaModel,
  		    GPTaPreTrainedModel,
  		    load_tf_weights_in_gpta,
  		)
  
  	try:
  		if not is_tf_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .modeling_tf_gpta import (
  		    TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST,
  		    TFGPTaDoubleHeadsModel,
  		    TFGPTaForSequenceClassification,
  		    TFGPTaLMHeadModel,
  		    TFGPTaMainLayer,
  		    TFGPTaModel,
  		    TFGPTaPreTrainedModel,
  		)
  
  	try:
  		if not is_keras_nlp_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .tokenization_gpta_tf import TFGPTaTokenizer
  
  	try:
  		if not is_flax_available():
  			raise OptionalDependencyNotAvailable()
  	except OptionalDependencyNotAvailable:
  		pass
  	else:
  		from .modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel, FlaxGPTaPreTrainedModel
  
  else:
  	import sys
  
  	A_    :					Optional[int]             =_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
style_context: 
  
  
  import importlib
  import sys
  from argparse import REMAINDER, ArgumentParser
  from pathlib import Path
  
  import torch_xla.distributed.xla_multiprocessing as xmp
  
  
  
  
  def   lowerCamelCase_       (					):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		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   lowerCamelCase_       (					):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		parse_args()
  
  						# Import training_script as a module.
  						a_					=		Path(args.training_script      )
  						sys.path.append(str(script_fpath.parent.resolve()      )      )
  						a_					=		script_fpath.stem
  						a_					=		importlib.import_module(UpperCAmelCase__      )
  
  						# Patch sys.argv
  						a_					=		[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()