


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


_snake_case			 =	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       UpperCAmelCase_   :

   '''simple docstring'''




   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		,							):






     """simple docstring"""





     lowerCamelCase					:   Any       =							d_model
     lowerCamelCase					:   Any       =							parent
     lowerCamelCase					:   str       =							batch_size
     lowerCamelCase					:   Tuple       =							prediction_length
     lowerCamelCase					:   Dict       =							context_length
     lowerCamelCase					:   Optional[int]       =							cardinality
     lowerCamelCase					:   Any       =							num_time_features
     lowerCamelCase					:   List[Any]       =							lags_sequence
     lowerCamelCase					:   Dict       =							embedding_dimension
     lowerCamelCase					:   Optional[Any]       =							is_training
     lowerCamelCase					:   Optional[Any]       =							hidden_size
     lowerCamelCase					:   Optional[int]       =							num_hidden_layers
     lowerCamelCase					:   int       =							num_attention_heads
     lowerCamelCase					:   str       =							intermediate_size
     lowerCamelCase					:   Any       =							hidden_act
     lowerCamelCase					:   Optional[int]       =							hidden_dropout_prob
     lowerCamelCase					:   Any       =							attention_probs_dropout_prob

     lowerCamelCase					:   Optional[Any]       =							context_length
     lowerCamelCase					:   str       =							prediction_length + label_length
     lowerCamelCase					:   Optional[Any]       =							label_length

     lowerCamelCase					:   List[str]       =							moving_average
     lowerCamelCase					:   Optional[int]       =							autocorrelation_factor






   def _snake_case       (						self					):






     """simple docstring"""





     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 _snake_case       (						self		,							__A					):






     """simple docstring"""





     lowerCamelCase					:   Optional[int]       =							config.context_length + max(config.lags_sequence					)

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

     # decoder inputs
     lowerCamelCase					:   str       =							floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]					)
     lowerCamelCase					:   Tuple       =							floats_tensor([self.batch_size, config.prediction_length]					)

     lowerCamelCase					:   Optional[int]       =							{
         "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 _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Union[str, Any]       =							self.get_config()
     lowerCamelCase					:   List[str]       =							self.prepare_autoformer_inputs_dict(__lowerCamelCase					)
     return config, inputs_dict






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase       ,      lowerCamelCase					:   Any       =							self.prepare_config_and_inputs()
     return config, inputs_dict






   def _snake_case       (						self		,							__A		,							__A					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							AutoformerModel(config=__lowerCamelCase					).to(__lowerCamelCase					).eval()
     lowerCamelCase					:   Optional[int]       =							model(**__lowerCamelCase					)

     lowerCamelCase					:   str       =							outputs.encoder_last_hidden_state
     lowerCamelCase					:   Any       =							outputs.last_hidden_state

     with tempfile.TemporaryDirectory() as tmpdirname:
       lowerCamelCase					:   Dict       =							model.get_encoder()
       encoder.save_pretrained(__lowerCamelCase					)
       lowerCamelCase					:   Dict       =							AutoformerEncoder.from_pretrained(__lowerCamelCase					).to(__lowerCamelCase					)

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

     lowerCamelCase					:   List[str]       =							torch.cat(
         (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])		,							dim=-1		,							)
     lowerCamelCase					:   int       =							encoder(inputs_embeds=__lowerCamelCase					)[0]
     self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3					)

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

     lowerCamelCase					:   Tuple       =							torch.cat(
         (
             torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)		,							dim=1					),
             feature[:, config.context_length - config.label_length :, ...],
         )		,							dim=-1		,							)
     lowerCamelCase					:   Union[str, Any]       =							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					:   List[str]       =							model.get_decoder()
       decoder.save_pretrained(__lowerCamelCase					)
       lowerCamelCase					:   List[str]       =							AutoformerDecoder.from_pretrained(__lowerCamelCase					).to(__lowerCamelCase					)

     lowerCamelCase					:   Optional[Any]       =							decoder(
         trend=__lowerCamelCase		,							inputs_embeds=__lowerCamelCase		,							encoder_hidden_states=__lowerCamelCase		,							)[0]

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



