


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


__SCREAMING_SNAKE_CASE      		=    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 __snake_case		:







   """simple docstring"""




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

          _a							 =					context_length
          _a							 =					prediction_length + label_length
          _a							 =					label_length

          _a							 =					moving_average
          _a							 =					autocorrelation_factor




   def SCREAMING_SNAKE_CASE_   (		self				:Any							):
          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				:Optional[int]					,	UpperCamelCase__				:List[Any]							):
          _a							 =					config.context_length + max(config.lags_sequence							)

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

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

          _a							 =					{
              "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				:Any							):
          _a							 =					self.get_config()
          _a							 =					self.prepare_autoformer_inputs_dict(snake_case_							)
          return config, inputs_dict




   def SCREAMING_SNAKE_CASE_   (		self				:List[Any]							):
          _a ,			_a							 =					self.prepare_config_and_inputs()
          return config, inputs_dict




   def SCREAMING_SNAKE_CASE_   (		self				:List[Any]					,	UpperCamelCase__				:Union[str, Any]					,	UpperCamelCase__				:str							):
          _a							 =					AutoformerModel(config=snake_case_							).to(snake_case_							).eval()
          _a							 =					model(**snake_case_							)

          _a							 =					outputs.encoder_last_hidden_state
          _a							 =					outputs.last_hidden_state

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

          _a ,			_a ,			_a ,			_a ,			_a							 =					model.create_network_inputs(**snake_case_							)
          _a ,			_a							 =					model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]							)

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

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

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

          _a							 =					decoder(
              trend=snake_case_					,	inputs_embeds=snake_case_					,	encoder_hidden_states=snake_case_					,	)[0]

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






