

"""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 						__UpperCamelCase     :

  def __init__(		self     ,_A     ,_A=16     ,_A=13     ,_A=7     ,_A=14     ,_A=10     ,_A=19     ,_A=5     ,_A=4     ,_A=True     ,_A=16     ,_A=2     ,_A=4     ,_A=4     ,_A="gelu"     ,_A=0.1     ,_A=0.1     ,_A=[1, 2, 3, 4, 5]     ,_A=25     ,_A=5     ,):
      '''simple docstring'''

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

      _lowerCAmelCase							: Union[str, Any]	=     context_length
      _lowerCAmelCase							: Union[str, Any]	=     prediction_length + label_length
      _lowerCAmelCase							: str	=     label_length

      _lowerCAmelCase							: List[str]	=     moving_average
      _lowerCAmelCase							: Optional[int]	=     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     ,_A   ):
      '''simple docstring'''

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

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

      # decoder inputs
      _lowerCAmelCase							: Optional[Any]	=     floats_tensor([self.batch_size, config.prediction_length, config.num_time_features]   )
      _lowerCAmelCase							: Union[str, Any]	=     floats_tensor([self.batch_size, config.prediction_length]   )

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

      _lowerCAmelCase							: Optional[Any]	=     self.get_config()
      _lowerCAmelCase							: int	=     self.prepare_autoformer_inputs_dict(_A   )
      return config, inputs_dict

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase,       _lowerCAmelCase							: int	=     self.prepare_config_and_inputs()
      return config, inputs_dict







  def __lowerCamelCase		(		self     ,_A     ,_A   ):
      '''simple docstring'''

      _lowerCAmelCase							: List[Any]	=     AutoformerModel(config=_A   ).to(_A   ).eval()
      _lowerCAmelCase							: Dict	=     model(**_A   )

      _lowerCAmelCase							: Optional[Any]	=     outputs.encoder_last_hidden_state
      _lowerCAmelCase							: int	=     outputs.last_hidden_state

      with tempfile.TemporaryDirectory() as tmpdirname:
          _lowerCAmelCase							: List[str]	=     model.get_encoder()
          encoder.save_pretrained(_A   )
          _lowerCAmelCase							: Union[str, Any]	=     AutoformerEncoder.from_pretrained(_A   ).to(_A   )

      _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase,       _lowerCAmelCase							: Dict	=     model.create_network_inputs(**_A   )
      _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							: Union[str, Any]	=     encoder(inputs_embeds=_A   )[0]
      self.parent.assertTrue((encoder_last_hidden_state_a - encoder_last_hidden_state).abs().max().item() < 1E-3   )

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

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

      _lowerCAmelCase							: Optional[int]	=     decoder(
          trend=_A     ,inputs_embeds=_A     ,encoder_hidden_states=_A     ,)[0]

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







@require_torch
class 						__UpperCamelCase     (     __lowercase				,				__lowercase				,				unittest.TestCase    ):
  _UpperCAmelCase        =		(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
  _UpperCAmelCase        =		(AutoformerForPrediction,) if is_torch_available() else ()
  _UpperCAmelCase        =		{"feature-extraction": AutoformerModel} if is_torch_available() else {}
  _UpperCAmelCase        =		False
  _UpperCAmelCase        =		False
  _UpperCAmelCase        =		False
  _UpperCAmelCase        =		False
  _UpperCAmelCase        =		False
  _UpperCAmelCase        =		False

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase							: List[str]	=     AutoformerModelTester(self   )
      _lowerCAmelCase							: Union[str, Any]	=     ConfigTester(self     ,config_class=_A     ,has_text_modality=_A   )

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      self.config_tester.run_common_tests()

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase,       _lowerCAmelCase							: List[Any]	=     self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
          _lowerCAmelCase							: Tuple	=     model_class(_A   )

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

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase							: int	=     self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_encoder_decoder_model_standalone(*_A   )

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

      pass

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

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

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase,       _lowerCAmelCase							: Dict	=     self.model_tester.prepare_config_and_inputs_for_common()

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

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

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase,       _lowerCAmelCase							: List[str]	=     self.model_tester.prepare_config_and_inputs_for_common()
      _lowerCAmelCase							: List[str]	=     True

      _lowerCAmelCase							: List[str]	=     getattr(self.model_tester     ,'seq_length'     ,_A   )
      _lowerCAmelCase							: Optional[Any]	=     getattr(self.model_tester     ,'decoder_seq_length'     ,_A   )
      _lowerCAmelCase							: Tuple	=     getattr(self.model_tester     ,'encoder_seq_length'     ,_A   )
      _lowerCAmelCase							: List[str]	=     getattr(self.model_tester     ,'d_model'     ,_A   )
      _lowerCAmelCase							: List[Any]	=     getattr(self.model_tester     ,'num_attention_heads'     ,_A   )
      _lowerCAmelCase							: Dict	=     d_model // num_attention_heads

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

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

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

          _lowerCAmelCase							: 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(_A     ,_A   )

          # decoder attentions
          _lowerCAmelCase							: Dict	=     outputs.decoder_attentions
          self.assertIsInstance(_A     ,(list, tuple)   )
          self.assertEqual(len(_A   )     ,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							: Optional[int]	=     outputs.cross_attentions
          self.assertIsInstance(_A     ,(list, tuple)   )
          self.assertEqual(len(_A   )     ,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							: Optional[int]	=     True
      _lowerCAmelCase							: Union[str, Any]	=     True
      _lowerCAmelCase							: Union[str, Any]	=     model_class(_A   )
      model.to(_A   )
      model.eval()
      with torch.no_grad():
          _lowerCAmelCase							: Dict	=     model(**self._prepare_for_class(_A     ,_A   )   )

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

      _lowerCAmelCase							: Optional[int]	=     outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

      self.assertEqual(len(_A   )     ,self.model_tester.num_hidden_layers   )
      self.assertListEqual(
          list(self_attentions[0].shape[-3:]   )     ,[self.model_tester.num_attention_heads, encoder_seq_length, dim]     ,)







  @is_flaky()
  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      super().test_retain_grad_hidden_states_attentions()





def 		lowerCamelCase__		(       _lowerCamelCase="train-batch.pt" ):

    '''simple docstring'''



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







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

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

      _lowerCAmelCase							: str	=     AutoformerModel.from_pretrained('huggingface/autoformer-tourism-monthly'   ).to(_A   )
      _lowerCAmelCase							: int	=     prepare_batch()

      with torch.no_grad():
          _lowerCAmelCase							: List[str]	=     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							: Any	=     torch.Size(
          (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)   )
      self.assertEqual(output.shape     ,_A   )

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

  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

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

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







  def __lowerCamelCase		(		self   ):
      '''simple docstring'''

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

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







from __future__ import annotations


def 				__A(lowerCAmelCase    ,	lowerCAmelCase			)		->					list[list[int]]:

		"""simple docstring"""






		_UpperCamelCase         =						[]
		_UpperCamelCase         =						[]
		_UpperCamelCase         =						0
		_UpperCamelCase         =						sum(lowerCAmelCase			)
		create_state_space_tree(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase			)
		return result


def 				__A(lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	)		->					None:

		"""simple docstring"""






		if sum(lowerCAmelCase			) > max_sum or (remaining_nums_sum + sum(lowerCAmelCase			)) < max_sum:
				return
		if sum(lowerCAmelCase			) == max_sum:
				result.append(lowerCAmelCase			)
				return
		for index in range(lowerCAmelCase    ,	len(lowerCAmelCase			)			):
				create_state_space_tree(
				    lowerCAmelCase    ,	lowerCAmelCase    ,	index + 1    ,	[*path, nums[index]]    ,	lowerCAmelCase    ,	remaining_nums_sum - nums[index]    ,	)
lowerCamelCase__						=				[3, 34, 4, 12, 5, 2]
lowerCamelCase__						=				9
lowerCamelCase__						=				generate_sum_of_subsets_soln(nums, max_sum)







print(*result)



