


from typing import List, Optional, Union

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


snake_case							:	Any					      =				logging.get_logger(__name__)

snake_case							:	Any					      =				{
    '''huggingface/informer-tourism-monthly''': (
        '''https://huggingface.co/huggingface/informer-tourism-monthly/resolve/main/config.json'''
    ),
    # See all Informer models at https://huggingface.co/models?filter=informer
}







class 	snake_case_       (lowerCamelCase_				):
					UpperCAmelCase__ :   int   				=      '''informer'''
					UpperCAmelCase__ :   Tuple   				=      {
					    '''hidden_size''': '''d_model''',
					    '''num_attention_heads''': '''encoder_attention_heads''',
					    '''num_hidden_layers''': '''encoder_layers''',
					}
					def __init__(				self       :Dict      ,__snake_case       :Optional[int] = None      ,__snake_case       :Optional[int] = None      ,__snake_case       :str = "student_t"      ,__snake_case       :str = "nll"      ,__snake_case       :int = 1      ,__snake_case       :List[int] = None      ,__snake_case       :Optional[Union[str, bool]] = "mean"      ,__snake_case       :int = 0      ,__snake_case       :int = 0      ,__snake_case       :int = 0      ,__snake_case       :int = 0      ,__snake_case       :Optional[List[int]] = None      ,__snake_case       :Optional[List[int]] = None      ,__snake_case       :int = 64      ,__snake_case       :int = 32      ,__snake_case       :int = 32      ,__snake_case       :int = 2      ,__snake_case       :int = 2      ,__snake_case       :int = 2      ,__snake_case       :int = 2      ,__snake_case       :bool = True      ,__snake_case       :str = "gelu"      ,__snake_case       :float = 0.05      ,__snake_case       :float = 0.1      ,__snake_case       :float = 0.1      ,__snake_case       :float = 0.1      ,__snake_case       :float = 0.1      ,__snake_case       :int = 1_00      ,__snake_case       :float = 0.02      ,__snake_case       :List[str]=True      ,__snake_case       :str = "prob"      ,__snake_case       :int = 5      ,__snake_case       :bool = True      ,**__snake_case       :Optional[Any]      ,) ->   Any:
												# time series specific configuration
												a__					=					prediction_length
												a__					=					context_length or prediction_length
												a__					=					distribution_output
												a__					=					loss
												a__					=					input_size
												a__					=					num_time_features
												a__					=					lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
												a__					=					scaling
												a__					=					num_dynamic_real_features
												a__					=					num_static_real_features
												a__					=					num_static_categorical_features

												# set cardinality
												if cardinality and num_static_categorical_features > 0:
																			if len(__snake_case				) != 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]

												# set embedding_dimension
												if embedding_dimension and num_static_categorical_features > 0:
																			if len(__snake_case				) != 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(self.lags_sequence				) + 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

												# Informer
												a__					=					attention_type
												a__					=					sampling_factor
												a__					=					distil

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



					@property
					def 			lowerCamelCase__(				self       :Optional[Any]				) ->   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
												)








from __future__ import annotations






def 							__lowercase       (			__lowerCAmelCase							:    float ,   __lowerCAmelCase							:    float ,   __lowerCAmelCase							:    float       ):
							if (voltage, current, resistance).count(0       ) != 1:
														raise ValueError('One and only one argument must be 0'       )
							if resistance < 0:
														raise ValueError('Resistance cannot be negative'       )
							if voltage == 0:
														return {"voltage": float(current * resistance       )}
							elif current == 0:
														return {"current": voltage / resistance}
							elif resistance == 0:
														return {"resistance": voltage / current}
							else:
														raise ValueError('Exactly one argument must be 0'       )


if __name__ == "__main__":
						import doctest

						doctest.testmod()




