


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


__UpperCamelCase       :       Tuple						       =				logging.get_logger(__name__)

def 			_a		(				):







 """simple docstring"""



 UpperCamelCase__					:    Union[str, Any]          =   os.getenv('''SM_HP_MP_PARAMETERS'''    , '''{}'''     )
 try:
  # Parse it and check the field "partitions" is included, it is required for model parallel.
  UpperCamelCase__					:    List[str]          =   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__					:    Optional[int]          =   os.getenv('''SM_FRAMEWORK_PARAMS'''    , '''{}'''     )
 try:
  # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
  UpperCamelCase__					:    Dict          =   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       __magic_name__	(     __lowerCAmelCase):
     A:		str			=      field(
         default=""					,				metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}					,				)


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      str:





      '''simple docstring'''






      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							:     Dict			)  ->      "torch.device":





      '''simple docstring'''






      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__					:    Union[str, Any]          =   torch.device('''cpu'''			)
       UpperCamelCase__					:    Union[str, Any]          =   0
      elif is_sagemaker_model_parallel_available():
       UpperCamelCase__					:    Union[str, Any]          =   smp.local_rank()
       UpperCamelCase__					:    str          =   torch.device('''cuda'''							,	lowerCamelCase__			)
       UpperCamelCase__					:    Tuple          =   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__					:    Optional[int]          =   int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''			)			)
       UpperCamelCase__					:    Optional[Any]          =   torch.device('''cuda'''							,	self.local_rank			)
       UpperCamelCase__					:    List[Any]          =   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[str]          =   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__					:    Union[str, 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__					:    Any          =   torch.device('''cuda'''							,	self.local_rank			)
       UpperCamelCase__					:    Any          =   1

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

      return device


     @property
     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      int:





      '''simple docstring'''






      if is_sagemaker_model_parallel_available():
       return smp.dp_size()

      return super().world_size


     @property
     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      Any:





      '''simple docstring'''






      return not is_sagemaker_model_parallel_available()


     @property
     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      List[Any]:





      '''simple docstring'''






      return False






from typing import TYPE_CHECKING

from ..utils import _LazyModule


__UpperCamelCase       :       int						       =				{
    "config": [
        "EXTERNAL_DATA_FORMAT_SIZE_LIMIT",
        "OnnxConfig",
        "OnnxConfigWithPast",
        "OnnxSeq2SeqConfigWithPast",
        "PatchingSpec",
    ],
    "convert": ["export", "validate_model_outputs"],
    "features": ["FeaturesManager"],
    "utils": ["ParameterFormat", "compute_serialized_parameters_size"],
}


if TYPE_CHECKING:
       from .config import (
           EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
           OnnxConfig,
           OnnxConfigWithPast,
           OnnxSeqaSeqConfigWithPast,
           PatchingSpec,
       )
       from .convert import export, validate_model_outputs
       from .features import FeaturesManager
       from .utils import ParameterFormat, compute_serialized_parameters_size

else:
       import sys

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


