



'''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											=		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    lowerCamelCase_       :
  """simple docstring"""




  def __init__(					self :      Dict     ,      _a :      Dict     ,      _a :      int=16     ,      _a :      List[str]=13     ,      _a :      int=7     ,      _a :      int=14     ,      _a :      Union[str, Any]=10     ,      _a :      str=19     ,      _a :      int=5     ,      _a :      List[Any]=4     ,      _a :      int=True     ,      _a :      List[str]=16     ,      _a :      int=2     ,      _a :      Union[str, Any]=4     ,      _a :      Union[str, Any]=4     ,      _a :      Optional[Any]="gelu"     ,      _a :      Optional[Any]=0.1     ,      _a :      str=0.1     ,      _a :      Union[str, Any]=[1, 2, 3, 4, 5]     ,      _a :      Union[str, Any]=25     ,      _a :      Optional[int]=5     ,      )   ->   str:
    __lowerCamelCase			:			Union[str, Any]       			=					d_model
    __lowerCamelCase			:			List[str]       			=					parent
    __lowerCamelCase			:			Dict       			=					batch_size
    __lowerCamelCase			:			Union[str, Any]       			=					prediction_length
    __lowerCamelCase			:			Union[str, Any]       			=					context_length
    __lowerCamelCase			:			List[str]       			=					cardinality
    __lowerCamelCase			:			int       			=					num_time_features
    __lowerCamelCase			:			Any       			=					lags_sequence
    __lowerCamelCase			:			List[str]       			=					embedding_dimension
    __lowerCamelCase			:			Optional[Any]       			=					is_training
    __lowerCamelCase			:			Optional[Any]       			=					hidden_size
    __lowerCamelCase			:			Dict       			=					num_hidden_layers
    __lowerCamelCase			:			str       			=					num_attention_heads
    __lowerCamelCase			:			List[str]       			=					intermediate_size
    __lowerCamelCase			:			List[Any]       			=					hidden_act
    __lowerCamelCase			:			Dict       			=					hidden_dropout_prob
    __lowerCamelCase			:			str       			=					attention_probs_dropout_prob

    __lowerCamelCase			:			Tuple       			=					context_length
    __lowerCamelCase			:			int       			=					prediction_length + label_length
    __lowerCamelCase			:			List[str]       			=					label_length

    __lowerCamelCase			:			Union[str, Any]       			=					moving_average
    __lowerCamelCase			:			int       			=					autocorrelation_factor




  def 		_lowercase	(					self :      List[Any]  )   ->   Dict:
    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 		_lowercase	(					self :      Any     ,      _a :      str  )   ->   Optional[Any]:
    __lowerCamelCase			:			Union[str, Any]       			=					config.context_length + max(config.lags_sequence  )

    __lowerCamelCase			:			Tuple       			=					ids_tensor([self.batch_size, 1]     ,      config.cardinality[0]  )
    __lowerCamelCase			:			Optional[int]       			=					floats_tensor([self.batch_size, _past_length, config.num_time_features]  )
    __lowerCamelCase			:			Optional[Any]       			=					floats_tensor([self.batch_size, _past_length]  )
    __lowerCamelCase			:			Tuple       			=					floats_tensor([self.batch_size, _past_length]  ) > 0.5

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

    __lowerCamelCase			:			Optional[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 		_lowercase	(					self :      Optional[Any]  )   ->   Optional[Any]:
    __lowerCamelCase			:			List[str]       			=					self.get_config()
    __lowerCamelCase			:			Union[str, Any]       			=					self.prepare_autoformer_inputs_dict(_a  )
    return config, inputs_dict




  def 		_lowercase	(					self :      Tuple  )   ->   List[Any]:
    __lowerCamelCase			,__lowerCamelCase			:			Dict       			=					self.prepare_config_and_inputs()
    return config, inputs_dict




  def 		_lowercase	(					self :      List[str]     ,      _a :      Union[str, Any]     ,      _a :      Optional[Any]  )   ->   Union[str, Any]:
    __lowerCamelCase			:			Dict       			=					AutoformerModel(config=_a  ).to(_a  ).eval()
    __lowerCamelCase			:			str       			=					model(**_a  )

    __lowerCamelCase			:			Optional[Any]       			=					outputs.encoder_last_hidden_state
    __lowerCamelCase			:			Optional[Any]       			=					outputs.last_hidden_state

    with tempfile.TemporaryDirectory() as tmpdirname:
      __lowerCamelCase			:			List[str]       			=					model.get_encoder()
      encoder.save_pretrained(_a  )
      __lowerCamelCase			:			str       			=					AutoformerEncoder.from_pretrained(_a  ).to(_a  )

    __lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			:			Tuple       			=					model.create_network_inputs(**_a  )
    __lowerCamelCase			,__lowerCamelCase			:			str       			=					model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]  )

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

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

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

    __lowerCamelCase			:			Optional[Any]       			=					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    lowerCamelCase_       (							SCREAMING_SNAKE_CASE_  ,  SCREAMING_SNAKE_CASE_  ,  unittest.TestCase	):
  """simple docstring"""




  a_				   =(AutoformerModel, AutoformerForPrediction) if is_torch_available() else ()
  a_				   =(AutoformerForPrediction,) if is_torch_available() else ()
  a_				   ={"""feature-extraction""": AutoformerModel} if is_torch_available() else {}
  a_				   =False
  a_				   =False
  a_				   =False
  a_				   =False
  a_				   =False
  a_				   =False




  def 		_lowercase	(					self :      Optional[int]  )   ->   Dict:
    __lowerCamelCase			:			str       			=					AutoformerModelTester(self  )
    __lowerCamelCase			:			Dict       			=					ConfigTester(self     ,      config_class=_a     ,      has_text_modality=_a  )




  def 		_lowercase	(					self :      Optional[Any]  )   ->   List[str]:
    self.config_tester.run_common_tests()




  def 		_lowercase	(					self :      str  )   ->   Optional[Any]:
    __lowerCamelCase			,__lowerCamelCase			:			Optional[Any]       			=					self.model_tester.prepare_config_and_inputs()
    for model_class in self.all_model_classes:
      __lowerCamelCase			:			str       			=					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 		_lowercase	(					self :      str  )   ->   Dict:
    __lowerCamelCase			:			Optional[Any]       			=					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 		_lowercase	(					self :      int  )   ->   List[Any]:
    pass




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




  def 		_lowercase	(					self :      List[str]  )   ->   Any:
    __lowerCamelCase			,__lowerCamelCase			:			List[Any]       			=					self.model_tester.prepare_config_and_inputs_for_common()

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

      __lowerCamelCase			:			List[Any]       			=					[
          '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 		_lowercase	(					self :      Dict  )   ->   List[Any]:
    __lowerCamelCase			,__lowerCamelCase			:			Dict       			=					self.model_tester.prepare_config_and_inputs_for_common()
    __lowerCamelCase			:			Tuple       			=					True

    __lowerCamelCase			:			List[str]       			=					getattr(self.model_tester     ,      'seq_length'     ,      _a  )
    __lowerCamelCase			:			Any       			=					getattr(self.model_tester     ,      'decoder_seq_length'     ,      _a  )
    __lowerCamelCase			:			List[str]       			=					getattr(self.model_tester     ,      'encoder_seq_length'     ,      _a  )
    __lowerCamelCase			:			Optional[Any]       			=					getattr(self.model_tester     ,      'd_model'     ,      _a  )
    __lowerCamelCase			:			str       			=					getattr(self.model_tester     ,      'num_attention_heads'     ,      _a  )
    __lowerCamelCase			:			Optional[Any]       			=					d_model // num_attention_heads

    for model_class in self.all_model_classes:
      __lowerCamelCase			:			Dict       			=					True
      __lowerCamelCase			:			Any       			=					False
      __lowerCamelCase			:			List[str]       			=					True
      __lowerCamelCase			:			Dict       			=					model_class(_a  )
      model.to(_a  )
      model.eval()
      with torch.no_grad():
        __lowerCamelCase			:			Dict       			=					model(**self._prepare_for_class(_a     ,      _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  )

      # check that output_attentions also work using config
      del inputs_dict["output_attentions"]
      __lowerCamelCase			:			List[Any]       			=					True
      __lowerCamelCase			:			int       			=					model_class(_a  )
      model.to(_a  )
      model.eval()
      with torch.no_grad():
        __lowerCamelCase			:			Tuple       			=					model(**self._prepare_for_class(_a     ,      _a  )  )
      __lowerCamelCase			:			Optional[Any]       			=					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			:			str       			=					len(_a  )

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

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

    __lowerCamelCase			:			List[Any]       			=					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 		_lowercase	(					self :      int  )   ->   Tuple:
    super().test_retain_grad_hidden_states_attentions()




def 			a_	(				_lowerCAmelCase="train-batch.pt"			) -> List[Any]:
  __lowerCamelCase			:			Optional[int]       			=					hf_hub_download(repo_id='hf-internal-testing/tourism-monthly-batch'			,filename=_lowerCAmelCase			,repo_type='dataset'			)
  __lowerCamelCase			:			int       			=					torch.load(_lowerCAmelCase			,map_location=_lowerCAmelCase			)
  return batch






@require_torch
@slow
class    lowerCamelCase_       (							unittest.TestCase	):
  """simple docstring"""




  def 		_lowercase	(					self :      Optional[int]  )   ->   List[str]:
    __lowerCamelCase			:			Any       			=					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			:			Union[str, Any]       			=					torch.Size(
        (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)  )
    self.assertEqual(output.shape     ,      _a  )

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




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

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




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

    __lowerCamelCase			:			str       			=					torch.tensor([3130.6763, 4056.5293, 7053.0786]     ,      device=_a  )
    __lowerCamelCase			:			Optional[int]       			=					outputs.sequences.mean(dim=1  )
    self.assertTrue(torch.allclose(mean_prediction[0, -3:]     ,      _a     ,      rtol=1e-1  )  )











'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCamelCase											=		{'configuration_ibert': ['IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'IBertConfig', 'IBertOnnxConfig']}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   _UpperCamelCase											=		[
       'IBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'IBertForMaskedLM',
       'IBertForMultipleChoice',
       'IBertForQuestionAnswering',
       'IBertForSequenceClassification',
       'IBertForTokenClassification',
       'IBertModel',
       'IBertPreTrainedModel',
   ]

if TYPE_CHECKING:
   from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_ibert import (
          IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
          IBertForMaskedLM,
          IBertForMultipleChoice,
          IBertForQuestionAnswering,
          IBertForSequenceClassification,
          IBertForTokenClassification,
          IBertModel,
          IBertPreTrainedModel,
      )

else:
   import sys

   _UpperCamelCase											=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






