





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

   '''simple docstring'''







   def __init__(					self ,						__lowerCAmelCase ,						__lowerCAmelCase=1_6 ,						__lowerCAmelCase=1_3 ,						__lowerCAmelCase=7 ,						__lowerCAmelCase=1_4 ,						__lowerCAmelCase=1_0 ,						__lowerCAmelCase=1_9 ,						__lowerCAmelCase=5 ,						__lowerCAmelCase=4 ,						__lowerCAmelCase=True ,						__lowerCAmelCase=1_6 ,						__lowerCAmelCase=2 ,						__lowerCAmelCase=4 ,						__lowerCAmelCase=4 ,						__lowerCAmelCase="gelu" ,						__lowerCAmelCase=0.1 ,						__lowerCAmelCase=0.1 ,						__lowerCAmelCase=[1, 2, 3, 4, 5] ,						__lowerCAmelCase=2_5 ,						__lowerCAmelCase=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 ,						__lowerCAmelCase							):



    '''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(__lowerCAmelCase							)
    return config, inputs_dict





   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__       ,			lowerCamelCase__              =	self.prepare_config_and_inputs()
    return config, inputs_dict





   def 	__lowerCamelCase       (					self ,						__lowerCAmelCase ,						__lowerCAmelCase							):



    '''simple docstring'''







    lowerCamelCase__              =	AutoformerModel(config=__lowerCAmelCase							).to(__lowerCAmelCase							).eval()
    lowerCamelCase__              =	model(**__lowerCAmelCase							)

    lowerCamelCase__              =	outputs.encoder_last_hidden_state
    lowerCamelCase__              =	outputs.last_hidden_state

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

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

    lowerCamelCase__              =	decoder(
        trend=__lowerCAmelCase ,						inputs_embeds=__lowerCAmelCase ,						encoder_hidden_states=__lowerCAmelCase ,						)[0]

    self.parent.assertTrue((last_hidden_state_a - last_hidden_state).abs().max().item() < 1E-3							)






@require_torch
class       __A					(					lowerCAmelCase    ,       lowerCAmelCase    ,       unittest.TestCase				):

   '''simple docstring'''







   lowerCAmelCase_							  =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
   lowerCAmelCase_							  =		(AutoformerForPrediction,) if is_torch_available() else ()
   lowerCAmelCase_							  =		{"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
   lowerCAmelCase_							  =		False
   lowerCAmelCase_							  =		False
   lowerCAmelCase_							  =		False
   lowerCAmelCase_							  =		False
   lowerCAmelCase_							  =		False
   lowerCAmelCase_							  =		False





   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__              =	AutoformerModelTester(self							)
    lowerCamelCase__              =	ConfigTester(self ,						config_class=__lowerCAmelCase ,						has_text_modality=__lowerCAmelCase							)





   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(__lowerCAmelCase							)

     with tempfile.TemporaryDirectory() as tmpdirname:
      model.save_pretrained(__lowerCAmelCase							)
      lowerCamelCase__       ,			lowerCamelCase__              =	model_class.from_pretrained(__lowerCAmelCase ,						output_loading_info=__lowerCAmelCase							)
     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(*__lowerCAmelCase							)





   @unittest.skip(reason='''Model has no tokens embeddings'''							)
   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    pass





   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__              =	inspect.signature(getattr(__lowerCAmelCase ,						'''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 ,						__lowerCAmelCase							)





   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(__lowerCAmelCase							)
     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(__lowerCAmelCase							)] ,						__lowerCAmelCase							)





   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''' ,						__lowerCAmelCase							)
    lowerCamelCase__              =	getattr(self.model_tester ,						'''decoder_seq_length''' ,						__lowerCAmelCase							)
    lowerCamelCase__              =	getattr(self.model_tester ,						'''encoder_seq_length''' ,						__lowerCAmelCase							)
    lowerCamelCase__              =	getattr(self.model_tester ,						'''d_model''' ,						__lowerCAmelCase							)
    lowerCamelCase__              =	getattr(self.model_tester ,						'''num_attention_heads''' ,						__lowerCAmelCase							)
    lowerCamelCase__              =	d_model // num_attention_heads

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

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

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

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

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

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

    self.assertEqual(len(__lowerCAmelCase							) ,						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 lowerCAmelCase__(__snake_case="train-batch.pt"							)       ->   Optional[int]:







 '''simple docstring'''







 lowerCamelCase__              =	hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch''' ,filename=__snake_case ,repo_type='''dataset'''							)
 lowerCamelCase__              =	torch.load(__snake_case ,map_location=__snake_case							)
 return batch






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

   '''simple docstring'''







   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__              =	AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''							).to(__lowerCAmelCase							)
    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(
        (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)							)
    self.assertEqual(output.shape ,						__lowerCAmelCase							)

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





   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__              =	AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''							).to(__lowerCAmelCase							)
    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((6_4, model.config.context_length, model.config.d_model)							)
    self.assertEqual(output.shape ,						__lowerCAmelCase							)

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





   def 	__lowerCamelCase       (					self							):



    '''simple docstring'''







    lowerCamelCase__              =	AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''							).to(__lowerCAmelCase							)
    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((6_4, model.config.num_parallel_samples, model.config.prediction_length)							)
    self.assertEqual(outputs.sequences.shape ,						__lowerCAmelCase							)

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










import warnings

from ...utils import logging
from .image_processing_segformer import SegformerImageProcessor


_a						=   logging.get_logger(__name__)






class       __A					(					lowerCAmelCase				):

			'''simple docstring'''







			def __init__(					self ,						*__lowerCAmelCase ,						**__lowerCAmelCase							):



				'''simple docstring'''







				warnings.warn(
				    '''The class SegformerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'''
				    ''' Please use SegformerImageProcessor instead.''' ,						__lowerCAmelCase ,						)
				super().__init__(*__lowerCAmelCase ,						**__lowerCAmelCase							)



