


'''simple docstring'''






import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


__UpperCAmelCase       =							1e-4

if is_torch_available():
		import torch

		from transformers import AutoformerConfig, AutoformerForPrediction, AutoformerModel
		from transformers.models.autoformer.modeling_autoformer import AutoformerDecoder, AutoformerEncoder




@require_torch
class 		a__    :





							'''simple docstring'''






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

														lowerCAmelCase__	       =     context_length
														lowerCAmelCase__	       =     prediction_length + label_length
														lowerCAmelCase__	       =     label_length

														lowerCAmelCase__	       =     moving_average
														lowerCAmelCase__	       =     autocorrelation_factor







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Tuple:
														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   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_       )	->							Optional[Any]:
														lowerCAmelCase__	       =     config.context_length + max(config.lags_sequence       )

														lowerCAmelCase__	       =     ids_tensor([self.batch_size, 1] ,   config.cardinality[0]       )
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, _past_length, config.num_time_features]       )
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, _past_length]       )
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, _past_length]       ) > 0.5

														# decoder inputs
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]       )
														lowerCAmelCase__	       =     floats_tensor([self.batch_size, config.prediction_length]       )

														lowerCAmelCase__	       =     {
														    '''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   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__	       =     self.get_config()
														lowerCAmelCase__	       =     self.prepare_autoformer_inputs_dict(lowerCamelCase_       )
														return config, inputs_dict







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.prepare_config_and_inputs()
														return config, inputs_dict







							def   __SCREAMING_SNAKE_CASE							(		self ,   lowerCamelCase_ ,   lowerCamelCase_       )	->							Dict:
														lowerCAmelCase__	       =     AutoformerModel(config=lowerCamelCase_       ).to(lowerCamelCase_       ).eval()
														lowerCAmelCase__	       =     model(**lowerCamelCase_       )

														lowerCAmelCase__	       =     outputs.encoder_last_hidden_state
														lowerCAmelCase__	       =     outputs.last_hidden_state

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

														lowerCAmelCase__       , lowerCAmelCase__       , lowerCAmelCase__       , lowerCAmelCase__       , lowerCAmelCase__	       =     model.create_network_inputs(**lowerCamelCase_       )
														lowerCAmelCase__       , lowerCAmelCase__	       =     model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]       )

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

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

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

														lowerCAmelCase__	       =     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 		a__    (							a__    ,    a__    ,    unittest.TestCase  ):





							'''simple docstring'''






							lowercase__      :       Union[str, Any]     						=				(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
							lowercase__      :       Any     						=				(AutoformerForPrediction,) if is_torch_available() else ()
							lowercase__      :       Union[str, Any]     						=				{"feature-extraction": AutoformerModel} if is_torch_available() else {}
							lowercase__      :       Any     						=				False
							lowercase__      :       Optional[Any]     						=				False
							lowercase__      :       Any     						=				False
							lowercase__      :       str     						=				False
							lowercase__      :       int     						=				False
							lowercase__      :       Any     						=				False







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__	       =     AutoformerModelTester(self       )
														lowerCAmelCase__	       =     ConfigTester(self ,   config_class=lowerCamelCase_ ,   has_text_modality=lowerCamelCase_       )







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[Any]:
														self.config_tester.run_common_tests()







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[int]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs()
														for model_class in self.all_model_classes:
																					lowerCAmelCase__	       =     model_class(lowerCamelCase_       )

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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Union[str, Any]:
														lowerCAmelCase__	       =     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   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														pass







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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							List[str]:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs_for_common()

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

																					lowerCAmelCase__	       =     [
																					    '''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   __SCREAMING_SNAKE_CASE							(		self       )	->							int:
														lowerCAmelCase__       , lowerCAmelCase__	       =     self.model_tester.prepare_config_and_inputs_for_common()
														lowerCAmelCase__	       =     True

														lowerCAmelCase__	       =     getattr(self.model_tester ,   '''seq_length''' ,   lowerCamelCase_       )
														lowerCAmelCase__	       =     getattr(self.model_tester ,   '''decoder_seq_length''' ,   lowerCamelCase_       )
														lowerCAmelCase__	       =     getattr(self.model_tester ,   '''encoder_seq_length''' ,   lowerCamelCase_       )
														lowerCAmelCase__	       =     getattr(self.model_tester ,   '''d_model''' ,   lowerCamelCase_       )
														lowerCAmelCase__	       =     getattr(self.model_tester ,   '''num_attention_heads''' ,   lowerCamelCase_       )
														lowerCAmelCase__	       =     d_model // num_attention_heads

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

																					lowerCAmelCase__	       =     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
																					lowerCAmelCase__	       =     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
																					lowerCAmelCase__	       =     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
														lowerCAmelCase__	       =     True
														lowerCAmelCase__	       =     True
														lowerCAmelCase__	       =     model_class(lowerCamelCase_       )
														model.to(lowerCamelCase_       )
														model.eval()
														with torch.no_grad():
																					lowerCAmelCase__	       =     model(**self._prepare_for_class(lowerCamelCase_ ,   lowerCamelCase_       )       )

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

														lowerCAmelCase__	       =     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   __SCREAMING_SNAKE_CASE							(		self       )	->							Dict:
														super().test_retain_grad_hidden_states_attentions()


def  _snake_case       (					A="train-batch.pt"	)						->   Dict:
							lowerCAmelCase__	       =     hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch'''			,   filename=A			,   repo_type='''dataset'''	)
							lowerCAmelCase__	       =     torch.load(A			,   map_location=A	)
							return batch






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





							'''simple docstring'''






							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Optional[Any]:
														lowerCAmelCase__	       =     AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''       ).to(lowerCamelCase_       )
														lowerCAmelCase__	       =     prepare_batch()

														with torch.no_grad():
																					lowerCAmelCase__	       =     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__	       =     torch.Size(
														    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)       )
														self.assertEqual(output.shape ,   lowerCamelCase_       )

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







							def   __SCREAMING_SNAKE_CASE							(		self       )	->							Any:
														lowerCAmelCase__	       =     AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''       ).to(lowerCamelCase_       )
														lowerCAmelCase__	       =     prepare_batch('''val-batch.pt'''       )
														with torch.no_grad():
																					lowerCAmelCase__	       =     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__	       =     torch.Size((64, model.config.context_length, model.config.d_model)       )
														self.assertEqual(output.shape ,   lowerCamelCase_       )

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







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

														lowerCAmelCase__	       =     torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786] ,   device=lowerCamelCase_       )
														lowerCAmelCase__	       =     outputs.sequences.mean(dim=1       )
														self.assertTrue(torch.allclose(mean_prediction[0, -3:] ,   lowerCamelCase_ ,   rtol=1e-1       )       )



'''simple docstring'''






from __future__ import annotations

import math
from collections.abc import Callable


def  _snake_case       (					A			,   A			,   A			,   A = 100			,   )						->   float:
							lowerCAmelCase__	       =     x_start
							lowerCAmelCase__	       =     fnc(A	)
							lowerCAmelCase__	       =     0.0

							for _ in range(A	):
														# Approximates curve as a sequence of linear lines and sums their length
														lowerCAmelCase__	       =     (x_end - x_start) / steps + xa
														lowerCAmelCase__	       =     fnc(A	)
														length += math.hypot(xa - xa			,   fxa - fxa	)

														# Increment step
														lowerCAmelCase__	       =     xa
														lowerCAmelCase__	       =     fxa

							return length


if __name__ == "__main__":


		def  _snake_case       (					A	)						->   List[Any]:
									return math.sin(10 * x	)

		print('''f(x) = sin(10 * x)''')
		print('''The length of the curve from x = -10 to x = 10 is:''')
		__UpperCAmelCase       =							10
		while i <= 100_000:
				print(f"""With {i} steps: {line_length(f, -10, 10, i)}""")
				i *= 10