

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			:					Optional[Any]						=			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 			_SCREAMING_SNAKE_CASE :







   '''simple docstring'''




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

       SCREAMING_SNAKE_CASE										=   context_length
       SCREAMING_SNAKE_CASE										=   prediction_length + label_length
       SCREAMING_SNAKE_CASE										=   label_length

       SCREAMING_SNAKE_CASE										=   moving_average
       SCREAMING_SNAKE_CASE										=   autocorrelation_factor





   def      _snake_case		(       self					:			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      _snake_case		(       self					:			Dict     , __lowerCamelCase					:			Dict			):
       SCREAMING_SNAKE_CASE										=   config.context_length + max(config.lags_sequence			)

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

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

       SCREAMING_SNAKE_CASE										=   {
           "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      _snake_case		(       self					:			Optional[Any]			):
       SCREAMING_SNAKE_CASE										=   self.get_config()
       SCREAMING_SNAKE_CASE										=   self.prepare_autoformer_inputs_dict(__lowerCamelCase			)
       return config, inputs_dict





   def      _snake_case		(       self					:			int			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.prepare_config_and_inputs()
       return config, inputs_dict





   def      _snake_case		(       self					:			int     , __lowerCamelCase					:			int     , __lowerCamelCase					:			Dict			):
       SCREAMING_SNAKE_CASE										=   AutoformerModel(config=__lowerCamelCase			).to(__lowerCamelCase			).eval()
       SCREAMING_SNAKE_CASE										=   model(**__lowerCamelCase			)

       SCREAMING_SNAKE_CASE										=   outputs.encoder_last_hidden_state
       SCREAMING_SNAKE_CASE										=   outputs.last_hidden_state

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

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

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

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

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

       SCREAMING_SNAKE_CASE										=   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 			_SCREAMING_SNAKE_CASE (   __snake_case					,       __snake_case					,       unittest.TestCase		):







   '''simple docstring'''




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





   def      _snake_case		(       self					:			Optional[int]			):
       SCREAMING_SNAKE_CASE										=   AutoformerModelTester(self			)
       SCREAMING_SNAKE_CASE										=   ConfigTester(self     , config_class=__lowerCamelCase     , has_text_modality=__lowerCamelCase			)





   def      _snake_case		(       self					:			int			):
       self.config_tester.run_common_tests()





   def      _snake_case		(       self					:			Union[str, Any]			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
       for model_class in self.all_model_classes:
           SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)

           with tempfile.TemporaryDirectory() as tmpdirname:
               model.save_pretrained(__lowerCamelCase			)
               SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   model_class.from_pretrained(__lowerCamelCase     , output_loading_info=__lowerCamelCase			)
           self.assertEqual(info["missing_keys"]     , []			)





   def      _snake_case		(       self					:			str			):
       SCREAMING_SNAKE_CASE										=   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      _snake_case		(       self					:			Tuple			):
       pass





   def      _snake_case		(       self					:			Dict			):
       SCREAMING_SNAKE_CASE										=   inspect.signature(getattr(__lowerCamelCase     , "forward"			)			)
       # The main input is the name of the argument after `self`
       SCREAMING_SNAKE_CASE										=   list(model_signature.parameters.keys()			)[1]
       self.assertEqual(AutoformerModel.main_input_name     , __lowerCamelCase			)





   def      _snake_case		(       self					:			Tuple			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()

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

           SCREAMING_SNAKE_CASE										=   [
               "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      _snake_case		(       self					:			str			):
       SCREAMING_SNAKE_CASE							,	SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE										=   True

       SCREAMING_SNAKE_CASE										=   getattr(self.model_tester     , "seq_length"     , __lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   getattr(self.model_tester     , "decoder_seq_length"     , __lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   getattr(self.model_tester     , "encoder_seq_length"     , __lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   getattr(self.model_tester     , "d_model"     , __lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   getattr(self.model_tester     , "num_attention_heads"     , __lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   d_model // num_attention_heads

       for model_class in self.all_model_classes:
           SCREAMING_SNAKE_CASE										=   True
           SCREAMING_SNAKE_CASE										=   False
           SCREAMING_SNAKE_CASE										=   True
           SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)
           model.to(__lowerCamelCase			)
           model.eval()
           with torch.no_grad():
               SCREAMING_SNAKE_CASE										=   model(**self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)			)
           SCREAMING_SNAKE_CASE										=   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"]
           SCREAMING_SNAKE_CASE										=   True
           SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)
           model.to(__lowerCamelCase			)
           model.eval()
           with torch.no_grad():
               SCREAMING_SNAKE_CASE										=   model(**self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)			)
           SCREAMING_SNAKE_CASE										=   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]     , )
           SCREAMING_SNAKE_CASE										=   len(__lowerCamelCase			)

           SCREAMING_SNAKE_CASE										=   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
           SCREAMING_SNAKE_CASE										=   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
           SCREAMING_SNAKE_CASE										=   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
       SCREAMING_SNAKE_CASE										=   True
       SCREAMING_SNAKE_CASE										=   True
       SCREAMING_SNAKE_CASE										=   model_class(__lowerCamelCase			)
       model.to(__lowerCamelCase			)
       model.eval()
       with torch.no_grad():
           SCREAMING_SNAKE_CASE										=   model(**self._prepare_for_class(__lowerCamelCase     , __lowerCamelCase			)			)

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

       SCREAMING_SNAKE_CASE										=   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      _snake_case		(       self					:			int			):
       super().test_retain_grad_hidden_states_attentions()





def 	__a     (      A__			:  Optional[int]="train-batch.pt"       ):
    SCREAMING_SNAKE_CASE										=   hf_hub_download(repo_id="hf-internal-testing/tourism-monthly-batch"			,  filename=A__			,  repo_type="dataset"       )
    SCREAMING_SNAKE_CASE										=   torch.load(A__			,  map_location=A__       )
    return batch





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







   '''simple docstring'''




   def      _snake_case		(       self					:			Optional[int]			):
       SCREAMING_SNAKE_CASE										=   AutoformerModel.from_pretrained("huggingface/autoformer-tourism-monthly"			).to(__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   prepare_batch()

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

       SCREAMING_SNAKE_CASE										=   torch.Size(
           (64, model.config.prediction_length + model.config.label_length, model.config.feature_size)			)
       self.assertEqual(output.shape     , __lowerCamelCase			)

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

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

       SCREAMING_SNAKE_CASE										=   torch.tensor([3_130.6_763, 4_056.5_293, 7_053.0_786]     , device=__lowerCamelCase			)
       SCREAMING_SNAKE_CASE										=   outputs.sequences.mean(dim=1			)
       self.assertTrue(torch.allclose(mean_prediction[0, -3:]     , __lowerCamelCase     , rtol=1e-1			)			)




"""simple docstring"""




import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
 from transformers.models.mobilevitva.modeling_mobilevitva import (
     MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
     make_divisible,
 )


if is_vision_available():
 from PIL import Image

 from transformers import MobileViTImageProcessor






class       UpperCAmelCase_    (							_UpperCamelCase		):



      def 		snake_case_   (	self	:      str		):
           _UpperCAmelCase     :      Dict														=       self.config_class(**self.inputs_dict		)
           self.parent.assertTrue(hasattr(A	,      "width_multiplier"		)		)







class       UpperCAmelCase_    :



      def __init__(	self	:      Dict	,      A	:      Union[str, Any]	,      A	:      Dict=1_3	,      A	:      Union[str, Any]=6_4	,      A	:      int=2	,      A	:      Tuple=3	,      A	:      int="swish"	,      A	:      Optional[int]=3	,      A	:      Tuple=3_2	,      A	:      Tuple=0.1	,      A	:      List[Any]=0.02	,      A	:      Dict=True	,      A	:      str=True	,      A	:      Any=1_0	,      A	:      Optional[int]=None	,      A	:      int=0.25	,      A	:      int=0.0	,      A	:      Dict=0.0	,      ):
           _UpperCAmelCase     :      List[Any]														=       parent
           _UpperCAmelCase     :      Optional[Any]														=       batch_size
           _UpperCAmelCase     :      Dict														=       image_size
           _UpperCAmelCase     :      int														=       patch_size
           _UpperCAmelCase     :      List[str]														=       num_channels
           _UpperCAmelCase     :      Optional[int]														=       make_divisible(5_1_2 * width_multiplier	,      divisor=8		)
           _UpperCAmelCase     :      Dict														=       hidden_act
           _UpperCAmelCase     :      List[str]														=       conv_kernel_size
           _UpperCAmelCase     :      Optional[int]														=       output_stride
           _UpperCAmelCase     :      Union[str, Any]														=       classifier_dropout_prob
           _UpperCAmelCase     :      str														=       use_labels
           _UpperCAmelCase     :      Dict														=       is_training
           _UpperCAmelCase     :      Optional[int]														=       num_labels
           _UpperCAmelCase     :      Tuple														=       initializer_range
           _UpperCAmelCase     :      Tuple														=       scope
           _UpperCAmelCase     :      List[Any]														=       width_multiplier
           _UpperCAmelCase     :      List[str]														=       ffn_dropout
           _UpperCAmelCase     :      List[Any]														=       attn_dropout



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Optional[Any]														=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

           _UpperCAmelCase     :      Optional[int]														=       self.get_config()

           return config, pixel_values, labels, pixel_labels



      def 		snake_case_   (	self	:      List[Any]		):
           return MobileViTVaConfig(
               image_size=self.image_size	,      patch_size=self.patch_size	,      num_channels=self.num_channels	,      hidden_act=self.hidden_act	,      conv_kernel_size=self.conv_kernel_size	,      output_stride=self.output_stride	,      classifier_dropout_prob=self.classifier_dropout_prob	,      initializer_range=self.initializer_range	,      width_multiplier=self.width_multiplier	,      ffn_dropout=self.ffn_dropout_prob	,      attn_dropout=self.attn_dropout_prob	,      )



      def 		snake_case_   (	self	:      int	,      A	:      Optional[Any]	,      A	:      Optional[int]	,      A	:      Any	,      A	:      int		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaModel(config=A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A		)
           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 		snake_case_   (	self	:      Any	,      A	:      Optional[int]	,      A	:      Optional[Any]	,      A	:      str	,      A	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       self.num_labels
           _UpperCAmelCase     :      int														=       MobileViTVaForImageClassification(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      str														=       model(A	,      labels=A		)
           self.parent.assertEqual(result.logits.shape	,      (self.batch_size, self.num_labels)		)



      def 		snake_case_   (	self	:      Optional[int]	,      A	:      Tuple	,      A	:      Any	,      A	:      Any	,      A	:      Optional[Any]		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.num_labels
           _UpperCAmelCase     :      Optional[int]														=       MobileViTVaForSemanticSegmentation(A		)
           model.to(A		)
           model.eval()
           _UpperCAmelCase     :      List[str]														=       model(A		)
           self.parent.assertEqual(
               result.logits.shape	,      (
                   self.batch_size,
                   self.num_labels,
                   self.image_size // self.output_stride,
                   self.image_size // self.output_stride,
               )	,      )
           _UpperCAmelCase     :      Optional[int]														=       model(A	,      labels=A		)
           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 		snake_case_   (	self	:      Any		):
           _UpperCAmelCase     :      Any														=       self.prepare_config_and_inputs()
           _UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase							,			_UpperCAmelCase     :      str														=       config_and_inputs
           _UpperCAmelCase     :      str														=       {"pixel_values": pixel_values}
           return config, inputs_dict







@require_torch
class       UpperCAmelCase_    (							_UpperCamelCase			,     _UpperCamelCase			,     unittest.TestCase		):
      __SCREAMING_SNAKE_CASE		:  Tuple						=					(
          (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
          if is_torch_available()
          else ()
      )

      __SCREAMING_SNAKE_CASE		:  Optional[Any]						=					(
          {
              'feature-extraction': MobileViTVaModel,
              'image-classification': MobileViTVaForImageClassification,
              'image-segmentation': MobileViTVaForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      __SCREAMING_SNAKE_CASE		:  str						=					False
      __SCREAMING_SNAKE_CASE		:  List[Any]						=					False
      __SCREAMING_SNAKE_CASE		:  Dict						=					False
      __SCREAMING_SNAKE_CASE		:  Union[str, Any]						=					False



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaModelTester(self		)
           _UpperCAmelCase     :      Optional[Any]														=       MobileViTVaConfigTester(self	,      config_class=A	,      has_text_modality=A		)



      def 		snake_case_   (	self	:      int		):
           self.config_tester.run_common_tests()



      @unittest.skip(reason="MobileViTV2 does not use inputs_embeds"		)
      def 		snake_case_   (	self	:      Optional[int]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not support input and output embeddings"		)
      def 		snake_case_   (	self	:      Optional[Any]		):
           pass



      @unittest.skip(reason="MobileViTV2 does not output attentions"		)
      def 		snake_case_   (	self	:      int		):
           pass



      @require_torch_multi_gpu
      @unittest.skip(reason="Got `CUDA error: misaligned address` for tests after this one being run."		)
      def 		snake_case_   (	self	:      Any		):
           pass



      @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
      def 		snake_case_   (	self	:      str		):
           pass



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase							,			_UpperCAmelCase     :      Optional[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

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

                _UpperCAmelCase     :      Optional[Any]														=       ["pixel_values"]
                self.assertListEqual(arg_names[:1]	,      A		)



      def 		snake_case_   (	self	:      int		):
           _UpperCAmelCase     :      Union[str, Any]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*A		)



      def 		snake_case_   (	self	:      Optional[Any]		):
           def check_hidden_states_output(A	:      Union[str, Any]	,      A	:      Dict	,      A	:      str		):
                _UpperCAmelCase     :      int														=       model_class(A		)
                model.to(A		)
                model.eval()

                with torch.no_grad():
                     _UpperCAmelCase     :      Tuple														=       model(**self._prepare_for_class(A	,      A		)		)

                _UpperCAmelCase     :      List[str]														=       outputs.hidden_states

                _UpperCAmelCase     :      int														=       5
                self.assertEqual(len(A		)	,      A		)

                # MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
                # with the width and height being successively divided by 2.
                _UpperCAmelCase     :      Optional[int]														=       2
                for i in range(len(A		)		):
                     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		)

           _UpperCAmelCase							,			_UpperCAmelCase     :      List[Any]														=       self.model_tester.prepare_config_and_inputs_for_common()

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

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

                check_hidden_states_output(A	,      A	,      A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      List[str]														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*A		)



      def 		snake_case_   (	self	:      Union[str, Any]		):
           _UpperCAmelCase     :      int														=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*A		)



      @slow
      def 		snake_case_   (	self	:      int		):
           for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                _UpperCAmelCase     :      Union[str, Any]														=       MobileViTVaModel.from_pretrained(A		)
                self.assertIsNotNone(A		)







def 		__snake_case		( )    ->  Optional[Any]:





     '''simple docstring'''

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






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



      @cached_property
      def 		snake_case_   (	self	:      Any		):
           return (
               MobileViTImageProcessor.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		)
               if is_vision_available()
               else None
           )



      @slow
      def 		snake_case_   (	self	:      Dict		):
           _UpperCAmelCase     :      Dict														=       MobileViTVaForImageClassification.from_pretrained("apple/mobilevitv2-1.0-imagenet1k-256"		).to(
               A		)

           _UpperCAmelCase     :      Optional[Any]														=       self.default_image_processor
           _UpperCAmelCase     :      Tuple														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           # verify the logits
           _UpperCAmelCase     :      Tuple														=       torch.Size((1, 1_0_0_0)		)
           self.assertEqual(outputs.logits.shape	,      A		)

           _UpperCAmelCase     :      Optional[Any]														=       torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]		).to(A		)

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



      @slow
      def 		snake_case_   (	self	:      Optional[int]		):
           _UpperCAmelCase     :      List[Any]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Any														=       model.to(A		)

           _UpperCAmelCase     :      Optional[Any]														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Dict														=       prepare_img()
           _UpperCAmelCase     :      Union[str, Any]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      int														=       model(**A		)
           _UpperCAmelCase     :      Any														=       outputs.logits

           # verify the logits
           _UpperCAmelCase     :      Optional[int]														=       torch.Size((1, 2_1, 3_2, 3_2)		)
           self.assertEqual(logits.shape	,      A		)

           _UpperCAmelCase     :      Union[str, Any]														=       torch.tensor(
               [
                   [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
                   [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
                   [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
               ]	,      device=A	,      )

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



      @slow
      def 		snake_case_   (	self	:      List[str]		):
           _UpperCAmelCase     :      List[str]														=       MobileViTVaForSemanticSegmentation.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)
           _UpperCAmelCase     :      Tuple														=       model.to(A		)

           _UpperCAmelCase     :      Dict														=       MobileViTImageProcessor.from_pretrained("shehan97/mobilevitv2-1.0-voc-deeplabv3"		)

           _UpperCAmelCase     :      Optional[int]														=       prepare_img()
           _UpperCAmelCase     :      Optional[int]														=       image_processor(images=A	,      return_tensors="pt"		).to(A		)

           # forward pass
           with torch.no_grad():
                _UpperCAmelCase     :      Tuple														=       model(**A		)

           _UpperCAmelCase     :      Optional[int]														=       outputs.logits.detach().cpu()

           _UpperCAmelCase     :      List[Any]														=       image_processor.post_process_semantic_segmentation(outputs=A	,      target_sizes=[(5_0, 6_0)]		)
           _UpperCAmelCase     :      Dict														=       torch.Size((5_0, 6_0)		)
           self.assertEqual(segmentation[0].shape	,      A		)

           _UpperCAmelCase     :      Dict														=       image_processor.post_process_semantic_segmentation(outputs=A		)
           _UpperCAmelCase     :      Union[str, Any]														=       torch.Size((3_2, 3_2)		)
           self.assertEqual(segmentation[0].shape	,      A		)
