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


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





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

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

												UpperCamelCase_		:							Union[str, Any]  =		moving_average
												UpperCamelCase_		:							Tuple  =		autocorrelation_factor





						def        A_							(self						)				->				int:
												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			,     __UpperCamelCase						)				->				Tuple:
												UpperCamelCase_		:							Optional[int]  =		config.context_length + max(config.lags_sequence						)

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

												# decoder inputs
												UpperCamelCase_		:							List[str]  =		floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]						)
												UpperCamelCase_		:							Tuple  =		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        A_							(self						)				->				Union[str, Any]:
												UpperCamelCase_		:							str  =		self.get_config()
												UpperCamelCase_		:							Optional[int]  =		self.prepare_autoformer_inputs_dict(lowercase_						)
												return config, inputs_dict





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							List[str]  =		self.prepare_config_and_inputs()
												return config, inputs_dict





						def        A_							(self			,     __UpperCamelCase			,     __UpperCamelCase						)				->				Optional[Any]:
												UpperCamelCase_		:							Any  =		AutoformerModel(config=lowercase_						).to(lowercase_						).eval()
												UpperCamelCase_		:							List[Any]  =		model(**lowercase_						)

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

												with tempfile.TemporaryDirectory() as tmpdirname:
																		UpperCamelCase_		:							str  =		model.get_encoder()
																		encoder.save_pretrained(lowercase_						)
																		UpperCamelCase_		:							Any  =		AutoformerEncoder.from_pretrained(lowercase_						).to(lowercase_						)

												UpperCamelCase_		:							List[str]  =		model.create_network_inputs(**lowercase_						)
												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_		:							Optional[int]  =		encoder(inputs_embeds=lowercase_						)[0]
												self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3						)

												UpperCamelCase_		:							Optional[int]  =		(
												    torch.mean(transformer_inputs[:, : config.context_length, ...]			,     dim=1						)
												    .unsqueeze(1						)
												    .repeat(1			,     config.prediction_length			,     1						)
												)
												UpperCamelCase_		:							Optional[int]  =		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_		:							Tuple  =		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_		:							Optional[int]  =		model.get_decoder()
																		decoder.save_pretrained(lowercase_						)
																		UpperCamelCase_		:							Union[str, Any]  =		AutoformerDecoder.from_pretrained(lowercase_						).to(lowercase_						)

												UpperCamelCase_		:							Tuple  =		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        UpperCamelCase						(				UpperCamelCase_	,	UpperCamelCase_	,	unittest.TestCase				):
						a__		:Optional[Any]      =			(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
						a__		:Optional[Any]      =			(AutoformerForPrediction,) if is_torch_available() else ()
						a__		:Optional[Any]      =			{'feature-extraction': AutoformerModel} if is_torch_available() else {}
						a__		:str      =			False
						a__		:Dict      =			False
						a__		:Optional[int]      =			False
						a__		:Union[str, Any]      =			False
						a__		:List[str]      =			False
						a__		:List[Any]      =			False





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							int  =		AutoformerModelTester(self						)
												UpperCamelCase_		:							List[Any]  =		ConfigTester(self			,     config_class=lowercase_			,     has_text_modality=lowercase_						)





						def        A_							(self						)				->				Any:
												self.config_tester.run_common_tests()





						def        A_							(self						)				->				List[Any]:
												UpperCamelCase_		:							Optional[Any]  =		self.model_tester.prepare_config_and_inputs()
												for model_class in self.all_model_classes:
																		UpperCamelCase_		:							List[str]  =		model_class(lowercase_						)

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





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							List[str]  =		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        A_							(self						)				->				int:
												pass





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							str  =		inspect.signature(getattr(lowercase_			,     """forward"""						)						)
												# The main input is the name of the argument after `self`
												UpperCamelCase_		:							str  =		list(model_signature.parameters.keys()						)[1]
												self.assertEqual(AutoformerModel.main_input_name			,     lowercase_						)





						def        A_							(self						)				->				Any:
												UpperCamelCase_		:							Optional[Any]  =		self.model_tester.prepare_config_and_inputs_for_common()

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

																		UpperCamelCase_		:							Union[str, 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(lowercase_						)]			,     lowercase_						)





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							int  =		self.model_tester.prepare_config_and_inputs_for_common()
												UpperCamelCase_		:							List[str]  =		True

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

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

																		UpperCamelCase_		:							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(lowercase_			,     lowercase_						)

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

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

												UpperCamelCase_		:							Any  =		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        A_							(self						)				->				Optional[Any]:
												super().test_retain_grad_hidden_states_attentions()






