






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


UpperCamelCase      					=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     :






 """simple docstring"""





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

       UpperCamelCase_					: Union[str, Any]            =				context_length
       UpperCamelCase_					: str            =				prediction_length + label_length
       UpperCamelCase_					: Dict            =				label_length

       UpperCamelCase_					: Any            =				moving_average
       UpperCamelCase_					: int            =				autocorrelation_factor
 def 	_UpperCAmelCase							(				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 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase			):
       UpperCamelCase_					: List[str]            =				config.context_length + max(config.lags_sequence			)

       UpperCamelCase_					: Any            =				ids_tensor([self.batch_size, 1]      ,  config.cardinality[0]			)
       UpperCamelCase_					: Any            =				floats_tensor([self.batch_size, _past_length, config.num_time_features]			)
       UpperCamelCase_					: Union[str, Any]            =				floats_tensor([self.batch_size, _past_length]			)
       UpperCamelCase_					: str            =				floats_tensor([self.batch_size, _past_length]			) > 0.5

       # decoder inputs
       UpperCamelCase_					: int            =				floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]			)
       UpperCamelCase_					: Optional[Any]            =				floats_tensor([self.batch_size, config.prediction_length]			)

       UpperCamelCase_					: 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 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[Any]            =				self.get_config()
       UpperCamelCase_					: int            =				self.prepare_autoformer_inputs_dict(_A			)
       return config, inputs_dict
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[int]            =				self.prepare_config_and_inputs()
       return config, inputs_dict





 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase			):
       UpperCamelCase_					: str            =				AutoformerModel(config=_A			).to(_A			).eval()
       UpperCamelCase_					: List[str]            =				model(**_A			)

       UpperCamelCase_					: Any            =				outputs.encoder_last_hidden_state
       UpperCamelCase_					: List[Any]            =				outputs.last_hidden_state

       with tempfile.TemporaryDirectory() as tmpdirname:
             UpperCamelCase_					: Optional[Any]            =				model.get_encoder()
             encoder.save_pretrained(_A			)
             UpperCamelCase_					: Union[str, Any]            =				AutoformerEncoder.from_pretrained(_A			).to(_A			)

       UpperCamelCase_					: Dict            =				model.create_network_inputs(**_A			)
       UpperCamelCase_					: Tuple            =				model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]			)

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

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

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

       UpperCamelCase_					: str            =				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    ):






 """simple docstring"""





 __a      :    Tuple			  =    (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
 __a      :    str			  =    (AutoformerForPrediction,) if is_torch_available() else ()
 __a      :    Dict			  =    {"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
 __a      :    List[Any]			  =    False
 __a      :    Any			  =    False
 __a      :    List[Any]			  =    False
 __a      :    Optional[int]			  =    False
 __a      :    Optional[Any]			  =    False
 __a      :    Optional[int]			  =    False
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[Any]            =				AutoformerModelTester(self			)
       UpperCamelCase_					: int            =				ConfigTester(self      ,  config_class=_A      ,  has_text_modality=_A			)
 def 	_UpperCAmelCase							(				self			):
       self.config_tester.run_common_tests()
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Tuple            =				self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
             UpperCamelCase_					: Optional[int]            =				model_class(_A			)

             with tempfile.TemporaryDirectory() as tmpdirname:
                   model.save_pretrained(_A			)
                   UpperCamelCase_					: Optional[Any]            =				model_class.from_pretrained(_A      ,  output_loading_info=_A			)
             self.assertEqual(info["""missing_keys"""]      ,  []			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Dict            =				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 	_UpperCAmelCase							(				self			):
       pass
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Any            =				inspect.signature(getattr(_A      ,  """forward"""			)			)
       # The main input is the name of the argument after `self`
       UpperCamelCase_					: Optional[Any]            =				list(model_signature.parameters.keys()			)[1]
       self.assertEqual(AutoformerModel.main_input_name      ,  _A			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Optional[int]            =				self.model_tester.prepare_config_and_inputs_for_common()

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

             UpperCamelCase_					: Optional[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(_A			)]      ,  _A			)
 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: List[str]            =				self.model_tester.prepare_config_and_inputs_for_common()
       UpperCamelCase_					: Dict            =				True

       UpperCamelCase_					: Tuple            =				getattr(self.model_tester      ,  """seq_length"""      ,  _A			)
       UpperCamelCase_					: Dict            =				getattr(self.model_tester      ,  """decoder_seq_length"""      ,  _A			)
       UpperCamelCase_					: Optional[Any]            =				getattr(self.model_tester      ,  """encoder_seq_length"""      ,  _A			)
       UpperCamelCase_					: Optional[int]            =				getattr(self.model_tester      ,  """d_model"""      ,  _A			)
       UpperCamelCase_					: Optional[Any]            =				getattr(self.model_tester      ,  """num_attention_heads"""      ,  _A			)
       UpperCamelCase_					: Tuple            =				d_model // num_attention_heads

       for model_class in self.all_model_classes:
             UpperCamelCase_					: List[Any]            =				True
             UpperCamelCase_					: Any            =				False
             UpperCamelCase_					: List[str]            =				True
             UpperCamelCase_					: List[str]            =				model_class(_A			)
             model.to(_A			)
             model.eval()
             with torch.no_grad():
                   UpperCamelCase_					: Tuple            =				model(**self._prepare_for_class(_A      ,  _A			)			)
             UpperCamelCase_					: Optional[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"]
             UpperCamelCase_					: Tuple            =				True
             UpperCamelCase_					: Optional[int]            =				model_class(_A			)
             model.to(_A			)
             model.eval()
             with torch.no_grad():
                   UpperCamelCase_					: List[Any]            =				model(**self._prepare_for_class(_A      ,  _A			)			)
             UpperCamelCase_					: List[str]            =				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]      ,  )
             UpperCamelCase_					: List[str]            =				len(_A			)

             UpperCamelCase_					: 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
             UpperCamelCase_					: Optional[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
             UpperCamelCase_					: int            =				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
       UpperCamelCase_					: Any            =				True
       UpperCamelCase_					: Dict            =				True
       UpperCamelCase_					: int            =				model_class(_A			)
       model.to(_A			)
       model.eval()
       with torch.no_grad():
             UpperCamelCase_					: int            =				model(**self._prepare_for_class(_A      ,  _A			)			)

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

       UpperCamelCase_					: str            =				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 	_UpperCAmelCase							(				self			):
       super().test_retain_grad_hidden_states_attentions()






def 				snake_case       (  a_				:			List[str]="train-batch.pt"						)							->					List[Any]:





      """simple docstring"""

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




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






 """simple docstring"""





 def 	_UpperCAmelCase							(				self			):
       UpperCamelCase_					: Dict            =				AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""			).to(_A			)
       UpperCamelCase_					: List[str]            =				prepare_batch()

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

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

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

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





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

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













"""simple docstring"""


# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__magic_name__       :					Tuple						=			{"""configuration_mra""": ["""MRA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """MraConfig"""]}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__magic_name__       :					Tuple						=			[
		    """MRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
		    """MraForMaskedLM""",
		    """MraForMultipleChoice""",
		    """MraForQuestionAnswering""",
		    """MraForSequenceClassification""",
		    """MraForTokenClassification""",
		    """MraLayer""",
		    """MraModel""",
		    """MraPreTrainedModel""",
		]


if TYPE_CHECKING:
		from .configuration_mra import MRA_PRETRAINED_CONFIG_ARCHIVE_MAP, MraConfig

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_mra import (
				    MRA_PRETRAINED_MODEL_ARCHIVE_LIST,
				    MraForMaskedLM,
				    MraForMultipleChoice,
				    MraForQuestionAnswering,
				    MraForSequenceClassification,
				    MraForTokenClassification,
				    MraLayer,
				    MraModel,
				    MraPreTrainedModel,
				)
else:
		import sys

		__magic_name__       :					Any						=			_LazyModule(__name__, globals()["""__file__"""], _import_structure)



