





'''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     :Dict       =				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       :    List[Any]	,			snake_case_       :    int	,			snake_case_       :    Dict=1_6	,			snake_case_       :    Dict=1_3	,			snake_case_       :    int=7	,			snake_case_       :    Any=1_4	,			snake_case_       :    int=1_0	,			snake_case_       :    Any=1_9	,			snake_case_       :    int=5	,			snake_case_       :    Any=4	,			snake_case_       :    Tuple=True	,			snake_case_       :    Optional[int]=1_6	,			snake_case_       :    List[str]=2	,			snake_case_       :    Any=4	,			snake_case_       :    List[Any]=4	,			snake_case_       :    Optional[Any]="gelu"	,			snake_case_       :    Optional[int]=0.1	,			snake_case_       :    Union[str, Any]=0.1	,			snake_case_       :    Tuple=[1, 2, 3, 4, 5]	,			snake_case_       :    str=2_5	,			snake_case_       :    Any=5	,			):
      _UpperCAmelCase     							=   d_model
      _UpperCAmelCase     							=   parent
      _UpperCAmelCase     							=   batch_size
      _UpperCAmelCase     							=   prediction_length
      _UpperCAmelCase     							=   context_length
      _UpperCAmelCase     							=   cardinality
      _UpperCAmelCase     							=   num_time_features
      _UpperCAmelCase     							=   lags_sequence
      _UpperCAmelCase     							=   embedding_dimension
      _UpperCAmelCase     							=   is_training
      _UpperCAmelCase     							=   hidden_size
      _UpperCAmelCase     							=   num_hidden_layers
      _UpperCAmelCase     							=   num_attention_heads
      _UpperCAmelCase     							=   intermediate_size
      _UpperCAmelCase     							=   hidden_act
      _UpperCAmelCase     							=   hidden_dropout_prob
      _UpperCAmelCase     							=   attention_probs_dropout_prob

      _UpperCAmelCase     							=   context_length
      _UpperCAmelCase     							=   prediction_length + label_length
      _UpperCAmelCase     							=   label_length

      _UpperCAmelCase     							=   moving_average
      _UpperCAmelCase     							=   autocorrelation_factor




 def      lowercase	(					self       :    Union[str, 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       :    int	,			snake_case_       :    Optional[Any]    ):
      _UpperCAmelCase     							=   config.context_length + max(config.lags_sequence    )

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

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

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




 def      lowercase	(					self       :    List[str]    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.prepare_config_and_inputs()
      return config, inputs_dict




 def      lowercase	(					self       :    Optional[Any]	,			snake_case_       :    int	,			snake_case_       :    Optional[int]    ):
      _UpperCAmelCase     							=   AutoformerModel(config=snake_case_    ).to(snake_case_    ).eval()
      _UpperCAmelCase     							=   model(**snake_case_    )

      _UpperCAmelCase     							=   outputs.encoder_last_hidden_state
      _UpperCAmelCase     							=   outputs.last_hidden_state

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

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

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

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

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

      with tempfile.TemporaryDirectory() as tmpdirname:
           _UpperCAmelCase     							=   model.get_decoder()
           decoder.save_pretrained(snake_case_    )
           _UpperCAmelCase     							=   AutoformerDecoder.from_pretrained(snake_case_    ).to(snake_case_    )

      _UpperCAmelCase     							=   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   A_	(  lowerCAmelCase_							,						lowerCAmelCase_							,						unittest.TestCase			):
 _lowerCamelCase  : List[Any]           =							(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
 _lowerCamelCase  : Tuple           =							(AutoformerForPrediction,) if is_torch_available() else ()
 _lowerCamelCase  : List[Any]           =							{"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
 _lowerCamelCase  : Optional[Any]           =							False
 _lowerCamelCase  : Tuple           =							False
 _lowerCamelCase  : int           =							False
 _lowerCamelCase  : Optional[Any]           =							False
 _lowerCamelCase  : Optional[Any]           =							False
 _lowerCamelCase  : List[Any]           =							False




 def      lowercase	(					self       :    Tuple    ):
      _UpperCAmelCase     							=   AutoformerModelTester(self    )
      _UpperCAmelCase     							=   ConfigTester(self	,			config_class=snake_case_	,			has_text_modality=snake_case_    )




 def      lowercase	(					self       :    Optional[Any]    ):
      self.config_tester.run_common_tests()




 def      lowercase	(					self       :    Union[str, Any]    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
           _UpperCAmelCase     							=   model_class(snake_case_    )

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




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   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      lowercase	(					self       :    Optional[int]    ):
      pass




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




 def      lowercase	(					self       :    List[str]    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs_for_common()

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

           _UpperCAmelCase     							=   [
               "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      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase							,  _UpperCAmelCase     							=   self.model_tester.prepare_config_and_inputs_for_common()
      _UpperCAmelCase     							=   True

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

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

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

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

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





def 	UpperCAmelCase_							(					__lowercase							:      str="train-batch.pt"       )		->       List[str]:


     '''simple docstring'''



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







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




 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"    ).to(snake_case_    )
      _UpperCAmelCase     							=   prepare_batch()

      with torch.no_grad():
           _UpperCAmelCase     							=   model(
               past_values=batch["past_values"]	,			past_time_features=batch["past_time_features"]	,			past_observed_mask=batch["past_observed_mask"]	,			static_categorical_features=batch["static_categorical_features"]	,			future_values=batch["future_values"]	,			future_time_features=batch["future_time_features"]	,			)[0]

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

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




 def      lowercase	(					self       :    Optional[Any]    ):
      _UpperCAmelCase     							=   AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"    ).to(snake_case_    )
      _UpperCAmelCase     							=   prepare_batch("val-batch.pt"    )
      with torch.no_grad():
           _UpperCAmelCase     							=   model(
               past_values=batch["past_values"]	,			past_time_features=batch["past_time_features"]	,			past_observed_mask=batch["past_observed_mask"]	,			static_categorical_features=batch["static_categorical_features"]	,			).encoder_last_hidden_state
      _UpperCAmelCase     							=   torch.Size((6_4, model.config.context_length, model.config.d_model)    )
      self.assertEqual(output.shape	,			snake_case_    )

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




 def      lowercase	(					self       :    Tuple    ):
      _UpperCAmelCase     							=   AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"    ).to(snake_case_    )
      _UpperCAmelCase     							=   prepare_batch("val-batch.pt"    )
      with torch.no_grad():
           _UpperCAmelCase     							=   model.generate(
               static_categorical_features=batch["static_categorical_features"]	,			past_time_features=batch["past_time_features"]	,			past_values=batch["past_values"]	,			future_time_features=batch["future_time_features"]	,			past_observed_mask=batch["past_observed_mask"]	,			)
      _UpperCAmelCase     							=   torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)    )
      self.assertEqual(outputs.sequences.shape	,			snake_case_    )

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







import unittest

import numpy as np
import torch

from diffusers import PNDMPipeline, PNDMScheduler, UNetaDModel
from diffusers.utils.testing_utils import enable_full_determinism, require_torch, slow, torch_device


enable_full_determinism()







class   __lowercase      (unittest.TestCase ):
 @property
 def 	UpperCamelCase__  (							self					)					->Tuple:



       '''simple docstring'''





       torch.manual_seed(0					)
       __lowerCAmelCase					:						List[Any]					=					UNetaDModel(
           block_out_channels=(32, 64)      ,							layers_per_block=2      ,							sample_size=32      ,							in_channels=3      ,							out_channels=3      ,							down_block_types=('''DownBlock2D''', '''AttnDownBlock2D''')      ,							up_block_types=('''AttnUpBlock2D''', '''UpBlock2D''')      ,							)
       return model





 def 	UpperCamelCase__  (							self					)					->int:



       '''simple docstring'''





       __lowerCAmelCase					:						List[str]					=					self.dummy_uncond_unet
       __lowerCAmelCase					:						Any					=					PNDMScheduler()

       __lowerCAmelCase					:						Dict					=					PNDMPipeline(unet=A_      ,							scheduler=A_					)
       pndm.to(A_					)
       pndm.set_progress_bar_config(disable=A_					)

       __lowerCAmelCase					:						Optional[Any]					=					torch.manual_seed(0					)
       __lowerCAmelCase					:						Any					=					pndm(generator=A_      ,							num_inference_steps=20      ,							output_type='''numpy'''					).images

       __lowerCAmelCase					:						Optional[Any]					=					torch.manual_seed(0					)
       __lowerCAmelCase					:						List[Any]					=					pndm(generator=A_      ,							num_inference_steps=20      ,							output_type='''numpy'''      ,							return_dict=A_					)[0]

       __lowerCAmelCase					:						Tuple					=					image[0, -3:, -3:, -1]
       __lowerCAmelCase					:						Optional[Any]					=					image_from_tuple[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       __lowerCAmelCase					:						int					=					np.array([1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2
       assert np.abs(image_from_tuple_slice.flatten() - expected_slice					).max() < 1e-2







@slow
@require_torch
class   __lowercase      (unittest.TestCase ):
 def 	UpperCamelCase__  (							self					)					->Optional[Any]:



       '''simple docstring'''





       __lowerCAmelCase					:						Optional[int]					=					'''google/ddpm-cifar10-32'''

       __lowerCAmelCase					:						Union[str, Any]					=					UNetaDModel.from_pretrained(A_					)
       __lowerCAmelCase					:						int					=					PNDMScheduler()

       __lowerCAmelCase					:						Any					=					PNDMPipeline(unet=A_      ,							scheduler=A_					)
       pndm.to(A_					)
       pndm.set_progress_bar_config(disable=A_					)
       __lowerCAmelCase					:						Tuple					=					torch.manual_seed(0					)
       __lowerCAmelCase					:						Any					=					pndm(generator=A_      ,							output_type='''numpy'''					).images

       __lowerCAmelCase					:						Optional[int]					=					image[0, -3:, -3:, -1]

       assert image.shape == (1, 32, 32, 3)
       __lowerCAmelCase					:						List[Any]					=					np.array([0.1_564, 0.14_645, 0.1_406, 0.14_715, 0.12_425, 0.14_045, 0.13_115, 0.12_175, 0.125]					)

       assert np.abs(image_slice.flatten() - expected_slice					).max() < 1e-2


