"""simple docstring"""




import inspect

import jax
import jax.lax as lax
import jax.numpy as jnp

from ..utils import add_start_docstrings
from ..utils.logging import get_logger


_a				:		Optional[Any]	   =       get_logger(__name__)


_a				:		List[Any]	   =       r'\n    Args:\n        input_ids (`jnp.ndarray` of shape `(batch_size, sequence_length)`):\n            Indices of input sequence tokens in the vocabulary.\n\n            Indices can be obtained using [`PreTrainedTokenizer`]. See [`PreTrainedTokenizer.encode`] and\n            [`PreTrainedTokenizer.__call__`] for details.\n\n            [What are input IDs?](../glossary#input-ids)\n        scores (`jnp.ndarray` of shape `(batch_size, config.vocab_size)`):\n            Prediction scores of a language modeling head. These can be logits for each vocabulary when not using beam\n            search or log softmax for each vocabulary token when using beam search\n        kwargs (`Dict[str, Any]`, *optional*):\n            Additional logits processor specific kwargs.\n\n    Return:\n        `jnp.ndarray` of shape `(batch_size, config.vocab_size)`: The processed prediction scores.\n\n'
class 						__A							:






     @add_start_docstrings(a__  )
     def __call__(		self    ,					a__    ,					a__  ):
       raise NotImplementedError(
           F"{self.__class__} is an abstract class. Only classes inheriting this class can be called."  )







