


'''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_    :			List[str]      				=			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					, __magic_name__					, __magic_name__=16					, __magic_name__=13					, __magic_name__=7					, __magic_name__=14					, __magic_name__=10					, __magic_name__=19					, __magic_name__=5					, __magic_name__=4					, __magic_name__=True					, __magic_name__=16					, __magic_name__=2					, __magic_name__=4					, __magic_name__=4					, __magic_name__="gelu"					, __magic_name__=0.1					, __magic_name__=0.1					, __magic_name__=[1, 2, 3, 4, 5]					, __magic_name__=25					, __magic_name__=5					, )    ->							Optional[int]:
      _a						=							d_model
      _a						=							parent
      _a						=							batch_size
      _a						=							prediction_length
      _a						=							context_length
      _a						=							cardinality
      _a						=							num_time_features
      _a						=							lags_sequence
      _a						=							embedding_dimension
      _a						=							is_training
      _a						=							hidden_size
      _a						=							num_hidden_layers
      _a						=							num_attention_heads
      _a						=							intermediate_size
      _a						=							hidden_act
      _a						=							hidden_dropout_prob
      _a						=							attention_probs_dropout_prob

      _a						=							context_length
      _a						=							prediction_length + label_length
      _a						=							label_length

      _a						=							moving_average
      _a						=							autocorrelation_factor
 def 							__UpperCAmelCase						(       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 							__UpperCAmelCase						(       self					, __magic_name__  )    ->							Dict:
      _a						=							config.context_length + max(config.lags_sequence  )

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

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

      _a						=							{
          '''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 							__UpperCAmelCase						(       self  )    ->							Optional[Any]:
      _a						=							self.get_config()
      _a						=							self.prepare_autoformer_inputs_dict(__magic_name__  )
      return config, inputs_dict
 def 							__UpperCAmelCase						(       self  )    ->							Union[str, Any]:
      _a						=							self.prepare_config_and_inputs()
      return config, inputs_dict




 def 							__UpperCAmelCase						(       self					, __magic_name__					, __magic_name__  )    ->							int:
      _a						=							AutoformerModel(config=__magic_name__  ).to(__magic_name__  ).eval()
      _a						=							model(**__magic_name__  )

      _a						=							outputs.encoder_last_hidden_state
      _a						=							outputs.last_hidden_state

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

      _a						=							model.create_network_inputs(**__magic_name__  )
      _a						=							model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]  )

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

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

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

      _a						=							decoder(
          trend=__magic_name__					, inputs_embeds=__magic_name__					, encoder_hidden_states=__magic_name__					, )[0]

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





@require_torch
class        a   (   _a     , _a     , unittest.TestCase				):
 _lowerCAmelCase           =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
 _lowerCAmelCase           =		(AutoformerForPrediction,) if is_torch_available() else ()
 _lowerCAmelCase           =		{'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 _lowerCAmelCase           =		False
 def 							__UpperCAmelCase						(       self  )    ->							int:
      _a						=							AutoformerModelTester(self  )
      _a						=							ConfigTester(self					, config_class=__magic_name__					, has_text_modality=__magic_name__  )
 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      self.config_tester.run_common_tests()
 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      _a						=							self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
           _a						=							model_class(__magic_name__  )

           with tempfile.TemporaryDirectory() as tmpdirname:
                model.save_pretrained(__magic_name__  )
                _a						=							model_class.from_pretrained(__magic_name__					, output_loading_info=__magic_name__  )
           self.assertEqual(info['missing_keys']					, []  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      _a						=							self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_encoder_decoder_model_standalone(*__magic_name__  )
 @unittest.skip(reason='Model has no tokens embeddings'  )
 def 							__UpperCAmelCase						(       self  )    ->							Any:
      pass
 def 							__UpperCAmelCase						(       self  )    ->							List[Any]:
      _a						=							inspect.signature(getattr(__magic_name__					, 'forward'  )  )
      # The main input is the name of the argument after `self`
      _a						=							list(model_signature.parameters.keys()  )[1]
      self.assertEqual(AutoformerModel.main_input_name					, __magic_name__  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[Any]:
      _a						=							self.model_tester.prepare_config_and_inputs_for_common()

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

           _a						=							[
               '''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(__magic_name__  )]					, __magic_name__  )
 def 							__UpperCAmelCase						(       self  )    ->							str:
      _a						=							self.model_tester.prepare_config_and_inputs_for_common()
      _a						=							True

      _a						=							getattr(self.model_tester					, 'seq_length'					, __magic_name__  )
      _a						=							getattr(self.model_tester					, 'decoder_seq_length'					, __magic_name__  )
      _a						=							getattr(self.model_tester					, 'encoder_seq_length'					, __magic_name__  )
      _a						=							getattr(self.model_tester					, 'd_model'					, __magic_name__  )
      _a						=							getattr(self.model_tester					, 'num_attention_heads'					, __magic_name__  )
      _a						=							d_model // num_attention_heads

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

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

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

           _a						=							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(__magic_name__					, __magic_name__  )

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

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

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

      self.assertEqual(len(__magic_name__  )					, 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 							__UpperCAmelCase						(       self  )    ->							str:
      super().test_retain_grad_hidden_states_attentions()






def 		_A (lowerCAmelCase__     :List[Any]="train-batch.pt"						)      ->     Optional[Any]:




     '''simple docstring'''



     _a						=							hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch' ,  filename=_UpperCamelCase ,  repo_type='dataset'						)
     _a						=							torch.load(_UpperCamelCase ,  map_location=_UpperCamelCase						)
     return batch






@require_torch
@slow
class        a   (   unittest.TestCase				):
 def 							__UpperCAmelCase						(       self  )    ->							int:
      _a						=							AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'  ).to(__magic_name__  )
      _a						=							prepare_batch()

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

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

      _a						=							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=__magic_name__  )
      self.assertTrue(torch.allclose(output[0, :3, :3]					, __magic_name__					, atol=__magic_name__  )  )
 def 							__UpperCAmelCase						(       self  )    ->							Optional[int]:
      _a						=							AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'  ).to(__magic_name__  )
      _a						=							prepare_batch('val-batch.pt'  )
      with torch.no_grad():
           _a						=							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
      _a						=							torch.Size((64, model.config.context_length, model.config.d_model)  )
      self.assertEqual(output.shape					, __magic_name__  )

      _a						=							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=__magic_name__  )
      self.assertTrue(torch.allclose(output[0, :3, :3]					, __magic_name__					, atol=__magic_name__  )  )




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

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








def      lowerCamelCase_						(				_UpperCamelCase ,				_UpperCamelCase )		->						str:






				"""simple docstring"""


				return "\n".join(
				    f'''{number} * {i} = {number * i}''' for i in range(1 ,				number_of_terms + 1 ) )


if __name__ == "__main__":
	print(multiplication_table(number=5, number_of_terms=1_0))
