
"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


UpperCAmelCase__      :    List[str]    							= {
    'configuration_albert': ['ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'AlbertConfig', 'AlbertOnnxConfig'],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__      :    Dict    							= ['AlbertTokenizer']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__      :    List[Any]    							= ['AlbertTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__      :    Any    							= [
					    'ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'AlbertForMaskedLM',
					    'AlbertForMultipleChoice',
					    'AlbertForPreTraining',
					    'AlbertForQuestionAnswering',
					    'AlbertForSequenceClassification',
					    'AlbertForTokenClassification',
					    'AlbertModel',
					    'AlbertPreTrainedModel',
					    'load_tf_weights_in_albert',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__      :    int    							= [
					    'TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFAlbertForMaskedLM',
					    'TFAlbertForMultipleChoice',
					    'TFAlbertForPreTraining',
					    'TFAlbertForQuestionAnswering',
					    'TFAlbertForSequenceClassification',
					    'TFAlbertForTokenClassification',
					    'TFAlbertMainLayer',
					    'TFAlbertModel',
					    'TFAlbertPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__      :    Dict    							= [
					    'FlaxAlbertForMaskedLM',
					    'FlaxAlbertForMultipleChoice',
					    'FlaxAlbertForPreTraining',
					    'FlaxAlbertForQuestionAnswering',
					    'FlaxAlbertForSequenceClassification',
					    'FlaxAlbertForTokenClassification',
					    'FlaxAlbertModel',
					    'FlaxAlbertPreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_albert import AlbertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_albert_fast import AlbertTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_albert import (
										    ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    AlbertForMaskedLM,
										    AlbertForMultipleChoice,
										    AlbertForPreTraining,
										    AlbertForQuestionAnswering,
										    AlbertForSequenceClassification,
										    AlbertForTokenClassification,
										    AlbertModel,
										    AlbertPreTrainedModel,
										    load_tf_weights_in_albert,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_albert import (
										    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFAlbertForMaskedLM,
										    TFAlbertForMultipleChoice,
										    TFAlbertForPreTraining,
										    TFAlbertForQuestionAnswering,
										    TFAlbertForSequenceClassification,
										    TFAlbertForTokenClassification,
										    TFAlbertMainLayer,
										    TFAlbertModel,
										    TFAlbertPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_albert import (
										    FlaxAlbertForMaskedLM,
										    FlaxAlbertForMultipleChoice,
										    FlaxAlbertForPreTraining,
										    FlaxAlbertForQuestionAnswering,
										    FlaxAlbertForSequenceClassification,
										    FlaxAlbertForTokenClassification,
										    FlaxAlbertModel,
										    FlaxAlbertPreTrainedModel,
										)
else:
					import sys

					UpperCAmelCase__      :    List[str]    							= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)










"""simple docstring"""




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

import torch_xla.distributed.xla_multiprocessing as xmp



def     a__ (				)						->					Union[str, Any]:
			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=snake_case__       , default=1       , help="""Number of TPU cores to use (1 or 8)."""				)

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

			return parser.parse_args()



def     a__ (				)						->					List[str]:
			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(snake_case__				)

			# 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()



