





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      lowerCamelCase:
     '''simple docstring'''


     def __init__(    self				,     snake_case_				,     snake_case_=16				,     snake_case_=13				,     snake_case_=7				,     snake_case_=14				,     snake_case_=10				,     snake_case_=19				,     snake_case_=5				,     snake_case_=4				,     snake_case_=True				,     snake_case_=16				,     snake_case_=2				,     snake_case_=4				,     snake_case_=4				,     snake_case_="gelu"				,     snake_case_=0.1				,     snake_case_=0.1				,     snake_case_=[1, 2, 3, 4, 5]				,     snake_case_=25				,     snake_case_=5				,     ):
         _A     =							d_model
         _A     =							parent
         _A     =							batch_size
         _A     =							prediction_length
         _A     =							context_length
         _A     =							cardinality
         _A     =							num_time_features
         _A     =							lags_sequence
         _A     =							embedding_dimension
         _A     =							is_training
         _A     =							hidden_size
         _A     =							num_hidden_layers
         _A     =							num_attention_heads
         _A     =							intermediate_size
         _A     =							hidden_act
         _A     =							hidden_dropout_prob
         _A     =							attention_probs_dropout_prob

         _A     =							context_length
         _A     =							prediction_length + label_length
         _A     =							label_length

         _A     =							moving_average
         _A     =							autocorrelation_factor




     def        lowerCAmelCase__		(    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        lowerCAmelCase__		(    self				,     snake_case_							):
         _A     =							config.context_length + max(config.lags_sequence							)

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

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

         _A     =							{
             '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							):
         _A     =							self.get_config()
         _A     =							self.prepare_autoformer_inputs_dict(snake_case_							)
         return config, inputs_dict




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.prepare_config_and_inputs()
         return config, inputs_dict




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_							):
         _A     =							AutoformerModel(config=snake_case_							).to(snake_case_							).eval()
         _A     =							model(**snake_case_							)

         _A     =							outputs.encoder_last_hidden_state
         _A     =							outputs.last_hidden_state

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

         _A,			_A,			_A,			_A,			_A     =							model.create_network_inputs(**snake_case_							)
         _A,			_A     =							model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]							)

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

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

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

         _A     =							decoder(
             trend=snake_case_				,     inputs_embeds=snake_case_				,     encoder_hidden_states=snake_case_				,     )[0]

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







@require_torch
class      lowerCamelCase(						__snake_case			, __snake_case			, unittest.TestCase	):
     '''simple docstring'''


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




     def        lowerCAmelCase__		(    self							):
         _A     =							AutoformerModelTester(self							)
         _A     =							ConfigTester(self				,     config_class=snake_case_				,     has_text_modality=snake_case_							)




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




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs()
         for model_class in self.all_model_classes:
             _A     =							model_class(snake_case_							)

             with tempfile.TemporaryDirectory() as tmpdirname:
                 model.save_pretrained(snake_case_							)
                 _A,			_A     =							model_class.from_pretrained(snake_case_				,     output_loading_info=snake_case_							)
             self.assertEqual(info['missing_keys']				,     []							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.check_encoder_decoder_model_standalone(*snake_case_							)




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




     def        lowerCAmelCase__		(    self							):
         _A     =							inspect.signature(getattr(snake_case_				,     'forward'							)							)
         # The main input is the name of the argument after `self`
         _A     =							list(model_signature.parameters.keys()							)[1]
         self.assertEqual(AutoformerModel.main_input_name				,     snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()

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

             _A     =							[
                 '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(snake_case_							)]				,     snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()
         _A     =							True

         _A     =							getattr(self.model_tester				,     'seq_length'				,     snake_case_							)
         _A     =							getattr(self.model_tester				,     'decoder_seq_length'				,     snake_case_							)
         _A     =							getattr(self.model_tester				,     'encoder_seq_length'				,     snake_case_							)
         _A     =							getattr(self.model_tester				,     'd_model'				,     snake_case_							)
         _A     =							getattr(self.model_tester				,     'num_attention_heads'				,     snake_case_							)
         _A     =							d_model // num_attention_heads

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

             # check that output_attentions also work using config
             del inputs_dict["output_attentions"]
             _A     =							True
             _A     =							model_class(snake_case_							)
             model.to(snake_case_							)
             model.eval()
             with torch.no_grad():
                 _A     =							model(**self._prepare_for_class(snake_case_				,     snake_case_							)							)
             _A     =							outputs.encoder_attentions
             self.assertEqual(len(snake_case_							)				,     self.model_tester.num_hidden_layers							)

             self.assertListEqual(
                 list(attentions[0].shape[-3:]							)				,     [self.model_tester.num_attention_heads, encoder_seq_length, dim]				,     )
             _A     =							len(snake_case_							)

             _A     =							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(snake_case_				,     snake_case_							)

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

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

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

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





def 				__lowerCAmelCase(       _SCREAMING_SNAKE_CASE="train-batch.pt"				)							-> Any:




    """simple docstring"""




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







@require_torch
@slow
class      lowerCamelCase(						unittest.TestCase	):
     '''simple docstring'''


     def        lowerCAmelCase__		(    self							):
         _A     =							AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'							).to(snake_case_							)
         _A     =							prepare_batch()

         with torch.no_grad():
             _A     =							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]

         _A     =							torch.Size(
             (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)							)
         self.assertEqual(output.shape				,     snake_case_							)

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




     def        lowerCAmelCase__		(    self							):
         _A     =							AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'							).to(snake_case_							)
         _A     =							prepare_batch('val-batch.pt'							)
         with torch.no_grad():
             _A     =							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
         _A     =							torch.Size((64, model.config.context_length, model.config.d_model)							)
         self.assertEqual(output.shape				,     snake_case_							)

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




     def        lowerCAmelCase__		(    self							):
         _A     =							AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'							).to(snake_case_							)
         _A     =							prepare_batch('val-batch.pt'							)
         with torch.no_grad():
             _A     =							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']				,     )
         _A     =							torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)							)
         self.assertEqual(outputs.sequences.shape				,     snake_case_							)

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










