


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


__UpperCamelCase       :       Dict						       =				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       __magic_name__	:


     def __init__(      self							:     Union[str, Any]							,	lowerCamelCase__							:     List[str]							,	lowerCamelCase__							:     List[str]=16							,	lowerCamelCase__							:     Dict=13							,	lowerCamelCase__							:     int=7							,	lowerCamelCase__							:     Optional[Any]=14							,	lowerCamelCase__							:     Optional[int]=10							,	lowerCamelCase__							:     List[Any]=19							,	lowerCamelCase__							:     List[str]=5							,	lowerCamelCase__							:     int=4							,	lowerCamelCase__							:     List[Any]=True							,	lowerCamelCase__							:     Optional[int]=16							,	lowerCamelCase__							:     str=2							,	lowerCamelCase__							:     Union[str, Any]=4							,	lowerCamelCase__							:     Optional[int]=4							,	lowerCamelCase__							:     List[Any]="gelu"							,	lowerCamelCase__							:     str=0.1							,	lowerCamelCase__							:     int=0.1							,	lowerCamelCase__							:     List[str]=[1, 2, 3, 4, 5]							,	lowerCamelCase__							:     Optional[Any]=25							,	lowerCamelCase__							:     Union[str, Any]=5							,	)  ->      List[Any]:





      '''simple docstring'''






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

      UpperCamelCase__					:    Any          =   context_length
      UpperCamelCase__					:    int          =   prediction_length + label_length
      UpperCamelCase__					:    Tuple          =   label_length

      UpperCamelCase__					:    str          =   moving_average
      UpperCamelCase__					:    Optional[int]          =   autocorrelation_factor


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      Any:





      '''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      UpperCAmelCase__	(      self							:     str							,	lowerCamelCase__							:     Optional[Any]			)  ->      int:





      '''simple docstring'''






      UpperCamelCase__					:    Optional[int]          =   config.context_length + max(config.lags_sequence			)

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

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

      UpperCamelCase__					:    Dict          =   {
          """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							:     List[str]			)  ->      Optional[int]:





      '''simple docstring'''






      UpperCamelCase__					:    int          =   self.get_config()
      UpperCamelCase__					:    List[Any]          =   self.prepare_autoformer_inputs_dict(_lowercase			)
      return config, inputs_dict


     def      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      Dict:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   self.prepare_config_and_inputs()
      return config, inputs_dict


     def      UpperCAmelCase__	(      self							:     int							,	lowerCamelCase__							:     Union[str, Any]							,	lowerCamelCase__							:     List[Any]			)  ->      List[Any]:





      '''simple docstring'''






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

      UpperCamelCase__					:    str          =   outputs.encoder_last_hidden_state
      UpperCamelCase__					:    Union[str, Any]          =   outputs.last_hidden_state

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

      UpperCamelCase__					:    Optional[Any]          =   model.create_network_inputs(**_lowercase			)
      UpperCamelCase__					:    int          =   model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]			)

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

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

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

      UpperCamelCase__					:    int          =   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       __magic_name__	(     __snake_case					,				__snake_case					,				unittest.TestCase):
     A:		int			=      (AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
     A:		str			=      (AutoformerForPrediction,) if is_torch_available() else ()
     A:		str			=      {"feature-extraction": AutoformerModel} if is_torch_available() else {}
     A:		Tuple			=      False
     A:		List[str]			=      False
     A:		Any			=      False
     A:		Optional[Any]			=      False
     A:		Optional[Any]			=      False
     A:		Optional[int]			=      False


     def      UpperCAmelCase__	(      self							:     Any			)  ->      Optional[Any]:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   AutoformerModelTester(self			)
      UpperCamelCase__					:    Dict          =   ConfigTester(self							,	config_class=_lowercase							,	has_text_modality=_lowercase			)


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      List[Any]:





      '''simple docstring'''






      self.config_tester.run_common_tests()


     def      UpperCAmelCase__	(      self							:     Tuple			)  ->      str:





      '''simple docstring'''






      UpperCamelCase__					:    List[str]          =   self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
       UpperCamelCase__					:    Optional[Any]          =   model_class(_lowercase			)

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


     def      UpperCAmelCase__	(      self							:     List[Any]			)  ->      List[str]:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   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      UpperCAmelCase__	(      self							:     int			)  ->      Dict:





      '''simple docstring'''






      pass


     def      UpperCAmelCase__	(      self							:     str			)  ->      Union[str, Any]:





      '''simple docstring'''






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


     def      UpperCAmelCase__	(      self							:     Optional[int]			)  ->      Optional[int]:





      '''simple docstring'''






      UpperCamelCase__					:    Optional[int]          =   self.model_tester.prepare_config_and_inputs_for_common()

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

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


     def      UpperCAmelCase__	(      self							:     Tuple			)  ->      int:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   self.model_tester.prepare_config_and_inputs_for_common()
      UpperCamelCase__					:    Optional[Any]          =   True

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

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

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

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

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

      UpperCamelCase__					:    Optional[int]          =   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      UpperCAmelCase__	(      self							:     Union[str, Any]			)  ->      str:





      '''simple docstring'''






      super().test_retain_grad_hidden_states_attentions()



def 			_a  (				SCREAMING_SNAKE_CASE	:				Tuple="train-batch.pt"     ):







 """simple docstring"""



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






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


     def      UpperCAmelCase__	(      self							:     int			)  ->      Any:





      '''simple docstring'''






      UpperCamelCase__					:    Dict          =   AutoformerModel.from_pretrained('''huggingface/autoformer-tourism-monthly'''			).to(_lowercase			)
      UpperCamelCase__					:    int          =   prepare_batch()

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

      UpperCamelCase__					:    Optional[int]          =   torch.Size(
          (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)			)
      self.assertEqual(output.shape							,	_lowercase			)

      UpperCamelCase__					:    Any          =   torch.tensor(
          [[0.3593, -1.3398, 0.6330], [0.2279, 1.5396, -0.1792], [0.0450, 1.3225, -0.2335]]							,	device=_lowercase			)
      self.assertTrue(torch.allclose(output[0, :3, :3]							,	_lowercase							,	atol=_lowercase			)			)


     def      UpperCAmelCase__	(      self							:     Optional[int]			)  ->      Tuple:





      '''simple docstring'''






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

      UpperCamelCase__					:    str          =   torch.tensor(
          [[-0.0734, -0.9036, 0.8358], [4.7186, 2.4113, 1.9581], [1.7953, 2.3558, 1.2970]]							,	device=_lowercase			)
      self.assertTrue(torch.allclose(output[0, :3, :3]							,	_lowercase							,	atol=_lowercase			)			)


     def      UpperCAmelCase__	(      self							:     Optional[int]			)  ->      Dict:





      '''simple docstring'''






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

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






import functools

def 			_a  (				SCREAMING_SNAKE_CASE	:				str    , SCREAMING_SNAKE_CASE	:				str     ):







 """simple docstring"""



 UpperCamelCase__					:    str          =   len(SCREAMING_SNAKE_CASE     )
 UpperCamelCase__					:    Optional[Any]          =   len(SCREAMING_SNAKE_CASE     )

 @functools.cache
 def min_distance(SCREAMING_SNAKE_CASE	:				int    , SCREAMING_SNAKE_CASE	:				int     ) -> int:
  # if first word index is overflow - delete all from the second word
  if indexa >= len_worda:
   return len_worda - indexa
  # if second word index is overflow - delete all from the first word
  if indexa >= len_worda:
   return len_worda - indexa
  UpperCamelCase__					:    Tuple          =   int(worda[indexa] != worda[indexa]     )  # current letters not identical
  return min(
      1 + min_distance(indexa + 1    , SCREAMING_SNAKE_CASE     )    , 1 + min_distance(SCREAMING_SNAKE_CASE    , indexa + 1     )    , diff + min_distance(indexa + 1    , indexa + 1     )    , )

 return min_distance(0    , 0     )


if __name__ == "__main__":
       import doctest

       doctest.testmod()