class 						__A							:






     @add_start_docstrings(a__  )
     def __call__(		self    ,					a__    ,					a__  ):
       raise NotImplementedError(
           F"{self.__class__} is an abstract class. Only classes inheriting this class can be called."  )







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     @add_start_docstrings(a__  )
     def __call__(		self    ,					a__    ,					a__    ,					a__    ,					**a__  ):
       for processor in self:
         _lowerCAmelCase						:	int        =					inspect.signature(processor.__call__  ).parameters
         if len(a__  ) > 3:
           if not all(arg in kwargs for arg in list(function_args.keys()  )[2:]  ):
             raise ValueError(
                 F"Make sure that all the required parameters: {list(function_args.keys()  )} for "
                 F"{processor.__class__} are passed to the logits processor."  )
           _lowerCAmelCase						:	int        =					processor(a__    ,					a__    ,					a__    ,					**a__  )
         else:
           _lowerCAmelCase						:	Tuple        =					processor(a__    ,					a__    ,					a__  )
       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__  ):
       if not isinstance(a__    ,					a__  ) or not (temperature > 0):
         raise ValueError(F"`temperature` has to be a strictly positive float, but is {temperature}"  )

       _lowerCAmelCase						:	Tuple        =					temperature






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	str        =					scores / self.temperature
       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__ = -float("""Inf"""  )    ,					a__ = 1  ):
       if not isinstance(a__    ,					a__  ) or (top_p < 0 or top_p > 1.0):
         raise ValueError(F"`top_p` has to be a float > 0 and < 1, but is {top_p}"  )
       if not isinstance(a__    ,					a__  ) or (min_tokens_to_keep < 1):
         raise ValueError(F"`min_tokens_to_keep` has to be a positive integer, but is {min_tokens_to_keep}"  )

       _lowerCAmelCase						:	Optional[Any]        =					top_p
       _lowerCAmelCase						:	Any        =					filter_value
       _lowerCAmelCase						:	Optional[Any]        =					min_tokens_to_keep






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	str        =					lax.top_k(a__    ,					scores.shape[-1]  )

       _lowerCAmelCase						:	List[Any]        =					jnp.full_like(a__    ,					self.filter_value  )
       _lowerCAmelCase						:	Optional[int]        =					jax.nn.softmax(a__    ,					axis=-1  ).cumsum(axis=-1  )
       _lowerCAmelCase						:	str        =					cumulative_probs < self.top_p

       # include the token that is higher than top_p as well
       _lowerCAmelCase						:	str        =					jnp.roll(a__    ,					1  )
       score_mask |= score_mask.at[:, 0].set(a__  )

       # min tokens to keep
       _lowerCAmelCase						:	List[Any]        =					score_mask.at[:, : self.min_tokens_to_keep].set(a__  )

       _lowerCAmelCase						:	Union[str, Any]        =					jnp.where(a__    ,					a__    ,					a__  )
       _lowerCAmelCase						:	Union[str, Any]        =					jax.lax.sort_key_val(a__    ,					a__  )[-1]

       return next_scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__ = -float("""Inf"""  )    ,					a__ = 1  ):
       if not isinstance(a__    ,					a__  ) or top_k <= 0:
         raise ValueError(F"`top_k` has to be a strictly positive integer, but is {top_k}"  )

       _lowerCAmelCase						:	Optional[Any]        =					max(a__    ,					a__  )
       _lowerCAmelCase						:	List[str]        =					filter_value






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	Any        =					scores.shape
       _lowerCAmelCase						:	Any        =					jnp.full(batch_size * vocab_size    ,					self.filter_value  )

       _lowerCAmelCase						:	int        =					min(self.top_k    ,					scores.shape[-1]  )  # Safety check
       _lowerCAmelCase      ,     _lowerCAmelCase						:	int        =					lax.top_k(a__    ,					a__  )
       _lowerCAmelCase						:	str        =					jnp.broadcast_to((jnp.arange(a__  ) * vocab_size)[:, None]    ,					(batch_size, topk)  ).flatten()
       _lowerCAmelCase						:	Optional[int]        =					topk_scores.flatten()
       _lowerCAmelCase						:	List[str]        =					topk_indices.flatten() + shift

       _lowerCAmelCase						:	Optional[Any]        =					next_scores_flat.at[topk_indices_flat].set(a__  )
       _lowerCAmelCase						:	Optional[int]        =					next_scores_flat.reshape(a__    ,					a__  )
       return next_scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__  ):
       _lowerCAmelCase						:	List[str]        =					bos_token_id






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[Any]        =					jnp.full(scores.shape    ,					-float("""inf"""  )  )

       _lowerCAmelCase						:	Optional[int]        =					1 - jnp.bool_(cur_len - 1  )

       _lowerCAmelCase						:	Tuple        =					jnp.where(a__    ,					new_scores.at[:, self.bos_token_id].set(0  )    ,					a__  )

       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Any        =					max_length
       _lowerCAmelCase						:	int        =					eos_token_id






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	List[Any]        =					jnp.full(scores.shape    ,					-float("""inf"""  )  )

       _lowerCAmelCase						:	int        =					1 - jnp.bool_(cur_len - self.max_length + 1  )

       _lowerCAmelCase						:	Dict        =					jnp.where(a__    ,					new_scores.at[:, self.eos_token_id].set(0  )    ,					a__  )

       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__  ):
       if not isinstance(a__    ,					a__  ) or min_length < 0:
         raise ValueError(F"`min_length` has to be a positive integer, but is {min_length}"  )

       if not isinstance(a__    ,					a__  ) or eos_token_id < 0:
         raise ValueError(F"`eos_token_id` has to be a positive integer, but is {eos_token_id}"  )

       _lowerCAmelCase						:	Optional[int]        =					min_length
       _lowerCAmelCase						:	int        =					eos_token_id






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       # create boolean flag to decide if min length penalty should be applied
       _lowerCAmelCase						:	Optional[int]        =					1 - jnp.clip(cur_len - self.min_length    ,					0    ,					1  )

       _lowerCAmelCase						:	Union[str, Any]        =					jnp.where(a__    ,					scores.at[:, self.eos_token_id].set(-float("""inf"""  )  )    ,					a__  )

       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Dict        =					list(a__  )
       _lowerCAmelCase						:	Union[str, Any]        =					begin_index






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[Any]        =					1 - jnp.bool_(cur_len - self.begin_index  )

       _lowerCAmelCase						:	Optional[Any]        =					jnp.where(a__    ,					scores.at[:, self.begin_suppress_tokens].set(-float("""inf"""  )  )    ,					a__  )

       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__  ):
       _lowerCAmelCase						:	Dict        =					list(a__  )






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Any        =					scores.at[..., self.suppress_tokens].set(-float("""inf"""  )  )

       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__  ):
       _lowerCAmelCase						:	Dict        =					dict(a__  )
       # Converts the dictionary of format {index: token} containing the tokens to be forced to an array, where the
       # index of the array corresponds to the index of the token to be forced, for XLA compatibility.
       # Indexes without forced tokens will have a negative value.
       _lowerCAmelCase						:	Dict        =					jnp.ones((max(force_token_map.keys()  ) + 1)    ,					dtype=jnp.intaa  ) * -1
       for index, token in force_token_map.items():
         if token is not None:
           _lowerCAmelCase						:	List[Any]        =					force_token_array.at[index].set(a__  )
       _lowerCAmelCase						:	Optional[Any]        =					jnp.intaa(a__  )






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       def _force_token(a__  ):
         _lowerCAmelCase						:	Tuple        =					scores.shape[0]
         _lowerCAmelCase						:	List[Any]        =					self.force_token_array[generation_idx]

         _lowerCAmelCase						:	Optional[int]        =					jnp.ones_like(a__    ,					dtype=scores.dtype  ) * -float("""inf"""  )
         _lowerCAmelCase						:	Optional[Any]        =					jnp.zeros((batch_size, 1)    ,					dtype=scores.dtype  )
         _lowerCAmelCase						:	Any        =					lax.dynamic_update_slice(a__    ,					a__    ,					(0, current_token)  )
         return new_scores

       _lowerCAmelCase						:	List[Any]        =					lax.cond(
           cur_len >= self.force_token_array.shape[0]    ,					lambda: scores    ,					lambda: lax.cond(
               self.force_token_array[cur_len] >= 0    ,					lambda: _force_token(a__  )    ,					lambda: scores    ,					)    ,					)
       return scores







