


import math
import time
from typing import Dict, List, Optional

from torch.utils.data import Dataset

from transformers import SeqaSeqTrainer, is_torch_tpu_available
from transformers.trainer_utils import PredictionOutput, speed_metrics


if is_torch_tpu_available(check_device=False):
   import torch_xla.core.xla_model as xm
   import torch_xla.debug.metrics as met







class lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

 def __init__(			self	,   *_UpperCAmelCase	,   _UpperCAmelCase=None	,   _UpperCAmelCase=None	,   **_UpperCAmelCase      ):
       super().__init__(*_UpperCAmelCase	,   **_UpperCAmelCase      )
       snake_case_ =   eval_examples
       snake_case_ =   post_process_function



 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase = None	,   _UpperCAmelCase=None	,   _UpperCAmelCase = None	,   _UpperCAmelCase = "eval"	,   **_UpperCAmelCase	,   ):
       snake_case_ =   gen_kwargs.copy()
       snake_case_ =   (
           gen_kwargs['''max_length'''] if gen_kwargs.get('''max_length'''      ) is not None else self.args.generation_max_length
       )
       snake_case_ =   (
           gen_kwargs['''num_beams'''] if gen_kwargs.get('''num_beams'''      ) is not None else self.args.generation_num_beams
       )
       snake_case_ =   gen_kwargs

       snake_case_ =   self.eval_dataset if eval_dataset is None else eval_dataset
       snake_case_ =   self.get_eval_dataloader(_UpperCAmelCase      )
       snake_case_ =   self.eval_examples if eval_examples is None else eval_examples

       # Temporarily disable metric computation, we will do it in the loop here.
       snake_case_ =   self.compute_metrics
       snake_case_ =   None
       snake_case_ =   time.time()
       snake_case_ =   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
       try:
             snake_case_ =   eval_loop(
                 _UpperCAmelCase	,   description='''Evaluation'''	,   prediction_loss_only=True if compute_metrics is None else None	,   ignore_keys=_UpperCAmelCase	,   metric_key_prefix=_UpperCAmelCase	,   )
       finally:
             snake_case_ =   compute_metrics
       snake_case_ =   self.args.eval_batch_size * self.args.world_size
       if F'''{metric_key_prefix}_jit_compilation_time''' in output.metrics:
             start_time += output.metrics[F'''{metric_key_prefix}_jit_compilation_time''']
       output.metrics.update(
           speed_metrics(
               _UpperCAmelCase	,   _UpperCAmelCase	,   num_samples=output.num_samples	,   num_steps=math.ceil(output.num_samples / total_batch_size      )	,   )      )

       if self.post_process_function is not None and self.compute_metrics is not None and self.args.should_save:
             # Only the main node write the results by default
             snake_case_ =   self.post_process_function(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase      )
             snake_case_ =   self.compute_metrics(_UpperCAmelCase      )

             # Prefix all keys with metric_key_prefix + '_'
             for key in list(metrics.keys()      ):
                   if not key.startswith(F'''{metric_key_prefix}_'''      ):
                         snake_case_ =   metrics.pop(_UpperCAmelCase      )

             metrics.update(output.metrics      )
       else:
             snake_case_ =   output.metrics

       if self.args.should_log:
             # Only the main node log the results by default
             self.log(_UpperCAmelCase      )

       if self.args.tpu_metrics_debug or self.args.debug:
             # tpu-comment: Logging debug metrics for PyTorch/XLA (compile, execute times, ops, etc.)
             xm.master_print(met.metrics_report()      )

       snake_case_ =   self.callback_handler.on_evaluate(self.args	,   self.state	,   self.control	,   _UpperCAmelCase      )
       return metrics





 def 		UpperCamelCase__  (			self	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase=None	,   _UpperCAmelCase = "test"	,   **_UpperCAmelCase      ):
       snake_case_ =   gen_kwargs.copy()

       snake_case_ =   self.get_test_dataloader(_UpperCAmelCase      )

       # Temporarily disable metric computation, we will do it in the loop here.
       snake_case_ =   self.compute_metrics
       snake_case_ =   None
       snake_case_ =   time.time()
       snake_case_ =   self.prediction_loop if self.args.use_legacy_prediction_loop else self.evaluation_loop
       try:
             snake_case_ =   eval_loop(
                 _UpperCAmelCase	,   description='''Prediction'''	,   prediction_loss_only=True if compute_metrics is None else None	,   ignore_keys=_UpperCAmelCase	,   metric_key_prefix=_UpperCAmelCase	,   )
       finally:
             snake_case_ =   compute_metrics

       snake_case_ =   self.args.eval_batch_size * self.args.world_size
       if F'''{metric_key_prefix}_jit_compilation_time''' in output.metrics:
             start_time += output.metrics[F'''{metric_key_prefix}_jit_compilation_time''']
       output.metrics.update(
           speed_metrics(
               _UpperCAmelCase	,   _UpperCAmelCase	,   num_samples=output.num_samples	,   num_steps=math.ceil(output.num_samples / total_batch_size      )	,   )      )
       if self.post_process_function is None or self.compute_metrics is None:
             return output

       snake_case_ =   self.post_process_function(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   '''predict'''      )
       snake_case_ =   self.compute_metrics(_UpperCAmelCase      )

       # Prefix all keys with metric_key_prefix + '_'
       for key in list(metrics.keys()      ):
             if not key.startswith(F'''{metric_key_prefix}_'''      ):
                   snake_case_ =   metrics.pop(_UpperCAmelCase      )
       metrics.update(output.metrics      )
       return PredictionOutput(predictions=predictions.predictions	,   label_ids=predictions.label_ids	,   metrics=_UpperCAmelCase      )



