



"""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__      =    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					:						Tuple						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						int=1_6						, __lowerCAmelCase					:						Tuple=1_3						, __lowerCAmelCase					:						Tuple=7						, __lowerCAmelCase					:						List[Any]=1_4						, __lowerCAmelCase					:						str=1_0						, __lowerCAmelCase					:						Union[str, Any]=1_9						, __lowerCAmelCase					:						List[str]=5						, __lowerCAmelCase					:						int=4						, __lowerCAmelCase					:						Dict=True						, __lowerCAmelCase					:						Union[str, Any]=1_6						, __lowerCAmelCase					:						List[str]=2						, __lowerCAmelCase					:						Optional[Any]=4						, __lowerCAmelCase					:						List[str]=4						, __lowerCAmelCase					:						str="gelu"						, __lowerCAmelCase					:						Tuple=0.1						, __lowerCAmelCase					:						int=0.1						, __lowerCAmelCase					:						Tuple=[1, 2, 3, 4, 5]						, __lowerCAmelCase					:						Any=2_5						, __lowerCAmelCase					:						Tuple=5						, ):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			d_model
         _lowerCamelCase						:    Dict         =			parent
         _lowerCamelCase						:    Optional[Any]         =			batch_size
         _lowerCamelCase						:    str         =			prediction_length
         _lowerCamelCase						:    Dict         =			context_length
         _lowerCamelCase						:    List[str]         =			cardinality
         _lowerCamelCase						:    Any         =			num_time_features
         _lowerCamelCase						:    Optional[Any]         =			lags_sequence
         _lowerCamelCase						:    List[str]         =			embedding_dimension
         _lowerCamelCase						:    Union[str, Any]         =			is_training
         _lowerCamelCase						:    str         =			hidden_size
         _lowerCamelCase						:    List[Any]         =			num_hidden_layers
         _lowerCamelCase						:    Tuple         =			num_attention_heads
         _lowerCamelCase						:    Optional[int]         =			intermediate_size
         _lowerCamelCase						:    Union[str, Any]         =			hidden_act
         _lowerCamelCase						:    List[str]         =			hidden_dropout_prob
         _lowerCamelCase						:    int         =			attention_probs_dropout_prob

         _lowerCamelCase						:    Union[str, Any]         =			context_length
         _lowerCamelCase						:    Tuple         =			prediction_length + label_length
         _lowerCamelCase						:    Optional[Any]         =			label_length

         _lowerCamelCase						:    int         =			moving_average
         _lowerCamelCase						:    List[Any]         =			autocorrelation_factor




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """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 						SCREAMING_SNAKE_CASE    (			self					:						Any						, __lowerCAmelCase					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			config.context_length + max(config.lags_sequence		)

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

         # decoder inputs
         _lowerCamelCase						:    List[Any]         =			floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]		)
         _lowerCamelCase						:    Any         =			floats_tensor([self.batch_size, config.prediction_length]		)

         _lowerCamelCase						:    Optional[int]         =			{
             '''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 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			self.get_config()
         _lowerCamelCase						:    Optional[Any]         =			self.prepare_autoformer_inputs_dict(__lowerCAmelCase		)
         return config, inputs_dict




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			self.prepare_config_and_inputs()
         return config, inputs_dict




  def 						SCREAMING_SNAKE_CASE    (			self					:						int						, __lowerCAmelCase					:						List[str]						, __lowerCAmelCase					:						Union[str, Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Union[str, Any]         =			AutoformerModel(config=__lowerCAmelCase		).to(__lowerCAmelCase		).eval()
         _lowerCamelCase						:    Optional[int]         =			model(**__lowerCAmelCase		)

         _lowerCamelCase						:    int         =			outputs.encoder_last_hidden_state
         _lowerCamelCase						:    str         =			outputs.last_hidden_state

         with tempfile.TemporaryDirectory() as tmpdirname:
                _lowerCamelCase						:    Any         =			model.get_encoder()
                encoder.save_pretrained(__lowerCAmelCase		)
                _lowerCamelCase						:    List[str]         =			AutoformerEncoder.from_pretrained(__lowerCAmelCase		).to(__lowerCAmelCase		)

         _lowerCamelCase						:    Optional[Any]         =			model.create_network_inputs(**__lowerCAmelCase		)
         _lowerCamelCase						:    Any         =			model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]		)

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

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

         _lowerCamelCase						:    Optional[Any]         =			torch.cat(
             (
                 torch.cat((seasonal_input[:, -config.label_length :, ...], zeros)						, dim=1		),
                 feature[:, config.context_length - config.label_length :, ...],
             )						, dim=-1						, )
         _lowerCamelCase						:    List[Any]         =			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(__lowerCAmelCase		)
                _lowerCamelCase						:    Optional[int]         =			AutoformerDecoder.from_pretrained(__lowerCAmelCase		).to(__lowerCAmelCase		)

         _lowerCamelCase						:    str         =			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 	__snake_case	(     _lowercase  ,					_lowercase  ,					unittest.TestCase):
  snake_case__    :       List[Any]        =						(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
  snake_case__    :       int        =						(AutoformerForPrediction,) if is_torch_available() else ()
  snake_case__    :       Any        =						{"feature-extraction": AutoformerModel} if is_torch_available() else {}
  snake_case__    :       Any        =						False
  snake_case__    :       Tuple        =						False
  snake_case__    :       List[str]        =						False
  snake_case__    :       Union[str, Any]        =						False
  snake_case__    :       Dict        =						False
  snake_case__    :       Union[str, Any]        =						False




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			AutoformerModelTester(self		)
         _lowerCamelCase						:    Tuple         =			ConfigTester(self						, config_class=__lowerCAmelCase						, has_text_modality=__lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         self.config_tester.run_common_tests()




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Dict         =			self.model_tester.prepare_config_and_inputs()
         for model_class in self.all_model_classes:
                _lowerCamelCase						:    List[Any]         =			model_class(__lowerCAmelCase		)

                with tempfile.TemporaryDirectory() as tmpdirname:
                       model.save_pretrained(__lowerCAmelCase		)
                       _lowerCamelCase						:    List[str]         =			model_class.from_pretrained(__lowerCAmelCase						, output_loading_info=__lowerCAmelCase		)
                self.assertEqual(info['''missing_keys''']						, []		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						int		):






         """simple docstring"""






         _lowerCamelCase						:    int         =			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 						SCREAMING_SNAKE_CASE    (			self					:						Dict		):






         """simple docstring"""






         pass




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			inspect.signature(getattr(__lowerCAmelCase						, '''forward'''		)		)
         # The main input is the name of the argument after `self`
         _lowerCamelCase						:    int         =			list(model_signature.parameters.keys()		)[1]
         self.assertEqual(AutoformerModel.main_input_name						, __lowerCAmelCase		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						str		):






         """simple docstring"""






         _lowerCamelCase						:    List[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                _lowerCamelCase						:    Dict         =			model_class(__lowerCAmelCase		)
                _lowerCamelCase						:    List[str]         =			inspect.signature(model.forward		)
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                _lowerCamelCase						:    Optional[Any]         =			[*signature.parameters.keys()]

                _lowerCamelCase						:    Any         =			[
                    '''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 						SCREAMING_SNAKE_CASE    (			self					:						Any		):






         """simple docstring"""






         _lowerCamelCase						:    Optional[Any]         =			self.model_tester.prepare_config_and_inputs_for_common()
         _lowerCamelCase						:    Optional[int]         =			True

         _lowerCamelCase						:    Optional[Any]         =			getattr(self.model_tester						, '''seq_length'''						, __lowerCAmelCase		)
         _lowerCamelCase						:    List[str]         =			getattr(self.model_tester						, '''decoder_seq_length'''						, __lowerCAmelCase		)
         _lowerCamelCase						:    List[str]         =			getattr(self.model_tester						, '''encoder_seq_length'''						, __lowerCAmelCase		)
         _lowerCamelCase						:    Union[str, Any]         =			getattr(self.model_tester						, '''d_model'''						, __lowerCAmelCase		)
         _lowerCamelCase						:    int         =			getattr(self.model_tester						, '''num_attention_heads'''						, __lowerCAmelCase		)
         _lowerCamelCase						:    Optional[int]         =			d_model // num_attention_heads

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

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

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

         _lowerCamelCase						:    Optional[Any]         =			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 						SCREAMING_SNAKE_CASE    (			self					:						List[str]		):






         """simple docstring"""






         super().test_retain_grad_hidden_states_attentions()






def 	snake_case_  (				A_ :		int="train-batch.pt"						):


       '''simple docstring'''





       _lowerCamelCase						:    List[Any]         =			hf_hub_download(repo_id='''hf-internal-testing/tourism-monthly-batch''',    filename=A_,    repo_type='''dataset'''						)
       _lowerCamelCase						:    Tuple         =			torch.load(A_,    map_location=A_						)
       return batch







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




  def 						SCREAMING_SNAKE_CASE    (			self					:						Optional[int]		):






         """simple docstring"""






         _lowerCamelCase						:    Any         =			AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''		).to(__lowerCAmelCase		)
         _lowerCamelCase						:    str         =			prepare_batch()

         with torch.no_grad():
                _lowerCamelCase						:    List[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''']						, future_values=batch['''future_values''']						, future_time_features=batch['''future_time_features''']						, )[0]

         _lowerCamelCase						:    int         =			torch.Size(
             (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)		)
         self.assertEqual(output.shape						, __lowerCAmelCase		)

         _lowerCamelCase						:    Optional[Any]         =			torch.tensor(
             [[0.35_93, -1.33_98, 0.63_30], [0.22_79, 1.53_96, -0.17_92], [0.04_50, 1.32_25, -0.23_35]]						, device=__lowerCAmelCase		)
         self.assertTrue(torch.allclose(output[0, :3, :3]						, __lowerCAmelCase						, atol=__lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						List[Any]		):






         """simple docstring"""






         _lowerCamelCase						:    str         =			AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''		).to(__lowerCAmelCase		)
         _lowerCamelCase						:    str         =			prepare_batch('''val-batch.pt'''		)
         with torch.no_grad():
                _lowerCamelCase						:    int         =			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((6_4, model.config.context_length, model.config.d_model)		)
         self.assertEqual(output.shape						, __lowerCAmelCase		)

         _lowerCamelCase						:    Any         =			torch.tensor(
             [[-0.07_34, -0.90_36, 0.83_58], [4.71_86, 2.41_13, 1.95_81], [1.79_53, 2.35_58, 1.29_70]]						, device=__lowerCAmelCase		)
         self.assertTrue(torch.allclose(output[0, :3, :3]						, __lowerCAmelCase						, atol=__lowerCAmelCase		)		)




  def 						SCREAMING_SNAKE_CASE    (			self					:						Tuple		):






         """simple docstring"""






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

         _lowerCamelCase						:    Any         =			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=__lowerCAmelCase		)
         _lowerCamelCase						:    List[str]         =			outputs.sequences.mean(dim=1		)
         self.assertTrue(torch.allclose(mean_prediction[0, -3:]						, __lowerCAmelCase						, rtol=1E-1		)		)







"""simple docstring"""






def 	snake_case_  (				A_ :		list						):


       '''simple docstring'''





       _lowerCamelCase						:    Union[str, Any]         =			len(A_						)
       for i in range(1,    A_						):
              _lowerCamelCase						:    Tuple         =			collection[i]
              _lowerCamelCase						:    Dict         =			0
              _lowerCamelCase						:    Any         =			i - 1

              while low <= high:
                     _lowerCamelCase						:    Optional[int]         =			(low + high) // 2
                     if val < collection[mid]:
                            _lowerCamelCase						:    List[str]         =			mid - 1
                     else:
                            _lowerCamelCase						:    Dict         =			mid + 1
              for j in range(A_,    A_,    -1						):
                     _lowerCamelCase						:    Optional[int]         =			collection[j - 1]
              _lowerCamelCase						:    Tuple         =			val
       return collection


if __name__ == "__main__":
   lowerCAmelCase__      =    input('''Enter numbers separated by a comma:\n''').strip()
   lowerCAmelCase__      =    [int(item) for item in user_input.split(''',''')]
   print(binary_insertion_sort(unsorted))


