"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_a				:		List[Any]	   =       {
    'configuration_vision_encoder_decoder': ['VisionEncoderDecoderConfig', 'VisionEncoderDecoderOnnxConfig']
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _a				:		List[str]	   =       ['VisionEncoderDecoderModel']

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _a				:		str	   =       ['TFVisionEncoderDecoderModel']

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _a				:		Optional[Any]	   =       ['FlaxVisionEncoderDecoderModel']

if TYPE_CHECKING:
     from .configuration_vision_encoder_decoder import VisionEncoderDecoderConfig, VisionEncoderDecoderOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_vision_encoder_decoder import VisionEncoderDecoderModel

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_vision_encoder_decoder import TFVisionEncoderDecoderModel

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_vision_encoder_decoder import FlaxVisionEncoderDecoderModel

else:
     import sys

     _a				:		Union[str, Any]	   =       _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





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


_a				:		Union[str, 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 						__A							:






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

       _lowerCAmelCase						:	Tuple        =					context_length
       _lowerCAmelCase						:	Optional[int]        =					prediction_length + label_length
       _lowerCAmelCase						:	Dict        =					label_length

       _lowerCAmelCase						:	Dict        =					moving_average
       _lowerCAmelCase						:	Union[str, Any]        =					autocorrelation_factor






     def    __A  (		self  ):
       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    ,					a__  ):
       _lowerCAmelCase						:	Dict        =					config.context_length + max(config.lags_sequence  )

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

       # decoder inputs
       _lowerCAmelCase						:	Any        =					floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]  )
       _lowerCAmelCase						:	Dict        =					floats_tensor([self.batch_size, config.prediction_length]  )

       _lowerCAmelCase						:	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  ):
       _lowerCAmelCase						:	Any        =					self.get_config()
       _lowerCAmelCase						:	str        =					self.prepare_autoformer_inputs_dict(a__  )
       return config, inputs_dict






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	Union[str, Any]        =					self.prepare_config_and_inputs()
       return config, inputs_dict






     def    __A  (		self    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[int]        =					AutoformerModel(config=a__  ).to(a__  ).eval()
       _lowerCAmelCase						:	int        =					model(**a__  )

       _lowerCAmelCase						:	List[str]        =					outputs.encoder_last_hidden_state
       _lowerCAmelCase						:	Any        =					outputs.last_hidden_state

       with tempfile.TemporaryDirectory() as tmpdirname:
         _lowerCAmelCase						:	Optional[int]        =					model.get_encoder()
         encoder.save_pretrained(a__  )
         _lowerCAmelCase						:	Optional[int]        =					AutoformerEncoder.from_pretrained(a__  ).to(a__  )

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

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

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

       _lowerCAmelCase						:	Optional[int]        =					torch.cat(
           (
               torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)    ,					dim=1  ),
               feature[:, config.context_length - config.label_length :, ...],
           )    ,					dim=-1    ,					)
       _lowerCAmelCase						:	Optional[int]        =					torch.cat(
           (
               torch.cat((trend_input[:, -config.label_length :, ...], mean)    ,					dim=1  ),
               feature[:, config.context_length - config.label_length :, ...],
           )    ,					dim=-1    ,					)

       with tempfile.TemporaryDirectory() as tmpdirname:
         _lowerCAmelCase						:	Optional[int]        =					model.get_decoder()
         decoder.save_pretrained(a__  )
         _lowerCAmelCase						:	Any        =					AutoformerDecoder.from_pretrained(a__  ).to(a__  )

       _lowerCAmelCase						:	List[Any]        =					decoder(
           trend=a__    ,					inputs_embeds=a__    ,					encoder_hidden_states=a__    ,					)[0]

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







