

import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


_lowerCAmelCase  :      Any			 =logging.get_logger(__name__)



def 			_A	(      ):
	# Get the sagemaker specific mp parameters from smp_options variable.
	UpperCAmelCase__:	Dict									= os.getenv("SM_HP_MP_PARAMETERS"	,"{}"      )
	try:
		# Parse it and check the field "partitions" is included, it is required for model parallel.
		UpperCAmelCase__:	Optional[Any]									= json.loads(SCREAMING_SNAKE_CASE      )
		if "partitions" not in smp_options:
			return False
	except json.JSONDecodeError:
		return False

	# Get the sagemaker specific framework parameters from mpi_options variable.
	UpperCAmelCase__:	str									= os.getenv("SM_FRAMEWORK_PARAMS"	,"{}"      )
	try:
		# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
		UpperCAmelCase__:	Any									= json.loads(SCREAMING_SNAKE_CASE      )
		if not mpi_options.get("sagemaker_mpi_enabled"	,SCREAMING_SNAKE_CASE      ):
			return False
	except json.JSONDecodeError:
		return False
	# Lastly, check if the `smdistributed` module is present.
	return importlib.util.find_spec("smdistributed"      ) is not None


if is_sagemaker_model_parallel_available():
					import smdistributed.modelparallel.torch as smp

					smp.init()

@dataclass
class __UpperCamelCase     (				_a		):






					'''simple docstring'''



					__magic_name__        =   field(
					    default=""					,metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}					,)





					def    _UpperCAmelCase    (				self						):
						super().__post_init__()
						warnings.warn(
						    "`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use "
						    "`TrainingArguments` instead."				,      lowerCamelCase__				,      )





					@cached_property
					def    _UpperCAmelCase    (				self						):
						logger.info("PyTorch: setting up devices"						)
						if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
							logger.warning(
							    "torch.distributed process group is initialized, but local_rank == -1. "
							    "In order to use Torch DDP, launch your script with `python -m torch.distributed.launch"						)
						if self.no_cuda:
							UpperCAmelCase__:	Dict									= torch.device("cpu"						)
							UpperCAmelCase__:	str									= 0
						elif is_sagemaker_model_parallel_available():
							UpperCAmelCase__:	List[Any]									= smp.local_rank()
							UpperCAmelCase__:	Optional[int]									= torch.device("cuda"				,      lowerCamelCase__						)
							UpperCAmelCase__:	str									= 1
						elif is_sagemaker_dp_enabled():
							import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

							torch.distributed.init_process_group(backend="smddp"				,      timeout=self.ddp_timeout_delta						)
							UpperCAmelCase__:	List[str]									= int(os.getenv("SMDATAPARALLEL_LOCAL_RANK"						)						)
							UpperCAmelCase__:	List[Any]									= torch.device("cuda"				,      self.local_rank						)
							UpperCAmelCase__:	Dict									= 1
						elif self.local_rank == -1:
							# if n_gpu is > 1 we'll use nn.DataParallel.
							# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
							# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
							# trigger an error that a device index is missing. Index 0 takes into account the
							# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
							# will use the first GPU in that env, i.e. GPU#1
							UpperCAmelCase__:	List[Any]									= torch.device("cuda:0" if torch.cuda.is_available() else "cpu"						)
							# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
							# the default value.
							UpperCAmelCase__:	Any									= torch.cuda.device_count()
						else:
							# Here, we'll use torch.distributed.
							# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
							if not torch.distributed.is_initialized():
								torch.distributed.init_process_group(backend="nccl"				,      timeout=self.ddp_timeout_delta						)
							UpperCAmelCase__:	List[Any]									= torch.device("cuda"				,      self.local_rank						)
							UpperCAmelCase__:	Optional[int]									= 1

						if device.type == "cuda":
							torch.cuda.set_device(lowerCamelCase__						)

						return device





					@property
					def    _UpperCAmelCase    (				self						):
						if is_sagemaker_model_parallel_available():
							return smp.dp_size()

						return super().world_size





					@property
					def    _UpperCAmelCase    (				self						):
						return not is_sagemaker_model_parallel_available()





					@property
					def    _UpperCAmelCase    (				self						):
						return False


_lowerCAmelCase  :      int			 ="""
# Installazione di Transformers
! pip install transformers datasets
# Per installare dalla fonte invece dell'ultima versione rilasciata, commenta il comando sopra e
# rimuovi la modalità commento al comando seguente.
# ! pip install git+https://github.com/huggingface/transformers.git
"""

_lowerCAmelCase  :      List[str]			 =[{"""type""": """code""", """content""": INSTALL_CONTENT}]
_lowerCAmelCase  :      int			 ={
    """{processor_class}""": """FakeProcessorClass""",
    """{model_class}""": """FakeModelClass""",
    """{object_class}""": """FakeObjectClass""",
}