def     lowerCAmelCase_			(   _SCREAMING_SNAKE_CASE     :				Optional[int]="train-batch.pt"			):
						UpperCamelCase_		:							Optional[int]  =		hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""		, filename=SCREAMING_SNAKE_CASE__		, repo_type="""dataset"""			)
						UpperCamelCase_		:							Tuple  =		torch.load(SCREAMING_SNAKE_CASE__		, map_location=SCREAMING_SNAKE_CASE__			)
						return batch







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





						def        A_							(self						)				->				int:
												UpperCamelCase_		:							Any  =		AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(lowercase_						)
												UpperCamelCase_		:							Dict  =		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_		:							Tuple  =		torch.Size(
												    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)						)
												self.assertEqual(output.shape			,     lowercase_						)

												UpperCamelCase_		:							int  =		torch.tensor(
												    [[0.3_593, -1.3_398, 0.6_330], [0.2_279, 1.5_396, -0.1_792], [0.0_450, 1.3_225, -0.2_335]]			,     device=lowercase_						)
												self.assertTrue(torch.allclose(output[0, :3, :3]			,     lowercase_			,     atol=lowercase_						)						)





						def        A_							(self						)				->				Optional[Any]:
												UpperCamelCase_		:							Tuple  =		AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(lowercase_						)
												UpperCamelCase_		:							int  =		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_		:							Optional[int]  =		torch.Size((64, model.config.context_length, model.config.d_model)						)
												self.assertEqual(output.shape			,     lowercase_						)

												UpperCamelCase_		:							List[Any]  =		torch.tensor(
												    [[-0.0_734, -0.9_036, 0.8_358], [4.7_186, 2.4_113, 1.9_581], [1.7_953, 2.3_558, 1.2_970]]			,     device=lowercase_						)
												self.assertTrue(torch.allclose(output[0, :3, :3]			,     lowercase_			,     atol=lowercase_						)						)





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

												UpperCamelCase_		:							Optional[int]  =		torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786]			,     device=lowercase_						)
												UpperCamelCase_		:							List[Any]  =		outputs.sequences.mean(dim=1						)
												self.assertTrue(torch.allclose(mean_prediction[0, -3:]			,     lowercase_			,     rtol=1E-1						)						)










from __future__ import annotations

import matplotlib.pyplot as plt  # type: ignore
import numpy

# initial triangle of Koch snowflake
lowerCamelCase		   =			numpy.array([0, 0])
lowerCamelCase		   =			numpy.array([0.5, 0.866_0254])
lowerCamelCase		   =			numpy.array([1, 0])
lowerCamelCase		   =			[VECTOR_1, VECTOR_2, VECTOR_3, VECTOR_1]




def       a_ (       SCREAMING_SNAKE_CASE__   : list[numpy.ndarray]						,     SCREAMING_SNAKE_CASE__   : int	):
       '''simple docstring'''





       _lowerCamelCase			:						List[Any]            =initial_vectors
       for _ in range(SCREAMING_SNAKE_CASE__	):
              _lowerCamelCase			:						List[str]            =iteration_step(SCREAMING_SNAKE_CASE__	)
       return vectors




def       a_ (       SCREAMING_SNAKE_CASE__   : list[numpy.ndarray]	):
       '''simple docstring'''





       _lowerCamelCase			:						Dict            =[]
       for i, start_vector in enumerate(vectors[:-1]	):
              _lowerCamelCase			:						Tuple            =vectors[i + 1]
              new_vectors.append(SCREAMING_SNAKE_CASE__	)
              _lowerCamelCase			:						Tuple            =end_vector - start_vector
              new_vectors.append(start_vector + difference_vector / 3	)
              new_vectors.append(
                  start_vector + difference_vector / 3 + rotate(difference_vector / 3						,     60	)	)
              new_vectors.append(start_vector + difference_vector * 2 / 3	)
       new_vectors.append(vectors[-1]	)
       return new_vectors




def       a_ (       SCREAMING_SNAKE_CASE__   : numpy.ndarray						,     SCREAMING_SNAKE_CASE__   : float	):
       '''simple docstring'''





       _lowerCamelCase			:						Union[str, Any]            =numpy.radians(SCREAMING_SNAKE_CASE__	)
       _lowerCamelCase      ,	_lowerCamelCase			:						List[Any]            =numpy.cos(SCREAMING_SNAKE_CASE__	), numpy.sin(SCREAMING_SNAKE_CASE__	)
       _lowerCamelCase			:						str            =numpy.array(((c, -s), (s, c))	)
       return numpy.dot(SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__	)




def       a_ (       SCREAMING_SNAKE_CASE__   : list[numpy.ndarray]	):
       '''simple docstring'''





       _lowerCamelCase			:						Optional[Any]            =plt.gca()
       axes.set_aspect('equal'	)

       # matplotlib.pyplot.plot takes a list of all x-coordinates and a list of all
       # y-coordinates as inputs, which are constructed from the vector-list using
       # zip()
       _lowerCamelCase      ,	_lowerCamelCase			:						Tuple            =zip(*SCREAMING_SNAKE_CASE__	)
       plt.plot(SCREAMING_SNAKE_CASE__						,     SCREAMING_SNAKE_CASE__	)
       plt.show()


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 lowerCamelCase		   =			iterate(INITIAL_VECTORS, 5)
 plot(processed_vectors)


