






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


a		:       List[Any]			     = logging.get_logger(__name__)






def 				lowerCamelCase__      (    ):
  # Get the sagemaker specific mp parameters from smp_options variable.
  __UpperCAmelCase							:	Optional[int]           =  os.getenv("""SM_HP_MP_PARAMETERS"""  ,		"""{}"""		)
  try:
    # Parse it and check the field "partitions" is included, it is required for model parallel.
    __UpperCAmelCase							:	Optional[int]           =  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.
  __UpperCAmelCase							:	List[str]           =  os.getenv("""SM_FRAMEWORK_PARAMS"""  ,		"""{}"""		)
  try:
    # Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
    __UpperCAmelCase							:	Optional[int]           =  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     a    ( lowercase__   ):



      """simple docstring"""


      a  : str							       =	field(
          default=''							,       metadata={'help': 'Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer'}							,       )
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      List[str]:
        super().__post_init__()
        warnings.warn(
            """`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use """
            """`TrainingArguments` instead."""		,      __lowercase		,      )
      @cached_property
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      "torch.device":
        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							:	List[str]           =  torch.device("""cpu"""					)
          __UpperCAmelCase							:	Tuple           =  0
        elif is_sagemaker_model_parallel_available():
          __UpperCAmelCase							:	List[Any]           =  smp.local_rank()
          __UpperCAmelCase							:	Tuple           =  torch.device("""cuda"""		,      __lowercase					)
          __UpperCAmelCase							:	Any           =  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							:	Dict           =  int(os.getenv("""SMDATAPARALLEL_LOCAL_RANK"""					)					)
          __UpperCAmelCase							:	Optional[int]           =  torch.device("""cuda"""		,      self.local_rank					)
          __UpperCAmelCase							:	Tuple           =  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							:	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							:	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							:	Optional[int]           =  torch.device("""cuda"""		,      self.local_rank					)
          __UpperCAmelCase							:	str           =  1

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

        return device
      @property
      def 	UpperCAmelCase      (      self					:			List[str]					)							->      List[str]:
        if is_sagemaker_model_parallel_available():
          return smp.dp_size()

        return super().world_size
      @property
      def 	UpperCAmelCase      (      self					:			str					)							->      int:
        return not is_sagemaker_model_parallel_available()




      @property
      def 	UpperCAmelCase      (      self					:			str					)							->      List[Any]:
        return False










import copy
from dataclasses import dataclass, field
from typing import ClassVar, Dict

from ..features import Audio, Features, Value
from .base import TaskTemplate
@dataclass(frozen=lowercase__   )
class     a    ( lowercase__   ):



      """simple docstring"""


      a  : str							       =	field(default='automatic-speech-recognition'							,       metadata={'include_in_asdict_even_if_is_default': True}   )
      a  : ClassVar[Features]							       =	Features({'audio': Audio()}   )
      a  : ClassVar[Features]							       =	Features({'transcription': Value('string'   )}   )
      a  : str							       =	"audio"
      a  : str							       =	"transcription"
      def 	UpperCAmelCase      (      self					:			Optional[Any]		,      __lowercase					:			Optional[int]					)							->      str:
        if self.audio_column not in features:
          raise ValueError(f"""Column {self.audio_column} is not present in features."""					)
        if not isinstance(features[self.audio_column]		,      __lowercase					):
          raise ValueError(f"""Column {self.audio_column} is not an Audio type."""					)
        __UpperCAmelCase							:	int           =  copy.deepcopy(self					)
        __UpperCAmelCase							:	str           =  self.input_schema.copy()
        __UpperCAmelCase							:	List[str]           =  features[self.audio_column]
        __UpperCAmelCase							:	Optional[Any]           =  input_schema
        return task_template




      @property
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      Dict[str, str]:
        return {self.audio_column: "audio", self.transcription_column: "transcription"}


