"""simple docstring"""




import pickle

import numpy as np
from matplotlib import pyplot as plt
class 						__A							:






     def __init__(		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__=0.2    ,					a__=0.2  ):
       _lowerCAmelCase						:	Union[str, Any]        =					bp_numa
       _lowerCAmelCase						:	Tuple        =					bp_numa
       _lowerCAmelCase						:	Union[str, Any]        =					bp_numa
       _lowerCAmelCase						:	List[str]        =					conva_get[:2]
       _lowerCAmelCase						:	List[Any]        =					conva_get[2]
       _lowerCAmelCase						:	Union[str, Any]        =					size_pa
       _lowerCAmelCase						:	List[Any]        =					rate_w
       _lowerCAmelCase						:	int        =					rate_t
       _lowerCAmelCase						:	List[str]        =					[
           np.mat(-1 * np.random.rand(self.conva[0]    ,					self.conva[0]  ) + 0.5  )
           for i in range(self.conva[1]  )
       ]
       _lowerCAmelCase						:	List[str]        =					np.mat(-1 * np.random.rand(self.num_bpa    ,					self.num_bpa  ) + 0.5  )
       _lowerCAmelCase						:	Optional[Any]        =					np.mat(-1 * np.random.rand(self.num_bpa    ,					self.num_bpa  ) + 0.5  )
       _lowerCAmelCase						:	int        =					-2 * np.random.rand(self.conva[1]  ) + 1
       _lowerCAmelCase						:	List[str]        =					-2 * np.random.rand(self.num_bpa  ) + 1
       _lowerCAmelCase						:	Any        =					-2 * np.random.rand(self.num_bpa  ) + 1






     def    __A  (		self    ,					a__  ):
       # save model dict with pickle
       _lowerCAmelCase						:	Tuple        =					{
           """num_bp1""": self.num_bpa,
           """num_bp2""": self.num_bpa,
           """num_bp3""": self.num_bpa,
           """conv1""": self.conva,
           """step_conv1""": self.step_conva,
           """size_pooling1""": self.size_poolinga,
           """rate_weight""": self.rate_weight,
           """rate_thre""": self.rate_thre,
           """w_conv1""": self.w_conva,
           """wkj""": self.wkj,
           """vji""": self.vji,
           """thre_conv1""": self.thre_conva,
           """thre_bp2""": self.thre_bpa,
           """thre_bp3""": self.thre_bpa,
       }
       with open(a__    ,					"""wb"""  ) as f:
         pickle.dump(a__    ,					a__  )

       print(F"Model saved： {save_path}"  )






     @classmethod
     def    __A  (		cls    ,					a__  ):
       # read saved model
       with open(a__    ,					"""rb"""  ) as f:
         _lowerCAmelCase						:	str        =					pickle.load(a__  )  # noqa: S301

       _lowerCAmelCase						:	Dict        =					model_dic.get("""conv1"""  )
       conv_get.append(model_dic.get("""step_conv1"""  )  )
       _lowerCAmelCase						:	Optional[int]        =					model_dic.get("""size_pooling1"""  )
       _lowerCAmelCase						:	List[Any]        =					model_dic.get("""num_bp1"""  )
       _lowerCAmelCase						:	List[Any]        =					model_dic.get("""num_bp2"""  )
       _lowerCAmelCase						:	Union[str, Any]        =					model_dic.get("""num_bp3"""  )
       _lowerCAmelCase						:	Optional[Any]        =					model_dic.get("""rate_weight"""  )
       _lowerCAmelCase						:	Any        =					model_dic.get("""rate_thre"""  )
       # create model instance
       _lowerCAmelCase						:	Any        =					CNN(a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  )
       # modify model parameter
       _lowerCAmelCase						:	Dict        =					model_dic.get("""w_conv1"""  )
       _lowerCAmelCase						:	Optional[Any]        =					model_dic.get("""wkj"""  )
       _lowerCAmelCase						:	List[Any]        =					model_dic.get("""vji"""  )
       _lowerCAmelCase						:	List[Any]        =					model_dic.get("""thre_conv1"""  )
       _lowerCAmelCase						:	Union[str, Any]        =					model_dic.get("""thre_bp2"""  )
       _lowerCAmelCase						:	Union[str, Any]        =					model_dic.get("""thre_bp3"""  )
       return conv_ins






     def    __A  (		self    ,					a__  ):
       return 1 / (1 + np.exp(-1 * x  ))






     def    __A  (		self    ,					a__  ):
       return round(a__    ,					3  )






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       # convolution process
       _lowerCAmelCase						:	Union[str, Any]        =					convs[0]
       _lowerCAmelCase						:	Optional[int]        =					convs[1]
       _lowerCAmelCase						:	Dict        =					np.shape(a__  )[0]
       # get the data slice of original image data, data_focus
       _lowerCAmelCase						:	Tuple        =					[]
       for i_focus in range(0    ,					size_data - size_conv + 1    ,					a__  ):
         for j_focus in range(0    ,					size_data - size_conv + 1    ,					a__  ):
           _lowerCAmelCase						:	List[Any]        =					data[
               i_focus : i_focus + size_conv, j_focus : j_focus + size_conv
           ]
           data_focus.append(a__  )
        # calculate the feature map of every single kernel, and saved as list of matrix
       _lowerCAmelCase						:	Union[str, Any]        =					[]
       _lowerCAmelCase						:	str        =					int((size_data - size_conv) / conv_step + 1  )
       for i_map in range(a__  ):
         _lowerCAmelCase						:	List[str]        =					[]
         for i_focus in range(len(a__  )  ):
           _lowerCAmelCase						:	Optional[Any]        =					(
               np.sum(np.multiply(data_focus[i_focus]    ,					w_convs[i_map]  )  )
               - thre_convs[i_map]
           )
           featuremap.append(self.sig(a__  )  )
         _lowerCAmelCase						:	Union[str, Any]        =					np.asmatrix(a__  ).reshape(
             a__    ,					a__  )
         data_featuremap.append(a__  )

       # expanding the data slice to One dimenssion
       _lowerCAmelCase						:	List[Any]        =					[]
       for each_focus in data_focus:
         focusa_list.extend(self.Expand_Mat(a__  )  )
       _lowerCAmelCase						:	Optional[int]        =					np.asarray(a__  )
       return focus_list, data_featuremap






     def    __A  (		self    ,					a__    ,					a__    ,					a__="average_pool"  ):
       # pooling process
       _lowerCAmelCase						:	str        =					len(featuremaps[0]  )
       _lowerCAmelCase						:	Optional[int]        =					int(size_map / size_pooling  )
       _lowerCAmelCase						:	List[str]        =					[]
       for i_map in range(len(a__  )  ):
         _lowerCAmelCase						:	Tuple        =					featuremaps[i_map]
         _lowerCAmelCase						:	Union[str, Any]        =					[]
         for i_focus in range(0    ,					a__    ,					a__  ):
           for j_focus in range(0    ,					a__    ,					a__  ):
             _lowerCAmelCase						:	Tuple        =					feature_map[
                 i_focus : i_focus + size_pooling,
                 j_focus : j_focus + size_pooling,
             ]
             if pooling_type == "average_pool":
               # average pooling
               map_pooled.append(np.average(a__  )  )
             elif pooling_type == "max_pooling":
               # max pooling
               map_pooled.append(np.max(a__  )  )
         _lowerCAmelCase						:	List[str]        =					np.asmatrix(a__  ).reshape(a__    ,					a__  )
         featuremap_pooled.append(a__  )
       return featuremap_pooled






     def    __A  (		self    ,					a__  ):
       # expanding three dimension data to one dimension list
       _lowerCAmelCase						:	List[Any]        =					[]
       for i in range(len(a__  )  ):
         _lowerCAmelCase						:	Tuple        =					np.shape(data[i]  )
         _lowerCAmelCase						:	Tuple        =					data[i].reshape(1    ,					shapes[0] * shapes[1]  )
         _lowerCAmelCase						:	List[Any]        =					data_listed.getA().tolist()[0]
         data_expanded.extend(a__  )
       _lowerCAmelCase						:	Tuple        =					np.asarray(a__  )
       return data_expanded






     def    __A  (		self    ,					a__  ):
       # expanding matrix to one dimension list
       _lowerCAmelCase						:	Tuple        =					np.asarray(a__  )
       _lowerCAmelCase						:	Tuple        =					np.shape(a__  )
       _lowerCAmelCase						:	Tuple        =					data_mat.reshape(1    ,					shapes[0] * shapes[1]  )
       return data_expanded






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__  ):
       _lowerCAmelCase						:	Optional[int]        =					[]
       _lowerCAmelCase						:	Union[str, Any]        =					0
       for i_map in range(a__  ):
         _lowerCAmelCase						:	Optional[int]        =					np.ones((size_map, size_map)  )
         for i in range(0    ,					a__    ,					a__  ):
           for j in range(0    ,					a__    ,					a__  ):
             _lowerCAmelCase						:	Tuple        =					pd_pool[
                 i_pool
             ]
             _lowerCAmelCase						:	Optional[int]        =					i_pool + 1
         _lowerCAmelCase						:	Dict        =					np.multiply(
             a__    ,					np.multiply(out_map[i_map]    ,					(1 - out_map[i_map])  )  )
         pd_all.append(a__  )
       return pd_all






     def    __A  (		self    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__    ,					a__=bool  ):
       # model traning
       print("""----------------------Start Training-------------------------"""  )
       print((""" - - Shape: Train_Data  """, np.shape(a__  ))  )
       print((""" - - Shape: Teach_Data  """, np.shape(a__  ))  )
       _lowerCAmelCase						:	List[str]        =					0
       _lowerCAmelCase						:	Any        =					[]
       _lowerCAmelCase						:	int        =					10000
       while rp < n_repeat and mse >= error_accuracy:
         _lowerCAmelCase						:	str        =					0
         print(F"-------------Learning Time {rp}--------------"  )
         for p in range(len(a__  )  ):
           # print('------------Learning Image: %d--------------'%p)
           _lowerCAmelCase						:	List[Any]        =					np.asmatrix(datas_train[p]  )
           _lowerCAmelCase						:	Union[str, Any]        =					np.asarray(datas_teach[p]  )
           _lowerCAmelCase						:	Optional[Any]        =					self.convolute(
               a__    ,					self.conva    ,					self.w_conva    ,					self.thre_conva    ,					conv_step=self.step_conva    ,					)
           _lowerCAmelCase						:	Dict        =					self.pooling(a__    ,					self.size_poolinga  )
           _lowerCAmelCase						:	Any        =					np.shape(a__  )
           _lowerCAmelCase						:	Optional[int]        =					self._expand(a__  )
           _lowerCAmelCase						:	Any        =					data_bp_input

           _lowerCAmelCase						:	Any        =					np.dot(a__    ,					self.vji.T  ) - self.thre_bpa
           _lowerCAmelCase						:	int        =					self.sig(a__  )
           _lowerCAmelCase						:	Union[str, Any]        =					np.dot(a__    ,					self.wkj.T  ) - self.thre_bpa
           _lowerCAmelCase						:	List[str]        =					self.sig(a__  )

           # --------------Model Leaning ------------------------
           # calculate error and gradient---------------
           _lowerCAmelCase						:	Dict        =					np.multiply(
               (data_teach - bp_outa)    ,					np.multiply(a__    ,					(1 - bp_outa)  )  )
           _lowerCAmelCase						:	Tuple        =					np.multiply(
               np.dot(a__    ,					self.wkj  )    ,					np.multiply(a__    ,					(1 - bp_outa)  )  )
           _lowerCAmelCase						:	Optional[int]        =					np.dot(a__    ,					self.vji  )

           _lowerCAmelCase						:	int        =					pd_i_all / (self.size_poolinga * self.size_poolinga)
           _lowerCAmelCase						:	List[Any]        =					pd_conva_pooled.T.getA().tolist()
           _lowerCAmelCase						:	Any        =					self._calculate_gradient_from_pool(
               a__    ,					a__    ,					shape_featuremapa[0]    ,					shape_featuremapa[1]    ,					self.size_poolinga    ,					)
           # weight and threshold learning process---------
           # convolution layer
           for k_conv in range(self.conva[1]  ):
             _lowerCAmelCase						:	Tuple        =					self._expand_mat(pd_conva_all[k_conv]  )
             _lowerCAmelCase						:	Optional[Any]        =					self.rate_weight * np.dot(a__    ,					a__  )

             _lowerCAmelCase						:	Tuple        =					self.w_conva[k_conv] + delta_w.reshape(
                 (self.conva[0], self.conva[0])  )

             _lowerCAmelCase						:	Optional[Any]        =					(
                 self.thre_conva[k_conv]
                 - np.sum(pd_conva_all[k_conv]  ) * self.rate_thre
             )
           # all connected layer
           _lowerCAmelCase						:	List[str]        =					self.wkj + pd_k_all.T * bp_outa * self.rate_weight
           _lowerCAmelCase						:	int        =					self.vji + pd_j_all.T * bp_outa * self.rate_weight
           _lowerCAmelCase						:	Any        =					self.thre_bpa - pd_k_all * self.rate_thre
           _lowerCAmelCase						:	Tuple        =					self.thre_bpa - pd_j_all * self.rate_thre
           # calculate the sum error of all single image
           _lowerCAmelCase						:	int        =					np.sum(abs(data_teach - bp_outa  )  )
           error_count += errors
           # print('   ----Teach      ',data_teach)
           # print('   ----BP_output  ',bp_out3)
         _lowerCAmelCase						:	str        =					rp + 1
         _lowerCAmelCase						:	Optional[Any]        =					error_count / patterns
         all_mse.append(a__  )

       def draw_error():
         _lowerCAmelCase						:	str        =					[error_accuracy for i in range(int(n_repeat * 1.2  )  )]
         plt.plot(a__    ,					"""+-"""  )
         plt.plot(a__    ,					"""r--"""  )
         plt.xlabel("""Learning Times"""  )
         plt.ylabel("""All_mse"""  )
         plt.grid(a__    ,					alpha=0.5  )
         plt.show()

       print("""------------------Training Complished---------------------"""  )
       print((""" - - Training epoch: """, rp, F"     - - Mse: {mse:.6f}")  )
       if draw_e:
         draw_error()
       return mse






     def    __A  (		self    ,					a__  ):
       # model predict
       _lowerCAmelCase						:	List[Any]        =					[]
       print("""-------------------Start Testing-------------------------"""  )
       print((""" - - Shape: Test_Data  """, np.shape(a__  ))  )
       for p in range(len(a__  )  ):
         _lowerCAmelCase						:	Optional[int]        =					np.asmatrix(datas_test[p]  )
         _lowerCAmelCase						:	Optional[Any]        =					self.convolute(
             a__    ,					self.conva    ,					self.w_conva    ,					self.thre_conva    ,					conv_step=self.step_conva    ,					)
         _lowerCAmelCase						:	Dict        =					self.pooling(a__    ,					self.size_poolinga  )
         _lowerCAmelCase						:	str        =					self._expand(a__  )

         _lowerCAmelCase						:	Optional[int]        =					data_bp_input
         _lowerCAmelCase						:	Optional[int]        =					bp_outa * self.vji.T - self.thre_bpa
         _lowerCAmelCase						:	Tuple        =					self.sig(a__  )
         _lowerCAmelCase						:	Any        =					bp_outa * self.wkj.T - self.thre_bpa
         _lowerCAmelCase						:	Dict        =					self.sig(a__  )
         produce_out.extend(bp_outa.getA().tolist()  )
       _lowerCAmelCase						:	int        =					[list(map(self.do_round    ,					a__  )  ) for each in produce_out]
       return np.asarray(a__  )






     def    __A  (		self    ,					a__  ):
       # return the data of image after convoluting process so we can check it out
       _lowerCAmelCase						:	List[Any]        =					np.asmatrix(a__  )
       _lowerCAmelCase						:	str        =					self.convolute(
           a__    ,					self.conva    ,					self.w_conva    ,					self.thre_conva    ,					conv_step=self.step_conva    ,					)
       _lowerCAmelCase						:	Tuple        =					self.pooling(a__    ,					self.size_poolinga  )

       return data_conveda, data_pooleda


if __name__ == "__main__":
     pass





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




