"""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   :	Optional[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		: List[Any]						    =  d_model
							_lowerCAmelCase		: Union[str, Any]						    =  parent
							_lowerCAmelCase		: List[str]						    =  batch_size
							_lowerCAmelCase		: Tuple						    =  prediction_length
							_lowerCAmelCase		: Tuple						    =  context_length
							_lowerCAmelCase		: List[Any]						    =  cardinality
							_lowerCAmelCase		: Dict						    =  num_time_features
							_lowerCAmelCase		: Optional[int]						    =  lags_sequence
							_lowerCAmelCase		: Union[str, Any]						    =  embedding_dimension
							_lowerCAmelCase		: int						    =  is_training
							_lowerCAmelCase		: Union[str, Any]						    =  hidden_size
							_lowerCAmelCase		: List[str]						    =  num_hidden_layers
							_lowerCAmelCase		: Dict						    =  num_attention_heads
							_lowerCAmelCase		: int						    =  intermediate_size
							_lowerCAmelCase		: int						    =  hidden_act
							_lowerCAmelCase		: Any						    =  hidden_dropout_prob
							_lowerCAmelCase		: List[Any]						    =  attention_probs_dropout_prob

							_lowerCAmelCase		: List[Any]						    =  context_length
							_lowerCAmelCase		: List[Any]						    =  prediction_length + label_length
							_lowerCAmelCase		: Tuple						    =  label_length

							_lowerCAmelCase		: int						    =  moving_average
							_lowerCAmelCase		: Optional[int]						    =  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		: List[str]						    =  config.context_length + max(config.lags_sequence						)

							_lowerCAmelCase		: List[str]						    =  ids_tensor([self.batch_size, 1]       ,  config.cardinality[0]						)
							_lowerCAmelCase		: Optional[Any]						    =  floats_tensor([self.batch_size, _past_length, config.num_time_features]						)
							_lowerCAmelCase		: str						    =  floats_tensor([self.batch_size, _past_length]						)
							_lowerCAmelCase		: Optional[Any]						    =  floats_tensor([self.batch_size, _past_length]						) > 0.5

							# decoder inputs
							_lowerCAmelCase		: Optional[Any]						    =  floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]						)
							_lowerCAmelCase		: Optional[int]						    =  floats_tensor([self.batch_size, config.prediction_length]						)

							_lowerCAmelCase		: Any						    =  {
							    """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		: List[str]						    =  self.get_config()
							_lowerCAmelCase		: List[str]						    =  self.prepare_autoformer_inputs_dict(__lowercase						)
							return config, inputs_dict






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






					def 					__A						(	self       ,  a__       ,  a__						):
							_lowerCAmelCase		: Union[str, Any]						    =  AutoformerModel(config=__lowercase						).to(__lowercase						).eval()
							_lowerCAmelCase		: Any						    =  model(**__lowercase						)

							_lowerCAmelCase		: Union[str, Any]						    =  outputs.encoder_last_hidden_state
							_lowerCAmelCase		: Optional[int]						    =  outputs.last_hidden_state

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

							_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase    ,			_lowerCAmelCase		: Optional[int]						    =  model.create_network_inputs(**__lowercase						)
							_lowerCAmelCase    ,			_lowerCAmelCase		: Optional[int]						    =  model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]						)

							_lowerCAmelCase		: Union[str, Any]						    =  torch.cat(
							    (transformer_inputs[:, : config.context_length, ...], feature[:, : config.context_length, ...])       ,  dim=-1       ,  )
							_lowerCAmelCase		: List[Any]						    =  encoder(inputs_embeds=__lowercase						)[0]
							self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1e-3						)

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

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

							_lowerCAmelCase		: int						    =  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 		__A							(				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						):
							_lowerCAmelCase		: List[Any]						    =  AutoformerModelTester(self						)
							_lowerCAmelCase		: Any						    =  ConfigTester(self       ,  config_class=__lowercase       ,  has_text_modality=__lowercase						)






					def 					__A						(	self						):
							self.config_tester.run_common_tests()






					def 					__A						(	self						):
							_lowerCAmelCase    ,			_lowerCAmelCase		: Any						    =  self.model_tester.prepare_config_and_inputs()
							for model_class in self.all_model_classes:
									_lowerCAmelCase		: Union[str, Any]						    =  model_class(__lowercase						)

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






					def 					__A						(	self						):
							_lowerCAmelCase		: Tuple						    =  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						):
							pass






					def 					__A						(	self						):
							_lowerCAmelCase		: Tuple						    =  inspect.signature(getattr(__lowercase       ,  """forward"""						)						)
							# The main input is the name of the argument after `self`
							_lowerCAmelCase		: str						    =  list(model_signature.parameters.keys()						)[1]
							self.assertEqual(AutoformerModel.main_input_name       ,  __lowercase						)






					def 					__A						(	self						):
							_lowerCAmelCase    ,			_lowerCAmelCase		: List[Any]						    =  self.model_tester.prepare_config_and_inputs_for_common()

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

									_lowerCAmelCase		: Dict						    =  [
									    """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						):
							_lowerCAmelCase    ,			_lowerCAmelCase		: str						    =  self.model_tester.prepare_config_and_inputs_for_common()
							_lowerCAmelCase		: int						    =  True

							_lowerCAmelCase		: Union[str, Any]						    =  getattr(self.model_tester       ,  """seq_length"""       ,  __lowercase						)
							_lowerCAmelCase		: Dict						    =  getattr(self.model_tester       ,  """decoder_seq_length"""       ,  __lowercase						)
							_lowerCAmelCase		: Dict						    =  getattr(self.model_tester       ,  """encoder_seq_length"""       ,  __lowercase						)
							_lowerCAmelCase		: Optional[int]						    =  getattr(self.model_tester       ,  """d_model"""       ,  __lowercase						)
							_lowerCAmelCase		: str						    =  getattr(self.model_tester       ,  """num_attention_heads"""       ,  __lowercase						)
							_lowerCAmelCase		: Union[str, Any]						    =  d_model // num_attention_heads

							for model_class in self.all_model_classes:
									_lowerCAmelCase		: Optional[int]						    =  True
									_lowerCAmelCase		: Dict						    =  False
									_lowerCAmelCase		: List[str]						    =  True
									_lowerCAmelCase		: Optional[Any]						    =  model_class(__lowercase						)
									model.to(__lowercase						)
									model.eval()
									with torch.no_grad():
											_lowerCAmelCase		: int						    =  model(**self._prepare_for_class(__lowercase       ,  __lowercase						)						)
									_lowerCAmelCase		: List[str]						    =  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"]
									_lowerCAmelCase		: str						    =  True
									_lowerCAmelCase		: List[str]						    =  model_class(__lowercase						)
									model.to(__lowercase						)
									model.eval()
									with torch.no_grad():
											_lowerCAmelCase		: Optional[int]						    =  model(**self._prepare_for_class(__lowercase       ,  __lowercase						)						)
									_lowerCAmelCase		: List[str]						    =  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]       ,  )
									_lowerCAmelCase		: Tuple						    =  len(__lowercase						)

									_lowerCAmelCase		: Optional[Any]						    =  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
									_lowerCAmelCase		: str						    =  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
									_lowerCAmelCase		: Optional[int]						    =  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
							_lowerCAmelCase		: Dict						    =  True
							_lowerCAmelCase		: Any						    =  True
							_lowerCAmelCase		: str						    =  model_class(__lowercase						)
							model.to(__lowercase						)
							model.eval()
							with torch.no_grad():
									_lowerCAmelCase		: List[str]						    =  model(**self._prepare_for_class(__lowercase       ,  __lowercase						)						)

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

							_lowerCAmelCase		: Optional[int]						    =  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						):
							super().test_retain_grad_hidden_states_attentions()







def 							SCREAMING_SNAKE_CASE  (    _lowerCamelCase		: List[str]="train-batch.pt"			) ->   str:
		_lowerCAmelCase		: List[Any]						    =  hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""    ,filename=SCREAMING_SNAKE_CASE_    ,repo_type="""dataset"""			)
		_lowerCAmelCase		: List[str]						    =  torch.load(SCREAMING_SNAKE_CASE_    ,map_location=SCREAMING_SNAKE_CASE_			)
		return batch






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






					def 					__A						(	self						):
							_lowerCAmelCase		: List[str]						    =  AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(__lowercase						)
							_lowerCAmelCase		: Optional[int]						    =  prepare_batch()

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

							_lowerCAmelCase		: Union[str, Any]						    =  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=__lowercase						)
							self.assertTrue(torch.allclose(output[0, :3, :3]       ,  __lowercase       ,  atol=__lowercase						)						)






					def 					__A						(	self						):
							_lowerCAmelCase		: str						    =  AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(__lowercase						)
							_lowerCAmelCase		: List[str]						    =  prepare_batch("""val-batch.pt"""						)
							with torch.no_grad():
									_lowerCAmelCase		: Any						    =  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		: Any						    =  torch.Size((64, model.config.context_length, model.config.d_model)						)
							self.assertEqual(output.shape       ,  __lowercase						)

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






					def 					__A						(	self						):
							_lowerCAmelCase		: Dict						    =  AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(__lowercase						)
							_lowerCAmelCase		: Any						    =  prepare_batch("""val-batch.pt"""						)
							with torch.no_grad():
									_lowerCAmelCase		: Tuple						    =  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		: List[Any]						    =  torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)						)
							self.assertEqual(outputs.sequences.shape       ,  __lowercase						)

							_lowerCAmelCase		: Dict						    =  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=__lowercase						)
							_lowerCAmelCase		: Union[str, Any]						    =  outputs.sequences.mean(dim=1						)
							self.assertTrue(torch.allclose(mean_prediction[0, -3:]       ,  __lowercase       ,  rtol=1e-1						)						)





"""simple docstring"""




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available


_a   :	Union[str, Any] 					=     {}

try:
     if not is_sentencepiece_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _a   :	Tuple 					=     ['GPTSw3Tokenizer']


if TYPE_CHECKING:
     try:
          if not is_sentencepiece_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_gpt_swa import GPTSwaTokenizer

else:
     import sys

     _a   :	Optional[int] 					=     _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)