@require_torch
class __snake_case		(       __snake_case					,							__snake_case					,							unittest.TestCase   ):







   """simple docstring"""




   lowerCAmelCase_					: Optional[Any]  						=      (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
   lowerCAmelCase_					: Optional[Any]  						=      (AutoformerForPrediction,) if is_torch_available() else ()
   lowerCAmelCase_					: str  						=      {'feature-extraction': AutoformerModel} if is_torch_available() else {}
   lowerCAmelCase_					: Dict  						=      False
   lowerCAmelCase_					: Optional[Any]  						=      False
   lowerCAmelCase_					: Optional[Any]  						=      False
   lowerCAmelCase_					: Optional[int]  						=      False
   lowerCAmelCase_					: Any  						=      False
   lowerCAmelCase_					: Tuple  						=      False




   def SCREAMING_SNAKE_CASE_   (		self				:Union[str, Any]							):
          _a							 =					AutoformerModelTester(self							)
          _a							 =					ConfigTester(self					,	config_class=snake_case_					,	has_text_modality=snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:Optional[int]							):
          self.config_tester.run_common_tests()




   def SCREAMING_SNAKE_CASE_   (		self				:int							):
          _a ,			_a							 =					self.model_tester.prepare_config_and_inputs()
          for model_class in self.all_model_classes:
                 _a							 =					model_class(snake_case_							)

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




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple							):
          _a							 =					self.model_tester.prepare_config_and_inputs_for_common()
          self.model_tester.check_encoder_decoder_model_standalone(*snake_case_							)




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




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




   def SCREAMING_SNAKE_CASE_   (		self				:Optional[Any]							):
          _a ,			_a							 =					self.model_tester.prepare_config_and_inputs_for_common()

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

                 _a							 =					[
                     "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(snake_case_							)]					,	snake_case_							)




   def SCREAMING_SNAKE_CASE_   (		self				:str							):
          _a ,			_a							 =					self.model_tester.prepare_config_and_inputs_for_common()
          _a							 =					True

          _a							 =					getattr(self.model_tester					,	"seq_length"					,	snake_case_							)
          _a							 =					getattr(self.model_tester					,	"decoder_seq_length"					,	snake_case_							)
          _a							 =					getattr(self.model_tester					,	"encoder_seq_length"					,	snake_case_							)
          _a							 =					getattr(self.model_tester					,	"d_model"					,	snake_case_							)
          _a							 =					getattr(self.model_tester					,	"num_attention_heads"					,	snake_case_							)
          _a							 =					d_model // num_attention_heads

          for model_class in self.all_model_classes:
                 _a							 =					True
                 _a							 =					False
                 _a							 =					True
                 _a							 =					model_class(snake_case_							)
                 model.to(snake_case_							)
                 model.eval()
                 with torch.no_grad():
                        _a							 =					model(**self._prepare_for_class(snake_case_					,	snake_case_							)							)
                 _a							 =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
                 self.assertEqual(len(snake_case_							)					,	self.model_tester.num_hidden_layers							)

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

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

                 _a							 =					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(snake_case_					,	snake_case_							)

                 # decoder attentions
                 _a							 =					outputs.decoder_attentions
                 self.assertIsInstance(snake_case_					,	(list, tuple)							)
                 self.assertEqual(len(snake_case_							)					,	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							 =					outputs.cross_attentions
                 self.assertIsInstance(snake_case_					,	(list, tuple)							)
                 self.assertEqual(len(snake_case_							)					,	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							 =					True
          _a							 =					True
          _a							 =					model_class(snake_case_							)
          model.to(snake_case_							)
          model.eval()
          with torch.no_grad():
                 _a							 =					model(**self._prepare_for_class(snake_case_					,	snake_case_							)							)

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

          _a							 =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

          self.assertEqual(len(snake_case_							)					,	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				:int							):
          super().test_retain_grad_hidden_states_attentions()






def     __a   (	a="train-batch.pt"       ):





       """simple docstring"""







       _a							 =					hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch",		filename=_SCREAMING_SNAKE_CASE,		repo_type="dataset"       )
       _a							 =					torch.load(_SCREAMING_SNAKE_CASE,		map_location=_SCREAMING_SNAKE_CASE       )
       return batch





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







   """simple docstring"""




   def SCREAMING_SNAKE_CASE_   (		self				:Tuple							):
          _a							 =					AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"							).to(snake_case_							)
          _a							 =					prepare_batch()

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

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




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

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




   def SCREAMING_SNAKE_CASE_   (		self				:Any							):
          _a							 =					AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"							).to(snake_case_							)
          _a							 =					prepare_batch("val-batch.pt"							)
          with torch.no_grad():
                 _a							 =					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							 =					torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)							)
          self.assertEqual(outputs.sequences.shape					,	snake_case_							)

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







from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE				)							-> bool:




    """simple docstring"""




    _A     =							int(number**0.5				)
    return number == sq * sq





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)							-> tuple[int, int]:




    """simple docstring"""




    _A     =							x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
    _A     =							x_den * y_den * z_den
    _A     =							gcd(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
    top //= hcf
    bottom //= hcf
    return top, bottom





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE = 35				)							-> int:




    """simple docstring"""




    _A     =							set()
    _A     =							42
    _A     =							Fraction(0				)
    _A     =							42

    for x_num in range(1							,     order + 1				):
        for x_den in range(x_num + 1							,     order + 1				):
            for y_num in range(1							,     order + 1				):
                for y_den in range(y_num + 1							,     order + 1				):
                    # n=1
                    _A     =							x_num * y_den + x_den * y_num
                    _A     =							x_den * y_den
                    _A     =							gcd(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                    z_num //= hcf
                    z_den //= hcf
                    if 0 < z_num < z_den <= order:
                        _A     =							add_three(
                            _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                        unique_s.add(_SCREAMING_SNAKE_CASE				)

                    # n=2
                    _A     =							(
                        x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
                    )
                    _A     =							x_den * x_den * y_den * y_den
                    if is_sq(_SCREAMING_SNAKE_CASE				) and is_sq(_SCREAMING_SNAKE_CASE				):
                        _A     =							int(sqrt(_SCREAMING_SNAKE_CASE				)				)
                        _A     =							int(sqrt(_SCREAMING_SNAKE_CASE				)				)
                        _A     =							gcd(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                        z_num //= hcf
                        z_den //= hcf
                        if 0 < z_num < z_den <= order:
                            _A     =							add_three(
                                _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                            unique_s.add(_SCREAMING_SNAKE_CASE				)

                    # n=-1
                    _A     =							x_num * y_num
                    _A     =							x_den * y_num + x_num * y_den
                    _A     =							gcd(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                    z_num //= hcf
                    z_den //= hcf
                    if 0 < z_num < z_den <= order:
                        _A     =							add_three(
                            _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                        unique_s.add(_SCREAMING_SNAKE_CASE				)

                    # n=2
                    _A     =							x_num * x_num * y_num * y_num
                    _A     =							(
                        x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
                    )
                    if is_sq(_SCREAMING_SNAKE_CASE				) and is_sq(_SCREAMING_SNAKE_CASE				):
                        _A     =							int(sqrt(_SCREAMING_SNAKE_CASE				)				)
                        _A     =							int(sqrt(_SCREAMING_SNAKE_CASE				)				)
                        _A     =							gcd(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                        z_num //= hcf
                        z_den //= hcf
                        if 0 < z_num < z_den <= order:
                            _A     =							add_three(
                                _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)
                            unique_s.add(_SCREAMING_SNAKE_CASE				)

    for num, den in unique_s:
        total += Fraction(_SCREAMING_SNAKE_CASE							,     _SCREAMING_SNAKE_CASE				)

    return total.denominator + total.numerator


if __name__ == "__main__":
 print(f"{solution() = }")





