






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


__lowerCamelCase						:    Any     				=  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   lowerCAmelCase__ :

			def __init__(					self					:		Any     ,		UpperCamelCase_					:		Tuple     ,		UpperCamelCase_					:		Any=16     ,		UpperCamelCase_					:		Optional[Any]=13     ,		UpperCamelCase_					:		str=7     ,		UpperCamelCase_					:		List[str]=14     ,		UpperCamelCase_					:		Optional[int]=10     ,		UpperCamelCase_					:		List[str]=19     ,		UpperCamelCase_					:		Dict=5     ,		UpperCamelCase_					:		int=4     ,		UpperCamelCase_					:		Tuple=True     ,		UpperCamelCase_					:		Optional[Any]=16     ,		UpperCamelCase_					:		Optional[Any]=2     ,		UpperCamelCase_					:		int=4     ,		UpperCamelCase_					:		List[str]=4     ,		UpperCamelCase_					:		Optional[Any]="gelu"     ,		UpperCamelCase_					:		Any=0.1     ,		UpperCamelCase_					:		Optional[int]=0.1     ,		UpperCamelCase_					:		int=[1, 2, 3, 4, 5]     ,		UpperCamelCase_					:		str=25     ,		UpperCamelCase_					:		str=5     ,		) ->  List[Any]:







				"""simple docstring"""






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

				lowerCamelCase_					:  Optional[int]						=    context_length
				lowerCamelCase_					:  Any						=    prediction_length + label_length
				lowerCamelCase_					:  Dict						=    label_length

				lowerCamelCase_					:  int						=    moving_average
				lowerCamelCase_					:  Optional[int]						=    autocorrelation_factor

			def 						__UpperCamelCase				(					self					:		str	) ->  Optional[int]:







				"""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 						__UpperCamelCase				(					self					:		Optional[Any]     ,		UpperCamelCase_					:		Optional[Any]	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_					:  List[str]						=    config.context_length + max(config.lags_sequence	)

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

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

				lowerCamelCase_					:  Tuple						=    {
				    '''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					:		Union[str, Any]	) ->  Tuple:







				"""simple docstring"""






				lowerCamelCase_					:  List[str]						=    self.get_config()
				lowerCamelCase_					:  int						=    self.prepare_autoformer_inputs_dict(UpperCamelCase_	)
				return config, inputs_dict

			def 						__UpperCamelCase				(					self					:		List[Any]	) ->  Union[str, Any]:







				"""simple docstring"""






				lowerCamelCase_	,				lowerCamelCase_					:  List[Any]						=    self.prepare_config_and_inputs()
				return config, inputs_dict





			def 						__UpperCamelCase				(					self					:		List[Any]     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		Optional[Any]	) ->  Tuple:







				"""simple docstring"""






				lowerCamelCase_					:  str						=    AutoformerModel(config=UpperCamelCase_	).to(UpperCamelCase_	).eval()
				lowerCamelCase_					:  int						=    model(**UpperCamelCase_	)

				lowerCamelCase_					:  Dict						=    outputs.encoder_last_hidden_state
				lowerCamelCase_					:  Any						=    outputs.last_hidden_state

				with tempfile.TemporaryDirectory() as tmpdirname:
					lowerCamelCase_					:  Tuple						=    model.get_encoder()
					encoder.save_pretrained(UpperCamelCase_	)
					lowerCamelCase_					:  List[Any]						=    AutoformerEncoder.from_pretrained(UpperCamelCase_	).to(UpperCamelCase_	)

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

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

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

				lowerCamelCase_					:  str						=    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_					:  Optional[int]						=    model.get_decoder()
					decoder.save_pretrained(UpperCamelCase_	)
					lowerCamelCase_					:  int						=    AutoformerDecoder.from_pretrained(UpperCamelCase_	).to(UpperCamelCase_	)

				lowerCamelCase_					:  List[Any]						=    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   lowerCAmelCase__ ( _lowerCAmelCase						,_lowerCAmelCase						,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 						__UpperCamelCase				(					self					:		Dict	) ->  List[Any]:







				"""simple docstring"""






				lowerCamelCase_					:  List[Any]						=    AutoformerModelTester(self	)
				lowerCamelCase_					:  Tuple						=    ConfigTester(self     ,		config_class=UpperCamelCase_     ,		has_text_modality=UpperCamelCase_	)

			def 						__UpperCamelCase				(					self					:		int	) ->  Optional[Any]:







				"""simple docstring"""






				self.config_tester.run_common_tests()

			def 						__UpperCamelCase				(					self					:		Union[str, Any]	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_	,				lowerCamelCase_					:  Union[str, Any]						=    self.model_tester.prepare_config_and_inputs()
				for model_class in self.all_model_classes:
					lowerCamelCase_					:  Dict						=    model_class(UpperCamelCase_	)

					with tempfile.TemporaryDirectory() as tmpdirname:
						model.save_pretrained(UpperCamelCase_	)
						lowerCamelCase_	,				lowerCamelCase_					:  List[str]						=    model_class.from_pretrained(UpperCamelCase_     ,		output_loading_info=UpperCamelCase_	)
					self.assertEqual(info['''missing_keys''']     ,		[]	)

			def 						__UpperCamelCase				(					self					:		Union[str, Any]	) ->  Optional[int]:







				"""simple docstring"""






				lowerCamelCase_					:  Union[str, Any]						=    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 						__UpperCamelCase				(					self					:		Dict	) ->  Optional[int]:







				"""simple docstring"""






				pass

			def 						__UpperCamelCase				(					self					:		str	) ->  List[Any]:







				"""simple docstring"""






				lowerCamelCase_					:  Tuple						=    inspect.signature(getattr(UpperCamelCase_     ,		'''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     ,		UpperCamelCase_	)

			def 						__UpperCamelCase				(					self					:		Union[str, Any]	) ->  int:







				"""simple docstring"""






				lowerCamelCase_	,				lowerCamelCase_					:  Tuple						=    self.model_tester.prepare_config_and_inputs_for_common()

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

					lowerCamelCase_					:  List[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(UpperCamelCase_	)]     ,		UpperCamelCase_	)

			def 						__UpperCamelCase				(					self					:		int	) ->  List[str]:







				"""simple docstring"""






				lowerCamelCase_	,				lowerCamelCase_					:  int						=    self.model_tester.prepare_config_and_inputs_for_common()
				lowerCamelCase_					:  Union[str, Any]						=    True

				lowerCamelCase_					:  Tuple						=    getattr(self.model_tester     ,		'''seq_length'''     ,		UpperCamelCase_	)
				lowerCamelCase_					:  Optional[int]						=    getattr(self.model_tester     ,		'''decoder_seq_length'''     ,		UpperCamelCase_	)
				lowerCamelCase_					:  List[str]						=    getattr(self.model_tester     ,		'''encoder_seq_length'''     ,		UpperCamelCase_	)
				lowerCamelCase_					:  Optional[Any]						=    getattr(self.model_tester     ,		'''d_model'''     ,		UpperCamelCase_	)
				lowerCamelCase_					:  str						=    getattr(self.model_tester     ,		'''num_attention_heads'''     ,		UpperCamelCase_	)
				lowerCamelCase_					:  Optional[int]						=    d_model // num_attention_heads

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

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

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

				lowerCamelCase_					:  Dict						=    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 						__UpperCamelCase				(					self					:		Any	) ->  Dict:







				"""simple docstring"""






				super().test_retain_grad_hidden_states_attentions()






def        __snake_case						(__UpperCAmelCase="train-batch.pt"    ):





	"""simple docstring"""
	lowerCamelCase_					:  Any						=    hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch'''       ,	filename=__UpperCAmelCase       ,	repo_type='''dataset'''    )
	lowerCamelCase_					:  str						=    torch.load(__UpperCAmelCase       ,	map_location=__UpperCAmelCase    )
	return batch




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

			def 						__UpperCamelCase				(					self					:		List[Any]	) ->  int:







				"""simple docstring"""






				lowerCamelCase_					:  Dict						=    AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''	).to(UpperCamelCase_	)
				lowerCamelCase_					:  List[str]						=    prepare_batch()

				with torch.no_grad():
					lowerCamelCase_					:  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''']     ,		future_values=batch['''future_values''']     ,		future_time_features=batch['''future_time_features''']     ,		)[0]

				lowerCamelCase_					:  Dict						=    torch.Size(
				    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)	)
				self.assertEqual(output.shape     ,		UpperCamelCase_	)

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

			def 						__UpperCamelCase				(					self					:		Dict	) ->  Optional[int]:







				"""simple docstring"""






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

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





			def 						__UpperCamelCase				(					self					:		Union[str, Any]	) ->  Tuple:







				"""simple docstring"""






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

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












'''simple docstring'''







from torch import nn







def 						_A      ( UpperCAmelCase						):






   '''simple docstring'''







   if act_fn in ["swish", "silu"]:
      return nn.SiLU()
   elif act_fn == "mish":
      return nn.Mish()
   elif act_fn == "gelu":
      return nn.GELU()
   else:
      raise ValueError(F"""Unsupported activation function: {act_fn}"""						)


