



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


SCREAMING_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 				snake_case :



       def __init__(				self     ,UpperCAmelCase_     ,UpperCAmelCase_=16     ,UpperCAmelCase_=13     ,UpperCAmelCase_=7     ,UpperCAmelCase_=14     ,UpperCAmelCase_=10     ,UpperCAmelCase_=19     ,UpperCAmelCase_=5     ,UpperCAmelCase_=4     ,UpperCAmelCase_=True     ,UpperCAmelCase_=16     ,UpperCAmelCase_=2     ,UpperCAmelCase_=4     ,UpperCAmelCase_=4     ,UpperCAmelCase_="gelu"     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=0.1     ,UpperCAmelCase_=[1, 2, 3, 4, 5]     ,UpperCAmelCase_=25     ,UpperCAmelCase_=5     ,)  ->							Optional[Any]:
           lowercase__		       =						d_model
           lowercase__		       =						parent
           lowercase__		       =						batch_size
           lowercase__		       =						prediction_length
           lowercase__		       =						context_length
           lowercase__		       =						cardinality
           lowercase__		       =						num_time_features
           lowercase__		       =						lags_sequence
           lowercase__		       =						embedding_dimension
           lowercase__		       =						is_training
           lowercase__		       =						hidden_size
           lowercase__		       =						num_hidden_layers
           lowercase__		       =						num_attention_heads
           lowercase__		       =						intermediate_size
           lowercase__		       =						hidden_act
           lowercase__		       =						hidden_dropout_prob
           lowercase__		       =						attention_probs_dropout_prob

           lowercase__		       =						context_length
           lowercase__		       =						prediction_length + label_length
           lowercase__		       =						label_length

           lowercase__		       =						moving_average
           lowercase__		       =						autocorrelation_factor



       def 							_a      (				self      )  ->							Dict:
           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     ,UpperCAmelCase_      )  ->							List[str]:
           lowercase__		       =						config.context_length + max(config.lags_sequence      )

           lowercase__		       =						ids_tensor([self.batch_size, 1]     ,config.cardinality[0]      )
           lowercase__		       =						floats_tensor([self.batch_size, _past_length, config.num_time_features]      )
           lowercase__		       =						floats_tensor([self.batch_size, _past_length]      )
           lowercase__		       =						floats_tensor([self.batch_size, _past_length]      ) > 0.5

           # decoder inputs
           lowercase__		       =						floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]      )
           lowercase__		       =						floats_tensor([self.batch_size, config.prediction_length]      )

           lowercase__		       =						{
               "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      )  ->							Dict:
           lowercase__		       =						self.get_config()
           lowercase__		       =						self.prepare_autoformer_inputs_dict(UpperCAmelCase_      )
           return config, inputs_dict



       def 							_a      (				self      )  ->							List[Any]:
           lowercase__       ,       lowercase__		       =						self.prepare_config_and_inputs()
           return config, inputs_dict







       def 							_a      (				self     ,UpperCAmelCase_     ,UpperCAmelCase_      )  ->							Any:
           lowercase__		       =						AutoformerModel(config=UpperCAmelCase_      ).to(UpperCAmelCase_      ).eval()
           lowercase__		       =						model(**UpperCAmelCase_      )

           lowercase__		       =						outputs.encoder_last_hidden_state
           lowercase__		       =						outputs.last_hidden_state

           with tempfile.TemporaryDirectory() as tmpdirname:
               lowercase__		       =						model.get_encoder()
               encoder.save_pretrained(UpperCAmelCase_      )
               lowercase__		       =						AutoformerEncoder.from_pretrained(UpperCAmelCase_      ).to(UpperCAmelCase_      )

           lowercase__       ,       lowercase__       ,       lowercase__       ,       lowercase__       ,       lowercase__		       =						model.create_network_inputs(**UpperCAmelCase_      )
           lowercase__       ,       lowercase__		       =						model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]      )

           lowercase__		       =						torch.cat(
               (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])     ,dim=-1     ,)
           lowercase__		       =						encoder(inputs_embeds=UpperCAmelCase_      )[0]
           self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3      )

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

           lowercase__		       =						torch.cat(
               (
                   torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)     ,dim=1      ),
                   feature[:, config.context_length - config.label_length :, ...],
               )     ,dim=-1     ,)
           lowercase__		       =						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:
               lowercase__		       =						model.get_decoder()
               decoder.save_pretrained(UpperCAmelCase_      )
               lowercase__		       =						AutoformerDecoder.from_pretrained(UpperCAmelCase_      ).to(UpperCAmelCase_      )

           lowercase__		       =						decoder(
               trend=UpperCAmelCase_     ,inputs_embeds=UpperCAmelCase_     ,encoder_hidden_states=UpperCAmelCase_     ,)[0]

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





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



       def 							_a      (				self      )  ->							Optional[int]:
           lowercase__		       =						AutoformerModelTester(self      )
           lowercase__		       =						ConfigTester(self     ,config_class=UpperCAmelCase_     ,has_text_modality=UpperCAmelCase_      )



       def 							_a      (				self      )  ->							List[Any]:
           self.config_tester.run_common_tests()



       def 							_a      (				self      )  ->							Dict:
           lowercase__       ,       lowercase__		       =						self.model_tester.prepare_config_and_inputs()
           for model_class in self.all_model_classes:
               lowercase__		       =						model_class(UpperCAmelCase_      )

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



       def 							_a      (				self      )  ->							Union[str, Any]:
           lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.check_encoder_decoder_model_standalone(*UpperCAmelCase_      )



       @unittest.skip(reason="Model has no tokens embeddings"      )
       def 							_a      (				self      )  ->							Optional[int]:
           pass



       def 							_a      (				self      )  ->							Any:
           lowercase__		       =						inspect.signature(getattr(UpperCAmelCase_     ,"forward"      )      )
           # The main input is the name of the argument after `self`
           lowercase__		       =						list(model_signature.parameters.keys()      )[1]
           self.assertEqual(AutoformerModel.main_input_name     ,UpperCAmelCase_      )



       def 							_a      (				self      )  ->							List[Any]:
           lowercase__       ,       lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()

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

               lowercase__		       =						[
                   "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(UpperCAmelCase_      )]     ,UpperCAmelCase_      )



       def 							_a      (				self      )  ->							List[Any]:
           lowercase__       ,       lowercase__		       =						self.model_tester.prepare_config_and_inputs_for_common()
           lowercase__		       =						True

           lowercase__		       =						getattr(self.model_tester     ,"seq_length"     ,UpperCAmelCase_      )
           lowercase__		       =						getattr(self.model_tester     ,"decoder_seq_length"     ,UpperCAmelCase_      )
           lowercase__		       =						getattr(self.model_tester     ,"encoder_seq_length"     ,UpperCAmelCase_      )
           lowercase__		       =						getattr(self.model_tester     ,"d_model"     ,UpperCAmelCase_      )
           lowercase__		       =						getattr(self.model_tester     ,"num_attention_heads"     ,UpperCAmelCase_      )
           lowercase__		       =						d_model // num_attention_heads

           for model_class in self.all_model_classes:
               lowercase__		       =						True
               lowercase__		       =						False
               lowercase__		       =						True
               lowercase__		       =						model_class(UpperCAmelCase_      )
               model.to(UpperCAmelCase_      )
               model.eval()
               with torch.no_grad():
                   lowercase__		       =						model(**self._prepare_for_class(UpperCAmelCase_     ,UpperCAmelCase_      )      )
               lowercase__		       =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
               self.assertEqual(len(UpperCAmelCase_      )     ,self.model_tester.num_hidden_layers      )

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

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

               lowercase__		       =						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(UpperCAmelCase_     ,UpperCAmelCase_      )

               # decoder attentions
               lowercase__		       =						outputs.decoder_attentions
               self.assertIsInstance(UpperCAmelCase_     ,(list, tuple)      )
               self.assertEqual(len(UpperCAmelCase_      )     ,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
               lowercase__		       =						outputs.cross_attentions
               self.assertIsInstance(UpperCAmelCase_     ,(list, tuple)      )
               self.assertEqual(len(UpperCAmelCase_      )     ,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
           lowercase__		       =						True
           lowercase__		       =						True
           lowercase__		       =						model_class(UpperCAmelCase_      )
           model.to(UpperCAmelCase_      )
           model.eval()
           with torch.no_grad():
               lowercase__		       =						model(**self._prepare_for_class(UpperCAmelCase_     ,UpperCAmelCase_      )      )

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

           lowercase__		       =						outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

           self.assertEqual(len(UpperCAmelCase_      )     ,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      )  ->							List[Any]:
           super().test_retain_grad_hidden_states_attentions()





def        lowerCamelCase  (				_snake_case  :						Optional[Any]="train-batch.pt"       ):





    '''simple docstring'''


    lowercase__		       =						hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"     ,filename=_snake_case     ,repo_type="dataset"       )
    lowercase__		       =						torch.load(_snake_case     ,map_location=_snake_case       )
    return batch



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



       def 							_a      (				self      )  ->							Union[str, Any]:
           lowercase__		       =						AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"      ).to(UpperCAmelCase_      )
           lowercase__		       =						prepare_batch()

           with torch.no_grad():
               lowercase__		       =						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]

           lowercase__		       =						torch.Size(
               (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)      )
           self.assertEqual(output.shape     ,UpperCAmelCase_      )

           lowercase__		       =						torch.tensor(
               [[0.35_93, -1.33_98, 0.63_30], [0.22_79, 1.53_96, -0.17_92], [0.04_50, 1.32_25, -0.23_35]]     ,device=UpperCAmelCase_      )
           self.assertTrue(torch.allclose(output[0, :3, :3]     ,UpperCAmelCase_     ,atol=UpperCAmelCase_      )      )



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

           lowercase__		       =						torch.tensor(
               [[-0.07_34, -0.90_36, 0.83_58], [4.71_86, 2.41_13, 1.95_81], [1.79_53, 2.35_58, 1.29_70]]     ,device=UpperCAmelCase_      )
           self.assertTrue(torch.allclose(output[0, :3, :3]     ,UpperCAmelCase_     ,atol=UpperCAmelCase_      )      )







       def 							_a      (				self      )  ->							Dict:
           lowercase__		       =						AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"      ).to(UpperCAmelCase_      )
           lowercase__		       =						prepare_batch("val-batch.pt"      )
           with torch.no_grad():
               lowercase__		       =						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"]     ,)
           lowercase__		       =						torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)      )
           self.assertEqual(outputs.sequences.shape     ,UpperCAmelCase_      )

           lowercase__		       =						torch.tensor([31_30.67_63, 40_56.52_93, 70_53.07_86]     ,device=UpperCAmelCase_      )
           lowercase__		       =						outputs.sequences.mean(dim=1      )
           self.assertTrue(torch.allclose(mean_prediction[0, -3:]     ,UpperCAmelCase_     ,rtol=1E-1      )      )









'''simple docstring'''





def        lowerCamelCase  (				_snake_case  :						int     ,_snake_case  :						int       ):





    '''simple docstring'''


    return x if y == 0 else greatest_common_divisor(_snake_case     ,x % y       )




def        lowerCamelCase  (				_snake_case  :						int     ,_snake_case  :						int       ):





    '''simple docstring'''


    return (x * y) // greatest_common_divisor(_snake_case     ,_snake_case       )




def        lowerCamelCase  (				_snake_case  :						int = 20       ):





    '''simple docstring'''


    lowercase__		       =						1
    for i in range(1     ,n + 1       ):
        lowercase__		       =						lcm(_snake_case     ,_snake_case       )
    return g


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




