





"""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 				lowerCAmelCase_			(      ):


							'''simple docstring'''







							__lowerCamelCase      :      List[str]         =os.getenv('''SM_HP_MP_PARAMETERS'''    ,						'''{}'''   )
							try:
														# Parse it and check the field "partitions" is included, it is required for model parallel.
														__lowerCamelCase      :      Tuple         =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.
							__lowerCamelCase      :      Tuple         =os.getenv('''SM_FRAMEWORK_PARAMS'''    ,						'''{}'''   )
							try:
														# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
														__lowerCamelCase      :      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 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""
				__snake_case   :       str	 =		field(
				    default=""""""       ,  metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""}       ,  )




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

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

											return device




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

											return super().world_size




				@property
				def 					__lowercase  (     self  :Union[str, Any]			):
											return not is_sagemaker_model_parallel_available()




				@property
				def 					__lowercase  (     self  :Tuple			):
											return False











"""simple docstring"""





from typing import List, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_UpperCamelCase							=      logging.get_logger(__name__)

_UpperCamelCase							=      {
    'huggingface/time-series-transformer-tourism-monthly': (
        'https://huggingface.co/huggingface/time-series-transformer-tourism-monthly/resolve/main/config.json'
    ),
    # See all TimeSeriesTransformer models at https://huggingface.co/models?filter=time_series_transformer
}
class 		SCREAMING_SNAKE_CASE_							(    snake_case__   ):
				"""simple docstring"""
				__snake_case   :       Union[str, Any]	 =		"""time_series_transformer"""
				__snake_case   :       Any	 =		{
				    """hidden_size""": """d_model""",
				    """num_attention_heads""": """encoder_attention_heads""",
				    """num_hidden_layers""": """encoder_layers""",
				}




				def __init__(     self  :List[Any]						,    __lowercase  :Optional[int] = None						,    __lowercase  :Optional[int] = None						,    __lowercase  :str = "student_t"						,    __lowercase  :str = "nll"						,    __lowercase  :int = 1						,    __lowercase  :List[int] = [1, 2, 3, 4, 5, 6, 7]						,    __lowercase  :Optional[Union[str, bool]] = "mean"						,    __lowercase  :int = 0						,    __lowercase  :int = 0						,    __lowercase  :int = 0						,    __lowercase  :int = 0						,    __lowercase  :Optional[List[int]] = None						,    __lowercase  :Optional[List[int]] = None						,    __lowercase  :int = 32						,    __lowercase  :int = 32						,    __lowercase  :int = 2						,    __lowercase  :int = 2						,    __lowercase  :int = 2						,    __lowercase  :int = 2						,    __lowercase  :bool = True						,    __lowercase  :str = "gelu"						,    __lowercase  :int = 64						,    __lowercase  :float = 0.1						,    __lowercase  :float = 0.1						,    __lowercase  :float = 0.1						,    __lowercase  :float = 0.1						,    __lowercase  :float = 0.1						,    __lowercase  :int = 100						,    __lowercase  :float = 0.02						,    __lowercase  :int=True						,    **__lowercase  :Optional[Any]						,    ):
											# time series specific configuration
											__lowerCamelCase      :      Tuple         =prediction_length
											__lowerCamelCase      :      List[Any]         =context_length or prediction_length
											__lowerCamelCase      :      Dict         =distribution_output
											__lowerCamelCase      :      str         =loss
											__lowerCamelCase      :      Tuple         =input_size
											__lowerCamelCase      :      int         =num_time_features
											__lowerCamelCase      :      int         =lags_sequence
											__lowerCamelCase      :      Optional[int]         =scaling
											__lowerCamelCase      :      str         =num_dynamic_real_features
											__lowerCamelCase      :      Optional[Any]         =num_static_real_features
											__lowerCamelCase      :      List[Any]         =num_static_categorical_features
											if cardinality and num_static_categorical_features > 0:
																		if len(__lowercase			) != num_static_categorical_features:
																									raise ValueError(
																									    '''The cardinality should be a list of the same length as `num_static_categorical_features`'''			)
																		__lowerCamelCase      :      Optional[int]         =cardinality
											else:
																		__lowerCamelCase      :      str         =[0]
											if embedding_dimension and num_static_categorical_features > 0:
																		if len(__lowercase			) != num_static_categorical_features:
																									raise ValueError(
																									    '''The embedding dimension should be a list of the same length as `num_static_categorical_features`'''			)
																		__lowerCamelCase      :      int         =embedding_dimension
											else:
																		__lowerCamelCase      :      Optional[int]         =[min(50						,    (cat + 1) // 2			) for cat in self.cardinality]
											__lowerCamelCase      :      List[str]         =num_parallel_samples

											# Transformer architecture configuration
											__lowerCamelCase      :      str         =input_size * len(__lowercase			) + self._number_of_features
											__lowerCamelCase      :      Union[str, Any]         =d_model
											__lowerCamelCase      :      int         =encoder_attention_heads
											__lowerCamelCase      :      int         =decoder_attention_heads
											__lowerCamelCase      :      Dict         =encoder_ffn_dim
											__lowerCamelCase      :      int         =decoder_ffn_dim
											__lowerCamelCase      :      List[Any]         =encoder_layers
											__lowerCamelCase      :      int         =decoder_layers

											__lowerCamelCase      :      Union[str, Any]         =dropout
											__lowerCamelCase      :      Optional[Any]         =attention_dropout
											__lowerCamelCase      :      List[str]         =activation_dropout
											__lowerCamelCase      :      List[str]         =encoder_layerdrop
											__lowerCamelCase      :      int         =decoder_layerdrop

											__lowerCamelCase      :      Tuple         =activation_function
											__lowerCamelCase      :      str         =init_std

											__lowerCamelCase      :      Dict         =use_cache

											super().__init__(is_encoder_decoder=__lowercase						,    **__lowercase			)




				@property
				def 					__lowercase  (     self  :int			):
											return (
											    sum(self.embedding_dimension			)
											    + self.num_dynamic_real_features
											    + self.num_time_features
											    + self.num_static_real_features
											    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
											)