from typing import List, Optional, Union

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


UpperCAmelCase    =					logging.get_logger(__name__)

UpperCAmelCase    =					{
    """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 lowerCAmelCase_		(				lowerCamelCase__ ):

 '''simple docstring'''

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



 def __init__(			self	,   _UpperCAmelCase = None	,   _UpperCAmelCase = None	,   _UpperCAmelCase = "student_t"	,   _UpperCAmelCase = "nll"	,   _UpperCAmelCase = 1	,   _UpperCAmelCase = None	,   _UpperCAmelCase = "mean"	,   _UpperCAmelCase = 0	,   _UpperCAmelCase = 0	,   _UpperCAmelCase = 0	,   _UpperCAmelCase = 0	,   _UpperCAmelCase = None	,   _UpperCAmelCase = None	,   _UpperCAmelCase = 64	,   _UpperCAmelCase = 32	,   _UpperCAmelCase = 32	,   _UpperCAmelCase = 2	,   _UpperCAmelCase = 2	,   _UpperCAmelCase = 2	,   _UpperCAmelCase = 2	,   _UpperCAmelCase = True	,   _UpperCAmelCase = "gelu"	,   _UpperCAmelCase = 0.05	,   _UpperCAmelCase = 0.1	,   _UpperCAmelCase = 0.1	,   _UpperCAmelCase = 0.1	,   _UpperCAmelCase = 0.1	,   _UpperCAmelCase = 1_00	,   _UpperCAmelCase = 0.02	,   _UpperCAmelCase=True	,   _UpperCAmelCase = "prob"	,   _UpperCAmelCase = 5	,   _UpperCAmelCase = True	,   **_UpperCAmelCase	,   ):
       # time series specific configuration
       snake_case_ =   prediction_length
       snake_case_ =   context_length or prediction_length
       snake_case_ =   distribution_output
       snake_case_ =   loss
       snake_case_ =   input_size
       snake_case_ =   num_time_features
       snake_case_ =   lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
       snake_case_ =   scaling
       snake_case_ =   num_dynamic_real_features
       snake_case_ =   num_static_real_features
       snake_case_ =   num_static_categorical_features

       # set cardinality
       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`'''      )
             snake_case_ =   cardinality
       else:
             snake_case_ =   [0]

       # set embedding_dimension
       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`'''      )
             snake_case_ =   embedding_dimension
       else:
             snake_case_ =   [min(50	,   (cat + 1) // 2      ) for cat in self.cardinality]

       snake_case_ =   num_parallel_samples

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

       snake_case_ =   dropout
       snake_case_ =   attention_dropout
       snake_case_ =   activation_dropout
       snake_case_ =   encoder_layerdrop
       snake_case_ =   decoder_layerdrop

       snake_case_ =   activation_function
       snake_case_ =   init_std

       snake_case_ =   use_cache

       # Informer
       snake_case_ =   attention_type
       snake_case_ =   sampling_factor
       snake_case_ =   distil

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





 @property
 def 		UpperCamelCase__  (			self      ):
       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
       )