



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


lowercase_      :				Tuple   					=    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       :







	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 ,				)    ->    Tuple:
							'''simple docstring'''






							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						)    ->    Tuple:
							'''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   _a   (    self ,				_lowerCAmelCase						)    ->    Optional[Any]:
							'''simple docstring'''






							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						)    ->    Any:
							'''simple docstring'''






							lowercase        =							self.get_config()
							lowercase        =							self.prepare_autoformer_inputs_dict(_lowerCAmelCase						)
							return config, inputs_dict







	def   _a   (    self						)    ->    Tuple:
							'''simple docstring'''






							lowercase     ,   lowercase        =							self.prepare_config_and_inputs()
							return config, inputs_dict







	def   _a   (    self ,				_lowerCAmelCase ,				_lowerCAmelCase						)    ->    Dict:
							'''simple docstring'''






							lowercase        =							AutoformerModel(config=_lowerCAmelCase						).to(_lowerCAmelCase						).eval()
							lowercase        =							model(**_lowerCAmelCase						)

							lowercase        =							outputs.encoder_last_hidden_state
							lowercase        =							outputs.last_hidden_state

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

							lowercase     ,   lowercase     ,   lowercase     ,   lowercase     ,   lowercase        =							model.create_network_inputs(**_lowerCAmelCase						)
							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=_lowerCAmelCase						)[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(_lowerCAmelCase						)
													lowercase        =							AutoformerDecoder.from_pretrained(_lowerCAmelCase						).to(_lowerCAmelCase						)

							lowercase        =							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       (_UpperCAmelCase			,   _UpperCAmelCase			,   unittest.TestCase			):
	__A			  =					(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
	__A			  =					(AutoformerForPrediction,) if is_torch_available() else ()
	__A			  =					{'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
	__A			  =					False
	__A			  =					False
	__A			  =					False
	__A			  =					False
	__A			  =					False
	__A			  =					False







	def   _a   (    self						)    ->    Optional[int]:
							'''simple docstring'''






							lowercase        =							AutoformerModelTester(self						)
							lowercase        =							ConfigTester(self ,				config_class=_lowerCAmelCase ,				has_text_modality=_lowerCAmelCase						)







	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							self.config_tester.run_common_tests()







	def   _a   (    self						)    ->    str:
							'''simple docstring'''






							lowercase     ,   lowercase        =							self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
													lowercase        =							model_class(_lowerCAmelCase						)

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







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							lowercase        =							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   _a   (    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							pass







	def   _a   (    self						)    ->    Optional[Any]:
							'''simple docstring'''






							lowercase        =							inspect.signature(getattr(_lowerCAmelCase ,				"""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 ,				_lowerCAmelCase						)







	def   _a   (    self						)    ->    List[str]:
							'''simple docstring'''






							lowercase     ,   lowercase        =							self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													lowercase        =							model_class(_lowerCAmelCase						)
													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(_lowerCAmelCase						)] ,				_lowerCAmelCase						)







	def   _a   (    self						)    ->    Any:
							'''simple docstring'''






							lowercase     ,   lowercase        =							self.model_tester.prepare_config_and_inputs_for_common()
							lowercase        =							True

							lowercase        =							getattr(self.model_tester ,				"""seq_length""" ,				_lowerCAmelCase						)
							lowercase        =							getattr(self.model_tester ,				"""decoder_seq_length""" ,				_lowerCAmelCase						)
							lowercase        =							getattr(self.model_tester ,				"""encoder_seq_length""" ,				_lowerCAmelCase						)
							lowercase        =							getattr(self.model_tester ,				"""d_model""" ,				_lowerCAmelCase						)
							lowercase        =							getattr(self.model_tester ,				"""num_attention_heads""" ,				_lowerCAmelCase						)
							lowercase        =							d_model // num_attention_heads

							for model_class in self.all_model_classes:
													lowercase        =							True
													lowercase        =							False
													lowercase        =							True
													lowercase        =							model_class(_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()
													with torch.no_grad():
																			lowercase        =							model(**self._prepare_for_class(_lowerCAmelCase ,				_lowerCAmelCase						)						)
													lowercase        =							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"]
													lowercase        =							True
													lowercase        =							model_class(_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()
													with torch.no_grad():
																			lowercase        =							model(**self._prepare_for_class(_lowerCAmelCase ,				_lowerCAmelCase						)						)
													lowercase        =							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] ,				)
													lowercase        =							len(_lowerCAmelCase						)

													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(_lowerCAmelCase ,				_lowerCAmelCase						)

													# decoder attentions
													lowercase        =							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
													lowercase        =							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
							lowercase        =							True
							lowercase        =							True
							lowercase        =							model_class(_lowerCAmelCase						)
							model.to(_lowerCAmelCase						)
							model.eval()
							with torch.no_grad():
													lowercase        =							model(**self._prepare_for_class(_lowerCAmelCase ,				_lowerCAmelCase						)						)

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

							lowercase        =							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   _a   (    self						)    ->    Any:
							'''simple docstring'''






							super().test_retain_grad_hidden_states_attentions()







def      SCREAMING_SNAKE_CASE				(				lowercase_    :      str="train-batch.pt"						):
						lowercase        =							hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch""" ,  filename=lowercase_ ,  repo_type="""dataset"""						)
						lowercase        =							torch.load(lowercase_ ,  map_location=lowercase_						)
						return batch




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







	def   _a   (    self						)    ->    int:
							'''simple docstring'''






							lowercase        =							AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(_lowerCAmelCase						)
							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 ,				_lowerCAmelCase						)

							lowercase        =							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   _a   (    self						)    ->    Optional[Any]:
							'''simple docstring'''






							lowercase        =							AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(_lowerCAmelCase						)
							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 ,				_lowerCAmelCase						)

							lowercase        =							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   _a   (    self						)    ->    Union[str, Any]:
							'''simple docstring'''






							lowercase        =							AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(_lowerCAmelCase						)
							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 ,				_lowerCAmelCase						)

							lowercase        =							torch.tensor([3130.6763, 4056.5293, 7053.0786] ,				device=_lowerCAmelCase						)
							lowercase        =							outputs.sequences.mean(dim=1						)
							self.assertTrue(torch.allclose(mean_prediction[0, -3:] ,				_lowerCAmelCase ,				rtol=1E-1						)						)







'''simple docstring'''


import os







def      SCREAMING_SNAKE_CASE				(				):
						lowercase        =							os.path.join(os.path.dirname(lowercase_						) ,  """num.txt"""						)
						with open(lowercase_						) as file_hand:
												return str(sum(int(lowercase_						) for line in file_hand						)						)[:10]


if __name__ == "__main__":
						print(solution())


