





'''simple docstring'''




import os
import sys
import tempfile

import torch

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




def 						__lowerCamelCase			(	UpperCAmelCase_					,				UpperCAmelCase_=()					,				UpperCAmelCase_=None					,				UpperCAmelCase_="no"					,				UpperCAmelCase_="29500"							)   ->str:
	snake_case__	       =   False
	snake_case__	       =   False
	if any(key.startswith('KAGGLE'							) for key in os.environ.keys()							):
		snake_case__	       =   True
	elif "IPython" in sys.modules:
		snake_case__	       =   'google.colab' in str(sys.modules['IPython'].get_ipython()							)

	try:
		snake_case__	       =   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'					,				UpperCAmelCase_							) 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:
			snake_case__	       =   8

		snake_case__	       =   PrepareForLaunch(UpperCAmelCase_					,				distributed_type='TPU'							)
		print(f'''Launching a training on {num_processes} TPU cores.'''							)
		xmp.spawn(UpperCAmelCase_					,				args=UpperCAmelCase_					,				nprocs=UpperCAmelCase_					,				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(*UpperCAmelCase_							)
	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=UpperCAmelCase_					,				master_addr='127.0.01'					,				master_port=UpperCAmelCase_					,				mixed_precision=UpperCAmelCase_							):
				snake_case__	       =   PrepareForLaunch(UpperCAmelCase_					,				distributed_type='MULTI_GPU'							)
				print(f'''Launching training on {num_processes} GPUs.'''							)
				try:
					start_processes(UpperCAmelCase_					,				args=UpperCAmelCase_					,				nprocs=UpperCAmelCase_					,				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():
				snake_case__	       =   '1'
				print('Launching training on MPS.'							)
			elif torch.cuda.is_available():
				print('Launching training on one GPU.'							)
			else:
				print('Launching training on CPU.'							)
			function(*UpperCAmelCase_							)







def 						__lowerCamelCase			(	UpperCAmelCase_					,				UpperCAmelCase_=()					,				UpperCAmelCase_=2							)   ->Tuple:
	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=UpperCAmelCase_					,				master_addr='127.0.01'					,				master_port='29500'					,				accelerate_mixed_precision='no'					,				accelerate_debug_rdv_file=tmp_file.name					,				accelerate_use_cpu='yes'					,				):
			snake_case__	       =   PrepareForLaunch(UpperCAmelCase_					,				debug=UpperCAmelCase_							)
			start_processes(UpperCAmelCase_					,				args=UpperCAmelCase_					,				nprocs=UpperCAmelCase_					,				start_method='fork'							)










'''simple docstring'''




from typing import TYPE_CHECKING

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


a__					:			Dict          =     {
    '''configuration_canine''': ['''CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CanineConfig'''],
    '''tokenization_canine''': ['''CanineTokenizer'''],
}

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			a__					:			Union[str, Any]          =     [
			    '''CANINE_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''CanineForMultipleChoice''',
			    '''CanineForQuestionAnswering''',
			    '''CanineForSequenceClassification''',
			    '''CanineForTokenClassification''',
			    '''CanineLayer''',
			    '''CanineModel''',
			    '''CaninePreTrainedModel''',
			    '''load_tf_weights_in_canine''',
			]


if TYPE_CHECKING:
			from .configuration_canine import CANINE_PRETRAINED_CONFIG_ARCHIVE_MAP, CanineConfig
			from .tokenization_canine import CanineTokenizer

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_canine import (
						    CANINE_PRETRAINED_MODEL_ARCHIVE_LIST,
						    CanineForMultipleChoice,
						    CanineForQuestionAnswering,
						    CanineForSequenceClassification,
						    CanineForTokenClassification,
						    CanineLayer,
						    CanineModel,
						    CaninePreTrainedModel,
						    load_tf_weights_in_canine,
						)


else:
			import sys

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



