





# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import torch

from accelerate import PartialState
from accelerate.utils.operations import broadcast, gather, gather_object, pad_across_processes, reduce







def        __lowerCamelCase (							__a       :List[str]   )		->    Tuple:






		"""simple docstring"""

		return (torch.arange(state.num_processes   ) + 1.0 + (state.num_processes * state.process_index)).to(state.device   )







def        __lowerCamelCase (							__a       :int   )		->    Optional[int]:






		"""simple docstring"""

		A__  				=       create_tensor(__a   )
		A__  				=       gather(__a   )
		assert gathered_tensor.tolist() == list(range(1   ,					state.num_processes**2 + 1   )   )







def        __lowerCamelCase (							__a       :Any   )		->    Any:






		"""simple docstring"""

		A__  				=       [state.process_index]
		A__  				=       gather_object(__a   )
		assert len(__a   ) == state.num_processes, F'{gathered_obj}, {len(__a   )} != {state.num_processes}'
		assert gathered_obj == list(range(state.num_processes   )   ), F'{gathered_obj} != {list(range(state.num_processes   )   )}'







def        __lowerCamelCase (							__a       :List[str]   )		->    List[str]:






		"""simple docstring"""

		A__  				=       create_tensor(__a   )
		A__  				=       broadcast(__a   )
		assert broadcasted_tensor.shape == torch.Size([state.num_processes]   )
		assert broadcasted_tensor.tolist() == list(range(1   ,					state.num_processes + 1   )   )







def        __lowerCamelCase (							__a       :Any   )		->    Any:






		"""simple docstring"""

		if state.is_main_process:
				A__  				=       torch.arange(state.num_processes + 1   ).to(state.device   )
		else:
				A__  				=       torch.arange(state.num_processes   ).to(state.device   )
		A__  				=       pad_across_processes(__a   )
		assert padded_tensor.shape == torch.Size([state.num_processes + 1]   )
		if not state.is_main_process:
				assert padded_tensor.tolist() == list(range(0   ,					state.num_processes   )   ) + [0]







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






		"""simple docstring"""

		if state.num_processes != 2:
				return
		A__  				=       create_tensor(__a   )
		A__  				=       reduce(__a   ,					"""sum"""   )
		A__  				=       torch.tensor([4.0, 6]   ).to(state.device   )
		assert torch.allclose(__a   ,					__a   ), F'{reduced_tensor} != {truth_tensor}'







def        __lowerCamelCase (							__a       :List[Any]   )		->    List[str]:






		"""simple docstring"""

		if state.num_processes != 2:
				return
		A__  				=       create_tensor(__a   )
		A__  				=       reduce(__a   ,					"""mean"""   )
		A__  				=       torch.tensor([2.0, 3]   ).to(state.device   )
		assert torch.allclose(__a   ,					__a   ), F'{reduced_tensor} != {truth_tensor}'







def        __lowerCamelCase (							__a       :str   )		->    Optional[int]:






		"""simple docstring"""

		main()







def        __lowerCamelCase (							)		->    str:






		"""simple docstring"""

		A__  				=       PartialState()
		state.print(F'State: {state}'   )
		state.print("""testing gather"""   )
		test_gather(__a   )
		state.print("""testing gather_object"""   )
		test_gather_object(__a   )
		state.print("""testing broadcast"""   )
		test_broadcast(__a   )
		state.print("""testing pad_across_processes"""   )
		test_pad_across_processes(__a   )
		state.print("""testing reduce_sum"""   )
		test_reduce_sum(__a   )
		state.print("""testing reduce_mean"""   )
		test_reduce_mean(__a   )


if __name__ == "__main__":
					main()










from typing import List, Optional, Union

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


A   : Optional[Any]			=				logging.get_logger(__name__)

A   : 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   A      (SCREAMING_SNAKE_CASE   ):
			'''simple docstring'''




			__lowerCamelCase     :	Any          =   '''time_series_transformer'''
			__lowerCamelCase     :	Dict          =   {
			    '''hidden_size''': '''d_model''',
			    '''num_attention_heads''': '''encoder_attention_heads''',
			    '''num_hidden_layers''': '''encoder_layers''',
			}






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







					"""simple docstring"""






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

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

					A__  				=       dropout
					A__  				=       attention_dropout
					A__  				=       activation_dropout
					A__  				=       encoder_layerdrop
					A__  				=       decoder_layerdrop

					A__  				=       activation_function
					A__  				=       init_std

					A__  				=       use_cache

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







			@property
			def        a_	(      self       :   List[Any]       )     ->     int:







					"""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
					)



