




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

import torch_xla.distributed.xla_multiprocessing as xmp





def      UpperCAmelCase  (						)     ->     List[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  (						)     ->     Dict:







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











from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available, is_vision_available


UpperCAmelCase_    ={"""configuration_vilt""": ["""VILT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ViltConfig"""]}

try:
		if not is_vision_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_    =["""ViltFeatureExtractor"""]
		UpperCAmelCase_    =["""ViltImageProcessor"""]
		UpperCAmelCase_    =["""ViltProcessor"""]

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase_    =[
		    """VILT_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """ViltForImageAndTextRetrieval""",
		    """ViltForImagesAndTextClassification""",
		    """ViltForTokenClassification""",
		    """ViltForMaskedLM""",
		    """ViltForQuestionAnswering""",
		    """ViltLayer""",
		    """ViltModel""",
		    """ViltPreTrainedModel""",
		]


if TYPE_CHECKING:
		from .configuration_vilt import VILT_PRETRAINED_CONFIG_ARCHIVE_MAP, ViltConfig

		try:
				if not is_vision_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .feature_extraction_vilt import ViltFeatureExtractor
				from .image_processing_vilt import ViltImageProcessor
				from .processing_vilt import ViltProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_vilt import (
				    VILT_PRETRAINED_MODEL_ARCHIVE_LIST,
				    ViltForImageAndTextRetrieval,
				    ViltForImagesAndTextClassification,
				    ViltForMaskedLM,
				    ViltForQuestionAnswering,
				    ViltForTokenClassification,
				    ViltLayer,
				    ViltModel,
				    ViltPreTrainedModel,
				)


else:
		import sys

		UpperCAmelCase_    =_LazyModule(__name__, globals()["""__file__"""], _import_structure)