import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
							from PIL import Image
else:


							class   __lowerCAmelCase  :
												"""simple docstring"""






												@staticmethod
												def      _a				(  *_snake_case       :							Any					,       **_snake_case       :							Optional[int]       ):






															"""simple docstring"""


															pass


@is_pipeline_test
@require_torch
@require_vision
class   __lowerCAmelCase  (		unittest.TestCase   ):
					"""simple docstring"""






					A__					:		Union[str, Any]      							=     MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING



					def      _a				(  self       :							List[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							Tuple					,       _snake_case       :							Union[str, Any]       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     [
								    {
								        'image': Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'       ),
								        'question': 'How many cats are there?',
								    },
								    {
								        'image': './tests/fixtures/tests_samples/COCO/000000039769.png',
								        'question': 'How many cats are there?',
								    },
								]
								return vqa_pipeline, examples



					def      _a				(  self       :							Optional[Any]					,       _snake_case       :							Union[str, Any]					,       _snake_case       :							List[str]       ):






								"""simple docstring"""


								A__	  =     vqa_pipeline(_snake_case					,       top_k=1       )
								self.assertEqual(
								    _snake_case					,       [
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								        [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}],
								    ]					,       )



					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='hf-internal-testing/tiny-vilt-random-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question='How many cats are there?'					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    _snake_case					,       [{'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}, {'score': ANY(_snake_case       ), 'answer': ANY(_snake_case       )}]       )



					@slow
					@require_torch
					def      _a				(  self       :							Any       ):






								"""simple docstring"""


								A__	  =     pipeline('visual-question-answering'					,       model='dandelin/vilt-b32-finetuned-vqa'       )
								A__	  =     './tests/fixtures/tests_samples/COCO/000000039769.png'
								A__	  =     'How many cats are there?'

								A__	  =     vqa_pipeline(image=_snake_case					,       question=_snake_case					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline({'image': image, 'question': question}					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]       )

								A__	  =     vqa_pipeline(
								    [{'image': image, 'question': question}, {'image': image, 'question': question}]					,       top_k=2       )
								self.assertEqual(
								    nested_simplify(_snake_case					,       decimals=4       )					,       [[{'score': 0.8799, 'answer': '2'}, {'score': 0.296, 'answer': '1'}]] * 2					,       )



					@require_tf
					@unittest.skip('Visual question answering not implemented in TF'       )
					def      _a				(  self       :							Dict       ):






								"""simple docstring"""


								pass




