



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


lowercase_								=     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 				_snake_case			:




				def __init__(						self					:						Union[str, Any],					__lowercase					:						str,					__lowercase					:						List[Any]=16,					__lowercase					:						Optional[Any]=13,					__lowercase					:						Optional[Any]=7,					__lowercase					:						Union[str, Any]=14,					__lowercase					:						Any=10,					__lowercase					:						Optional[Any]=19,					__lowercase					:						Optional[int]=5,					__lowercase					:						Any=4,					__lowercase					:						List[str]=True,					__lowercase					:						int=16,					__lowercase					:						Optional[Any]=2,					__lowercase					:						List[Any]=4,					__lowercase					:						Optional[Any]=4,					__lowercase					:						Union[str, Any]="gelu",					__lowercase					:						Union[str, Any]=0.1,					__lowercase					:						List[str]=0.1,					__lowercase					:						Union[str, Any]=[1, 2, 3, 4, 5],					__lowercase					:						List[Any]=25,					__lowercase					:						Optional[Any]=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 							A__      (						self					:						List[str]						):
							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					:						int,					__lowercase					:						Union[str, Any]						):
							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 							A__      (						self					:						Union[str, Any]						):
							lowercase__					  =				self.get_config()
							lowercase__					  =				self.prepare_autoformer_inputs_dict(__lowercase						)
							return config, inputs_dict




				def 							A__      (						self					:						int						):
							lowercase__  ,       lowercase__					  =				self.prepare_config_and_inputs()
							return config, inputs_dict




				def 							A__      (						self					:						int,					__lowercase					:						List[str],					__lowercase					:						List[str]						):
							lowercase__					  =				AutoformerModel(config=__lowercase						).to(__lowercase						).eval()
							lowercase__					  =				model(**__lowercase						)

							lowercase__					  =				outputs.encoder_last_hidden_state
							lowercase__					  =				outputs.last_hidden_state

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

							lowercase__  ,       lowercase__  ,       lowercase__  ,       lowercase__  ,       lowercase__					  =				model.create_network_inputs(**__lowercase						)
							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=__lowercase						)[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(__lowercase						)
										lowercase__					  =				AutoformerDecoder.from_pretrained(__lowercase						).to(__lowercase						)

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

							self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1e-3						)
@require_torch
class 				_snake_case			(					lowercase__    ,	lowercase__    ,	unittest.TestCase):
				UpperCamelCase__				:					Any     		=(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
				UpperCamelCase__				:					Optional[int]     		=(AutoformerForPrediction,) if is_torch_available() else ()
				UpperCamelCase__				:					Any     		={"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
				UpperCamelCase__				:					Union[str, Any]     		=False
				UpperCamelCase__				:					Union[str, Any]     		=False
				UpperCamelCase__				:					Optional[Any]     		=False
				UpperCamelCase__				:					Any     		=False
				UpperCamelCase__				:					Optional[Any]     		=False
				UpperCamelCase__				:					Optional[Any]     		=False




				def 							A__      (						self					:						int						):
							lowercase__					  =				AutoformerModelTester(self						)
							lowercase__					  =				ConfigTester(self,					config_class=__lowercase,					has_text_modality=__lowercase						)




				def 							A__      (						self					:						Any						):
							self.config_tester.run_common_tests()




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__  ,       lowercase__					  =				self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
										lowercase__					  =				model_class(__lowercase						)

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




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.check_encoder_decoder_model_standalone(*__lowercase						)




				@unittest.skip(reason="Model has no tokens embeddings"						)
				def 							A__      (						self					:						List[str]						):
							pass




				def 							A__      (						self					:						Optional[Any]						):
							lowercase__					  =				inspect.signature(getattr(__lowercase,					"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,					__lowercase						)




				def 							A__      (						self					:						int						):
							lowercase__  ,       lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowercase__					  =				model_class(__lowercase						)
										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(__lowercase						)],					__lowercase						)




				def 							A__      (						self					:						List[Any]						):
							lowercase__  ,       lowercase__					  =				self.model_tester.prepare_config_and_inputs_for_common()
							lowercase__					  =				True

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

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

										# check that output_attentions also work using config
										del inputs_dict["output_attentions"]
										lowercase__					  =				True
										lowercase__					  =				model_class(__lowercase						)
										model.to(__lowercase						)
										model.eval()
										with torch.no_grad():
													lowercase__					  =				model(**self._prepare_for_class(__lowercase,					__lowercase						)						)
										lowercase__					  =				outputs.encoder_attentions
										self.assertEqual(len(__lowercase						),					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(__lowercase						)

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

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

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

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

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



def __lowerCAmelCase (     SCREAMING_SNAKE_CASE_="train-batch.pt"  ):
			lowercase__					  =				hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"						,  filename=SCREAMING_SNAKE_CASE_						,  repo_type="dataset"  )
			lowercase__					  =				torch.load(SCREAMING_SNAKE_CASE_						,  map_location=SCREAMING_SNAKE_CASE_  )
			return batch




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




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"						).to(__lowercase						)
							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(
							    (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)						)
							self.assertEqual(output.shape,					__lowercase						)

							lowercase__					  =				torch.tensor(
							    [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]],					device=__lowercase						)
							self.assertTrue(torch.allclose(output[0, :3, :3],					__lowercase,					atol=__lowercase						)						)




				def 							A__      (						self					:						Tuple						):
							lowercase__					  =				AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"						).to(__lowercase						)
							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((64, model.config.context_length, model.config.d_model)						)
							self.assertEqual(output.shape,					__lowercase						)

							lowercase__					  =				torch.tensor(
							    [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]],					device=__lowercase						)
							self.assertTrue(torch.allclose(output[0, :3, :3],					__lowercase,					atol=__lowercase						)						)




				def 							A__      (						self					:						Any						):
							lowercase__					  =				AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"						).to(__lowercase						)
							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((64, model.config.num_parallel_samples, model.config.prediction_length)						)
							self.assertEqual(outputs.sequences.shape,					__lowercase						)

							lowercase__					  =				torch.tensor([3130.6763, 4056.5293, 7053.0786],					device=__lowercase						)
							lowercase__					  =				outputs.sequences.mean(dim=1						)
							self.assertTrue(torch.allclose(mean_prediction[0, -3:],					__lowercase,					rtol=1e-1						)						)









# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowercase_								=     {
    """configuration_xmod""": [
        """XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """XmodConfig""",
        """XmodOnnxConfig""",
    ],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase_								=     [
							    """XMOD_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """XmodForCausalLM""",
							    """XmodForMaskedLM""",
							    """XmodForMultipleChoice""",
							    """XmodForQuestionAnswering""",
							    """XmodForSequenceClassification""",
							    """XmodForTokenClassification""",
							    """XmodModel""",
							    """XmodPreTrainedModel""",
							]

if TYPE_CHECKING:
							from .configuration_xmod import XMOD_PRETRAINED_CONFIG_ARCHIVE_MAP, XmodConfig, XmodOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xmod import (
														    XMOD_PRETRAINED_MODEL_ARCHIVE_LIST,
														    XmodForCausalLM,
														    XmodForMaskedLM,
														    XmodForMultipleChoice,
														    XmodForQuestionAnswering,
														    XmodForSequenceClassification,
														    XmodForTokenClassification,
														    XmodModel,
														    XmodPreTrainedModel,
														)

else:
							import sys

							lowercase_								=     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




