
"""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 	__snake_case  (    SCREAMING_SNAKE_CASE:					Union[str, Any]     ,  SCREAMING_SNAKE_CASE:					Optional[Any]=()     ,  SCREAMING_SNAKE_CASE:					Dict=None     ,  SCREAMING_SNAKE_CASE:					Optional[int]="no"     ,  SCREAMING_SNAKE_CASE:					int="29500"						):






							"""simple docstring"""



							_lowerCAmelCase  	=			False
							_lowerCAmelCase  	=			False
							if any(key.startswith('KAGGLE'						) for key in os.environ.keys()						):
														_lowerCAmelCase  	=			True
							elif "IPython" in sys.modules:
														_lowerCAmelCase  	=			'google.colab' in str(sys.modules['IPython'].get_ipython()						)

							try:
														_lowerCAmelCase  	=			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'     ,  SCREAMING_SNAKE_CASE						) 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:
																					_lowerCAmelCase  	=			8

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






def 	__snake_case  (    SCREAMING_SNAKE_CASE:					List[Any]     ,  SCREAMING_SNAKE_CASE:					Union[str, Any]=()     ,  SCREAMING_SNAKE_CASE:					Tuple=2						):






							"""simple docstring"""



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



"""simple docstring"""



from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


_snake_case          =						logging.get_logger(__name__)

_snake_case          =						{
    '''google/mobilenet_v1_1.0_224''': '''https://huggingface.co/google/mobilenet_v1_1.0_224/resolve/main/config.json''',
    '''google/mobilenet_v1_0.75_192''': '''https://huggingface.co/google/mobilenet_v1_0.75_192/resolve/main/config.json''',
    # See all MobileNetV1 models at https://huggingface.co/models?filter=mobilenet_v1
}
class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Dict							=					"mobilenet_v1"


				def __init__(					self	:			List[Any]				,     UpperCAmelCase_	:			Optional[int]=3				,     UpperCAmelCase_	:			str=224				,     UpperCAmelCase_	:			Union[str, Any]=1.0				,     UpperCAmelCase_	:			List[str]=8				,     UpperCAmelCase_	:			Union[str, Any]="relu6"				,     UpperCAmelCase_	:			Optional[Any]=True				,     UpperCAmelCase_	:			Optional[int]=0.999				,     UpperCAmelCase_	:			Optional[Any]=0.02				,     UpperCAmelCase_	:			Union[str, Any]=0.001				,     **UpperCAmelCase_	:			List[Any]				,     )		->  Dict:







											"""simple docstring"""




											super().__init__(**UpperCAmelCase_  )

											if depth_multiplier <= 0:
																		raise ValueError('depth_multiplier must be greater than zero.'  )

											_lowerCAmelCase  	=			num_channels
											_lowerCAmelCase  	=			image_size
											_lowerCAmelCase  	=			depth_multiplier
											_lowerCAmelCase  	=			min_depth
											_lowerCAmelCase  	=			hidden_act
											_lowerCAmelCase  	=			tf_padding
											_lowerCAmelCase  	=			classifier_dropout_prob
											_lowerCAmelCase  	=			initializer_range
											_lowerCAmelCase  	=			layer_norm_eps






class        _SCREAMING_SNAKE_CASE  (  UpperCAmelCase							):






				'''simple docstring'''



				SCREAMING_SNAKE_CASE_:							Optional[int]							=					version.parse("1.11"							)


				@property
				def 				__lowerCamelCase	(					self	:			List[str]  )		->  Mapping[str, Mapping[int, str]]:







											"""simple docstring"""




											return OrderedDict([('pixel_values', {0: 'batch'})]  )


				@property
				def 				__lowerCamelCase	(					self	:			Dict  )		->  Mapping[str, Mapping[int, str]]:







											"""simple docstring"""




											if self.task == "image-classification":
																		return OrderedDict([('logits', {0: 'batch'})]  )
											else:
																		return OrderedDict([('last_hidden_state', {0: 'batch'}), ('pooler_output', {0: 'batch'})]  )







				@property
				def 				__lowerCamelCase	(					self	:			Optional[Any]  )		->  float:







											"""simple docstring"""




											return 1E-4