class 						__A							(			SCREAMING_SNAKE_CASE_		):






     def __init__(		self    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Tuple        =					generate_config.eos_token_id
       _lowerCAmelCase						:	List[str]        =					generate_config.no_timestamps_token_id
       _lowerCAmelCase						:	Union[str, Any]        =					generate_config.no_timestamps_token_id + 1

       _lowerCAmelCase						:	str        =					decoder_input_length + 1

       if generate_config.is_multilingual:
         # room for language token and task token
         self.begin_index += 2
       if hasattr(a__    ,					"""max_initial_timestamp_index"""  ):
         _lowerCAmelCase						:	Any        =					generate_config.max_initial_timestamp_index
       else:
         _lowerCAmelCase						:	Dict        =					model_config.vocab_size
       if self.max_initial_timestamp_index is None:
         _lowerCAmelCase						:	Optional[int]        =					model_config.vocab_size






     def __call__(		self    ,					a__    ,					a__    ,					a__  ):
       # suppress <|notimestamps|> which is handled by without_timestamps
       _lowerCAmelCase						:	Tuple        =					scores.at[:, self.no_timestamps_token_id].set(-float("""inf"""  )  )

       def handle_pairs(a__    ,					a__  ):
         _lowerCAmelCase						:	Union[str, Any]        =					jnp.where((cur_len - self.begin_index) >= 1    ,					a__    ,					a__  )
         _lowerCAmelCase						:	Union[str, Any]        =					jnp.where(
             input_ids_k[cur_len - 1] >= self.timestamp_begin    ,					True and last_was_timestamp    ,					a__    ,					)

         _lowerCAmelCase						:	List[Any]        =					jnp.where((cur_len - self.begin_index) < 2    ,					a__    ,					a__  )
         _lowerCAmelCase						:	str        =					jnp.where(
             input_ids_k[cur_len - 2] >= self.timestamp_begin    ,					a__    ,					a__    ,					)

         return jnp.where(
             a__    ,					jnp.where(
                 penultimate_was_timestamp > 0    ,					scores_k.at[self.timestamp_begin :].set(-float("""inf"""  )  )    ,					scores_k.at[: self.eos_token_id].set(-float("""inf"""  )  )    ,					)    ,					a__    ,					)

       _lowerCAmelCase						:	Tuple        =					jax.vmap(a__  )(a__    ,					a__  )

       _lowerCAmelCase						:	int        =					jnp.where(cur_len == self.begin_index    ,					a__    ,					a__  )
       _lowerCAmelCase						:	Union[str, Any]        =					jnp.where(
           self.max_initial_timestamp_index is not None    ,					True and apply_max_initial_timestamp    ,					a__    ,					)

       _lowerCAmelCase						:	List[str]        =					self.timestamp_begin + self.max_initial_timestamp_index

       _lowerCAmelCase						:	Dict        =					jnp.where(
           a__    ,					scores.at[:, last_allowed + 1 :].set(-float("""inf"""  )  )    ,					a__    ,					)

       # if sum of probability over timestamps is above any other token, sample timestamp
       _lowerCAmelCase						:	List[Any]        =					jax.nn.log_softmax(a__    ,					axis=-1  )

       def handle_cumulative_probs(a__    ,					a__  ):
         _lowerCAmelCase						:	Optional[int]        =					jax.nn.logsumexp(logprobs_k[self.timestamp_begin :]    ,					axis=-1  )
         _lowerCAmelCase						:	Optional[int]        =					jnp.max(logprobs_k[: self.timestamp_begin]  )
         return jnp.where(
             timestamp_logprob > max_text_token_logprob    ,					scores_k.at[: self.timestamp_begin].set(-float("""inf"""  )  )    ,					a__    ,					)

       _lowerCAmelCase						:	List[str]        =					jax.vmap(a__  )(a__    ,					a__  )

       return scores





"""simple docstring"""




import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


_a				:		Union[str, Any]	   =       1e-4

if is_torch_available():
     import torch

     from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
     from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder
@require_torch
class 						__A							:






     def __init__(		self    ,					a__    ,					a__=16    ,					a__=13    ,					a__=7    ,					a__=14    ,					a__=10    ,					a__=19    ,					a__=5    ,					a__=4    ,					a__=True    ,					a__=16    ,					a__=2    ,					a__=4    ,					a__=4    ,					a__="gelu"    ,					a__=0.1    ,					a__=0.1    ,					a__=[1, 2, 3, 4, 5]    ,					a__=25    ,					a__=5    ,					):
       _lowerCAmelCase						:	Union[str, Any]        =					d_model
       _lowerCAmelCase						:	int        =					parent
       _lowerCAmelCase						:	List[Any]        =					batch_size
       _lowerCAmelCase						:	Optional[int]        =					prediction_length
       _lowerCAmelCase						:	int        =					context_length
       _lowerCAmelCase						:	Optional[Any]        =					cardinality
       _lowerCAmelCase						:	Tuple        =					num_time_features
       _lowerCAmelCase						:	str        =					lags_sequence
       _lowerCAmelCase						:	int        =					embedding_dimension
       _lowerCAmelCase						:	Dict        =					is_training
       _lowerCAmelCase						:	Tuple        =					hidden_size
       _lowerCAmelCase						:	Dict        =					num_hidden_layers
       _lowerCAmelCase						:	str        =					num_attention_heads
       _lowerCAmelCase						:	List[str]        =					intermediate_size
       _lowerCAmelCase						:	int        =					hidden_act
       _lowerCAmelCase						:	Tuple        =					hidden_dropout_prob
       _lowerCAmelCase						:	Optional[Any]        =					attention_probs_dropout_prob

       _lowerCAmelCase						:	Tuple        =					context_length
       _lowerCAmelCase						:	Optional[int]        =					prediction_length + label_length
       _lowerCAmelCase						:	Dict        =					label_length

       _lowerCAmelCase						:	Dict        =					moving_average
       _lowerCAmelCase						:	Union[str, Any]        =					autocorrelation_factor






     def    __A  (		self  ):
       return AutoformerConfig(
           d_model=self.d_model    ,					encoder_layers=self.num_hidden_layers    ,					decoder_layers=self.num_hidden_layers    ,					encoder_attention_heads=self.num_attention_heads    ,					decoder_attention_heads=self.num_attention_heads    ,					encoder_ffn_dim=self.intermediate_size    ,					decoder_ffn_dim=self.intermediate_size    ,					dropout=self.hidden_dropout_prob    ,					attention_dropout=self.attention_probs_dropout_prob    ,					prediction_length=self.prediction_length    ,					context_length=self.context_length    ,					label_length=self.label_length    ,					lags_sequence=self.lags_sequence    ,					num_time_features=self.num_time_features    ,					num_static_categorical_features=1    ,					cardinality=[self.cardinality]    ,					embedding_dimension=[self.embedding_dimension]    ,					moving_average=self.moving_average    ,					)






     def    __A  (		self    ,					a__  ):
       _lowerCAmelCase						:	Dict        =					config.context_length + max(config.lags_sequence  )

       _lowerCAmelCase						:	int        =					ids_tensor([self.batch_size, 1]    ,					config.cardinality[0]  )
       _lowerCAmelCase						:	Tuple        =					floats_tensor([self.batch_size, _past_length, config.num_time_features]  )
       _lowerCAmelCase						:	int        =					floats_tensor([self.batch_size, _past_length]  )
       _lowerCAmelCase						:	List[str]        =					floats_tensor([self.batch_size, _past_length]  ) > 0.5

       # decoder inputs
       _lowerCAmelCase						:	Any        =					floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]  )
       _lowerCAmelCase						:	Dict        =					floats_tensor([self.batch_size, config.prediction_length]  )

       _lowerCAmelCase						:	Dict        =					{
           """past_values""": past_values,
           """static_categorical_features""": static_categorical_features,
           """past_time_features""": past_time_features,
           """past_observed_mask""": past_observed_mask,
           """future_time_features""": future_time_features,
           """future_values""": future_values,
       }
       return inputs_dict






     def    __A  (		self  ):
       _lowerCAmelCase						:	Any        =					self.get_config()
       _lowerCAmelCase						:	str        =					self.prepare_autoformer_inputs_dict(a__  )
       return config, inputs_dict






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	Union[str, Any]        =					self.prepare_config_and_inputs()
       return config, inputs_dict






     def    __A  (		self    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[int]        =					AutoformerModel(config=a__  ).to(a__  ).eval()
       _lowerCAmelCase						:	int        =					model(**a__  )

       _lowerCAmelCase						:	List[str]        =					outputs.encoder_last_hidden_state
       _lowerCAmelCase						:	Any        =					outputs.last_hidden_state

       with tempfile.TemporaryDirectory() as tmpdirname:
         _lowerCAmelCase						:	Optional[int]        =					model.get_encoder()
         encoder.save_pretrained(a__  )
         _lowerCAmelCase						:	Optional[int]        =					AutoformerEncoder.from_pretrained(a__  ).to(a__  )

       _lowerCAmelCase      ,     _lowerCAmelCase      ,     _lowerCAmelCase      ,     _lowerCAmelCase      ,     _lowerCAmelCase						:	List[Any]        =					model.create_network_inputs(**a__  )
       _lowerCAmelCase      ,     _lowerCAmelCase						:	str        =					model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]  )

       _lowerCAmelCase						:	Any        =					torch.cat(
           (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])    ,					dim=-1    ,					)
       _lowerCAmelCase						:	Dict        =					encoder(inputs_embeds=a__  )[0]
       self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3  )

       _lowerCAmelCase						:	str        =					(
           torch.mean(transformer_inputs[:, : config.context_length, ...]    ,					dim=1  )
           .unsqueeze(1  )
           .repeat(1    ,					config.prediction_length    ,					1  )
       )
       _lowerCAmelCase						:	Optional[Any]        =					torch.zeros(
           [transformer_inputs.shape[0], config.prediction_length, transformer_inputs.shape[2]]    ,					device=enc_input.device    ,					)

       _lowerCAmelCase						:	Optional[int]        =					torch.cat(
           (
               torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)    ,					dim=1  ),
               feature[:, config.context_length - config.label_length :, ...],
           )    ,					dim=-1    ,					)
       _lowerCAmelCase						:	Optional[int]        =					torch.cat(
           (
               torch.cat((trend_input[:, -config.label_length :, ...], mean)    ,					dim=1  ),
               feature[:, config.context_length - config.label_length :, ...],
           )    ,					dim=-1    ,					)

       with tempfile.TemporaryDirectory() as tmpdirname:
         _lowerCAmelCase						:	Optional[int]        =					model.get_decoder()
         decoder.save_pretrained(a__  )
         _lowerCAmelCase						:	Any        =					AutoformerDecoder.from_pretrained(a__  ).to(a__  )

       _lowerCAmelCase						:	List[Any]        =					decoder(
           trend=a__    ,					inputs_embeds=a__    ,					encoder_hidden_states=a__    ,					)[0]

       self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3  )







