
"""simple docstring"""



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__          = logging.get_logger(__name__)
def 					_UpperCAmelCase      ( )     ->					int:
  # Get the sagemaker specific mp parameters from smp_options variable.
  _snake_case					     =       os.getenv('''SM_HP_MP_PARAMETERS''' ,					'''{}'''		)
  try:
    # Parse it and check the field "partitions" is included, it is required for model parallel.
    _snake_case					     =       json.loads(__lowerCamelCase		)
    if "partitions" not in smp_options:
      return False
  except json.JSONDecodeError:
    return False

  # Get the sagemaker specific framework parameters from mpi_options variable.
  _snake_case					     =       os.getenv('''SM_FRAMEWORK_PARAMS''' ,					'''{}'''		)
  try:
    # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
    _snake_case					     =       json.loads(__lowerCamelCase		)
    if not mpi_options.get('''sagemaker_mpi_enabled''' ,					__lowerCamelCase		):
      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       lowerCAmelCase__				(						A_	):
     __a						=					field(
         default="""""" ,	metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""} ,	)







     def      lowercase	(							self			:			Optional[Any]			):
       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      lowercase	(							self			:			int			):
       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:
         _snake_case					     =       torch.device('''cpu'''			)
         _snake_case					     =       0
       elif is_sagemaker_model_parallel_available():
         _snake_case					     =       smp.local_rank()
         _snake_case					     =       torch.device('''cuda'''    ,      _lowerCamelCase			)
         _snake_case					     =       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			)
         _snake_case					     =       int(os.getenv('''SMDATAPARALLEL_LOCAL_RANK'''			)			)
         _snake_case					     =       torch.device('''cuda'''    ,      self.local_rank			)
         _snake_case					     =       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
         _snake_case					     =       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.
         _snake_case					     =       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			)
         _snake_case					     =       torch.device('''cuda'''    ,      self.local_rank			)
         _snake_case					     =       1

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

       return device







     @property
     def      lowercase	(							self			:			List[str]			):
       if is_sagemaker_model_parallel_available():
         return smp.dp_size()

       return super().world_size







     @property
     def      lowercase	(							self			:			int			):
       return not is_sagemaker_model_parallel_available()







     @property
     def      lowercase	(							self			:			Optional[int]			):
       return False





"""simple docstring"""



UpperCAmelCase__          = {
    'Pillow': 'Pillow',
    'accelerate': 'accelerate>=0.11.0',
    'compel': 'compel==0.1.8',
    'black': 'black~=23.1',
    'datasets': 'datasets',
    'filelock': 'filelock',
    'flax': 'flax>=0.4.1',
    'hf-doc-builder': 'hf-doc-builder>=0.3.0',
    'huggingface-hub': 'huggingface-hub>=0.13.2',
    'requests-mock': 'requests-mock==1.10.0',
    'importlib_metadata': 'importlib_metadata',
    'invisible-watermark': 'invisible-watermark',
    'isort': 'isort>=5.5.4',
    'jax': 'jax>=0.2.8,!=0.3.2',
    'jaxlib': 'jaxlib>=0.1.65',
    'Jinja2': 'Jinja2',
    'k-diffusion': 'k-diffusion>=0.0.12',
    'torchsde': 'torchsde',
    'note_seq': 'note_seq',
    'librosa': 'librosa',
    'numpy': 'numpy',
    'omegaconf': 'omegaconf',
    'parameterized': 'parameterized',
    'protobuf': 'protobuf>=3.20.3,<4',
    'pytest': 'pytest',
    'pytest-timeout': 'pytest-timeout',
    'pytest-xdist': 'pytest-xdist',
    'ruff': 'ruff>=0.0.241',
    'safetensors': 'safetensors',
    'sentencepiece': 'sentencepiece>=0.1.91,!=0.1.92',
    'scipy': 'scipy',
    'onnx': 'onnx',
    'regex': 'regex!=2019.12.17',
    'requests': 'requests',
    'tensorboard': 'tensorboard',
    'torch': 'torch>=1.4',
    'torchvision': 'torchvision',
    'transformers': 'transformers>=4.25.1',
    'urllib3': 'urllib3<=2.0.0',
}



