

"""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							=							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  _lowerCAmelCase  :







 """simple docstring"""







 def __init__(      self							:      int, UpperCAmelCase__							:      Tuple, UpperCAmelCase__							:      Tuple=1_6, UpperCAmelCase__							:      Optional[Any]=1_3, UpperCAmelCase__							:      List[Any]=7, UpperCAmelCase__							:      List[Any]=1_4, UpperCAmelCase__							:      Dict=1_0, UpperCAmelCase__							:      Dict=1_9, UpperCAmelCase__							:      List[Any]=5, UpperCAmelCase__							:      Optional[int]=4, UpperCAmelCase__							:      Union[str, Any]=True, UpperCAmelCase__							:      int=1_6, UpperCAmelCase__							:      Dict=2, UpperCAmelCase__							:      Union[str, Any]=4, UpperCAmelCase__							:      List[Any]=4, UpperCAmelCase__							:      int="gelu", UpperCAmelCase__							:      Tuple=0.1, UpperCAmelCase__							:      int=0.1, UpperCAmelCase__							:      Union[str, Any]=[1, 2, 3, 4, 5], UpperCAmelCase__							:      Optional[int]=2_5, UpperCAmelCase__							:      Tuple=5, ):
    __lowercase								=						d_model
    __lowercase								=						parent
    __lowercase								=						batch_size
    __lowercase								=						prediction_length
    __lowercase								=						context_length
    __lowercase								=						cardinality
    __lowercase								=						num_time_features
    __lowercase								=						lags_sequence
    __lowercase								=						embedding_dimension
    __lowercase								=						is_training
    __lowercase								=						hidden_size
    __lowercase								=						num_hidden_layers
    __lowercase								=						num_attention_heads
    __lowercase								=						intermediate_size
    __lowercase								=						hidden_act
    __lowercase								=						hidden_dropout_prob
    __lowercase								=						attention_probs_dropout_prob

    __lowercase								=						context_length
    __lowercase								=						prediction_length + label_length
    __lowercase								=						label_length

    __lowercase								=						moving_average
    __lowercase								=						autocorrelation_factor


 def  _lowercase			(      self							:      List[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  _lowercase			(      self							:      str, UpperCAmelCase__							:      int     ):
    __lowercase								=						config.context_length + max(config.lags_sequence     )

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

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

    __lowercase								=						{
        "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  _lowercase			(      self							:      List[Any]     ):
    __lowercase								=						self.get_config()
    __lowercase								=						self.prepare_autoformer_inputs_dict(UpperCAmelCase__     )
    return config, inputs_dict


 def  _lowercase			(      self							:      Tuple     ):
    __lowercase		,__lowercase								=						self.prepare_config_and_inputs()
    return config, inputs_dict



 def  _lowercase			(      self							:      List[str], UpperCAmelCase__							:      int, UpperCAmelCase__							:      Union[str, Any]     ):
    __lowercase								=						AutoformerModel(config=UpperCAmelCase__     ).to(UpperCAmelCase__     ).eval()
    __lowercase								=						model(**UpperCAmelCase__     )

    __lowercase								=						outputs.encoder_last_hidden_state
    __lowercase								=						outputs.last_hidden_state

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

    __lowercase		,__lowercase		,__lowercase		,__lowercase		,__lowercase								=						model.create_network_inputs(**UpperCAmelCase__     )
    __lowercase		,__lowercase								=						model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]     )

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

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

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

    __lowercase								=						decoder(
        trend=UpperCAmelCase__, inputs_embeds=UpperCAmelCase__, encoder_hidden_states=UpperCAmelCase__, )[0]

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







@require_torch
class  _lowerCAmelCase  (     lowercase					,lowercase					,unittest.TestCase       ):







 """simple docstring"""







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


 def  _lowercase			(      self							:      Any     ):
    __lowercase								=						AutoformerModelTester(self     )
    __lowercase								=						ConfigTester(self, config_class=UpperCAmelCase__, has_text_modality=UpperCAmelCase__     )


 def  _lowercase			(      self							:      List[Any]     ):
    self.config_tester.run_common_tests()


 def  _lowercase			(      self							:      List[Any]     ):
    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs()
    for model_class in self.all_model_classes:
       __lowercase								=						model_class(UpperCAmelCase__     )

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


 def  _lowercase			(      self							:      str     ):
    __lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()
    self.model_tester.check_encoder_decoder_model_standalone(*UpperCAmelCase__     )


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


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


 def  _lowercase			(      self							:      Tuple     ):
    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()

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

       __lowercase								=						[
           "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(UpperCAmelCase__     )], UpperCAmelCase__     )


 def  _lowercase			(      self							:      Any     ):
    __lowercase		,__lowercase								=						self.model_tester.prepare_config_and_inputs_for_common()
    __lowercase								=						True

    __lowercase								=						getattr(self.model_tester, "seq_length", UpperCAmelCase__     )
    __lowercase								=						getattr(self.model_tester, "decoder_seq_length", UpperCAmelCase__     )
    __lowercase								=						getattr(self.model_tester, "encoder_seq_length", UpperCAmelCase__     )
    __lowercase								=						getattr(self.model_tester, "d_model", UpperCAmelCase__     )
    __lowercase								=						getattr(self.model_tester, "num_attention_heads", UpperCAmelCase__     )
    __lowercase								=						d_model // num_attention_heads

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

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

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

       __lowercase								=						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(UpperCAmelCase__, UpperCAmelCase__     )

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

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

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

    self.assertEqual(len(UpperCAmelCase__     ), 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  _lowercase			(      self							:      Optional[int]     ):
    super().test_retain_grad_hidden_states_attentions()







def   _A  (  UpperCamelCase_					:	Dict="train-batch.pt")     ->						List[str]:
   '''simple docstring'''


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




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







 """simple docstring"""







 def  _lowercase			(      self							:      Union[str, Any]     ):
    __lowercase								=						AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"     ).to(UpperCAmelCase__     )
    __lowercase								=						prepare_batch()

    with torch.no_grad():
       __lowercase								=						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]

    __lowercase								=						torch.Size(
        (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)     )
    self.assertEqual(output.shape, UpperCAmelCase__     )

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


 def  _lowercase			(      self							:      str     ):
    __lowercase								=						AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"     ).to(UpperCAmelCase__     )
    __lowercase								=						prepare_batch("val-batch.pt"     )
    with torch.no_grad():
       __lowercase								=						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
    __lowercase								=						torch.Size((6_4, model.config.context_length, model.config.d_model)     )
    self.assertEqual(output.shape, UpperCAmelCase__     )

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



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

    __lowercase								=						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=UpperCAmelCase__     )
    __lowercase								=						outputs.sequences.mean(dim=1     )
    self.assertTrue(torch.allclose(mean_prediction[0, -3:], UpperCAmelCase__, rtol=1E-1     )     )








"""simple docstring"""





from ...configuration_utils import PretrainedConfig
from ...utils import logging


_a							=							logging.get_logger(__name__)

_a							=							{
    'caidas/swin2sr-classicalsr-x2-64': (
        'https://huggingface.co/caidas/swin2sr-classicalsr-x2-64/resolve/main/config.json'
    ),
}




class  _lowerCAmelCase  (     lowercase       ):







 """simple docstring"""







 __UpperCAmelCase     : List[Any]       		=     "swin2sr"

 __UpperCAmelCase     : List[Any]       		=     {
     "hidden_size": "embed_dim",
     "num_attention_heads": "num_heads",
     "num_hidden_layers": "num_layers",
 }


 def __init__(      self							:      Any, UpperCAmelCase__							:      Dict=6_4, UpperCAmelCase__							:      List[Any]=1, UpperCAmelCase__							:      Dict=3, UpperCAmelCase__							:      Optional[Any]=1_8_0, UpperCAmelCase__							:      Any=[6, 6, 6, 6, 6, 6], UpperCAmelCase__							:      Dict=[6, 6, 6, 6, 6, 6], UpperCAmelCase__							:      Tuple=8, UpperCAmelCase__							:      Optional[int]=2.0, UpperCAmelCase__							:      List[str]=True, UpperCAmelCase__							:      Tuple=0.0, UpperCAmelCase__							:      Optional[Any]=0.0, UpperCAmelCase__							:      List[str]=0.1, UpperCAmelCase__							:      Dict="gelu", UpperCAmelCase__							:      Dict=False, UpperCAmelCase__							:      Dict=0.02, UpperCAmelCase__							:      Tuple=1E-5, UpperCAmelCase__							:      str=2, UpperCAmelCase__							:      str=1.0, UpperCAmelCase__							:      Optional[int]="1conv", UpperCAmelCase__							:      Dict="pixelshuffle", **UpperCAmelCase__							:      List[Any], ):
    super().__init__(**UpperCAmelCase__     )

    __lowercase								=						image_size
    __lowercase								=						patch_size
    __lowercase								=						num_channels
    __lowercase								=						embed_dim
    __lowercase								=						depths
    __lowercase								=						len(UpperCAmelCase__     )
    __lowercase								=						num_heads
    __lowercase								=						window_size
    __lowercase								=						mlp_ratio
    __lowercase								=						qkv_bias
    __lowercase								=						hidden_dropout_prob
    __lowercase								=						attention_probs_dropout_prob
    __lowercase								=						drop_path_rate
    __lowercase								=						hidden_act
    __lowercase								=						use_absolute_embeddings
    __lowercase								=						layer_norm_eps
    __lowercase								=						initializer_range
    __lowercase								=						upscale
    __lowercase								=						img_range
    __lowercase								=						resi_connection
    __lowercase								=						upsampler




