


'''simple docstring'''






import inspect
import unittest

from transformers import MobileViTConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
  import torch

  from transformers import MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
  from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import MobileViTImageProcessor






class   __snake_case			(  _SCREAMING_SNAKE_CASE):







    """simple docstring"""



    def __lowercase  (  self       :    str						)  ->    str:
      lowerCAmelCase_     : List[str]     =  self.config_class(**self.inputs_dict						)
      self.parent.assertTrue(hasattr(lowerCamelCase       ,		"""hidden_sizes"""						)						)
      self.parent.assertTrue(hasattr(lowerCamelCase       ,		"""neck_hidden_sizes"""						)						)
      self.parent.assertTrue(hasattr(lowerCamelCase       ,		"""num_attention_heads"""						)						)







class   __snake_case			:







    """simple docstring"""



    def __init__(  self       :    Tuple       ,		lowerCamelCase       :    Optional[Any]       ,		lowerCamelCase       :    int=13       ,		lowerCamelCase       :    Optional[Any]=32       ,		lowerCamelCase       :    List[str]=2       ,		lowerCamelCase       :    Tuple=3       ,		lowerCamelCase       :    Union[str, Any]=6_40       ,		lowerCamelCase       :    List[str]=4       ,		lowerCamelCase       :    Tuple="silu"       ,		lowerCamelCase       :    int=3       ,		lowerCamelCase       :    Any=32       ,		lowerCamelCase       :    str=0.1       ,		lowerCamelCase       :    Union[str, Any]=0.1       ,		lowerCamelCase       :    Optional[Any]=0.1       ,		lowerCamelCase       :    List[str]=0.02       ,		lowerCamelCase       :    Any=True       ,		lowerCamelCase       :    Optional[int]=True       ,		lowerCamelCase       :    Any=10       ,		lowerCamelCase       :    List[Any]=None       ,		)  ->    Any:
      lowerCAmelCase_     : int     =  parent
      lowerCAmelCase_     : Optional[Any]     =  batch_size
      lowerCAmelCase_     : Union[str, Any]     =  image_size
      lowerCAmelCase_     : Tuple     =  patch_size
      lowerCAmelCase_     : str     =  num_channels
      lowerCAmelCase_     : int     =  last_hidden_size
      lowerCAmelCase_     : Optional[int]     =  num_attention_heads
      lowerCAmelCase_     : Union[str, Any]     =  hidden_act
      lowerCAmelCase_     : str     =  conv_kernel_size
      lowerCAmelCase_     : Dict     =  output_stride
      lowerCAmelCase_     : Union[str, Any]     =  hidden_dropout_prob
      lowerCAmelCase_     : List[Any]     =  attention_probs_dropout_prob
      lowerCAmelCase_     : int     =  classifier_dropout_prob
      lowerCAmelCase_     : Tuple     =  use_labels
      lowerCAmelCase_     : Optional[Any]     =  is_training
      lowerCAmelCase_     : Union[str, Any]     =  num_labels
      lowerCAmelCase_     : Optional[Any]     =  initializer_range
      lowerCAmelCase_     : Any     =  scope

    def __lowercase  (  self       :    int						)  ->    Dict:
      lowerCAmelCase_     : Any     =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

      lowerCAmelCase_     : List[Any]     =  None
      lowerCAmelCase_     : str     =  None
      if self.use_labels:
        lowerCAmelCase_     : List[Any]     =  ids_tensor([self.batch_size]       ,		self.num_labels						)
        lowerCAmelCase_     : Union[str, Any]     =  ids_tensor([self.batch_size, self.image_size, self.image_size]       ,		self.num_labels						)

      lowerCAmelCase_     : Union[str, Any]     =  self.get_config()

      return config, pixel_values, labels, pixel_labels

    def __lowercase  (  self       :    Union[str, Any]						)  ->    Any:
      return MobileViTConfig(
          image_size=self.image_size       ,		patch_size=self.patch_size       ,		num_channels=self.num_channels       ,		num_attention_heads=self.num_attention_heads       ,		hidden_act=self.hidden_act       ,		conv_kernel_size=self.conv_kernel_size       ,		output_stride=self.output_stride       ,		hidden_dropout_prob=self.hidden_dropout_prob       ,		attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,		classifier_dropout_prob=self.classifier_dropout_prob       ,		initializer_range=self.initializer_range       ,		)

    def __lowercase  (  self       :    List[str]       ,		lowerCamelCase       :    Any       ,		lowerCamelCase       :    Dict       ,		lowerCamelCase       :    Union[str, Any]       ,		lowerCamelCase       :    Optional[Any]						)  ->    Optional[Any]:
      lowerCAmelCase_     : Tuple     =  MobileViTModel(config=lowerCamelCase						)
      model.to(lowerCamelCase						)
      model.eval()
      lowerCAmelCase_     : Union[str, Any]     =  model(lowerCamelCase						)
      self.parent.assertEqual(
          result.last_hidden_state.shape       ,		(
              self.batch_size,
              self.last_hidden_size,
              self.image_size // self.output_stride,
              self.image_size // self.output_stride,
          )       ,		)

    def __lowercase  (  self       :    Optional[Any]       ,		lowerCamelCase       :    List[str]       ,		lowerCamelCase       :    Optional[Any]       ,		lowerCamelCase       :    Dict       ,		lowerCamelCase       :    Union[str, Any]						)  ->    Tuple:
      lowerCAmelCase_     : Tuple     =  self.num_labels
      lowerCAmelCase_     : List[str]     =  MobileViTForImageClassification(lowerCamelCase						)
      model.to(lowerCamelCase						)
      model.eval()
      lowerCAmelCase_     : Dict     =  model(lowerCamelCase       ,		labels=lowerCamelCase						)
      self.parent.assertEqual(result.logits.shape       ,		(self.batch_size, self.num_labels)						)

    def __lowercase  (  self       :    Union[str, Any]       ,		lowerCamelCase       :    Optional[Any]       ,		lowerCamelCase       :    Optional[Any]       ,		lowerCamelCase       :    Union[str, Any]       ,		lowerCamelCase       :    List[str]						)  ->    Union[str, Any]:
      lowerCAmelCase_     : str     =  self.num_labels
      lowerCAmelCase_     : Tuple     =  MobileViTForSemanticSegmentation(lowerCamelCase						)
      model.to(lowerCamelCase						)
      model.eval()
      lowerCAmelCase_     : Optional[Any]     =  model(lowerCamelCase						)
      self.parent.assertEqual(
          result.logits.shape       ,		(
              self.batch_size,
              self.num_labels,
              self.image_size // self.output_stride,
              self.image_size // self.output_stride,
          )       ,		)
      lowerCAmelCase_     : Union[str, Any]     =  model(lowerCamelCase       ,		labels=lowerCamelCase						)
      self.parent.assertEqual(
          result.logits.shape       ,		(
              self.batch_size,
              self.num_labels,
              self.image_size // self.output_stride,
              self.image_size // self.output_stride,
          )       ,		)





    def __lowercase  (  self       :    Optional[Any]						)  ->    Tuple:
      lowerCAmelCase_     : List[Any]     =  self.prepare_config_and_inputs()
      lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_     : Optional[Any]     =  config_and_inputs
      lowerCAmelCase_     : List[Any]     =  {"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_torch
class   __snake_case			(  _SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE      ,unittest.TestCase):







    """simple docstring"""



    lowercase  					=   (
        (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
        if is_torch_available()
        else ()
    )
    lowercase  					=   (
        {
            'feature-extraction': MobileViTModel,
            'image-classification': MobileViTForImageClassification,
            'image-segmentation': MobileViTForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    lowercase  					=   False
    lowercase  					=   False
    lowercase  					=   False
    lowercase  					=   False

    def __lowercase  (  self       :    List[Any]						)  ->    Optional[Any]:
      lowerCAmelCase_     : Dict     =  MobileViTModelTester(self						)
      lowerCAmelCase_     : List[Any]     =  MobileViTConfigTester(self       ,		config_class=lowerCamelCase       ,		has_text_modality=lowerCamelCase						)

    def __lowercase  (  self       :    Union[str, Any]						)  ->    int:
      self.config_tester.run_common_tests()

    @unittest.skip(reason="""MobileViT does not use inputs_embeds"""						)
    def __lowercase  (  self       :    Dict						)  ->    Dict:
      pass

    @unittest.skip(reason="""MobileViT does not support input and output embeddings"""						)
    def __lowercase  (  self       :    Dict						)  ->    int:
      pass

    @unittest.skip(reason="""MobileViT does not output attentions"""						)
    def __lowercase  (  self       :    List[Any]						)  ->    Optional[int]:
      pass

    def __lowercase  (  self       :    Optional[int]						)  ->    Tuple:
      lowerCAmelCase_,				lowerCAmelCase_     : List[Any]     =  self.model_tester.prepare_config_and_inputs_for_common()

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

        lowerCAmelCase_     : Optional[int]     =  ["""pixel_values"""]
        self.assertListEqual(arg_names[:1]       ,		lowerCamelCase						)

    @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""						)
    def __lowercase  (  self       :    int						)  ->    Union[str, Any]:
      pass

    def __lowercase  (  self       :    Any						)  ->    Dict:
      lowerCAmelCase_     : List[str]     =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase						)

    def __lowercase  (  self       :    Dict						)  ->    Optional[int]:
      def check_hidden_states_output(lowerCamelCase       :    Optional[Any]       ,		lowerCamelCase       :    Optional[int]       ,		lowerCamelCase       :    Optional[int]						):
        lowerCAmelCase_     : List[Any]     =  model_class(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()

        with torch.no_grad():
          lowerCAmelCase_     : Optional[Any]     =  model(**self._prepare_for_class(lowerCamelCase       ,		lowerCamelCase						)						)

        lowerCAmelCase_     : Tuple     =  outputs.hidden_states

        lowerCAmelCase_     : Dict     =  5
        self.assertEqual(len(lowerCamelCase						)       ,		lowerCamelCase						)

        # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
        # with the width and height being successively divided by 2.
        lowerCAmelCase_     : Any     =  2
        for i in range(len(lowerCamelCase						)						):
          self.assertListEqual(
              list(hidden_states[i].shape[-2:]						)       ,		[self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]       ,		)
          divisor *= 2

        self.assertEqual(self.model_tester.output_stride       ,		divisor // 2						)

      lowerCAmelCase_,				lowerCAmelCase_     : Union[str, Any]     =  self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowerCAmelCase_     : Optional[Any]     =  True
        check_hidden_states_output(lowerCamelCase       ,		lowerCamelCase       ,		lowerCamelCase						)

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowerCAmelCase_     : Tuple     =  True

        check_hidden_states_output(lowerCamelCase       ,		lowerCamelCase       ,		lowerCamelCase						)

    def __lowercase  (  self       :    str						)  ->    Dict:
      lowerCAmelCase_     : int     =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase						)

    def __lowercase  (  self       :    Optional[int]						)  ->    int:
      lowerCAmelCase_     : Optional[Any]     =  self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase						)





    @slow
    def __lowercase  (  self       :    str						)  ->    List[str]:
      for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCAmelCase_     : Tuple     =  MobileViTModel.from_pretrained(lowerCamelCase						)
        self.assertIsNotNone(lowerCamelCase						)







def 							UpperCamelCase_     (       ):
  '''simple docstring'''





  lowerCAmelCase_     : int     =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""   )
  return image






@require_torch
@require_vision
class   __snake_case			(  unittest.TestCase):







    """simple docstring"""



    @cached_property
    def __lowercase  (  self       :    Optional[int]						)  ->    Tuple:
      return MobileViTImageProcessor.from_pretrained("""apple/mobilevit-xx-small"""						) if is_vision_available() else None

    @slow
    def __lowercase  (  self       :    Optional[int]						)  ->    Tuple:
      lowerCAmelCase_     : Any     =  MobileViTForImageClassification.from_pretrained("""apple/mobilevit-xx-small"""						).to(lowerCamelCase						)

      lowerCAmelCase_     : List[str]     =  self.default_image_processor
      lowerCAmelCase_     : Dict     =  prepare_img()
      lowerCAmelCase_     : Any     =  image_processor(images=lowerCamelCase       ,		return_tensors="""pt"""						).to(lowerCamelCase						)

      # forward pass
      with torch.no_grad():
        lowerCAmelCase_     : int     =  model(**lowerCamelCase						)

      # verify the logits
      lowerCAmelCase_     : List[str]     =  torch.Size((1, 10_00)						)
      self.assertEqual(outputs.logits.shape       ,		lowerCamelCase						)

      lowerCAmelCase_     : Union[str, Any]     =  torch.tensor([-1.9_364, -1.2_327, -0.4_653]						).to(lowerCamelCase						)

      self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,		lowerCamelCase       ,		atol=1E-4						)						)

    @slow
    def __lowercase  (  self       :    Tuple						)  ->    Optional[Any]:
      lowerCAmelCase_     : str     =  MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""						)
      lowerCAmelCase_     : str     =  model.to(lowerCamelCase						)

      lowerCAmelCase_     : Dict     =  MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""						)

      lowerCAmelCase_     : Union[str, Any]     =  prepare_img()
      lowerCAmelCase_     : int     =  image_processor(images=lowerCamelCase       ,		return_tensors="""pt"""						).to(lowerCamelCase						)

      # forward pass
      with torch.no_grad():
        lowerCAmelCase_     : Optional[Any]     =  model(**lowerCamelCase						)
      lowerCAmelCase_     : Any     =  outputs.logits

      # verify the logits
      lowerCAmelCase_     : List[Any]     =  torch.Size((1, 21, 32, 32)						)
      self.assertEqual(logits.shape       ,		lowerCamelCase						)

      lowerCAmelCase_     : int     =  torch.tensor(
          [
              [[6.9_713, 6.9_786, 7.2_422], [7.2_893, 7.2_825, 7.4_446], [7.6_580, 7.8_797, 7.9_420]],
              [[-10.6_869, -10.3_250, -10.3_471], [-10.4_228, -9.9_868, -9.7_132], [-11.0_405, -11.0_221, -10.7_318]],
              [[-3.3_089, -2.8_539, -2.6_740], [-3.2_706, -2.5_621, -2.5_108], [-3.2_534, -2.6_615, -2.6_651]],
          ]       ,		device=lowerCamelCase       ,		)

      self.assertTrue(torch.allclose(logits[0, :3, :3, :3]       ,		lowerCamelCase       ,		atol=1E-4						)						)





    @slow
    def __lowercase  (  self       :    Union[str, Any]						)  ->    Optional[Any]:
      lowerCAmelCase_     : Any     =  MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""						)
      lowerCAmelCase_     : List[Any]     =  model.to(lowerCamelCase						)

      lowerCAmelCase_     : Any     =  MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""						)

      lowerCAmelCase_     : Optional[int]     =  prepare_img()
      lowerCAmelCase_     : Optional[Any]     =  image_processor(images=lowerCamelCase       ,		return_tensors="""pt"""						).to(lowerCamelCase						)

      # forward pass
      with torch.no_grad():
        lowerCAmelCase_     : str     =  model(**lowerCamelCase						)

      lowerCAmelCase_     : Optional[Any]     =  outputs.logits.detach().cpu()

      lowerCAmelCase_     : Tuple     =  image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase       ,		target_sizes=[(50, 60)]						)
      lowerCAmelCase_     : str     =  torch.Size((50, 60)						)
      self.assertEqual(segmentation[0].shape       ,		lowerCamelCase						)

      lowerCAmelCase_     : Tuple     =  image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase						)
      lowerCAmelCase_     : Optional[Any]     =  torch.Size((32, 32)						)
      self.assertEqual(segmentation[0].shape       ,		lowerCamelCase						)







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







    """simple docstring"""



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

      lowerCAmelCase_     : str     =  context_length
      lowerCAmelCase_     : int     =  prediction_length + label_length
      lowerCAmelCase_     : int     =  label_length

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

    def __lowercase  (  self       :    int						)  ->    List[str]:
      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       ,		lowerCamelCase       :    Dict						)  ->    List[str]:
      lowerCAmelCase_     : Union[str, Any]     =  config.context_length + max(config.lags_sequence						)

      lowerCAmelCase_     : Any     =  ids_tensor([self.batch_size, 1]       ,		config.cardinality[0]						)
      lowerCAmelCase_     : Any     =  floats_tensor([self.batch_size, _past_length, config.num_time_features]						)
      lowerCAmelCase_     : Tuple     =  floats_tensor([self.batch_size, _past_length]						)
      lowerCAmelCase_     : List[str]     =  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_     : Optional[int]     =  floats_tensor([self.batch_size, config.prediction_length]						)

      lowerCAmelCase_     : List[str]     =  {
          """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       :    Tuple						)  ->    Optional[Any]:
      lowerCAmelCase_     : List[Any]     =  self.get_config()
      lowerCAmelCase_     : str     =  self.prepare_autoformer_inputs_dict(lowerCamelCase						)
      return config, inputs_dict

    def __lowercase  (  self       :    Optional[int]						)  ->    Optional[Any]:
      lowerCAmelCase_,				lowerCAmelCase_     : List[str]     =  self.prepare_config_and_inputs()
      return config, inputs_dict





    def __lowercase  (  self       :    str       ,		lowerCamelCase       :    Any       ,		lowerCamelCase       :    Dict						)  ->    Union[str, Any]:
      lowerCAmelCase_     : int     =  AutoformerModel(config=lowerCamelCase						).to(lowerCamelCase						).eval()
      lowerCAmelCase_     : List[str]     =  model(**lowerCamelCase						)

      lowerCAmelCase_     : Any     =  outputs.encoder_last_hidden_state
      lowerCAmelCase_     : List[str]     =  outputs.last_hidden_state

      with tempfile.TemporaryDirectory() as tmpdirname:
        lowerCAmelCase_     : Optional[int]     =  model.get_encoder()
        encoder.save_pretrained(lowerCamelCase						)
        lowerCAmelCase_     : List[Any]     =  AutoformerEncoder.from_pretrained(lowerCamelCase						).to(lowerCamelCase						)

      lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_,				lowerCAmelCase_     : Dict     =  model.create_network_inputs(**lowerCamelCase						)
      lowerCAmelCase_,				lowerCAmelCase_     : Optional[Any]     =  model.decomposition_layer(transformer_inputs[:, : config.context_length, ...]						)

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

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

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

      lowerCAmelCase_     : int     =  decoder(
          trend=lowerCamelCase       ,		inputs_embeds=lowerCamelCase       ,		encoder_hidden_states=lowerCamelCase       ,		)[0]

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







@require_torch
class   __snake_case			(  _SCREAMING_SNAKE_CASE      ,_SCREAMING_SNAKE_CASE      ,unittest.TestCase):







    """simple docstring"""



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

    def __lowercase  (  self       :    Optional[Any]						)  ->    List[str]:
      lowerCAmelCase_     : str     =  AutoformerModelTester(self						)
      lowerCAmelCase_     : Union[str, Any]     =  ConfigTester(self       ,		config_class=lowerCamelCase       ,		has_text_modality=lowerCamelCase						)

    def __lowercase  (  self       :    Dict						)  ->    List[str]:
      self.config_tester.run_common_tests()

    def __lowercase  (  self       :    Optional[Any]						)  ->    Optional[int]:
      lowerCAmelCase_,				lowerCAmelCase_     : Tuple     =  self.model_tester.prepare_config_and_inputs()
      for model_class in self.all_model_classes:
        lowerCAmelCase_     : int     =  model_class(lowerCamelCase						)

        with tempfile.TemporaryDirectory() as tmpdirname:
          model.save_pretrained(lowerCamelCase						)
          lowerCAmelCase_,				lowerCAmelCase_     : Union[str, Any]     =  model_class.from_pretrained(lowerCamelCase       ,		output_loading_info=lowerCamelCase						)
        self.assertEqual(info["""missing_keys"""]       ,		[]						)

    def __lowercase  (  self       :    str						)  ->    str:
      lowerCAmelCase_     : Union[str, Any]     =  self.model_tester.prepare_config_and_inputs_for_common()
      self.model_tester.check_encoder_decoder_model_standalone(*lowerCamelCase						)

    @unittest.skip(reason="""Model has no tokens embeddings"""						)
    def __lowercase  (  self       :    List[Any]						)  ->    Dict:
      pass

    def __lowercase  (  self       :    Optional[Any]						)  ->    Tuple:
      lowerCAmelCase_     : Dict     =  inspect.signature(getattr(lowerCamelCase       ,		"""forward"""						)						)
      # The main input is the name of the argument after `self`
      lowerCAmelCase_     : Optional[int]     =  list(model_signature.parameters.keys()						)[1]
      self.assertEqual(AutoformerModel.main_input_name       ,		lowerCamelCase						)

    def __lowercase  (  self       :    str						)  ->    List[str]:
      lowerCAmelCase_,				lowerCAmelCase_     : Dict     =  self.model_tester.prepare_config_and_inputs_for_common()

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

        lowerCAmelCase_     : 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(lowerCamelCase						)]       ,		lowerCamelCase						)

    def __lowercase  (  self       :    Optional[int]						)  ->    Optional[int]:
      lowerCAmelCase_,				lowerCAmelCase_     : int     =  self.model_tester.prepare_config_and_inputs_for_common()
      lowerCAmelCase_     : Tuple     =  True

      lowerCAmelCase_     : Tuple     =  getattr(self.model_tester       ,		"""seq_length"""       ,		lowerCamelCase						)
      lowerCAmelCase_     : Union[str, Any]     =  getattr(self.model_tester       ,		"""decoder_seq_length"""       ,		lowerCamelCase						)
      lowerCAmelCase_     : Tuple     =  getattr(self.model_tester       ,		"""encoder_seq_length"""       ,		lowerCamelCase						)
      lowerCAmelCase_     : Optional[int]     =  getattr(self.model_tester       ,		"""d_model"""       ,		lowerCamelCase						)
      lowerCAmelCase_     : Any     =  getattr(self.model_tester       ,		"""num_attention_heads"""       ,		lowerCamelCase						)
      lowerCAmelCase_     : Optional[Any]     =  d_model // num_attention_heads

      for model_class in self.all_model_classes:
        lowerCAmelCase_     : List[Any]     =  True
        lowerCAmelCase_     : Optional[int]     =  False
        lowerCAmelCase_     : Optional[int]     =  True
        lowerCAmelCase_     : List[Any]     =  model_class(lowerCamelCase						)
        model.to(lowerCamelCase						)
        model.eval()
        with torch.no_grad():
          lowerCAmelCase_     : str     =  model(**self._prepare_for_class(lowerCamelCase       ,		lowerCamelCase						)						)
        lowerCAmelCase_     : Any     =  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
        self.assertEqual(len(lowerCamelCase						)       ,		self.model_tester.num_hidden_layers						)

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

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

        lowerCAmelCase_     : Any     =  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(lowerCamelCase       ,		lowerCamelCase						)

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

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

      lowerCAmelCase_     : int     =  outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions

      self.assertEqual(len(lowerCamelCase						)       ,		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       :    Any						)  ->    Dict:
      super().test_retain_grad_hidden_states_attentions()







def 							UpperCamelCase_     (       A__   :  Optional[Any]="train-batch.pt"   ):
  '''simple docstring'''





  lowerCAmelCase_     : Dict     =  hf_hub_download(repo_id="""hf-internal-testing/tourism-monthly-batch"""				,       filename=A__				,       repo_type="""dataset"""   )
  lowerCAmelCase_     : int     =  torch.load(A__				,       map_location=A__   )
  return batch






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







    """simple docstring"""



    def __lowercase  (  self       :    int						)  ->    Optional[Any]:
      lowerCAmelCase_     : Optional[int]     =  AutoformerModel.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(lowerCamelCase						)
      lowerCAmelCase_     : Optional[Any]     =  prepare_batch()

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

      lowerCAmelCase_     : Dict     =  torch.tensor(
          [[0.3_593, -1.3_398, 0.6_330], [0.2_279, 1.5_396, -0.1_792], [0.0_450, 1.3_225, -0.2_335]]       ,		device=lowerCamelCase						)
      self.assertTrue(torch.allclose(output[0, :3, :3]       ,		lowerCamelCase       ,		atol=lowerCamelCase						)						)

    def __lowercase  (  self       :    Union[str, Any]						)  ->    Any:
      lowerCAmelCase_     : List[str]     =  AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(lowerCamelCase						)
      lowerCAmelCase_     : str     =  prepare_batch("""val-batch.pt"""						)
      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"""]       ,		).encoder_last_hidden_state
      lowerCAmelCase_     : List[Any]     =  torch.Size((64, model.config.context_length, model.config.d_model)						)
      self.assertEqual(output.shape       ,		lowerCamelCase						)

      lowerCAmelCase_     : List[Any]     =  torch.tensor(
          [[-0.0_734, -0.9_036, 0.8_358], [4.7_186, 2.4_113, 1.9_581], [1.7_953, 2.3_558, 1.2_970]]       ,		device=lowerCamelCase						)
      self.assertTrue(torch.allclose(output[0, :3, :3]       ,		lowerCamelCase       ,		atol=lowerCamelCase						)						)





    def __lowercase  (  self       :    Any						)  ->    Optional[Any]:
      lowerCAmelCase_     : List[str]     =  AutoformerForPrediction.from_pretrained("""huggingface/autoformer-tourism-monthly"""						).to(lowerCamelCase						)
      lowerCAmelCase_     : int     =  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_     : Any     =  torch.Size((64, model.config.num_parallel_samples, model.config.prediction_length)						)
      self.assertEqual(outputs.sequences.shape       ,		lowerCamelCase						)

      lowerCAmelCase_     : List[Any]     =  torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786]       ,		device=lowerCamelCase						)
      lowerCAmelCase_     : str     =  outputs.sequences.mean(dim=1						)
      self.assertTrue(torch.allclose(mean_prediction[0, -3:]       ,		lowerCamelCase       ,		rtol=1E-1						)						)



