





from typing import List, Optional, Union

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


__UpperCAmelCase       :   Tuple				       =							logging.get_logger(__name__)

__UpperCAmelCase       :   Optional[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			):





       '''simple docstring'''







       lowerCAmelCase__      		=     """informer"""
       lowerCAmelCase__      		=     {
           """hidden_size""": """d_model""",
           """num_attention_heads""": """encoder_attention_heads""",
           """num_hidden_layers""": """encoder_layers""",
       }




       def __init__(  self :    List[Any]							,				A :    Union[str, Any] = None							,				A :    int = None							,				A :    Any = "student_t"							,				A :    int = "nll"							,				A :    List[str] = 1							,				A :    Any = None							,				A :    Tuple = "mean"							,				A :    Union[str, Any] = 0							,				A :    Optional[Any] = 0							,				A :    Any = 0							,				A :    str = 0							,				A :    Any = None							,				A :    Dict = None							,				A :    Tuple = 64							,				A :    Optional[Any] = 32							,				A :    Tuple = 32							,				A :    List[Any] = 2							,				A :    str = 2							,				A :    str = 2							,				A :    Optional[int] = 2							,				A :    List[str] = True							,				A :    Union[str, Any] = "gelu"							,				A :    List[Any] = 0.05							,				A :    Any = 0.1							,				A :    Optional[int] = 0.1							,				A :    Dict = 0.1							,				A :    Tuple = 0.1							,				A :    List[Any] = 100							,				A :    Union[str, Any] = 0.02							,				A :    Optional[int]=True							,				A :    str = "prob"							,				A :    List[str] = 5							,				A :    Any = True							,				**A :    List[Any]							,				):
         __snake_case:						Any   =						prediction_length
         __snake_case:						Optional[Any]   =						context_length or prediction_length
         __snake_case:						int   =						distribution_output
         __snake_case:						Optional[Any]   =						loss
         __snake_case:						Union[str, Any]   =						input_size
         __snake_case:						Any   =						num_time_features
         __snake_case:						Optional[int]   =						lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
         __snake_case:						Tuple   =						scaling
         __snake_case:						int   =						num_dynamic_real_features
         __snake_case:						Union[str, Any]   =						num_static_real_features
         __snake_case:						int   =						num_static_categorical_features

         # set cardinality
         if cardinality and num_static_categorical_features > 0:
           if len(__a		) != num_static_categorical_features:
             raise ValueError(
                 """The cardinality should be a list of the same length as `num_static_categorical_features`"""		)
           __snake_case:						Optional[Any]   =						cardinality
         else:
           __snake_case:						str   =						[0]

         # set embedding_dimension
         if embedding_dimension and num_static_categorical_features > 0:
           if len(__a		) != num_static_categorical_features:
             raise ValueError(
                 """The embedding dimension should be a list of the same length as `num_static_categorical_features`"""		)
           __snake_case:						List[str]   =						embedding_dimension
         else:
           __snake_case:						List[Any]   =						[min(50							,				(cat + 1) // 2		) for cat in self.cardinality]

         __snake_case:						Tuple   =						num_parallel_samples

         # Transformer architecture configuration
         __snake_case:						Tuple   =						input_size * len(self.lags_sequence		) + self._number_of_features
         __snake_case:						Optional[Any]   =						d_model
         __snake_case:						Optional[Any]   =						encoder_attention_heads
         __snake_case:						List[str]   =						decoder_attention_heads
         __snake_case:						Dict   =						encoder_ffn_dim
         __snake_case:						Optional[Any]   =						decoder_ffn_dim
         __snake_case:						Optional[Any]   =						encoder_layers
         __snake_case:						List[str]   =						decoder_layers

         __snake_case:						List[str]   =						dropout
         __snake_case:						List[str]   =						attention_dropout
         __snake_case:						int   =						activation_dropout
         __snake_case:						int   =						encoder_layerdrop
         __snake_case:						List[Any]   =						decoder_layerdrop

         __snake_case:						List[str]   =						activation_function
         __snake_case:						int   =						init_std

         __snake_case:						List[str]   =						use_cache

         # Informer
         __snake_case:						Any   =						attention_type
         __snake_case:						Any   =						sampling_factor
         __snake_case:						Tuple   =						distil

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






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








"""simple docstring"""





import torch
from torch import nn






class     _UpperCAmelCase(    nn.Module	):



		def __init__(					self				,		__a				,		__a				,		__a				,		__a				,		__a=1				,		__a=False)       ->       Tuple:






							'''simple docstring'''
							super().__init__()

							_UpperCamelCase							 =  n_token
							_UpperCamelCase							 =  d_embed
							_UpperCamelCase							 =  d_proj

							_UpperCamelCase							 =  cutoffs + [n_token]
							_UpperCamelCase							 =  [0] + self.cutoffs
							_UpperCamelCase							 =  div_val

							_UpperCamelCase							 =  self.cutoffs[0]
							_UpperCamelCase							 =  len(self.cutoffs) - 1
							_UpperCamelCase							 =  self.shortlist_size + self.n_clusters

							if self.n_clusters > 0:
												_UpperCamelCase							 =  nn.Parameter(torch.zeros(self.n_clusters				,		self.d_embed))
												_UpperCamelCase							 =  nn.Parameter(torch.zeros(self.n_clusters))

							_UpperCamelCase							 =  nn.ModuleList()
							_UpperCamelCase							 =  nn.ParameterList()

							if div_val == 1:
												for i in range(len(self.cutoffs)):
																	if d_proj != d_embed:
																						self.out_projs.append(nn.Parameter(torch.FloatTensor(__a				,		__a)))
																	else:
																						self.out_projs.append(__a)

												self.out_layers.append(nn.Linear(__a				,		__a))
							else:
												for i in range(len(self.cutoffs)):
																	_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																	_UpperCamelCase							 =  d_embed // (div_val**i)

																	self.out_projs.append(nn.Parameter(torch.FloatTensor(__a				,		__a)))

																	self.out_layers.append(nn.Linear(__a				,		r_idx - l_idx))

							_UpperCamelCase							 =  keep_order



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a)       ->       Any:






							'''simple docstring'''
							if proj is None:
												_UpperCamelCase							 =  nn.functional.linear(__a				,		__a				,		bias=__a)
							else:
												# if CUDA_MAJOR <= 9 and CUDA_MINOR <= 1:
												_UpperCamelCase							 =  nn.functional.linear(__a				,		proj.t().contiguous())
												_UpperCamelCase							 =  nn.functional.linear(__a				,		__a				,		bias=__a)
												# else:
												#     logit = torch.einsum('bd,de,ev->bv', (hidden, proj, weight.t()))
												#     if bias is not None:
												#         logit = logit + bias

							return logit



		def 						UpperCAmelCase							(					self				,		__a				,		__a=None				,		__a=False)       ->       Dict:






							'''simple docstring'''

							if labels is not None:
												# Shift so that tokens < n predict n
												_UpperCamelCase							 =  hidden[..., :-1, :].contiguous()
												_UpperCamelCase							 =  labels[..., 1:].contiguous()
												_UpperCamelCase							 =  hidden.view(-1				,		hidden.size(-1))
												_UpperCamelCase							 =  labels.view(-1)
												if hidden.size(0) != labels.size(0):
																	raise RuntimeError('''Input and labels should have the same size in the batch dimension.''')
							else:
												_UpperCamelCase							 =  hidden.view(-1				,		hidden.size(-1))

							if self.n_clusters == 0:
												_UpperCamelCase							 =  self._compute_logit(__a				,		self.out_layers[0].weight				,		self.out_layers[0].bias				,		self.out_projs[0])
												if labels is not None:
																	_UpperCamelCase							 =  labels != -1_00
																	_UpperCamelCase							 =  torch.zeros_like(__a				,		dtype=hidden.dtype				,		device=hidden.device)
																	_UpperCamelCase							 =  (
																	    -nn.functional.log_softmax(__a				,		dim=-1)[mask].gather(1				,		labels[mask].unsqueeze(1)).squeeze(1)
																	)
												else:
																	_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=-1)
							else:
												# construct weights and biases
												_UpperCamelCase ,  _UpperCamelCase							 =  [], []
												for i in range(len(self.cutoffs)):
																	if self.div_val == 1:
																						_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																						_UpperCamelCase							 =  self.out_layers[0].weight[l_idx:r_idx]
																						_UpperCamelCase							 =  self.out_layers[0].bias[l_idx:r_idx]
																	else:
																						_UpperCamelCase							 =  self.out_layers[i].weight
																						_UpperCamelCase							 =  self.out_layers[i].bias

																	if i == 0:
																						_UpperCamelCase							 =  torch.cat([weight_i, self.cluster_weight]				,		dim=0)
																						_UpperCamelCase							 =  torch.cat([bias_i, self.cluster_bias]				,		dim=0)

																	weights.append(__a)
																	biases.append(__a)

												_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[0], biases[0], self.out_projs[0]

												_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
												_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

												if labels is None:
																	_UpperCamelCase							 =  hidden.new_empty((head_logit.size(0), self.n_token))
												else:
																	_UpperCamelCase							 =  torch.zeros_like(__a				,		dtype=hidden.dtype				,		device=hidden.device)

												_UpperCamelCase							 =  0
												_UpperCamelCase							 =  [0] + self.cutoffs
												for i in range(len(__a) - 1):
																	_UpperCamelCase ,  _UpperCamelCase							 =  cutoff_values[i], cutoff_values[i + 1]

																	if labels is not None:
																						_UpperCamelCase							 =  (labels >= l_idx) & (labels < r_idx)
																						_UpperCamelCase							 =  mask_i.nonzero().squeeze()

																						if indices_i.numel() == 0:
																											continue

																						_UpperCamelCase							 =  labels.index_select(0				,		__a) - l_idx
																						_UpperCamelCase							 =  head_logprob.index_select(0				,		__a)
																						_UpperCamelCase							 =  hidden.index_select(0				,		__a)
																	else:
																						_UpperCamelCase							 =  hidden

																	if i == 0:
																						if labels is not None:
																											_UpperCamelCase							 =  head_logprob_i.gather(1				,		target_i[:, None]).squeeze(1)
																						else:
																											_UpperCamelCase							 =  head_logprob[:, : self.cutoffs[0]]
																	else:
																						_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[i], biases[i], self.out_projs[i]

																						_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
																						_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)
																						_UpperCamelCase							 =  self.cutoffs[0] + i - 1  # No probability for the head cluster
																						if labels is not None:
																											_UpperCamelCase							 =  head_logprob_i[:, cluster_prob_idx] + tail_logprob_i.gather(
																											    1				,		target_i[:, None]).squeeze(1)
																						else:
																											_UpperCamelCase							 =  head_logprob[:, cluster_prob_idx, None] + tail_logprob_i
																											_UpperCamelCase							 =  logprob_i

																	if labels is not None:
																						if (hasattr(self				,		'''keep_order''') and self.keep_order) or keep_order:
																											out.index_copy_(0				,		__a				,		-logprob_i)
																						else:
																											out[offset : offset + logprob_i.size(0)].copy_(-logprob_i)
																						offset += logprob_i.size(0)

							return out




		def 						UpperCAmelCase							(					self				,		__a)       ->       List[str]:






							'''simple docstring'''
							if self.n_clusters == 0:
												_UpperCamelCase							 =  self._compute_logit(__a				,		self.out_layers[0].weight				,		self.out_layers[0].bias				,		self.out_projs[0])
												return nn.functional.log_softmax(__a				,		dim=-1)
							else:
												# construct weights and biases
												_UpperCamelCase ,  _UpperCamelCase							 =  [], []
												for i in range(len(self.cutoffs)):
																	if self.div_val == 1:
																						_UpperCamelCase ,  _UpperCamelCase							 =  self.cutoff_ends[i], self.cutoff_ends[i + 1]
																						_UpperCamelCase							 =  self.out_layers[0].weight[l_idx:r_idx]
																						_UpperCamelCase							 =  self.out_layers[0].bias[l_idx:r_idx]
																	else:
																						_UpperCamelCase							 =  self.out_layers[i].weight
																						_UpperCamelCase							 =  self.out_layers[i].bias

																	if i == 0:
																						_UpperCamelCase							 =  torch.cat([weight_i, self.cluster_weight]				,		dim=0)
																						_UpperCamelCase							 =  torch.cat([bias_i, self.cluster_bias]				,		dim=0)

																	weights.append(__a)
																	biases.append(__a)

												_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[0], biases[0], self.out_projs[0]
												_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)

												_UpperCamelCase							 =  hidden.new_empty((head_logit.size(0), self.n_token))
												_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

												_UpperCamelCase							 =  [0] + self.cutoffs
												for i in range(len(__a) - 1):
																	_UpperCamelCase ,  _UpperCamelCase							 =  cutoff_values[i], cutoff_values[i + 1]

																	if i == 0:
																						_UpperCamelCase							 =  head_logprob[:, : self.cutoffs[0]]
																	else:
																						_UpperCamelCase ,  _UpperCamelCase ,  _UpperCamelCase							 =  weights[i], biases[i], self.out_projs[i]

																						_UpperCamelCase							 =  self._compute_logit(__a				,		__a				,		__a				,		__a)
																						_UpperCamelCase							 =  nn.functional.log_softmax(__a				,		dim=1)

																						_UpperCamelCase							 =  head_logprob[:, -i] + tail_logprob_i
																						_UpperCamelCase							 =  logprob_i

												return out






