

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


_snake_case         =  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      ,    _UpperCamelCase      ,    _UpperCamelCase=16      ,    _UpperCamelCase=13      ,    _UpperCamelCase=7      ,    _UpperCamelCase=14      ,    _UpperCamelCase=10      ,    _UpperCamelCase=19      ,    _UpperCamelCase=5      ,    _UpperCamelCase=4      ,    _UpperCamelCase=True      ,    _UpperCamelCase=16      ,    _UpperCamelCase=2      ,    _UpperCamelCase=4      ,    _UpperCamelCase=4      ,    _UpperCamelCase="gelu"      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=0.1      ,    _UpperCamelCase=[1, 2, 3, 4, 5]      ,    _UpperCamelCase=25      ,    _UpperCamelCase=5      ,    ):





      """simple docstring"""





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

      _lowercase      :				int      					=       context_length
      _lowercase      :				Optional[int]      					=       prediction_length + label_length
      _lowercase      :				Union[str, Any]      					=       label_length

      _lowercase      :				int      					=       moving_average
      _lowercase      :				Dict      					=       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      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				Optional[Any]      					=       config.context_length + max(config.lags_sequence  )

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

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

      _lowercase      :				Union[str, 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 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Dict      					=       self.get_config()
      _lowercase      :				Optional[Any]      					=       self.prepare_autoformer_inputs_dict(__snake_case  )
      return config, inputs_dict


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





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






   def 						_lowerCamelCase       (			self      ,    _UpperCamelCase      ,    _UpperCamelCase  ):





      """simple docstring"""





      _lowercase      :				str      					=       AutoformerModel(config=__snake_case  ).to(__snake_case  ).eval()
      _lowercase      :				Tuple      					=       model(**__snake_case  )

      _lowercase      :				List[str]      					=       outputs.encoder_last_hidden_state
      _lowercase      :				List[Any]      					=       outputs.last_hidden_state

      with tempfile.TemporaryDirectory() as tmpdirname:
         _lowercase      :				Union[str, Any]      					=       model.get_encoder()
         encoder.save_pretrained(__snake_case  )
         _lowercase      :				int      					=       AutoformerEncoder.from_pretrained(__snake_case  ).to(__snake_case  )

      _lowercase					,				_lowercase					,				_lowercase					,				_lowercase					,				_lowercase      :				List[str]      					=       model.create_network_inputs(**__snake_case  )
      _lowercase					,				_lowercase      :				Optional[int]      					=       model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]  )

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

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

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

      _lowercase      :				str      					=       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        a__  (							lowerCamelCase_  ,				lowerCamelCase_  ,				unittest.TestCase  ):
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE   :					Optional[Any]     	=							(AutoformerForPrediction,) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE   :					Dict     	=							{'''feature-extraction''': AutoformerModel} if is_torch_available() else {}
   _SCREAMING_SNAKE_CASE   :					Optional[Any]     	=							False
   _SCREAMING_SNAKE_CASE   :					Tuple     	=							False
   _SCREAMING_SNAKE_CASE   :					str     	=							False
   _SCREAMING_SNAKE_CASE   :					List[str]     	=							False
   _SCREAMING_SNAKE_CASE   :					Optional[Any]     	=							False
   _SCREAMING_SNAKE_CASE   :					List[Any]     	=							False


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Union[str, Any]      					=       AutoformerModelTester(self  )
      _lowercase      :				Union[str, Any]      					=       ConfigTester(self      ,    config_class=__snake_case      ,    has_text_modality=__snake_case  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      self.config_tester.run_common_tests()


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase					,				_lowercase      :				Tuple      					=       self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
         _lowercase      :				Optional[int]      					=       model_class(__snake_case  )

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


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Tuple      					=       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  ):





      """simple docstring"""





      pass


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				Union[str, Any]      					=       inspect.signature(getattr(__snake_case      ,    "forward"  )  )
      # The main input is the name of the argument after `self`
      _lowercase      :				List[str]      					=       list(model_signature.parameters.keys()  )[1]
      self.assertEqual(AutoformerModel.main_input_name      ,    __snake_case  )


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





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

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

         _lowercase      :				Optional[int]      					=       [
             "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  ):





      """simple docstring"""





      _lowercase					,				_lowercase      :				Tuple      					=       self.model_tester.prepare_config_and_inputs_for_common()
      _lowercase      :				Optional[int]      					=       True

      _lowercase      :				List[Any]      					=       getattr(self.model_tester      ,    "seq_length"      ,    __snake_case  )
      _lowercase      :				str      					=       getattr(self.model_tester      ,    "decoder_seq_length"      ,    __snake_case  )
      _lowercase      :				Any      					=       getattr(self.model_tester      ,    "encoder_seq_length"      ,    __snake_case  )
      _lowercase      :				Optional[int]      					=       getattr(self.model_tester      ,    "d_model"      ,    __snake_case  )
      _lowercase      :				Tuple      					=       getattr(self.model_tester      ,    "num_attention_heads"      ,    __snake_case  )
      _lowercase      :				Tuple      					=       d_model // num_attention_heads

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

         _lowercase      :				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(__snake_case      ,    __snake_case  )

         # decoder attentions
         _lowercase      :				Optional[int]      					=       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
         _lowercase      :				Optional[Any]      					=       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
      _lowercase      :				Dict      					=       True
      _lowercase      :				Union[str, Any]      					=       True
      _lowercase      :				str      					=       model_class(__snake_case  )
      model.to(__snake_case  )
      model.eval()
      with torch.no_grad():
         _lowercase      :				Union[str, Any]      					=       model(**self._prepare_for_class(__snake_case      ,    __snake_case  )  )

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

      _lowercase      :				List[str]      					=       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  ):





      """simple docstring"""





      super().test_retain_grad_hidden_states_attentions()







