

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




  """simple docstring"""




  def __init__(      self   :     Any					,lowercase__   :     Optional[Any]					,lowercase__   :     List[str]=1_6					,lowercase__   :     List[Any]=1_3					,lowercase__   :     str=7					,lowercase__   :     int=1_4					,lowercase__   :     Dict=1_0					,lowercase__   :     Any=1_9					,lowercase__   :     Optional[Any]=5					,lowercase__   :     Tuple=4					,lowercase__   :     int=True					,lowercase__   :     Any=1_6					,lowercase__   :     Tuple=2					,lowercase__   :     str=4					,lowercase__   :     str=4					,lowercase__   :     Dict="gelu"					,lowercase__   :     str=0.1					,lowercase__   :     Tuple=0.1					,lowercase__   :     List[Any]=[1, 2, 3, 4, 5]					,lowercase__   :     Optional[int]=2_5					,lowercase__   :     str=5					,):
   __lowercase							  = d_model
   __lowercase							  = parent
   __lowercase							  = batch_size
   __lowercase							  = prediction_length
   __lowercase							  = context_length
   __lowercase							  = cardinality
   __lowercase							  = num_time_features
   __lowercase							  = lags_sequence
   __lowercase							  = embedding_dimension
   __lowercase							  = is_training
   __lowercase							  = hidden_size
   __lowercase							  = num_hidden_layers
   __lowercase							  = num_attention_heads
   __lowercase							  = intermediate_size
   __lowercase							  = hidden_act
   __lowercase							  = hidden_dropout_prob
   __lowercase							  = attention_probs_dropout_prob

   __lowercase							  = context_length
   __lowercase							  = prediction_length + label_length
   __lowercase							  = label_length

   __lowercase							  = moving_average
   __lowercase							  = autocorrelation_factor






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   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   :     Dict					,lowercase__   :     List[str]			):
   __lowercase							  = config.context_length + max(config.lags_sequence			)

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

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

   __lowercase							  = {
       '''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   :     Optional[Any]			):
   __lowercase							  = self.get_config()
   __lowercase							  = self.prepare_autoformer_inputs_dict(lowercase__			)
   return config, inputs_dict






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]			):
   __lowercase  ,	__lowercase							  = self.prepare_config_and_inputs()
   return config, inputs_dict






  def 					SCREAMING_SNAKE_CASE      (      self   :     Any					,lowercase__   :     int					,lowercase__   :     Any			):
   __lowercase							  = AutoformerModel(config=lowercase__			).to(lowercase__			).eval()
   __lowercase							  = model(**lowercase__			)

   __lowercase							  = outputs.encoder_last_hidden_state
   __lowercase							  = outputs.last_hidden_state

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

   __lowercase  ,	__lowercase  ,	__lowercase  ,	__lowercase  ,	__lowercase							  = model.create_network_inputs(**lowercase__			)
   __lowercase  ,	__lowercase							  = model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]			)

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

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

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

   __lowercase							  = decoder(
       trend=lowercase__					,inputs_embeds=lowercase__					,encoder_hidden_states=lowercase__					,)[0]

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






@require_torch
class 			lowercase_	(lowerCamelCase__				,       lowerCamelCase__				,       unittest.TestCase      ):




  """simple docstring"""




  SCREAMING_SNAKE_CASE    :  Union[str, Any]							=			(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
  SCREAMING_SNAKE_CASE    :  Any							=			(AutoformerForPrediction,) if is_torch_available() else ()
  SCREAMING_SNAKE_CASE    :  List[Any]							=			{'feature-extraction': AutoformerModel} if is_torch_available() else {}
  SCREAMING_SNAKE_CASE    :  Union[str, Any]							=			False
  SCREAMING_SNAKE_CASE    :  int							=			False
  SCREAMING_SNAKE_CASE    :  str							=			False
  SCREAMING_SNAKE_CASE    :  Optional[int]							=			False
  SCREAMING_SNAKE_CASE    :  Optional[Any]							=			False
  SCREAMING_SNAKE_CASE    :  List[Any]							=			False






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase							  = AutoformerModelTester(self			)
   __lowercase							  = ConfigTester(self					,config_class=lowercase__					,has_text_modality=lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Tuple			):
   self.config_tester.run_common_tests()






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase  ,	__lowercase							  = self.model_tester.prepare_config_and_inputs()
   for model_class in self.all_model_classes:
    __lowercase							  = model_class(lowercase__			)

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






  def 					SCREAMING_SNAKE_CASE      (      self   :     Dict			):
   __lowercase							  = self.model_tester.prepare_config_and_inputs_for_common()
   self.model_tester.check_encoder_decoder_model_standalone(*lowercase__			)






  @unittest.skip(reason='''Model has no tokens embeddings'''			)
  def 					SCREAMING_SNAKE_CASE      (      self   :     List[str]			):
   pass






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






  def 					SCREAMING_SNAKE_CASE      (      self   :     List[Any]			):
   __lowercase  ,	__lowercase							  = self.model_tester.prepare_config_and_inputs_for_common()

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

    __lowercase							  = [
        '''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(lowercase__			)]					,lowercase__			)






  def 					SCREAMING_SNAKE_CASE      (      self   :     Optional[Any]			):
   __lowercase  ,	__lowercase							  = self.model_tester.prepare_config_and_inputs_for_common()
   __lowercase							  = True

   __lowercase							  = getattr(self.model_tester					,'''seq_length'''					,lowercase__			)
   __lowercase							  = getattr(self.model_tester					,'''decoder_seq_length'''					,lowercase__			)
   __lowercase							  = getattr(self.model_tester					,'''encoder_seq_length'''					,lowercase__			)
   __lowercase							  = getattr(self.model_tester					,'''d_model'''					,lowercase__			)
   __lowercase							  = getattr(self.model_tester					,'''num_attention_heads'''					,lowercase__			)
   __lowercase							  = d_model // num_attention_heads

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

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

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

    __lowercase							  = 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(lowercase__					,lowercase__			)

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

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

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

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


