
'''simple docstring'''
import argparse
import os
import subprocess

from packaging.version import Version, parse

from accelerate.commands.config.config_args import default_config_file, load_config_from_file


lowercase__  :      Tuple        =					"Run commands across TPU VMs for initial setup before running `accelerate launch`."



def  __lowerCamelCase       (      _UpperCamelCase  :  Union[str, Any]=None					):


      '''simple docstring'''


      if subparsers is not None:
            UpperCAmelCase_            =  subparsers.add_parser('''tpu-config'''							,    description=_description					)
      else:
            UpperCAmelCase_            =  argparse.ArgumentParser('''Accelerate tpu-config command'''							,    description=_description					)
      # Core arguments
      UpperCAmelCase_            =  parser.add_argument_group(
          '''Config Arguments'''							,    '''Arguments that can be configured through `accelerate config`.'''					)
      config_args.add_argument(
          '''--config_file'''							,    type=_UpperCamelCase							,    default=_UpperCamelCase							,    help='''Path to the config file to use for accelerate.'''							,    )
      config_args.add_argument(
          '''--tpu_name'''							,    default=_UpperCamelCase							,    help='''The name of the TPU to use. If not specified, will use the TPU specified in the config file.'''							,    )
      config_args.add_argument(
          '''--tpu_zone'''							,    default=_UpperCamelCase							,    help='''The zone of the TPU to use. If not specified, will use the zone specified in the config file.'''							,    )
      UpperCAmelCase_            =  parser.add_argument_group('''TPU Arguments'''							,    '''Arguments for options ran inside the TPU.'''					)
      pod_args.add_argument(
          '''--use_alpha'''							,    action='''store_true'''							,    help='''Whether to use `gcloud alpha` when running the TPU training script instead of `gcloud`.'''							,    )
      pod_args.add_argument(
          '''--command_file'''							,    default=_UpperCamelCase							,    help='''The path to the file containing the commands to run on the pod on startup.'''							,    )
      pod_args.add_argument(
          '''--command'''							,    action='''append'''							,    nargs='''+'''							,    help='''A command to run on the pod. Can be passed multiple times.'''							,    )
      pod_args.add_argument(
          '''--install_accelerate'''							,    action='''store_true'''							,    help='''Whether to install accelerate on the pod. Defaults to False.'''							,    )
      pod_args.add_argument(
          '''--accelerate_version'''							,    default='''latest'''							,    help='''The version of accelerate to install on the pod. If not specified, will use the latest pypi version. Specify \'dev\' to install from GitHub.'''							,    )
      pod_args.add_argument(
          '''--debug'''							,    action='''store_true'''							,    help='''If set, will print the command that would be run instead of running it.'''					)

      if subparsers is not None:
            parser.set_defaults(func=_UpperCamelCase					)
      return parser



