




'''simple docstring'''



import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


UpperCamelCase_    	=				get_tests_dir("fixtures/test_sentencepiece.model")






@require_sentencepiece
@require_tokenizers
class 							_a				(			SCREAMING_SNAKE_CASE ,      unittest.TestCase ):





       '''simple docstring'''






       A						:				Any        =						ReformerTokenizer
       A						:				Any        =						ReformerTokenizerFast
       A						:				Any        =						True
       A						:				Tuple        =						False
       A						:				Optional[Any]        =						True







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             super().setUp()

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						ReformerTokenizer(A,							keep_accents=A  )
             tokenizer.save_pretrained(self.tmpdirname  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						'<s>'
             SCREAMING_SNAKE_CASE   :      Dict    					=						1

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(A  ),							A  )
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(A  ),							A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						list(self.get_tokenizer().get_vocab().keys()  )

             self.assertEqual(vocab_keys[0],							'<unk>'  )
             self.assertEqual(vocab_keys[1],							'<s>'  )
             self.assertEqual(vocab_keys[-1],							'j'  )
             self.assertEqual(len(A  ),							1_000  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             self.assertEqual(self.get_tokenizer().vocab_size,							1_000  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             if not self.test_rust_tokenizer:
                   return

             SCREAMING_SNAKE_CASE   :      str    					=						self.get_tokenizer()
             SCREAMING_SNAKE_CASE   :      int    					=						self.get_rust_tokenizer()

             SCREAMING_SNAKE_CASE   :      Tuple    					=						'I was born in 92000, and this is falsé.'

             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						tokenizer.tokenize(A  )
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						rust_tokenizer.tokenize(A  )
             self.assertListEqual(A,							A  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						tokenizer.encode(A,							add_special_tokens=A  )
             SCREAMING_SNAKE_CASE   :      Any    					=						rust_tokenizer.encode(A,							add_special_tokens=A  )
             self.assertListEqual(A,							A  )

             SCREAMING_SNAKE_CASE   :      int    					=						self.get_rust_tokenizer()
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						tokenizer.encode(A  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						rust_tokenizer.encode(A  )
             self.assertListEqual(A,							A  )







       def        UpperCamelCase_							(      self,							A=15  ):







             '''simple docstring'''







             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"  ):
                         SCREAMING_SNAKE_CASE   :      str    					=						self.rust_tokenizer_class.from_pretrained(A,							**A  )

                         # Simple input
                         SCREAMING_SNAKE_CASE   :      Tuple    					=						'This is a simple input'
                         SCREAMING_SNAKE_CASE   :      List[Any]    					=						['This is a simple input 1', 'This is a simple input 2']
                         SCREAMING_SNAKE_CASE   :      int    					=						('This is a simple input', 'This is a pair')
                         SCREAMING_SNAKE_CASE   :      List[Any]    					=						[
                             ('This is a simple input 1', 'This is a simple input 2'),
                             ('This is a simple pair 1', 'This is a simple pair 2'),
                         ]

                         # Simple input tests
                         self.assertRaises(A,							tokenizer_r.encode,							A,							max_length=A,							padding='max_length'  )

                         # Simple input
                         self.assertRaises(A,							tokenizer_r.encode_plus,							A,							max_length=A,							padding='max_length'  )

                         # Simple input
                         self.assertRaises(
                             A,							tokenizer_r.batch_encode_plus,							A,							max_length=A,							padding='max_length',							)

                         # Pair input
                         self.assertRaises(A,							tokenizer_r.encode,							A,							max_length=A,							padding='max_length'  )

                         # Pair input
                         self.assertRaises(A,							tokenizer_r.encode_plus,							A,							max_length=A,							padding='max_length'  )

                         # Pair input
                         self.assertRaises(
                             A,							tokenizer_r.batch_encode_plus,							A,							max_length=A,							padding='max_length',							)







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						ReformerTokenizer(A,							keep_accents=A  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						tokenizer.tokenize('This is a test'  )
             self.assertListEqual(A,							['▁This', '▁is', '▁a', '▁t', 'est']  )

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(A  ),							[285, 46, 10, 170, 382],							)

             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						tokenizer.tokenize('I was born in 92000, and this is falsé.'  )
             self.assertListEqual(
                 A,							[
                     SPIECE_UNDERLINE + 'I',
                     SPIECE_UNDERLINE + 'was',
                     SPIECE_UNDERLINE + 'b',
                     'or',
                     'n',
                     SPIECE_UNDERLINE + 'in',
                     SPIECE_UNDERLINE + '',
                     '9',
                     '2',
                     '0',
                     '0',
                     '0',
                     ',',
                     SPIECE_UNDERLINE + 'and',
                     SPIECE_UNDERLINE + 'this',
                     SPIECE_UNDERLINE + 'is',
                     SPIECE_UNDERLINE + 'f',
                     'al',
                     's',
                     'é',
                     '.',
                 ],							)
             SCREAMING_SNAKE_CASE   :      List[str]    					=						tokenizer.convert_tokens_to_ids(A  )
             self.assertListEqual(
                 A,							[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4],							)

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						tokenizer.convert_ids_to_tokens(A  )
             self.assertListEqual(
                 A,							[
                     SPIECE_UNDERLINE + 'I',
                     SPIECE_UNDERLINE + 'was',
                     SPIECE_UNDERLINE + 'b',
                     'or',
                     'n',
                     SPIECE_UNDERLINE + 'in',
                     SPIECE_UNDERLINE + '',
                     '<unk>',
                     '2',
                     '0',
                     '0',
                     '0',
                     ',',
                     SPIECE_UNDERLINE + 'and',
                     SPIECE_UNDERLINE + 'this',
                     SPIECE_UNDERLINE + 'is',
                     SPIECE_UNDERLINE + 'f',
                     'al',
                     's',
                     '<unk>',
                     '.',
                 ],							)







       @cached_property
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return ReformerTokenizer.from_pretrained('google/reformer-crime-and-punishment'  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Dict    					=						'Hello World!'
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						[126, 32, 262, 152, 38, 72, 287]

             self.assertListEqual(A,							self.big_tokenizer.encode(A  )  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						(
                 'This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'
                 ' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'
             )
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						[
                 108,
                 265,
                 24,
                 111,
                 4,
                 258,
                 156,
                 35,
                 28,
                 275,
                 3,
                 259,
                 297,
                 260,
                 84,
                 4,
                 35,
                 110,
                 44,
                 8,
                 259,
                 91,
                 268,
                 21,
                 11,
                 209,
                 274,
                 109,
                 266,
                 277,
                 117,
                 86,
                 93,
                 315,
                 258,
                 278,
                 258,
                 277,
                 258,
                 0,
                 258,
                 288,
                 258,
                 319,
                 258,
                 0,
                 258,
                 0,
                 258,
                 0,
                 258,
                 0,
                 258,
                 287,
                 258,
                 315,
                 258,
                 289,
                 258,
                 278,
                 99,
                 269,
                 266,
                 262,
                 8,
                 259,
                 241,
                 4,
                 217,
                 230,
                 268,
                 266,
                 55,
                 168,
                 106,
                 75,
                 193,
                 266,
                 223,
                 27,
                 49,
                 26,
                 282,
                 25,
                 264,
                 299,
                 19,
                 26,
                 0,
                 258,
                 277,
                 117,
                 86,
                 93,
                 176,
                 183,
                 270,
                 11,
                 262,
                 42,
                 61,
                 265,
             ]

             self.assertListEqual(A,							self.big_tokenizer.encode(A  )  )







       @require_torch
       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             import torch

             from transformers import ReformerConfig, ReformerModel

             # Build sequence
             SCREAMING_SNAKE_CASE   :      List[str]    					=						list(self.big_tokenizer.get_vocab().keys()  )[:10]
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						' '.join(A  )
             SCREAMING_SNAKE_CASE   :      Dict    					=						self.big_tokenizer.encode_plus(A,							return_tensors='pt'  )
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.big_tokenizer.batch_encode_plus([sequence, sequence],							return_tensors='pt'  )

             SCREAMING_SNAKE_CASE   :      str    					=						ReformerConfig()
             # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						encoded_sequence['input_ids'].shape
             SCREAMING_SNAKE_CASE   :      List[str]    					=						ReformerModel(A  )

             # Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
             assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

             with torch.no_grad():
                   model(**A  )
                   model(**A  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						{'input_ids': [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
             # fmt: on

             # This tokenizer does not know some characters like ")".
             # That is the reason why we use very simple texts here.
             # Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
             SCREAMING_SNAKE_CASE   :      Dict    					=						[
                 'This is a very simple sentence.',
                 'The quick brown fox jumps over the lazy dog.',
             ]

             self.tokenizer_integration_test_util(
                 expected_encoding=A,							model_name='google/reformer-crime-and-punishment',							revision='0e6c3decb8211d49bf881013425dc8b0448b3f5a',							padding=A,							sequences=A,							)








'''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 							_a				(			SCREAMING_SNAKE_CASE ):





       '''simple docstring'''






       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Tuple    					=						self.config_class(**self.inputs_dict  )
             self.parent.assertTrue(hasattr(A,							'hidden_sizes'  )  )
             self.parent.assertTrue(hasattr(A,							'neck_hidden_sizes'  )  )
             self.parent.assertTrue(hasattr(A,							'num_attention_heads'  )  )






class 							_a				:





       '''simple docstring'''






       def __init__(      self,							A,							A=13,							A=32,							A=2,							A=3,							A=640,							A=4,							A="silu",							A=3,							A=32,							A=0.1,							A=0.1,							A=0.1,							A=0.02,							A=True,							A=True,							A=10,							A=None,							):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						parent
             SCREAMING_SNAKE_CASE   :      int    					=						batch_size
             SCREAMING_SNAKE_CASE   :      int    					=						image_size
             SCREAMING_SNAKE_CASE   :      str    					=						patch_size
             SCREAMING_SNAKE_CASE   :      Tuple    					=						num_channels
             SCREAMING_SNAKE_CASE   :      int    					=						last_hidden_size
             SCREAMING_SNAKE_CASE   :      Any    					=						num_attention_heads
             SCREAMING_SNAKE_CASE   :      List[Any]    					=						hidden_act
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						conv_kernel_size
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						output_stride
             SCREAMING_SNAKE_CASE   :      Any    					=						hidden_dropout_prob
             SCREAMING_SNAKE_CASE   :      Dict    					=						attention_probs_dropout_prob
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						classifier_dropout_prob
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						use_labels
             SCREAMING_SNAKE_CASE   :      int    					=						is_training
             SCREAMING_SNAKE_CASE   :      Dict    					=						num_labels
             SCREAMING_SNAKE_CASE   :      Dict    					=						initializer_range
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						scope







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						None
             SCREAMING_SNAKE_CASE   :      Dict    					=						None
             if self.use_labels:
                   SCREAMING_SNAKE_CASE   :      Any    					=						ids_tensor([self.batch_size],							self.num_labels  )
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						ids_tensor([self.batch_size, self.image_size, self.image_size],							self.num_labels  )

             SCREAMING_SNAKE_CASE   :      int    					=						self.get_config()

             return config, pixel_values, labels, pixel_labels







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             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        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      int    					=						MobileViTModel(config=A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						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        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						self.num_labels
             SCREAMING_SNAKE_CASE   :      Tuple    					=						MobileViTForImageClassification(A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      List[str]    					=						model(A,							labels=A  )
             self.parent.assertEqual(result.logits.shape,							(self.batch_size, self.num_labels)  )







       def        UpperCamelCase_							(      self,							A,							A,							A,							A  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						self.num_labels
             SCREAMING_SNAKE_CASE   :      str    					=						MobileViTForSemanticSegmentation(A  )
             model.to(A  )
             model.eval()
             SCREAMING_SNAKE_CASE   :      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,
                 ),							)
             SCREAMING_SNAKE_CASE   :      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        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						self.prepare_config_and_inputs()
             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Optional[int]    					=						config_and_inputs
             SCREAMING_SNAKE_CASE   :      str    					=						{'pixel_values': pixel_values}
             return config, inputs_dict






@require_torch
class 							_a				(			SCREAMING_SNAKE_CASE ,      SCREAMING_SNAKE_CASE ,      unittest.TestCase ):





       '''simple docstring'''






       A						:				Tuple        =						(
           (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
           if is_torch_available()
           else ()
       )
       A						:				List[Any]        =						(
           {
               '''feature-extraction''': MobileViTModel,
               '''image-classification''': MobileViTForImageClassification,
               '''image-segmentation''': MobileViTForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       A						:				Optional[int]        =						False
       A						:				Dict        =						False
       A						:				List[Any]        =						False
       A						:				Optional[int]        =						False







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						MobileViTModelTester(self  )
             SCREAMING_SNAKE_CASE   :      str    					=						MobileViTConfigTester(self,							config_class=A,							has_text_modality=A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             self.config_tester.run_common_tests()







       @unittest.skip(reason='MobileViT does not use inputs_embeds'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       @unittest.skip(reason='MobileViT does not support input and output embeddings'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       @unittest.skip(reason='MobileViT does not output attentions'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







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

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

                   SCREAMING_SNAKE_CASE   :      Any    					=						['pixel_values']
                   self.assertListEqual(arg_names[:1],							A  )







       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'  )
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             pass







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[str]    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             def check_hidden_states_output(A,							A,							A  ):
                   SCREAMING_SNAKE_CASE   :      Any    					=						model_class(A  )
                   model.to(A  )
                   model.eval()

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

                   SCREAMING_SNAKE_CASE   :      Dict    					=						outputs.hidden_states

                   SCREAMING_SNAKE_CASE   :      List[str]    					=						5
                   self.assertEqual(len(A  ),							A  )

                   # MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
                   # with the width and height being successively divided by 2.
                   SCREAMING_SNAKE_CASE   :      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  )

             SCREAMING_SNAKE_CASE					,    SCREAMING_SNAKE_CASE   :      Any    					=						self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   SCREAMING_SNAKE_CASE   :      Tuple    					=						True
                   check_hidden_states_output(A,							A,							A  )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						True

                   check_hidden_states_output(A,							A,							A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_image_classification(*A  )







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      str    					=						self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_semantic_segmentation(*A  )







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   SCREAMING_SNAKE_CASE   :      int    					=						MobileViTModel.from_pretrained(A  )
                   self.assertIsNotNone(A  )




def   lowercase__(			):

      """simple docstring"""






      SCREAMING_SNAKE_CASE   :      str    					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
      return image






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





       '''simple docstring'''






       @cached_property
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             return MobileViTImageProcessor.from_pretrained('apple/mobilevit-xx-small'  ) if is_vision_available() else None







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      List[Any]    					=						MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'  ).to(A  )

             SCREAMING_SNAKE_CASE   :      Any    					=						self.default_image_processor
             SCREAMING_SNAKE_CASE   :      Dict    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Dict    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

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

             # verify the logits
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						torch.Size((1, 1_000)  )
             self.assertEqual(outputs.logits.shape,							A  )

             SCREAMING_SNAKE_CASE   :      int    					=						torch.tensor([-1.93_64, -1.23_27, -0.46_53]  ).to(A  )

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







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )
             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						model.to(A  )

             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )

             SCREAMING_SNAKE_CASE   :      str    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Optional[int]    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE   :      Dict    					=						model(**A  )
             SCREAMING_SNAKE_CASE   :      List[str]    					=						outputs.logits

             # verify the logits
             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						torch.Size((1, 21, 32, 32)  )
             self.assertEqual(logits.shape,							A  )

             SCREAMING_SNAKE_CASE   :      Tuple    					=						torch.tensor(
                 [
                     [[6.97_13, 6.97_86, 7.24_22], [7.28_93, 7.28_25, 7.44_46], [7.65_80, 7.87_97, 7.94_20]],
                     [[-10.68_69, -10.32_50, -10.34_71], [-10.42_28, -9.98_68, -9.71_32], [-11.04_05, -11.02_21, -10.73_18]],
                     [[-3.30_89, -2.85_39, -2.67_40], [-3.27_06, -2.56_21, -2.51_08], [-3.25_34, -2.66_15, -2.66_51]],
                 ],							device=A,							)

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







       @slow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Union[str, Any]    					=						MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )
             SCREAMING_SNAKE_CASE   :      List[str]    					=						model.to(A  )

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'  )

             SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						prepare_img()
             SCREAMING_SNAKE_CASE   :      Any    					=						image_processor(images=A,							return_tensors='pt'  ).to(A  )

             # forward pass
             with torch.no_grad():
                   SCREAMING_SNAKE_CASE   :      Optional[Any]    					=						model(**A  )

             SCREAMING_SNAKE_CASE   :      int    					=						outputs.logits.detach().cpu()

             SCREAMING_SNAKE_CASE   :      Dict    					=						image_processor.post_process_semantic_segmentation(outputs=A,							target_sizes=[(50, 60)]  )
             SCREAMING_SNAKE_CASE   :      Dict    					=						torch.Size((50, 60)  )
             self.assertEqual(segmentation[0].shape,							A  )

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


