



"""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__			   =  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 SCREAMING_SNAKE_CASE__					:



						def __init__(self						,     _lowercase						,     _lowercase=16						,     _lowercase=13						,     _lowercase=7						,     _lowercase=14						,     _lowercase=10						,     _lowercase=19						,     _lowercase=5						,     _lowercase=4						,     _lowercase=True						,     _lowercase=16						,     _lowercase=2						,     _lowercase=4						,     _lowercase=4						,     _lowercase="gelu"						,     _lowercase=0.1						,     _lowercase=0.1						,     _lowercase=[1, 2, 3, 4, 5]						,     _lowercase=25						,     _lowercase=5						,     ):





													'''simple docstring'''

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

													__a		:		Any									=       context_length
													__a		:		int									=       prediction_length + label_length
													__a		:		Tuple									=       label_length

													__a		:		str									=       moving_average
													__a		:		Optional[int]									=       autocorrelation_factor



						def     lowerCAmelCase__(self							):





													'''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     lowerCAmelCase__(self						,     _lowercase							):





													'''simple docstring'''

													__a		:		Optional[int]									=       config.context_length + max(config.lags_sequence							)

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

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

													__a		:		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     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		int									=       self.get_config()
													__a		:		List[Any]									=       self.prepare_autoformer_inputs_dict(_lowercase							)
													return config, inputs_dict



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Dict									=       self.prepare_config_and_inputs()
													return config, inputs_dict





						def     lowerCAmelCase__(self						,     _lowercase						,     _lowercase							):





													'''simple docstring'''

													__a		:		Tuple									=       AutoformerModel(config=_lowercase							).to(_lowercase							).eval()
													__a		:		Tuple									=       model(**_lowercase							)

													__a		:		str									=       outputs.encoder_last_hidden_state
													__a		:		Union[str, Any]									=       outputs.last_hidden_state

													with tempfile.TemporaryDirectory() as tmpdirname:
																				__a		:		List[str]									=       model.get_encoder()
																				encoder.save_pretrained(_lowercase							)
																				__a		:		Union[str, Any]									=       AutoformerEncoder.from_pretrained(_lowercase							).to(_lowercase							)

													__a							,     __a							,     __a							,     __a							,     __a		:		Optional[Any]									=       model.create_network_inputs(**_lowercase							)
													__a							,     __a		:		int									=       model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]							)

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

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

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

													__a		:		int									=       decoder(
													    trend=_lowercase						,     inputs_embeds=_lowercase						,     encoder_hidden_states=_lowercase						,     )[0]

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







@require_torch
class SCREAMING_SNAKE_CASE__					(		__snake_case     ,					__snake_case     ,					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     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Dict									=       AutoformerModelTester(self							)
													__a		:		Dict									=       ConfigTester(self						,     config_class=_lowercase						,     has_text_modality=_lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													self.config_tester.run_common_tests()



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		List[str]									=       self.model_tester.prepare_config_and_inputs()
													for model_class in self.all_model_classes:
																				__a		:		Optional[Any]									=       model_class(_lowercase							)

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



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Dict									=       self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.check_encoder_decoder_model_standalone(*_lowercase							)



						@unittest.skip(reason="""Model has no tokens embeddings"""							)
						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													pass



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Tuple									=       inspect.signature(getattr(_lowercase						,     """forward"""							)							)
													# The main input is the name of the argument after `self`
													__a		:		str									=       list(model_signature.parameters.keys()							)[1]
													self.assertEqual(AutoformerModel.main_input_name						,     _lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Optional[int]									=       self.model_tester.prepare_config_and_inputs_for_common()

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

																				__a		:		Dict									=       [
																				    """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(_lowercase							)]						,     _lowercase							)



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a							,     __a		:		Dict									=       self.model_tester.prepare_config_and_inputs_for_common()
													__a		:		Optional[Any]									=       True

													__a		:		Optional[int]									=       getattr(self.model_tester						,     """seq_length"""						,     _lowercase							)
													__a		:		Optional[int]									=       getattr(self.model_tester						,     """decoder_seq_length"""						,     _lowercase							)
													__a		:		Optional[int]									=       getattr(self.model_tester						,     """encoder_seq_length"""						,     _lowercase							)
													__a		:		List[str]									=       getattr(self.model_tester						,     """d_model"""						,     _lowercase							)
													__a		:		Union[str, Any]									=       getattr(self.model_tester						,     """num_attention_heads"""						,     _lowercase							)
													__a		:		List[Any]									=       d_model // num_attention_heads

													for model_class in self.all_model_classes:
																				__a		:		int									=       True
																				__a		:		Union[str, Any]									=       False
																				__a		:		List[Any]									=       True
																				__a		:		int									=       model_class(_lowercase							)
																				model.to(_lowercase							)
																				model.eval()
																				with torch.no_grad():
																											__a		:		int									=       model(**self._prepare_for_class(_lowercase						,     _lowercase							)							)
																				__a		:		Optional[Any]									=       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
																				self.assertEqual(len(_lowercase							)						,     self.model_tester.num_hidden_layers							)

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

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

																				__a		:		int									=       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(_lowercase						,     _lowercase							)

																				# decoder attentions
																				__a		:		Dict									=       outputs.decoder_attentions
																				self.assertIsInstance(_lowercase						,     (list, tuple)							)
																				self.assertEqual(len(_lowercase							)						,     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		:		Optional[Any]									=       outputs.cross_attentions
																				self.assertIsInstance(_lowercase						,     (list, tuple)							)
																				self.assertEqual(len(_lowercase							)						,     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		:		Any									=       True
													__a		:		Any									=       True
													__a		:		List[Any]									=       model_class(_lowercase							)
													model.to(_lowercase							)
													model.eval()
													with torch.no_grad():
																				__a		:		List[str]									=       model(**self._prepare_for_class(_lowercase						,     _lowercase							)							)

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

													__a		:		Optional[int]									=       outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

													self.assertEqual(len(_lowercase							)						,     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     lowerCAmelCase__(self							):





													'''simple docstring'''

													super().test_retain_grad_hidden_states_attentions()







def       __magic_name__    (   _lowerCamelCase				: Tuple="train-batch.pt"					):
							__a		:		Any									=       hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""  ,       filename=_lowerCamelCase  ,       repo_type="""dataset"""					)
							__a		:		int									=       torch.load(_lowerCamelCase  ,       map_location=_lowerCamelCase					)
							return batch







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



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

													__a		:		Dict									=       AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""							).to(_lowercase							)
													__a		:		int									=       prepare_batch()

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

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

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



						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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

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





						def     lowerCAmelCase__(self							):





													'''simple docstring'''

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

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






"""simple docstring"""

def       __magic_name__    (   _lowerCamelCase				: int  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float(moles / volume					) * nfactor					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((moles * 0.08_21 * temperature) / (volume)					)					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((moles * 0.08_21 * temperature) / (pressure)					)					)





def       __magic_name__    (   _lowerCamelCase				: float  ,       _lowerCamelCase				: float  ,       _lowerCamelCase				: float					):
							return round(float((pressure * volume) / (0.08_21 * moles)					)					)


if __name__ == "__main__":
	import doctest

	doctest.testmod()