def 		_A     (    A__="train-batch.pt"      ):






 """simple docstring"""



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






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




  """simple docstring"""




  def 					SCREAMING_SNAKE_CASE      (      self   :     Any			):
   __lowercase							  = AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''			).to(lowercase__			)
   __lowercase							  = prepare_batch()

   with torch.no_grad():
    __lowercase							  = 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							  = torch.Size(
       (6_4, model.config.prediction_length + model.config.label_length, model.config.feature_size)			)
   self.assertEqual(output.shape					,lowercase__			)

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






  def 					SCREAMING_SNAKE_CASE      (      self   :     Union[str, Any]			):
   __lowercase							  = AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''			).to(lowercase__			)
   __lowercase							  = prepare_batch('''val-batch.pt'''			)
   with torch.no_grad():
    __lowercase							  = 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							  = torch.Size((6_4, model.config.context_length, model.config.d_model)			)
   self.assertEqual(output.shape					,lowercase__			)

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






  def 					SCREAMING_SNAKE_CASE      (      self   :     str			):
   __lowercase							  = AutoformerForPrediction.from_pretrained('''huggingface/autoformer-tourism-monthly'''			).to(lowercase__			)
   __lowercase							  = prepare_batch('''val-batch.pt'''			)
   with torch.no_grad():
    __lowercase							  = 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							  = torch.Size((6_4, model.config.num_parallel_samples, model.config.prediction_length)			)
   self.assertEqual(outputs.sequences.shape					,lowercase__			)

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




'''simple docstring'''






from __future__ import annotations


def 		_A     (    A__      ):






 """simple docstring"""



 __lowercase							  = len(A__      )
 # We need to create solution object to save path.
 __lowercase							  = [[0 for _ in range(A__      )] for _ in range(A__      )]
 __lowercase							  = run_maze(A__     ,				0     ,				0     ,				A__      )
 if solved:
  print('''\n'''.join(str(A__      ) for row in solutions      )      )
 else:
  print('''No solution exists!'''      )
 return solved


def 		_A     (    A__     ,				A__     ,				A__     ,				A__      ):






 """simple docstring"""



 __lowercase							  = len(A__      )
 # Final check point.
 if i == j == (size - 1):
  __lowercase							  = 1
  return True

 __lowercase							  = (not i < 0) and (not j < 0)  # Check lower bounds
 __lowercase							  = (i < size) and (j < size)  # Check upper bounds

 if lower_flag and upper_flag:
  # check for already visited and block points.
  __lowercase							  = (not solutions[i][j]) and (not maze[i][j])
  if block_flag:
   # check visited
   __lowercase							  = 1

   # check for directions
   if (
       run_maze(A__     ,				i + 1     ,				A__     ,				A__      )
       or run_maze(A__     ,				A__     ,				j + 1     ,				A__      )
       or run_maze(A__     ,				i - 1     ,				A__     ,				A__      )
       or run_maze(A__     ,				A__     ,				j - 1     ,				A__      )
   ):
    return True

   __lowercase							  = 0
   return False
 return False


if __name__ == "__main__":
 import doctest

 doctest.testmod()