def  _A		(     snake_case="train-batch.pt"					)      ->     int:
   _lowercase      :				int      					=       hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"		,							filename=__lowerCAmelCase		,							repo_type="dataset"					)
   _lowercase      :				str      					=       torch.load(__lowerCAmelCase		,							map_location=__lowerCAmelCase					)
   return batch


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


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[str]      					=       AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"  ).to(__snake_case  )
      _lowercase      :				str      					=       prepare_batch()

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

      _lowercase      :				Union[str, Any]      					=       torch.Size(
          (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)  )
      self.assertEqual(output.shape      ,    __snake_case  )

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


   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





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

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






   def 						_lowerCamelCase       (			self  ):





      """simple docstring"""





      _lowercase      :				List[Any]      					=       AutoformerForPrediction.from_pretrained("huggingface/autoformer-tourism-monthly"  ).to(__snake_case  )
      _lowercase      :				Dict      					=       prepare_batch("val-batch.pt"  )
      with torch.no_grad():
         _lowercase      :				List[str]      					=       model.generate(
             static_categorical_features=batch["static_categorical_features"]      ,    past_time_features=batch["past_time_features"]      ,    past_values=batch["past_values"]      ,    future_time_features=batch["future_time_features"]      ,    past_observed_mask=batch["past_observed_mask"]      ,    )
      _lowercase      :				Dict      					=       torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)  )
      self.assertEqual(outputs.sequences.shape      ,    __snake_case  )

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






'''simple docstring'''
from timeit import timeit







def  _A		(     snake_case					)      ->     int:
   if number < 0:
      raise ValueError("the value of input must not be negative"					)
   _lowercase      :				Union[str, Any]      					=       0
   while number:
      number &= number - 1
      result += 1
   return result







def  _A		(     snake_case					)      ->     int:
   if number < 0:
      raise ValueError("the value of input must not be negative"					)
   _lowercase      :				int      					=       0
   while number:
      if number % 2 == 1:
         result += 1
      number >>= 1
   return result







def  _A		(     )      ->     None:

   def do_benchmark(snake_case					) -> None:
      _lowercase      :				Optional[int]      					=       "import __main__ as z"
      print(F'''Benchmark when {number = }:'''					)
      print(F'''{get_set_bits_count_using_modulo_operator(snake_case					) = }'''					)
      _lowercase      :				int      					=       timeit("z.get_set_bits_count_using_modulo_operator(25)"		,							setup=snake_case					)
      print(F'''timeit() runs in {timing} seconds'''					)
      print(F'''{get_set_bits_count_using_brian_kernighans_algorithm(snake_case					) = }'''					)
      _lowercase      :				Optional[int]      					=       timeit(
          "z.get_set_bits_count_using_brian_kernighans_algorithm(25)"		,							setup=snake_case		,							)
      print(F'''timeit() runs in {timing} seconds'''					)

   for number in (25, 37, 58, 0):
      do_benchmark(snake_case					)
      print()


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()