@require_torch
class 						__A							(			SCREAMING_SNAKE_CASE_   ,     SCREAMING_SNAKE_CASE_   ,     unittest.TestCase		):
     _UpperCamelCase							:      Dict		 =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
     _UpperCamelCase							:      Optional[Any]		 =		(AutoformerForPrediction,) if is_torch_available() else ()
     _UpperCamelCase							:      int		 =		{"feature-extraction": AutoformerModel} if is_torch_available() else {}
     _UpperCamelCase							:      Optional[Any]		 =		False
     _UpperCamelCase							:      Optional[int]		 =		False
     _UpperCamelCase							:      Optional[int]		 =		False
     _UpperCamelCase							:      List[Any]		 =		False
     _UpperCamelCase							:      List[Any]		 =		False
     _UpperCamelCase							:      str		 =		False






     def    __A  (		self  ):
       _lowerCAmelCase						:	Tuple        =					AutoformerModelTester(self  )
       _lowerCAmelCase						:	Union[str, Any]        =					ConfigTester(self    ,					config_class=a__    ,					has_text_modality=a__  )






     def    __A  (		self  ):
       self.config_tester.run_common_tests()






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	List[str]        =					self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
         _lowerCAmelCase						:	int        =					model_class(a__  )

         with tempfile.TemporaryDirectory() as tmpdirname:
           model.save_pretrained(a__  )
           _lowerCAmelCase      ,     _lowerCAmelCase						:	List[str]        =					model_class.from_pretrained(a__    ,					output_loading_info=a__  )
         self.assertEqual(info["""missing_keys"""]    ,					[]  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Optional[Any]        =					self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_encoder_decoder_model_standalone(*a__  )






     @unittest.skip(reason="""Model has no tokens embeddings"""  )
     def    __A  (		self  ):
       pass






     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					inspect.signature(getattr(a__    ,					"""forward"""  )  )
       # The main input is the name of the argument after `self`
       _lowerCAmelCase						:	Dict        =					list(model_signature.parameters.keys()  )[1]
       self.assertEqual(AutoformerModel.main_input_name    ,					a__  )






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	int        =					self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
         _lowerCAmelCase						:	List[Any]        =					model_class(a__  )
         _lowerCAmelCase						:	Tuple        =					inspect.signature(model.forward  )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         _lowerCAmelCase						:	Tuple        =					[*signature.parameters.keys()]

         _lowerCAmelCase						:	List[str]        =					[
             """past_values""",
             """past_time_features""",
             """past_observed_mask""",
             """static_categorical_features""",
             """static_real_features""",
             """future_values""",
             """future_time_features""",
         ]

         if model.__class__.__name__ in ["AutoformerForPrediction"]:
           expected_arg_names.append("""future_observed_mask"""  )

         expected_arg_names.extend(
             [
                 """decoder_attention_mask""",
                 """head_mask""",
                 """decoder_head_mask""",
                 """cross_attn_head_mask""",
                 """encoder_outputs""",
                 """past_key_values""",
                 """output_hidden_states""",
                 """output_attentions""",
                 """use_cache""",
                 """return_dict""",
             ]  )

         self.assertListEqual(arg_names[: len(a__  )]    ,					a__  )






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	Union[str, Any]        =					self.model_tester.prepare_config_and_inputs_for_common()
       _lowerCAmelCase						:	Optional[int]        =					True

       _lowerCAmelCase						:	Optional[Any]        =					getattr(self.model_tester    ,					"""seq_length"""    ,					a__  )
       _lowerCAmelCase						:	List[str]        =					getattr(self.model_tester    ,					"""decoder_seq_length"""    ,					a__  )
       _lowerCAmelCase						:	Union[str, Any]        =					getattr(self.model_tester    ,					"""encoder_seq_length"""    ,					a__  )
       _lowerCAmelCase						:	int        =					getattr(self.model_tester    ,					"""d_model"""    ,					a__  )
       _lowerCAmelCase						:	Optional[Any]        =					getattr(self.model_tester    ,					"""num_attention_heads"""    ,					a__  )
       _lowerCAmelCase						:	Optional[int]        =					d_model // num_attention_heads

       for model_class in self.all_model_classes:
         _lowerCAmelCase						:	Dict        =					True
         _lowerCAmelCase						:	Dict        =					False
         _lowerCAmelCase						:	Optional[int]        =					True
         _lowerCAmelCase						:	List[Any]        =					model_class(a__  )
         model.to(a__  )
         model.eval()
         with torch.no_grad():
           _lowerCAmelCase						:	Union[str, Any]        =					model(**self._prepare_for_class(a__    ,					a__  )  )
         _lowerCAmelCase						:	Any        =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
         self.assertEqual(len(a__  )    ,					self.model_tester.num_hidden_layers  )

         # check that output_attentions also work using config
         del inputs_dict["output_attentions"]
         _lowerCAmelCase						:	int        =					True
         _lowerCAmelCase						:	Optional[Any]        =					model_class(a__  )
         model.to(a__  )
         model.eval()
         with torch.no_grad():
           _lowerCAmelCase						:	int        =					model(**self._prepare_for_class(a__    ,					a__  )  )
         _lowerCAmelCase						:	Optional[int]        =					outputs.encoder_attentions
         self.assertEqual(len(a__  )    ,					self.model_tester.num_hidden_layers  )

         self.assertListEqual(
             list(attentions[0].shape[-3:]  )    ,					[self.model_tester.num_attention_heads, encoder_seq_length, dim]    ,					)
         _lowerCAmelCase						:	Dict        =					len(a__  )

         _lowerCAmelCase						:	List[str]        =					7

         if "last_hidden_state" in outputs:
           correct_outlen += 1

         if "trend" in outputs:
           correct_outlen += 1

         if "past_key_values" in outputs:
           correct_outlen += 1  # past_key_values have been returned

         if "loss" in outputs:
           correct_outlen += 1

         if "params" in outputs:
           correct_outlen += 1

         self.assertEqual(a__    ,					a__  )

         # decoder attentions
         _lowerCAmelCase						:	int        =					outputs.decoder_attentions
         self.assertIsInstance(a__    ,					(list, tuple)  )
         self.assertEqual(len(a__  )    ,					self.model_tester.num_hidden_layers  )
         self.assertListEqual(
             list(decoder_attentions[0].shape[-3:]  )    ,					[self.model_tester.num_attention_heads, decoder_seq_length, dim]    ,					)

         # cross attentions
         _lowerCAmelCase						:	Optional[Any]        =					outputs.cross_attentions
         self.assertIsInstance(a__    ,					(list, tuple)  )
         self.assertEqual(len(a__  )    ,					self.model_tester.num_hidden_layers  )
         self.assertListEqual(
             list(cross_attentions[0].shape[-3:]  )    ,					[self.model_tester.num_attention_heads, decoder_seq_length, dim]    ,					)

       # Check attention is always last and order is fine
       _lowerCAmelCase						:	Dict        =					True
       _lowerCAmelCase						:	List[str]        =					True
       _lowerCAmelCase						:	Optional[int]        =					model_class(a__  )
       model.to(a__  )
       model.eval()
       with torch.no_grad():
         _lowerCAmelCase						:	Optional[Any]        =					model(**self._prepare_for_class(a__    ,					a__  )  )

       self.assertEqual(out_len + 2    ,					len(a__  )  )

       _lowerCAmelCase						:	Dict        =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

       self.assertEqual(len(a__  )    ,					self.model_tester.num_hidden_layers  )
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]  )    ,					[self.model_tester.num_attention_heads, encoder_seq_length, dim]    ,					)






     @is_flaky()
     def    __A  (		self  ):
       super().test_retain_grad_hidden_states_attentions()







