





'''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


__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       UpperCAmelCase :




		def __init__(self      :	Tuple							,			A__      :	Optional[Any]							,			A__      :	List[Any]=1_6							,			A__      :	int=1_3							,			A__      :	Dict=7							,			A__      :	Union[str, Any]=1_4							,			A__      :	Dict=1_0							,			A__      :	Union[str, Any]=1_9							,			A__      :	Dict=5							,			A__      :	Any=4							,			A__      :	Tuple=True							,			A__      :	List[Any]=1_6							,			A__      :	Optional[int]=2							,			A__      :	Tuple=4							,			A__      :	Dict=4							,			A__      :	List[Any]="gelu"							,			A__      :	Union[str, Any]=0.1							,			A__      :	str=0.1							,			A__      :	Any=[1, 2, 3, 4, 5]							,			A__      :	Union[str, Any]=2_5							,			A__      :	List[Any]=5							,			)					-> Optional[Any]:
						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 				UpperCAmelCase__   (self      :	List[Any]				)					-> Dict:
						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 				UpperCAmelCase__   (self      :	int							,			A__      :	Optional[Any]				)					-> List[str]:
						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 				UpperCAmelCase__   (self      :	Dict				)					-> int:
						lowercase         = self.get_config()
						lowercase         = self.prepare_autoformer_inputs_dict(_a				)
						return config, inputs_dict




		def 				UpperCAmelCase__   (self      :	Dict				)					-> List[Any]:
						lowercase         = self.prepare_config_and_inputs()
						return config, inputs_dict





		def 				UpperCAmelCase__   (self      :	Dict							,			A__      :	Dict							,			A__      :	Dict				)					-> Optional[Any]:
						lowercase         = AutoformerModel(config=_a				).to(_a				).eval()
						lowercase         = model(**_a				)

						lowercase         = outputs.encoder_last_hidden_state
						lowercase         = outputs.last_hidden_state

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

						lowercase         = model.create_network_inputs(**_a				)
						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=_a				)[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(_a				)
										lowercase         = AutoformerDecoder.from_pretrained(_a				).to(_a				)

						lowercase         = 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       UpperCAmelCase (						__SCREAMING_SNAKE_CASE			,       __SCREAMING_SNAKE_CASE			,       unittest.TestCase  ):
		UpperCAmelCase					:	Optional[int] 			=		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
		UpperCAmelCase					:	Union[str, Any] 			=		(AutoformerForPrediction,) if is_torch_available() else ()
		UpperCAmelCase					:	int 			=		{'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
		UpperCAmelCase					:	str 			=		False
		UpperCAmelCase					:	int 			=		False
		UpperCAmelCase					:	str 			=		False
		UpperCAmelCase					:	Optional[int] 			=		False
		UpperCAmelCase					:	str 			=		False
		UpperCAmelCase					:	Optional[int] 			=		False




		def 				UpperCAmelCase__   (self      :	str				)					-> Optional[int]:
						lowercase         = AutoformerModelTester(self				)
						lowercase         = ConfigTester(self							,			config_class=_a							,			has_text_modality=_a				)




		def 				UpperCAmelCase__   (self      :	Any				)					-> Optional[int]:
						self.config_tester.run_common_tests()




		def 				UpperCAmelCase__   (self      :	Dict				)					-> List[Any]:
						lowercase         = self.model_tester.prepare_config_and_inputs()
						for model_class in self.all_model_classes:
										lowercase         = model_class(_a				)

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




		def 				UpperCAmelCase__   (self      :	Any				)					-> Dict:
						lowercase         = 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 				UpperCAmelCase__   (self      :	List[str]				)					-> List[str]:
						pass




		def 				UpperCAmelCase__   (self      :	List[Any]				)					-> List[Any]:
						lowercase         = inspect.signature(getattr(_a							,			"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							,			_a				)




		def 				UpperCAmelCase__   (self      :	str				)					-> int:
						lowercase         = self.model_tester.prepare_config_and_inputs_for_common()

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




		def 				UpperCAmelCase__   (self      :	Dict				)					-> Union[str, Any]:
						lowercase         = self.model_tester.prepare_config_and_inputs_for_common()
						lowercase         = True

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

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

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

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

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

						lowercase         = 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 				UpperCAmelCase__   (self      :	str				)					-> Tuple:
						super().test_retain_grad_hidden_states_attentions()







def 							UpperCAmelCase_    (	lowerCAmelCase_="train-batch.pt"							):

				"""simple docstring"""






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


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




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

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

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

						lowercase         = 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 				UpperCAmelCase__   (self      :	List[str]				)					-> Optional[Any]:
						lowercase         = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"				).to(_a				)
						lowercase         = prepare_batch("val-batch.pt"				)
						with torch.no_grad():
										lowercase         = model(
										    past_values=batch["past_values"]							,			past_time_features=batch["past_time_features"]							,			past_observed_mask=batch["past_observed_mask"]							,			static_categorical_features=batch["static_categorical_features"]							,			).encoder_last_hidden_state
						lowercase         = torch.Size((6_4, model.config.context_length, model.config.d_model)				)
						self.assertEqual(output.shape							,			_a				)

						lowercase         = 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 				UpperCAmelCase__   (self      :	Tuple				)					-> str:
						lowercase         = AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"				).to(_a				)
						lowercase         = prepare_batch("val-batch.pt"				)
						with torch.no_grad():
										lowercase         = model.generate(
										    static_categorical_features=batch["static_categorical_features"]							,			past_time_features=batch["past_time_features"]							,			past_values=batch["past_values"]							,			future_time_features=batch["future_time_features"]							,			past_observed_mask=batch["past_observed_mask"]							,			)
						lowercase         = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)				)
						self.assertEqual(outputs.sequences.shape							,			_a				)

						lowercase         = torch.tensor([3_1_3_0.6_7_6_3, 4_0_5_6.5_2_9_3, 7_0_5_3.0_7_8_6]							,			device=_a				)
						lowercase         = outputs.sequences.mean(dim=1				)
						self.assertTrue(torch.allclose(mean_prediction[0, -3:]							,			_a							,			rtol=1e-1				)				)







'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


__lowerCamelCase : List[str]											=			logging.get_logger(__name__)

__lowerCamelCase : str											=			{
    "facebook/data2vec-text-base": "https://huggingface.co/data2vec/resolve/main/config.json",
}

class       UpperCAmelCase (						_lowercase  ):
		UpperCAmelCase					:	List[str] 			=		'''data2vec-text'''




		def __init__(self      :	List[str]							,			A__      :	str=3_0_5_2_2							,			A__      :	Tuple=7_6_8							,			A__      :	Any=1_2							,			A__      :	Optional[int]=1_2							,			A__      :	str=3_0_7_2							,			A__      :	List[str]="gelu"							,			A__      :	List[Any]=0.1							,			A__      :	Optional[int]=0.1							,			A__      :	Union[str, Any]=5_1_2							,			A__      :	Any=2							,			A__      :	str=0.0_2							,			A__      :	int=1e-12							,			A__      :	Union[str, Any]=1							,			A__      :	Optional[int]=0							,			A__      :	Union[str, Any]=2							,			A__      :	Optional[int]="absolute"							,			A__      :	Tuple=True							,			A__      :	int=None							,			**A__      :	Any							,			)					-> Any:
						super().__init__(pad_token_id=A__							,			bos_token_id=A__							,			eos_token_id=A__							,			**A__				)

						lowercase         = vocab_size
						lowercase         = hidden_size
						lowercase         = num_hidden_layers
						lowercase         = num_attention_heads
						lowercase         = hidden_act
						lowercase         = intermediate_size
						lowercase         = hidden_dropout_prob
						lowercase         = attention_probs_dropout_prob
						lowercase         = max_position_embeddings
						lowercase         = type_vocab_size
						lowercase         = initializer_range
						lowercase         = layer_norm_eps
						lowercase         = position_embedding_type
						lowercase         = use_cache
						lowercase         = classifier_dropout




class       UpperCAmelCase (						_lowercase  ):




		@property
		def 				UpperCAmelCase__   (self      :	List[str]				)					-> Mapping[str, Mapping[int, str]]:
						if self.task == "multiple-choice":
										lowercase         = {0: "batch", 1: "choice", 2: "sequence"}
						else:
										lowercase         = {0: "batch", 1: "sequence"}
						return OrderedDict(
						    [
						        ("input_ids", dynamic_axis),
						        ("attention_mask", dynamic_axis),
						    ]				)