def  __lowerCamelCase       (      _UpperCamelCase  :  List[Any]					):


      '''simple docstring'''


      UpperCAmelCase_            =  None

      # Get the default from the config file if it exists.
      if args.config_file is not None or os.path.isfile(_UpperCamelCase					):
            UpperCAmelCase_            =  load_config_from_file(args.config_file					)
            if not args.command_file and defaults.command_file is not None and not args.command:
                  UpperCAmelCase_            =  defaults.command_file
            if not args.command and defaults.commands is not None:
                  UpperCAmelCase_            =  defaults.commands
            if not args.tpu_name:
                  UpperCAmelCase_            =  defaults.tpu_name
            if not args.tpu_zone:
                  UpperCAmelCase_            =  defaults.tpu_zone
      if args.accelerate_version == "dev":
            UpperCAmelCase_            =  '''git+https://github.com/huggingface/accelerate.git'''
      elif args.accelerate_version == "latest":
            UpperCAmelCase_            =  '''accelerate -U'''
      elif isinstance(parse(args.accelerate_version					)							,    _UpperCamelCase					):
            UpperCAmelCase_            =  F"""accelerate=={args.accelerate_version}"""

      if not args.command_file and not args.command:
            raise ValueError('''You must specify either a command file or a command to run on the pod.'''					)

      if args.command_file:
            with open(args.command_file							,    '''r'''					) as f:
                  UpperCAmelCase_            =  [f.read().splitlines()]

    # To turn list of lists into list of strings
      if isinstance(args.command[0]							,    _UpperCamelCase					):
            UpperCAmelCase_            =  [line for cmd in args.command for line in cmd]
      # Default to the shared folder and install accelerate
      UpperCAmelCase_            =  ['''cd /usr/share''']
      if args.install_accelerate:
            new_cmd += [F"""pip install {args.accelerate_version}"""]
      new_cmd += args.command
      UpperCAmelCase_            =  '''; '''.join(_UpperCamelCase					)

      # Then send it to gcloud
      # Eventually try to use google-api-core to do this instead of subprocess
      UpperCAmelCase_            =  ['''gcloud''']
      if args.use_alpha:
            cmd += ["alpha"]
      cmd += [
          "compute",
          "tpus",
          "tpu-vm",
          "ssh",
          args.tpu_name,
          "--zone",
          args.tpu_zone,
          "--command",
          args.command,
          "--worker",
          "all",
      ]
      if args.debug:
            print(F"""Running {" ".join(_UpperCamelCase					)}"""					)
            return
      subprocess.run(_UpperCamelCase					)
      print('''Successfully setup pod.'''					)





def  __lowerCamelCase       (      ):


      '''simple docstring'''


      UpperCAmelCase_            =  tpu_command_parser()
      UpperCAmelCase_            =  parser.parse_args()

      tpu_command_launcher(_UpperCamelCase					)






'''simple docstring'''
from typing import List, Optional, Union

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


lowercase__  :      int        =					logging.get_logger(__name__)

lowercase__  :      List[str]        =					{
    "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 lowerCamelCase							(	lowerCamelCase					):




  '''simple docstring'''



  lowerCAmelCase__										=	'''time_series_transformer'''
  lowerCAmelCase__										=	{
      '''hidden_size''': '''d_model''',
      '''num_attention_heads''': '''encoder_attention_heads''',
      '''num_hidden_layers''': '''encoder_layers''',
  }






  def __init__(      self			:       Optional[int]  ,							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 = 100  ,							UpperCAmelCase__			:       float = 0.02  ,							UpperCAmelCase__			:       Union[str, Any]=True  ,							**UpperCAmelCase__			:       Tuple  ,							)				->Optional[int]:
        # time series specific configuration
        UpperCAmelCase_            =  prediction_length
        UpperCAmelCase_            =  context_length or prediction_length
        UpperCAmelCase_            =  distribution_output
        UpperCAmelCase_            =  loss
        UpperCAmelCase_            =  input_size
        UpperCAmelCase_            =  num_time_features
        UpperCAmelCase_            =  lags_sequence
        UpperCAmelCase_            =  scaling
        UpperCAmelCase_            =  num_dynamic_real_features
        UpperCAmelCase_            =  num_static_real_features
        UpperCAmelCase_            =  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`'''  )
              UpperCAmelCase_            =  cardinality
        else:
              UpperCAmelCase_            =  [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`'''  )
              UpperCAmelCase_            =  embedding_dimension
        else:
              UpperCAmelCase_            =  [min(50  ,							(cat + 1) // 2  ) for cat in self.cardinality]
        UpperCAmelCase_            =  num_parallel_samples

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

        UpperCAmelCase_            =  dropout
        UpperCAmelCase_            =  attention_dropout
        UpperCAmelCase_            =  activation_dropout
        UpperCAmelCase_            =  encoder_layerdrop
        UpperCAmelCase_            =  decoder_layerdrop

        UpperCAmelCase_            =  activation_function
        UpperCAmelCase_            =  init_std

        UpperCAmelCase_            =  use_cache

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






  @property
  def  lowerCAmelCase__ (      self			:       List[str]  )				->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
        )





