
"""simple docstring"""





import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


__magic_name__       =			logging.get_logger(__name__)
class 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  str						   =		['''input_values''', '''attention_mask''']




		def __init__(     self							,  lowerCAmelCase__ = 1							,  lowerCAmelCase__ = 1_6_0_0_0							,  lowerCAmelCase__ = 0.0							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = 8_0							,  lowerCAmelCase__ = 1_6							,  lowerCAmelCase__ = 6_4							,  lowerCAmelCase__ = "hann_window"							,  lowerCAmelCase__ = 1.0							,  lowerCAmelCase__ = 8_0							,  lowerCAmelCase__ = 7_6_0_0							,  lowerCAmelCase__ = 1E-10							,  lowerCAmelCase__ = 2							,  lowerCAmelCase__ = True							,  **lowerCAmelCase__							,  ):
				super().__init__(feature_size=lowerCAmelCase__							,  sampling_rate=lowerCAmelCase__							,  padding_value=lowerCAmelCase__							,  **lowerCAmelCase__)
				__SCREAMING_SNAKE_CASE            = do_normalize
				__SCREAMING_SNAKE_CASE            = return_attention_mask

				__SCREAMING_SNAKE_CASE            = num_mel_bins
				__SCREAMING_SNAKE_CASE            = hop_length
				__SCREAMING_SNAKE_CASE            = win_length
				__SCREAMING_SNAKE_CASE            = win_function
				__SCREAMING_SNAKE_CASE            = frame_signal_scale
				__SCREAMING_SNAKE_CASE            = fmin
				__SCREAMING_SNAKE_CASE            = fmax
				__SCREAMING_SNAKE_CASE            = mel_floor
				__SCREAMING_SNAKE_CASE            = reduction_factor

				__SCREAMING_SNAKE_CASE            = win_length * sampling_rate // 1_0_0_0
				__SCREAMING_SNAKE_CASE            = hop_length * sampling_rate // 1_0_0_0
				__SCREAMING_SNAKE_CASE            = optimal_fft_length(self.sample_size)
				__SCREAMING_SNAKE_CASE            = (self.n_fft // 2) + 1

				__SCREAMING_SNAKE_CASE            = window_function(window_length=self.sample_size							,  name=self.win_function							,  periodic=lowerCAmelCase__)

				__SCREAMING_SNAKE_CASE            = mel_filter_bank(
				    num_frequency_bins=self.n_freqs							,  num_mel_filters=self.num_mel_bins							,  min_frequency=self.fmin							,  max_frequency=self.fmax							,  sampling_rate=self.sampling_rate							,  norm="""slaney"""							,  mel_scale="""slaney"""							,  )

				if frame_signal_scale != 1.0:
						warnings.warn(
						    """The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers"""							,  lowerCAmelCase__							,  )
				if reduction_factor != 2.0:
						warnings.warn(
						    """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"""							,  lowerCAmelCase__							,  )




		@staticmethod
		# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
		def 	snake_case_     (     lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__ = 0.0):
				if attention_mask is not None:
						__SCREAMING_SNAKE_CASE            = np.array(lowerCAmelCase__							,  np.intaa)
						__SCREAMING_SNAKE_CASE            = []

						for vector, length in zip(lowerCAmelCase__							,  attention_mask.sum(-1)):
								__SCREAMING_SNAKE_CASE            = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7)
								if length < normed_slice.shape[0]:
										__SCREAMING_SNAKE_CASE            = padding_value

								normed_input_values.append(lowerCAmelCase__)
				else:
						__SCREAMING_SNAKE_CASE            = [(x - x.mean()) / np.sqrt(x.var() + 1E-7) for x in input_values]

				return normed_input_values




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  ):
				__SCREAMING_SNAKE_CASE            = spectrogram(
				    lowerCAmelCase__							,  window=self.window							,  frame_length=self.sample_size							,  hop_length=self.sample_stride							,  fft_length=self.n_fft							,  mel_filters=self.mel_filters							,  mel_floor=self.mel_floor							,  log_mel="""log10"""							,  )
				return log_mel_spec.T




		def __call__(     self							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				if audio is None and audio_target is None:
						raise ValueError("""You must provide either `audio` or `audio_target` values.""")

				if sampling_rate is not None:
						if sampling_rate != self.sampling_rate:
								raise ValueError(
								    f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
								    f" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
								    f" {self.sampling_rate} and not {sampling_rate}.")
				else:
						logger.warning(
						    """It is strongly recommended to pass the ``sampling_rate`` argument to this function. """
						    """Failing to do so can result in silent errors that might be hard to debug.""")

				if audio is not None:
						__SCREAMING_SNAKE_CASE            = self._process_audio(
						    lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  **lowerCAmelCase__							,  )
				else:
						__SCREAMING_SNAKE_CASE            = None

				if audio_target is not None:
						__SCREAMING_SNAKE_CASE            = self._process_audio(
						    lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  lowerCAmelCase__							,  **lowerCAmelCase__							,  )

						if inputs is None:
								return inputs_target
						else:
								__SCREAMING_SNAKE_CASE            = inputs_target["""input_values"""]
								__SCREAMING_SNAKE_CASE            = inputs_target.get("""attention_mask""")
								if decoder_attention_mask is not None:
										__SCREAMING_SNAKE_CASE            = decoder_attention_mask

				return inputs




		def 	snake_case_     (     self							,  lowerCAmelCase__							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = False							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  **lowerCAmelCase__							,  ):
				__SCREAMING_SNAKE_CASE            = isinstance(lowerCAmelCase__							,  np.ndarray) and len(speech.shape) > 1
				if is_batched_numpy and len(speech.shape) > 2:
						raise ValueError(f"Only mono-channel audio is supported for input to {self}")
				__SCREAMING_SNAKE_CASE            = is_batched_numpy or (
				    isinstance(lowerCAmelCase__							,  (list, tuple)) and (isinstance(speech[0]							,  (np.ndarray, tuple, list)))
				)

				if is_batched:
						__SCREAMING_SNAKE_CASE            = [np.asarray(lowerCAmelCase__							,  dtype=np.floataa) for speech in speech]
				elif not is_batched and not isinstance(lowerCAmelCase__							,  np.ndarray):
						__SCREAMING_SNAKE_CASE            = np.asarray(lowerCAmelCase__							,  dtype=np.floataa)
				elif isinstance(lowerCAmelCase__							,  np.ndarray) and speech.dtype is np.dtype(np.floataa):
						__SCREAMING_SNAKE_CASE            = speech.astype(np.floataa)

				# always return batch
				if not is_batched:
						__SCREAMING_SNAKE_CASE            = [speech]

				# needed to make pad() work on spectrogram inputs
				__SCREAMING_SNAKE_CASE            = self.feature_size

				# convert into correct format for padding
				if is_target:
						__SCREAMING_SNAKE_CASE            = [self._extract_mel_features(lowerCAmelCase__) for waveform in speech]
						__SCREAMING_SNAKE_CASE            = BatchFeature({"""input_values""": features})
						__SCREAMING_SNAKE_CASE            = self.num_mel_bins
				else:
						__SCREAMING_SNAKE_CASE            = BatchFeature({"""input_values""": speech})

				__SCREAMING_SNAKE_CASE            = self.pad(
				    lowerCAmelCase__							,  padding=lowerCAmelCase__							,  max_length=lowerCAmelCase__							,  truncation=lowerCAmelCase__							,  pad_to_multiple_of=lowerCAmelCase__							,  return_attention_mask=lowerCAmelCase__							,  **lowerCAmelCase__							,  )

				__SCREAMING_SNAKE_CASE            = feature_size_hack

				# convert input values to correct format
				__SCREAMING_SNAKE_CASE            = padded_inputs["""input_values"""]
				if not isinstance(input_values[0]							,  np.ndarray):
						__SCREAMING_SNAKE_CASE            = [np.asarray(lowerCAmelCase__							,  dtype=np.floataa) for array in input_values]
				elif (
				    not isinstance(lowerCAmelCase__							,  np.ndarray)
				    and isinstance(input_values[0]							,  np.ndarray)
				    and input_values[0].dtype is np.dtype(np.floataa)
				):
						__SCREAMING_SNAKE_CASE            = [array.astype(np.floataa) for array in input_values]
				elif isinstance(lowerCAmelCase__							,  np.ndarray) and input_values.dtype is np.dtype(np.floataa):
						__SCREAMING_SNAKE_CASE            = input_values.astype(np.floataa)

				# convert attention_mask to correct format
				__SCREAMING_SNAKE_CASE            = padded_inputs.get("""attention_mask""")
				if attention_mask is not None:
						__SCREAMING_SNAKE_CASE            = [np.asarray(lowerCAmelCase__							,  dtype=np.intaa) for array in attention_mask]

				# zero-mean and unit-variance normalization
				if not is_target and self.do_normalize:
						__SCREAMING_SNAKE_CASE            = (
						    attention_mask
						    if self._get_padding_strategies(lowerCAmelCase__							,  max_length=lowerCAmelCase__) is not PaddingStrategy.DO_NOT_PAD
						    else None
						)
						__SCREAMING_SNAKE_CASE            = self.zero_mean_unit_var_norm(
						    padded_inputs["""input_values"""]							,  attention_mask=lowerCAmelCase__							,  padding_value=self.padding_value)

				if return_tensors is not None:
						__SCREAMING_SNAKE_CASE            = padded_inputs.convert_to_tensors(lowerCAmelCase__)

				return padded_inputs




		def 	snake_case_     (     self):
				__SCREAMING_SNAKE_CASE            = super().to_dict()

				# Don't serialize these as they are derived from the other properties.
				__SCREAMING_SNAKE_CASE            = ["""window""", """mel_filters""", """sample_size""", """sample_stride""", """n_fft""", """n_freqs"""]
				for name in names:
						if name in output:
								del output[name]

				return output






"""simple docstring"""





from typing import List, Optional, Union

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


__magic_name__       =			logging.get_logger(__name__)

__magic_name__       =			{
    "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 						SCREAMING_SNAKE_CASE_ (						__a ):




		"""simple docstring"""





		__lowercase							:  Dict						   =		'''informer'''
		__lowercase							:  Union[str, Any]						   =		{
		    '''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__ = None							,  lowerCAmelCase__ = "mean"							,  lowerCAmelCase__ = 0							,  lowerCAmelCase__ = 0							,  lowerCAmelCase__ = 0							,  lowerCAmelCase__ = 0							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = None							,  lowerCAmelCase__ = 6_4							,  lowerCAmelCase__ = 3_2							,  lowerCAmelCase__ = 3_2							,  lowerCAmelCase__ = 2							,  lowerCAmelCase__ = 2							,  lowerCAmelCase__ = 2							,  lowerCAmelCase__ = 2							,  lowerCAmelCase__ = True							,  lowerCAmelCase__ = "gelu"							,  lowerCAmelCase__ = 0.05							,  lowerCAmelCase__ = 0.1							,  lowerCAmelCase__ = 0.1							,  lowerCAmelCase__ = 0.1							,  lowerCAmelCase__ = 0.1							,  lowerCAmelCase__ = 1_0_0							,  lowerCAmelCase__ = 0.02							,  lowerCAmelCase__=True							,  lowerCAmelCase__ = "prob"							,  lowerCAmelCase__ = 5							,  lowerCAmelCase__ = True							,  **lowerCAmelCase__							,  ):
				# time series specific configuration
				__SCREAMING_SNAKE_CASE            = prediction_length
				__SCREAMING_SNAKE_CASE            = context_length or prediction_length
				__SCREAMING_SNAKE_CASE            = distribution_output
				__SCREAMING_SNAKE_CASE            = loss
				__SCREAMING_SNAKE_CASE            = input_size
				__SCREAMING_SNAKE_CASE            = num_time_features
				__SCREAMING_SNAKE_CASE            = lags_sequence if lags_sequence is not None else [1, 2, 3, 4, 5, 6, 7]
				__SCREAMING_SNAKE_CASE            = scaling
				__SCREAMING_SNAKE_CASE            = num_dynamic_real_features
				__SCREAMING_SNAKE_CASE            = num_static_real_features
				__SCREAMING_SNAKE_CASE            = num_static_categorical_features

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

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

				__SCREAMING_SNAKE_CASE            = num_parallel_samples

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

				__SCREAMING_SNAKE_CASE            = dropout
				__SCREAMING_SNAKE_CASE            = attention_dropout
				__SCREAMING_SNAKE_CASE            = activation_dropout
				__SCREAMING_SNAKE_CASE            = encoder_layerdrop
				__SCREAMING_SNAKE_CASE            = decoder_layerdrop

				__SCREAMING_SNAKE_CASE            = activation_function
				__SCREAMING_SNAKE_CASE            = init_std

				__SCREAMING_SNAKE_CASE            = use_cache

				# Informer
				__SCREAMING_SNAKE_CASE            = attention_type
				__SCREAMING_SNAKE_CASE            = sampling_factor
				__SCREAMING_SNAKE_CASE            = distil

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




		@property
		def 	snake_case_     (     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
				)




