



"""simple docstring"""





from typing import List, Optional

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


SCREAMING_SNAKE_CASE					:  str        =						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE					:  Tuple        =						{
    '''huggingface/autoformer-tourism-monthly''': '''https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json''',
}


class    __lowerCamelCase						( lowerCamelCase__     ):
   __UpperCamelCase						= 'autoformer'
   __UpperCamelCase						= {
       'hidden_size': 'd_model',
       'num_attention_heads': 'encoder_attention_heads',
       'num_hidden_layers': 'encoder_layers',
   }







   def __init__(self							,						lowerCamelCase = None							,						lowerCamelCase = None							,						lowerCamelCase = "student_t"							,						lowerCamelCase = "nll"							,						lowerCamelCase = 1							,						lowerCamelCase = [1, 2, 3, 4, 5, 6, 7]							,						lowerCamelCase = True							,						lowerCamelCase = 0							,						lowerCamelCase = 0							,						lowerCamelCase = 0							,						lowerCamelCase = 0							,						lowerCamelCase = None							,						lowerCamelCase = None							,						lowerCamelCase = 64							,						lowerCamelCase = 2							,						lowerCamelCase = 2							,						lowerCamelCase = 2							,						lowerCamelCase = 2							,						lowerCamelCase = 32							,						lowerCamelCase = 32							,						lowerCamelCase = "gelu"							,						lowerCamelCase = 0.1							,						lowerCamelCase = 0.1							,						lowerCamelCase = 0.1							,						lowerCamelCase = 0.1							,						lowerCamelCase = 0.1							,						lowerCamelCase = 100							,						lowerCamelCase = 0.02							,						lowerCamelCase = True							,						lowerCamelCase=True							,						lowerCamelCase = 10							,						lowerCamelCase = 25							,						lowerCamelCase = 3							,						**lowerCamelCase							,						):




      '''simple docstring'''




      _lowerCAmelCase         =		prediction_length
      _lowerCAmelCase         =		context_length if context_length is not None else prediction_length
      _lowerCAmelCase         =		distribution_output
      _lowerCAmelCase         =		loss
      _lowerCAmelCase         =		input_size
      _lowerCAmelCase         =		num_time_features
      _lowerCAmelCase         =		lags_sequence
      _lowerCAmelCase         =		scaling
      _lowerCAmelCase         =		num_dynamic_real_features
      _lowerCAmelCase         =		num_static_real_features
      _lowerCAmelCase         =		num_static_categorical_features
      if cardinality is not None 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`"""					)
         _lowerCAmelCase         =		cardinality
      else:
         _lowerCAmelCase         =		[0]
      if embedding_dimension is not None 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`"""					)
         _lowerCAmelCase         =		embedding_dimension
      else:
         _lowerCAmelCase         =		[min(50							,						(cat + 1) // 2					) for cat in self.cardinality]
      _lowerCAmelCase         =		num_parallel_samples

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

      _lowerCAmelCase         =		dropout
      _lowerCAmelCase         =		attention_dropout
      _lowerCAmelCase         =		activation_dropout
      _lowerCAmelCase         =		encoder_layerdrop
      _lowerCAmelCase         =		decoder_layerdrop

      _lowerCAmelCase         =		activation_function
      _lowerCAmelCase         =		init_std

      _lowerCAmelCase         =		use_cache

      # Autoformer
      _lowerCAmelCase         =		label_length
      _lowerCAmelCase         =		moving_average
      _lowerCAmelCase         =		autocorrelation_factor

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







   @property
   def 				A__    (self					):




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






from __future__ import annotations




def  __UpperCAmelCase(   lowercase_			,     lowercase_ = None			,     lowercase_ = None			,     lowercase_ = False			,     ):
       _lowerCamelCase				:  Tuple						=		cipher_alphabet or [chr(lowercase_   ) for i in range(97			,     1_23   )]

       # If the argument is None or the user provided an empty dictionary
       if not frequencies_dict:
              # Frequencies of letters in the english language (how much they show up)
              _lowerCamelCase				:  Dict						=		{
                  '''a''': 0.0_8_4_9_7,
                  '''b''': 0.0_1_4_9_2,
                  '''c''': 0.0_2_2_0_2,
                  '''d''': 0.0_4_2_5_3,
                  '''e''': 0.1_1_1_6_2,
                  '''f''': 0.0_2_2_2_8,
                  '''g''': 0.0_2_0_1_5,
                  '''h''': 0.0_6_0_9_4,
                  '''i''': 0.0_7_5_4_6,
                  '''j''': 0.0_0_1_5_3,
                  '''k''': 0.0_1_2_9_2,
                  '''l''': 0.0_4_0_2_5,
                  '''m''': 0.0_2_4_0_6,
                  '''n''': 0.0_6_7_4_9,
                  '''o''': 0.0_7_5_0_7,
                  '''p''': 0.0_1_9_2_9,
                  '''q''': 0.0_0_0_9_5,
                  '''r''': 0.0_7_5_8_7,
                  '''s''': 0.0_6_3_2_7,
                  '''t''': 0.0_9_3_5_6,
                  '''u''': 0.0_2_7_5_8,
                  '''v''': 0.0_0_9_7_8,
                  '''w''': 0.0_2_5_6_0,
                  '''x''': 0.0_0_1_5_0,
                  '''y''': 0.0_1_9_9_4,
                  '''z''': 0.0_0_0_7_7,
              }
       else:
              # Custom frequencies dictionary
              _lowerCamelCase				:  Tuple						=		frequencies_dict

       if not case_sensitive:
              _lowerCamelCase				:  Optional[int]						=		ciphertext.lower()

       # Chi squared statistic values
       _lowerCamelCase				:  dict[int, tuple[float, str]]						=		{}

       # cycle through all of the shifts
       for shift in range(len(lowercase_   )   ):
              _lowerCamelCase				:  Any						=		''''''

              # decrypt the message with the shift
              for letter in ciphertext:
                     try:
                            # Try to index the letter in the alphabet
                            _lowerCamelCase				:  int						=		(alphabet_letters.index(letter.lower()   ) - shift) % len(
                                lowercase_   )
                            decrypted_with_shift += (
                                alphabet_letters[new_key].upper()
                                if case_sensitive and letter.isupper()
                                else alphabet_letters[new_key]
                            )
                     except ValueError:
                            # Append the character if it isn't in the alphabet
                            decrypted_with_shift += letter

              _lowerCamelCase				:  Optional[Any]						=		0.0

              # Loop through each letter in the decoded message with the shift
              for letter in decrypted_with_shift:
                     if case_sensitive:
                            _lowerCamelCase				:  Any						=		letter.lower()
                            if letter in frequencies:
                                   # Get the amount of times the letter occurs in the message
                                   _lowerCamelCase				:  List[str]						=		decrypted_with_shift.lower().count(lowercase_   )

                                   # Get the excepcted amount of times the letter should appear based
                                   # on letter frequencies
                                   _lowerCamelCase				:  Optional[Any]						=		frequencies[letter] * occurrences

                                   # Complete the chi squared statistic formula
                                   _lowerCamelCase				:  int						=		((occurrences - expected) ** 2) / expected

                                   # Add the margin of error to the total chi squared statistic
                                   chi_squared_statistic += chi_letter_value
                     else:
                            if letter.lower() in frequencies:
                                   # Get the amount of times the letter occurs in the message
                                   _lowerCamelCase				:  Union[str, Any]						=		decrypted_with_shift.count(lowercase_   )

                                   # Get the excepcted amount of times the letter should appear based
                                   # on letter frequencies
                                   _lowerCamelCase				:  List[str]						=		frequencies[letter] * occurrences

                                   # Complete the chi squared statistic formula
                                   _lowerCamelCase				:  str						=		((occurrences - expected) ** 2) / expected

                                   # Add the margin of error to the total chi squared statistic
                                   chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
              _lowerCamelCase				:  Tuple						=		(
                  chi_squared_statistic,
                  decrypted_with_shift,
              )

       # Get the most likely cipher by finding the cipher with the smallest chi squared
       # statistic
       def chi_squared_statistic_values_sorting_key(lowercase_   ) -> tuple[float, str]:
              return chi_squared_statistic_values[key]

       _lowerCamelCase				:  int						=		min(
           lowercase_			,     key=lowercase_			,     )

       # Get all the data from the most likely cipher (key, decoded message)
       (
           (
           _lowerCamelCase
       ),	(
           _lowerCamelCase
       ),	
       )				:  Optional[int]						=		chi_squared_statistic_values[most_likely_cipher]

       # Return the data on the most likely shift
       return (
           most_likely_cipher,
           most_likely_cipher_chi_squared_value,
           decoded_most_likely_cipher,
       )