@require_torch
class 						__A							(			SCREAMING_SNAKE_CASE_   ,     SCREAMING_SNAKE_CASE_   ,     unittest.TestCase		):
     _UpperCamelCase							:      Dict		 =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
     _UpperCamelCase							:      Optional[Any]		 =		(AutoformerForPrediction,) if is_torch_available() else ()
     _UpperCamelCase							:      int		 =		{"feature-extraction": AutoformerModel} if is_torch_available() else {}
     _UpperCamelCase							:      Optional[Any]		 =		False
     _UpperCamelCase							:      Optional[int]		 =		False
     _UpperCamelCase							:      Optional[int]		 =		False
     _UpperCamelCase							:      List[Any]		 =		False
     _UpperCamelCase							:      List[Any]		 =		False
     _UpperCamelCase							:      str		 =		False






     def    __A  (		self  ):
       _lowerCAmelCase						:	Tuple        =					AutoformerModelTester(self  )
       _lowerCAmelCase						:	Union[str, Any]        =					ConfigTester(self    ,					config_class=a__    ,					has_text_modality=a__  )






     def    __A  (		self  ):
       self.config_tester.run_common_tests()






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	List[str]        =					self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
         _lowerCAmelCase						:	int        =					model_class(a__  )

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






     def    __A  (		self  ):
       _lowerCAmelCase						:	Optional[Any]        =					self.model_tester.prepare_config_and_inputs_for_common()
       self.model_tester.check_encoder_decoder_model_standalone(*a__  )






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






     def    __A  (		self  ):
       _lowerCAmelCase						:	Dict        =					inspect.signature(getattr(a__    ,					"""forward"""  )  )
       # The main input is the name of the argument after `self`
       _lowerCAmelCase						:	Dict        =					list(model_signature.parameters.keys()  )[1]
       self.assertEqual(AutoformerModel.main_input_name    ,					a__  )






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	int        =					self.model_tester.prepare_config_and_inputs_for_common()

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

         _lowerCAmelCase						:	List[str]        =					[
             """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(a__  )]    ,					a__  )






     def    __A  (		self  ):
       _lowerCAmelCase      ,     _lowerCAmelCase						:	Union[str, Any]        =					self.model_tester.prepare_config_and_inputs_for_common()
       _lowerCAmelCase						:	Optional[int]        =					True

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

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

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

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

         _lowerCAmelCase						:	List[str]        =					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(a__    ,					a__  )

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

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

       _lowerCAmelCase						:	Dict        =					outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

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







def 							SCREAMING_SNAKE_CASE					(      _lowerCamelCase						:	Any="train-batch.pt"     )	->				Optional[int]:
  _lowerCAmelCase						:	List[Any]        =					hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""      ,filename=_lowerCamelCase      ,repo_type="""dataset"""     )
  _lowerCAmelCase						:	Dict        =					torch.load(_lowerCamelCase      ,map_location=_lowerCamelCase     )
  return batch






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






     def    __A  (		self  ):
       _lowerCAmelCase						:	str        =					AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""  ).to(a__  )
       _lowerCAmelCase						:	List[Any]        =					prepare_batch()

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

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

       _lowerCAmelCase						:	Optional[int]        =					torch.tensor(
           [[0.3_5_9_3, -1.3_3_9_8, 0.6_3_3_0], [0.2_2_7_9, 1.5_3_9_6, -0.1_7_9_2], [0.0_4_5_0, 1.3_2_2_5, -0.2_3_3_5]]    ,					device=a__  )
       self.assertTrue(torch.allclose(output[0, :3, :3]    ,					a__    ,					atol=a__  )  )






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

       _lowerCAmelCase						:	Any        =					torch.tensor(
           [[-0.0_7_3_4, -0.9_0_3_6, 0.8_3_5_8], [4.7_1_8_6, 2.4_1_1_3, 1.9_5_8_1], [1.7_9_5_3, 2.3_5_5_8, 1.2_9_7_0]]    ,					device=a__  )
       self.assertTrue(torch.allclose(output[0, :3, :3]    ,					a__    ,					atol=a__  )  )






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

       _lowerCAmelCase						:	Optional[Any]        =					torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6]    ,					device=a__  )
       _lowerCAmelCase						:	Optional[int]        =					outputs.sequences.mean(dim=1  )
       self.assertTrue(torch.allclose(mean_prediction[0, -3:]    ,					a__    ,					rtol=1e-1  )  )




