




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


lowerCAmelCase							:    str  							=							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 					__magic_name__							:






				'''simple docstring'''





				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	,				):





							"""simple docstring"""
							lowerCamelCase       =      d_model
							lowerCamelCase       =      parent
							lowerCamelCase       =      batch_size
							lowerCamelCase       =      prediction_length
							lowerCamelCase       =      context_length
							lowerCamelCase       =      cardinality
							lowerCamelCase       =      num_time_features
							lowerCamelCase       =      lags_sequence
							lowerCamelCase       =      embedding_dimension
							lowerCamelCase       =      is_training
							lowerCamelCase       =      hidden_size
							lowerCamelCase       =      num_hidden_layers
							lowerCamelCase       =      num_attention_heads
							lowerCamelCase       =      intermediate_size
							lowerCamelCase       =      hidden_act
							lowerCamelCase       =      hidden_dropout_prob
							lowerCamelCase       =      attention_probs_dropout_prob

							lowerCamelCase       =      context_length
							lowerCamelCase       =      prediction_length + label_length
							lowerCamelCase       =      label_length

							lowerCamelCase       =      moving_average
							lowerCamelCase       =      autocorrelation_factor





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							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      _lowerCAmelCase       ( self	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      config.context_length + max(config.lags_sequence				)

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

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

							lowerCamelCase       =      {
							    """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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_config()
							lowerCamelCase       =      self.prepare_autoformer_inputs_dict(_a				)
							return config, inputs_dict





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase   ,     lowerCamelCase       =      self.prepare_config_and_inputs()
							return config, inputs_dict





				def      _lowerCAmelCase       ( self	,				_a	,				_a				):





							"""simple docstring"""
							lowerCamelCase       =      AutoformerModel(config=_a				).to(_a				).eval()
							lowerCamelCase       =      model(**_a				)

							lowerCamelCase       =      outputs.encoder_last_hidden_state
							lowerCamelCase       =      outputs.last_hidden_state

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

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

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

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

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

							lowerCamelCase       =      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 					__magic_name__							( __SCREAMING_SNAKE_CASE		,      __SCREAMING_SNAKE_CASE		,      unittest.TestCase       ):






				'''simple docstring'''
				__UpperCamelCase    						=		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
				__UpperCamelCase    						=		(AutoformerForPrediction,) if is_torch_available() else ()
				__UpperCamelCase    						=		{'feature-extraction': AutoformerModel} if is_torch_available() else {}
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False
				__UpperCamelCase    						=		False





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      AutoformerModelTester(self				)
							lowerCamelCase       =      ConfigTester(self	,				config_class=_a	,				has_text_modality=_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							self.config_tester.run_common_tests()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase   ,     lowerCamelCase       =      self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
										lowerCamelCase       =      model_class(_a				)

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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							pass





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      inspect.signature(getattr(_a	,				"""forward"""				)				)
							# The main input is the name of the argument after `self`
							lowerCamelCase       =      list(model_signature.parameters.keys()				)[1]
							self.assertEqual(AutoformerModel.main_input_name	,				_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase   ,     lowerCamelCase       =      self.model_tester.prepare_config_and_inputs_for_common()

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

										lowerCamelCase       =      [
										    """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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase   ,     lowerCamelCase       =      self.model_tester.prepare_config_and_inputs_for_common()
							lowerCamelCase       =      True

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

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

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

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

							lowerCamelCase       =      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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							super().test_retain_grad_hidden_states_attentions()




def 					a__				(       snake_case__="train-batch.pt"       )		->      List[str]:
			lowerCamelCase       =      hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch""" ,				filename=lowerCAmelCase__ ,				repo_type="""dataset"""       )
			lowerCamelCase       =      torch.load(lowerCAmelCase__ ,				map_location=lowerCAmelCase__       )
			return batch






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






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""				).to(_a				)
							lowerCamelCase       =      prepare_batch()

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

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





				def      _lowerCAmelCase       ( self				):





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

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





				def      _lowerCAmelCase       ( self				):





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

							lowerCamelCase       =      torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786]	,				device=_a				)
							lowerCamelCase       =      outputs.sequences.mean(dim=1				)
							self.assertTrue(torch.allclose(mean_prediction[0, -3:]	,				_a	,				rtol=1e-1				)				)









"""simple docstring"""




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


lowerCAmelCase							:    Dict  							=							logging.get_logger(__name__)

lowerCAmelCase							:    Optional[Any]  							=							{
    """MIT/ast-finetuned-audioset-10-10-0.4593""": (
        """https://huggingface.co/MIT/ast-finetuned-audioset-10-10-0.4593/resolve/main/config.json"""
    ),
}






class 					__magic_name__							( UpperCAmelCase__       ):






				'''simple docstring'''
				__UpperCamelCase    						=		"audio-spectrogram-transformer"





				def __init__( self	,				_a=768	,				_a=12	,				_a=12	,				_a=3_072	,				_a="gelu"	,				_a=0.0	,				_a=0.0	,				_a=0.02	,				_a=1e-1_2	,				_a=16	,				_a=True	,				_a=10	,				_a=10	,				_a=1_024	,				_a=128	,				**_a	,				):





							"""simple docstring"""
							super().__init__(**_a				)

							lowerCamelCase       =      hidden_size
							lowerCamelCase       =      num_hidden_layers
							lowerCamelCase       =      num_attention_heads
							lowerCamelCase       =      intermediate_size
							lowerCamelCase       =      hidden_act
							lowerCamelCase       =      hidden_dropout_prob
							lowerCamelCase       =      attention_probs_dropout_prob
							lowerCamelCase       =      initializer_range
							lowerCamelCase       =      layer_norm_eps
							lowerCamelCase       =      patch_size
							lowerCamelCase       =      qkv_bias
							lowerCamelCase       =      frequency_stride
							lowerCamelCase       =      time_stride
							lowerCamelCase       =      max_length
							lowerCamelCase       =      num_mel_bins