@require_torch
class       UpperCAmelCase_   (   __snake_case						,					__snake_case						,					unittest.TestCase       ):

   '''simple docstring'''




   __A					: str							=						(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
   __A					: Optional[int]							=						(AutoformerForPrediction,) if is_torch_available() else ()
   __A					: List[str]							=						{"feature-extraction": AutoformerModel} if is_torch_available() else {}
   __A					: Any							=						False
   __A					: Tuple							=						False
   __A					: Optional[int]							=						False
   __A					: Dict							=						False
   __A					: Union[str, Any]							=						False
   __A					: Union[str, Any]							=						False






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   List[Any]       =							AutoformerModelTester(self					)
     lowerCamelCase					:   Optional[Any]       =							ConfigTester(self		,							config_class=__lowerCamelCase		,							has_text_modality=__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     self.config_tester.run_common_tests()






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase       ,      lowerCamelCase					:   str       =							self.model_tester.prepare_config_and_inputs()
     for model_class in self.all_model_classes:
       lowerCamelCase					:   Dict       =							model_class(__lowerCamelCase					)

       with tempfile.TemporaryDirectory() as tmpdirname:
         model.save_pretrained(__lowerCamelCase					)
         lowerCamelCase       ,      lowerCamelCase					:   int       =							model_class.from_pretrained(__lowerCamelCase		,							output_loading_info=__lowerCamelCase					)
       self.assertEqual(info["missing_keys"]		,							[]					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							self.model_tester.prepare_config_and_inputs_for_common()
     self.model_tester.check_encoder_decoder_model_standalone(*__lowerCamelCase					)






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






     """simple docstring"""





     pass






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   List[str]       =							inspect.signature(getattr(__lowerCamelCase		,							"forward"					)					)
     # The main input is the name of the argument after `self`
     lowerCamelCase					:   Tuple       =							list(model_signature.parameters.keys()					)[1]
     self.assertEqual(AutoformerModel.main_input_name		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase       ,      lowerCamelCase					:   Union[str, Any]       =							self.model_tester.prepare_config_and_inputs_for_common()

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

       lowerCamelCase					:   Any       =							[
           "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(__lowerCamelCase					)]		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase       ,      lowerCamelCase					:   Any       =							self.model_tester.prepare_config_and_inputs_for_common()
     lowerCamelCase					:   Tuple       =							True

     lowerCamelCase					:   Tuple       =							getattr(self.model_tester		,							"seq_length"		,							__lowerCamelCase					)
     lowerCamelCase					:   int       =							getattr(self.model_tester		,							"decoder_seq_length"		,							__lowerCamelCase					)
     lowerCamelCase					:   int       =							getattr(self.model_tester		,							"encoder_seq_length"		,							__lowerCamelCase					)
     lowerCamelCase					:   List[Any]       =							getattr(self.model_tester		,							"d_model"		,							__lowerCamelCase					)
     lowerCamelCase					:   List[str]       =							getattr(self.model_tester		,							"num_attention_heads"		,							__lowerCamelCase					)
     lowerCamelCase					:   List[str]       =							d_model // num_attention_heads

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

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

       self.assertListEqual(
           list(attentions[0].shape[-3:]					)		,							[self.model_tester.num_attention_heads, encoder_seq_length, dim]		,							)
       lowerCamelCase					:   Optional[int]       =							len(__lowerCamelCase					)

       lowerCamelCase					:   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(__lowerCamelCase		,							__lowerCamelCase					)

       # decoder attentions
       lowerCamelCase					:   int       =							outputs.decoder_attentions
       self.assertIsInstance(__lowerCamelCase		,							(list, tuple)					)
       self.assertEqual(len(__lowerCamelCase					)		,							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					:   str       =							outputs.cross_attentions
       self.assertIsInstance(__lowerCamelCase		,							(list, tuple)					)
       self.assertEqual(len(__lowerCamelCase					)		,							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					:   Any       =							True
     lowerCamelCase					:   int       =							True
     lowerCamelCase					:   str       =							model_class(__lowerCamelCase					)
     model.to(__lowerCamelCase					)
     model.eval()
     with torch.no_grad():
       lowerCamelCase					:   Optional[int]       =							model(**self._prepare_for_class(__lowerCamelCase		,							__lowerCamelCase					)					)

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

     lowerCamelCase					:   Optional[Any]       =							outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

     self.assertEqual(len(__lowerCamelCase					)		,							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 _snake_case       (						self					):






     """simple docstring"""





     super().test_retain_grad_hidden_states_attentions()






def 						lowercase_(    SCREAMING_SNAKE_CASE_="train-batch.pt"      ):


  '''simple docstring'''

  lowerCamelCase					:   List[Any]       =							hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch" ,		filename=A__ ,		repo_type="dataset"      )
  lowerCamelCase					:   str       =							torch.load(A__ ,		map_location=A__      )
  return batch







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

   '''simple docstring'''




   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   int       =							AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"					).to(__lowerCamelCase					)
     lowerCamelCase					:   List[str]       =							prepare_batch()

     with torch.no_grad():
       lowerCamelCase					:   Dict       =							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					:   List[Any]       =							torch.Size(
         (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)					)
     self.assertEqual(output.shape		,							__lowerCamelCase					)

     lowerCamelCase					:   List[Any]       =							torch.tensor(
         [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]		,							device=__lowerCamelCase					)
     self.assertTrue(torch.allclose(output[0, :3, :3]		,							__lowerCamelCase		,							atol=__lowerCamelCase					)					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   str       =							AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"					).to(__lowerCamelCase					)
     lowerCamelCase					:   Any       =							prepare_batch("val-batch.pt"					)
     with torch.no_grad():
       lowerCamelCase					:   List[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					:   str       =							torch.Size((64, model.config.context_length, model.config.d_model)					)
     self.assertEqual(output.shape		,							__lowerCamelCase					)

     lowerCamelCase					:   Dict       =							torch.tensor(
         [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]		,							device=__lowerCamelCase					)
     self.assertTrue(torch.allclose(output[0, :3, :3]		,							__lowerCamelCase		,							atol=__lowerCamelCase					)					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Optional[int]       =							AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"					).to(__lowerCamelCase					)
     lowerCamelCase					:   Any       =							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					:   Optional[Any]       =							torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)					)
     self.assertEqual(outputs.sequences.shape		,							__lowerCamelCase					)

     lowerCamelCase					:   Optional[Any]       =							torch.tensor([3130.6763, 4056.5293, 7053.0786]		,							device=__lowerCamelCase					)
     lowerCamelCase					:   Union[str, Any]       =							outputs.sequences.mean(dim=1					)
     self.assertTrue(torch.allclose(mean_prediction[0, -3:]		,							__lowerCamelCase		,							rtol=1e-1					)					)






def 	__a     (      A__			:  int = 1000       ):
    SCREAMING_SNAKE_CASE										=   3
    SCREAMING_SNAKE_CASE										=   0
    while a < n:
        if a % 3 == 0 or a % 5 == 0:
            result += a
        elif a % 15 == 0:
            result -= a
        a += 1
    return result


if __name__ == "__main__":
    print(f'{solution() = }')