def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	Any="train-batch.pt"     )	->				Optional[int]:
  _lowerCAmelCase						:	List[Any]        =					hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""      ,filename=_lowerCamelCase      ,repo_type="""dataset"""     )
  _lowerCAmelCase						:	Dict        =					torch.load(_lowerCamelCase      ,map_location=_lowerCamelCase     )
  return batch






@require_torch
@slow
class 						__A							(			unittest.TestCase		):






     def    __A  (		self  ):
       _lowerCAmelCase						:	str        =					AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""  ).to(a__  )
       _lowerCAmelCase						:	List[Any]        =					prepare_batch()

       with torch.no_grad():
         _lowerCAmelCase						:	str        =					model(
             past_values=batch["""past_values"""]    ,					past_time_features=batch["""past_time_features"""]    ,					past_observed_mask=batch["""past_observed_mask"""]    ,					static_categorical_features=batch["""static_categorical_features"""]    ,					future_values=batch["""future_values"""]    ,					future_time_features=batch["""future_time_features"""]    ,					)[0]

       _lowerCAmelCase						:	Optional[int]        =					torch.Size(
           (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)  )
       self.assertEqual(output.shape    ,					a__  )

       _lowerCAmelCase						:	Optional[int]        =					torch.tensor(
           [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]]    ,					device=a__  )
       self.assertTrue(torch.allclose(output[0, :3, :3]    ,					a__    ,					atol=a__  )  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	Union[str, Any]        =					AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""  ).to(a__  )
       _lowerCAmelCase						:	Union[str, Any]        =					prepare_batch("""val-batch.pt"""  )
       with torch.no_grad():
         _lowerCAmelCase						:	str        =					model(
             past_values=batch["""past_values"""]    ,					past_time_features=batch["""past_time_features"""]    ,					past_observed_mask=batch["""past_observed_mask"""]    ,					static_categorical_features=batch["""static_categorical_features"""]    ,					).encoder_last_hidden_state
       _lowerCAmelCase						:	Optional[int]        =					torch.Size((64, model.config.context_length, model.config.d_model)  )
       self.assertEqual(output.shape    ,					a__  )

       _lowerCAmelCase						:	Any        =					torch.tensor(
           [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]]    ,					device=a__  )
       self.assertTrue(torch.allclose(output[0, :3, :3]    ,					a__    ,					atol=a__  )  )






     def    __A  (		self  ):
       _lowerCAmelCase						:	List[Any]        =					AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""  ).to(a__  )
       _lowerCAmelCase						:	str        =					prepare_batch("""val-batch.pt"""  )
       with torch.no_grad():
         _lowerCAmelCase						:	str        =					model.generate(
             static_categorical_features=batch["""static_categorical_features"""]    ,					past_time_features=batch["""past_time_features"""]    ,					past_values=batch["""past_values"""]    ,					future_time_features=batch["""future_time_features"""]    ,					past_observed_mask=batch["""past_observed_mask"""]    ,					)
       _lowerCAmelCase						:	int        =					torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)  )
       self.assertEqual(outputs.sequences.shape    ,					a__  )

       _lowerCAmelCase						:	Optional[Any]        =					torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6]    ,					device=a__  )
       _lowerCAmelCase						:	Optional[int]        =					outputs.sequences.mean(dim=1  )
       self.assertTrue(torch.allclose(mean_prediction[0, -3:]    ,					a__    ,					rtol=1e-1  )  )




