

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__						=							logging.get_logger(__name__)




def 					_lowercase     (				)				->	Union[str, Any]:




					'''simple docstring'''







					__magic_name__							=    os.getenv('SM_HP_MP_PARAMETERS'					,'{}'				)
					try:
										# Parse it and check the field "partitions" is included, it is required for model parallel.
										__magic_name__							=    json.loads(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.
					__magic_name__							=    os.getenv('SM_FRAMEWORK_PARAMS'					,'{}'				)
					try:
										# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
										__magic_name__							=    json.loads(snake_case_				)
										if not mpi_options.get('sagemaker_mpi_enabled'					,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				(					UpperCamelCase_			):
	_lowercase  :   List[str]       				=  field(
	    default=""  ,						metadata={"help": "Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"}  ,						)







	def 	_SCREAMING_SNAKE_CASE							(   self: Any      ):

						'''simple docstring'''





						super().__post_init__()
						warnings.warn(
						    '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
						    '`TrainingArguments` instead.'  , __UpperCamelCase  , )







	@cached_property
	def 	_SCREAMING_SNAKE_CASE							(   self: Optional[int]      ):

						'''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:
											__magic_name__							=    torch.device('cpu'      )
											__magic_name__							=    0
						elif is_sagemaker_model_parallel_available():
											__magic_name__							=    smp.local_rank()
											__magic_name__							=    torch.device('cuda'  , __UpperCamelCase      )
											__magic_name__							=    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      )
											__magic_name__							=    int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'      )      )
											__magic_name__							=    torch.device('cuda'  , self.local_rank      )
											__magic_name__							=    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
											__magic_name__							=    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.
											__magic_name__							=    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      )
											__magic_name__							=    torch.device('cuda'  , self.local_rank      )
											__magic_name__							=    1

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

						return device







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Union[str, Any]      ):

						'''simple docstring'''





						if is_sagemaker_model_parallel_available():
											return smp.dp_size()

						return super().world_size







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						return not is_sagemaker_model_parallel_available()







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: Dict      ):

						'''simple docstring'''





						return False







from typing import List, Optional, Union

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


A__						=							logging.get_logger(__name__)

A__						=							{
    "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 				__UpperCamelCase				(					SCREAMING_SNAKE_CASE			):
	_lowercase  :   Optional[int]       				=  "time_series_transformer"
	_lowercase  :   Dict       				=  {
	    "hidden_size": "d_model",
	    "num_attention_heads": "encoder_attention_heads",
	    "num_hidden_layers": "encoder_layers",
	}







	def __init__(   self: str  , __UpperCamelCase: Optional[int] = None  , __UpperCamelCase: Optional[int] = None  , __UpperCamelCase: str = "student_t"  , __UpperCamelCase: str = "nll"  , __UpperCamelCase: int = 1  , __UpperCamelCase: List[int] = [1, 2, 3, 4, 5, 6, 7]  , __UpperCamelCase: Optional[Union[str, bool]] = "mean"  , __UpperCamelCase: int = 0  , __UpperCamelCase: int = 0  , __UpperCamelCase: int = 0  , __UpperCamelCase: int = 0  , __UpperCamelCase: Optional[List[int]] = None  , __UpperCamelCase: Optional[List[int]] = None  , __UpperCamelCase: int = 32  , __UpperCamelCase: int = 32  , __UpperCamelCase: int = 2  , __UpperCamelCase: int = 2  , __UpperCamelCase: int = 2  , __UpperCamelCase: int = 2  , __UpperCamelCase: bool = True  , __UpperCamelCase: str = "gelu"  , __UpperCamelCase: int = 64  , __UpperCamelCase: float = 0.1  , __UpperCamelCase: float = 0.1  , __UpperCamelCase: float = 0.1  , __UpperCamelCase: float = 0.1  , __UpperCamelCase: float = 0.1  , __UpperCamelCase: int = 1_00  , __UpperCamelCase: float = 0.02  , __UpperCamelCase: Any=True  , **__UpperCamelCase: Optional[Any]  , ):

						'''simple docstring'''





						__magic_name__							=    prediction_length
						__magic_name__							=    context_length or prediction_length
						__magic_name__							=    distribution_output
						__magic_name__							=    loss
						__magic_name__							=    input_size
						__magic_name__							=    num_time_features
						__magic_name__							=    lags_sequence
						__magic_name__							=    scaling
						__magic_name__							=    num_dynamic_real_features
						__magic_name__							=    num_static_real_features
						__magic_name__							=    num_static_categorical_features
						if cardinality and num_static_categorical_features > 0:
											if len(__UpperCamelCase      ) != num_static_categorical_features:
																raise ValueError(
																    'The cardinality should be a list of the same length as `num_static_categorical_features`'      )
											__magic_name__							=    cardinality
						else:
											__magic_name__							=    [0]
						if embedding_dimension and num_static_categorical_features > 0:
											if len(__UpperCamelCase      ) != num_static_categorical_features:
																raise ValueError(
																    'The embedding dimension should be a list of the same length as `num_static_categorical_features`'      )
											__magic_name__							=    embedding_dimension
						else:
											__magic_name__							=    [min(50  , (cat + 1) // 2      ) for cat in self.cardinality]
						__magic_name__							=    num_parallel_samples

						# Transformer architecture configuration
						__magic_name__							=    input_size * len(__UpperCamelCase      ) + self._number_of_features
						__magic_name__							=    d_model
						__magic_name__							=    encoder_attention_heads
						__magic_name__							=    decoder_attention_heads
						__magic_name__							=    encoder_ffn_dim
						__magic_name__							=    decoder_ffn_dim
						__magic_name__							=    encoder_layers
						__magic_name__							=    decoder_layers

						__magic_name__							=    dropout
						__magic_name__							=    attention_dropout
						__magic_name__							=    activation_dropout
						__magic_name__							=    encoder_layerdrop
						__magic_name__							=    decoder_layerdrop

						__magic_name__							=    activation_function
						__magic_name__							=    init_std

						__magic_name__							=    use_cache

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







	@property
	def 	_SCREAMING_SNAKE_CASE							(   self: str      ):

						'''simple docstring'''





						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
						)




