


'''simple docstring'''






import inspect
import tempfile
import unittest

from huggingface_hub import hf_hub_download

from transformers import is_torch_available
from transformers.testing_utils import is_flaky, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


a_   :      int				    =      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 ,			__magic_name__ ,			__magic_name__=16 ,			__magic_name__=13 ,			__magic_name__=7 ,			__magic_name__=14 ,			__magic_name__=10 ,			__magic_name__=19 ,			__magic_name__=5 ,			__magic_name__=4 ,			__magic_name__=True ,			__magic_name__=16 ,			__magic_name__=2 ,			__magic_name__=4 ,			__magic_name__=4 ,			__magic_name__="gelu" ,			__magic_name__=0.1 ,			__magic_name__=0.1 ,			__magic_name__=[1, 2, 3, 4, 5] ,			__magic_name__=25 ,			__magic_name__=5 ,			)   ->							List[str]:
      _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 							__UpperCAmelCase						(	self  )   ->							Optional[int]:
      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 							__UpperCAmelCase						(	self ,			__magic_name__  )   ->							Tuple:
      _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 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a      =							self.get_config()
      _a      =							self.prepare_autoformer_inputs_dict(__magic_name__  )
      return config, inputs_dict
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a ,				_a      =							self.prepare_config_and_inputs()
      return config, inputs_dict




 def 							__UpperCAmelCase						(	self ,			__magic_name__ ,			__magic_name__  )   ->							int:
      _a      =							AutoformerModel(config=__magic_name__  ).to(__magic_name__  ).eval()
      _a      =							model(**__magic_name__  )

      _a      =							outputs.encoder_last_hidden_state
      _a      =							outputs.last_hidden_state

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

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

      _a      =							decoder(
          trend=__magic_name__ ,			inputs_embeds=__magic_name__ ,			encoder_hidden_states=__magic_name__ ,			)[0]

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





@require_torch
class 	a       (       _SCREAMING_SNAKE_CASE					,			_SCREAMING_SNAKE_CASE					,			unittest.TestCase    ):
 _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 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							AutoformerModelTester(self  )
      _a      =							ConfigTester(self ,			config_class=__magic_name__ ,			has_text_modality=__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      self.config_tester.run_common_tests()
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _a ,				_a      =							self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
           _a      =							model_class(__magic_name__  )

           with tempfile.TemporaryDirectory() as tmpdirname:
                model.save_pretrained(__magic_name__  )
                _a ,				_a      =							model_class.from_pretrained(__magic_name__ ,			output_loading_info=__magic_name__  )
           self.assertEqual(info['missing_keys'] ,			[]  )
 def 							__UpperCAmelCase						(	self  )   ->							List[Any]:
      _a      =							self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_encoder_decoder_model_standalone(*__magic_name__  )
 @unittest.skip(reason='Model has no tokens embeddings'  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      pass
 def 							__UpperCAmelCase						(	self  )   ->							Optional[Any]:
      _a      =							inspect.signature(getattr(__magic_name__ ,			'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 ,			__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a ,				_a      =							self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _a      =							model_class(__magic_name__  )
           _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(__magic_name__  )] ,			__magic_name__  )
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a ,				_a      =							self.model_tester.prepare_config_and_inputs_for_common()
      _a      =							True

      _a      =							getattr(self.model_tester ,			'seq_length' ,			__magic_name__  )
      _a      =							getattr(self.model_tester ,			'decoder_seq_length' ,			__magic_name__  )
      _a      =							getattr(self.model_tester ,			'encoder_seq_length' ,			__magic_name__  )
      _a      =							getattr(self.model_tester ,			'd_model' ,			__magic_name__  )
      _a      =							getattr(self.model_tester ,			'num_attention_heads' ,			__magic_name__  )
      _a      =							d_model // num_attention_heads

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

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

           _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(__magic_name__ ,			__magic_name__  )

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

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

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

      self.assertEqual(len(__magic_name__  ) ,			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 							__UpperCAmelCase						(	self  )   ->							Union[str, Any]:
      super().test_retain_grad_hidden_states_attentions()






def 		_A			(lowerCAmelCase__					:Optional[Any]="train-batch.pt"						)				->					Tuple:




     '''simple docstring'''



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






@require_torch
@slow
class 	a       (       unittest.TestCase    ):
 def 							__UpperCAmelCase						(	self  )   ->							Dict:
      _a      =							AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'  ).to(__magic_name__  )
      _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 ,			__magic_name__  )

      _a      =							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=__magic_name__  )
      self.assertTrue(torch.allclose(output[0, :3, :3] ,			__magic_name__ ,			atol=__magic_name__  )  )
 def 							__UpperCAmelCase						(	self  )   ->							List[str]:
      _a      =							AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'  ).to(__magic_name__  )
      _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 ,			__magic_name__  )

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




 def 							__UpperCAmelCase						(	self  )   ->							str:
      _a      =							AutoformerForPrediction.from_pretrained('huggingface/autoformer-tourism-monthly'  ).to(__magic_name__  )
      _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 ,			__magic_name__  )

      _a      =							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=__magic_name__  )
      _a      =							outputs.sequences.mean(dim=1  )
      self.assertTrue(torch.allclose(mean_prediction[0, -3:] ,			__magic_name__ ,			rtol=1e-1  )  )





'''simple docstring'''






from timeit import timeit






def 		_A			(lowerCAmelCase__					:int						)				->					int:




     '''simple docstring'''



     if number < 0:
          raise ValueError('the value of input must not be negative'						)
     _a      =							0
     while number:
          number &= number - 1
          result += 1
     return result






def 		_A			(lowerCAmelCase__					:int						)				->					int:




     '''simple docstring'''



     if number < 0:
          raise ValueError('the value of input must not be negative'						)
     _a      =							0
     while number:
          if number % 2 == 1:
               result += 1
          number >>= 1
     return result






def 		_A			()				->					None:




     '''simple docstring'''



     def do_benchmark(lowerCAmelCase__					:int						) -> None:
          _a      =							'import __main__ as z'
          print(f'Benchmark when {number = }:'						)
          print(f'{get_set_bits_count_using_modulo_operator(lowerCAmelCase__						) = }'						)
          _a      =							timeit('z.get_set_bits_count_using_modulo_operator(25)'			,  setup=lowerCAmelCase__						)
          print(f'timeit() runs in {timing} seconds'						)
          print(f'{get_set_bits_count_using_brian_kernighans_algorithm(lowerCAmelCase__						) = }'						)
          _a      =							timeit(
              'z.get_set_bits_count_using_brian_kernighans_algorithm(25)'			,  setup=lowerCAmelCase__			,  )
          print(f'timeit() runs in {timing} seconds'						)

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


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 benchmark()

