__lowerCamelCase					:	Dict       =  {
    '''Pillow''': '''Pillow<10.0.0''',
    '''accelerate''': '''accelerate>=0.20.3''',
    '''av''': '''av==9.2.0''',
    '''beautifulsoup4''': '''beautifulsoup4''',
    '''black''': '''black~=23.1''',
    '''codecarbon''': '''codecarbon==1.2.0''',
    '''cookiecutter''': '''cookiecutter==1.7.3''',
    '''dataclasses''': '''dataclasses''',
    '''datasets''': '''datasets!=2.5.0''',
    '''decord''': '''decord==0.6.0''',
    '''deepspeed''': '''deepspeed>=0.9.3''',
    '''diffusers''': '''diffusers''',
    '''dill''': '''dill<0.3.5''',
    '''evaluate''': '''evaluate>=0.2.0''',
    '''fairscale''': '''fairscale>0.3''',
    '''faiss-cpu''': '''faiss-cpu''',
    '''fastapi''': '''fastapi''',
    '''filelock''': '''filelock''',
    '''flax''': '''flax>=0.4.1,<=0.7.0''',
    '''ftfy''': '''ftfy''',
    '''fugashi''': '''fugashi>=1.0''',
    '''GitPython''': '''GitPython<3.1.19''',
    '''hf-doc-builder''': '''hf-doc-builder>=0.3.0''',
    '''huggingface-hub''': '''huggingface-hub>=0.14.1,<1.0''',
    '''importlib_metadata''': '''importlib_metadata''',
    '''ipadic''': '''ipadic>=1.0.0,<2.0''',
    '''isort''': '''isort>=5.5.4''',
    '''jax''': '''jax>=0.2.8,!=0.3.2,<=0.4.13''',
    '''jaxlib''': '''jaxlib>=0.1.65,<=0.4.13''',
    '''jieba''': '''jieba''',
    '''kenlm''': '''kenlm''',
    '''keras-nlp''': '''keras-nlp>=0.3.1''',
    '''librosa''': '''librosa''',
    '''nltk''': '''nltk''',
    '''natten''': '''natten>=0.14.6''',
    '''numpy''': '''numpy>=1.17''',
    '''onnxconverter-common''': '''onnxconverter-common''',
    '''onnxruntime-tools''': '''onnxruntime-tools>=1.4.2''',
    '''onnxruntime''': '''onnxruntime>=1.4.0''',
    '''opencv-python''': '''opencv-python''',
    '''optuna''': '''optuna''',
    '''optax''': '''optax>=0.0.8,<=0.1.4''',
    '''packaging''': '''packaging>=20.0''',
    '''parameterized''': '''parameterized''',
    '''phonemizer''': '''phonemizer''',
    '''protobuf''': '''protobuf''',
    '''psutil''': '''psutil''',
    '''pyyaml''': '''pyyaml>=5.1''',
    '''pydantic''': '''pydantic<2''',
    '''pytest''': '''pytest>=7.2.0''',
    '''pytest-timeout''': '''pytest-timeout''',
    '''pytest-xdist''': '''pytest-xdist''',
    '''python''': '''python>=3.8.0''',
    '''ray[tune]''': '''ray[tune]''',
    '''regex''': '''regex!=2019.12.17''',
    '''requests''': '''requests''',
    '''rhoknp''': '''rhoknp>=1.1.0,<1.3.1''',
    '''rjieba''': '''rjieba''',
    '''rouge-score''': '''rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1''',
    '''ruff''': '''ruff>=0.0.241,<=0.0.259''',
    '''sacrebleu''': '''sacrebleu>=1.4.12,<2.0.0''',
    '''sacremoses''': '''sacremoses''',
    '''safetensors''': '''safetensors>=0.3.1''',
    '''sagemaker''': '''sagemaker>=2.31.0''',
    '''scikit-learn''': '''scikit-learn''',
    '''sentencepiece''': '''sentencepiece>=0.1.91,!=0.1.92''',
    '''sigopt''': '''sigopt''',
    '''starlette''': '''starlette''',
    '''sudachipy''': '''sudachipy>=0.6.6''',
    '''sudachidict_core''': '''sudachidict_core>=20220729''',
    '''tensorflow-cpu''': '''tensorflow-cpu>=2.6,<2.14''',
    '''tensorflow''': '''tensorflow>=2.6,<2.14''',
    '''tensorflow-text''': '''tensorflow-text<2.14''',
    '''tf2onnx''': '''tf2onnx''',
    '''timeout-decorator''': '''timeout-decorator''',
    '''timm''': '''timm''',
    '''tokenizers''': '''tokenizers>=0.11.1,!=0.11.3,<0.14''',
    '''torch''': '''torch>=1.9,!=1.12.0''',
    '''torchaudio''': '''torchaudio''',
    '''torchvision''': '''torchvision''',
    '''pyctcdecode''': '''pyctcdecode>=0.4.0''',
    '''tqdm''': '''tqdm>=4.27''',
    '''unidic''': '''unidic>=1.0.2''',
    '''unidic_lite''': '''unidic_lite>=1.0.7''',
    '''urllib3''': '''urllib3<2.0.0''',
    '''uvicorn''': '''uvicorn''',
}




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 _lowerCamelCase(						_a   ):
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							Tuple      		=		self.config_class(**self.inputs_dict)
           self.parent.assertTrue(hasattr(lowerCamelCase,      'width_multiplier'))






class _lowerCamelCase:
       def __init__(					self,      lowerCamelCase,      lowerCamelCase=13,      lowerCamelCase=64,      lowerCamelCase=2,      lowerCamelCase=3,      lowerCamelCase="swish",      lowerCamelCase=3,      lowerCamelCase=32,      lowerCamelCase=0.1,      lowerCamelCase=0.0_2,      lowerCamelCase=True,      lowerCamelCase=True,      lowerCamelCase=10,      lowerCamelCase=None,      lowerCamelCase=0.2_5,      lowerCamelCase=0.0,      lowerCamelCase=0.0,      )       ->   Any:




           """simple docstring"""

           _lowercase       :							Any      		=		parent
           _lowercase       :							Optional[int]      		=		batch_size
           _lowercase       :							Dict      		=		image_size
           _lowercase       :							str      		=		patch_size
           _lowercase       :							Optional[int]      		=		num_channels
           _lowercase       :							Optional[Any]      		=		make_divisible(5_12 * width_multiplier,      divisor=8)
           _lowercase       :							str      		=		hidden_act
           _lowercase       :							Dict      		=		conv_kernel_size
           _lowercase       :							int      		=		output_stride
           _lowercase       :							Optional[Any]      		=		classifier_dropout_prob
           _lowercase       :							Tuple      		=		use_labels
           _lowercase       :							int      		=		is_training
           _lowercase       :							Optional[Any]      		=		num_labels
           _lowercase       :							Dict      		=		initializer_range
           _lowercase       :							List[str]      		=		scope
           _lowercase       :							Tuple      		=		width_multiplier
           _lowercase       :							List[str]      		=		ffn_dropout
           _lowercase       :							Dict      		=		attn_dropout
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase       :							Dict      		=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

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

           return config, pixel_values, labels, pixel_labels
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           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 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Any:




           """simple docstring"""

           _lowercase       :							Optional[int]      		=		MobileViTVaModel(config=lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[int]      		=		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 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   Optional[int]:




           """simple docstring"""

           _lowercase       :							int      		=		self.num_labels
           _lowercase       :							Optional[int]      		=		MobileViTVaForImageClassification(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[Any]      		=		model(lowerCamelCase,      labels=lowerCamelCase)
           self.parent.assertEqual(result.logits.shape,      (self.batch_size, self.num_labels))
       def 			UpperCamelCase     (					self,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase,      lowerCamelCase)       ->   int:




           """simple docstring"""

           _lowercase       :							Any      		=		self.num_labels
           _lowercase       :							Union[str, Any]      		=		MobileViTVaForSemanticSegmentation(lowerCamelCase)
           model.to(lowerCamelCase)
           model.eval()
           _lowercase       :							Optional[int]      		=		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,
               ),      )
           _lowercase       :							List[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 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

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






@require_torch
class _lowerCamelCase(						_a, _a, unittest.TestCase   ):
       lowercase_ :	List[Any]     =			(
           (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
           if is_torch_available()
           else ()
       )

       lowercase_ :	Dict     =			(
           {
               """feature-extraction""": MobileViTVaModel,
               """image-classification""": MobileViTVaForImageClassification,
               """image-segmentation""": MobileViTVaForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       lowercase_ :	List[Any]     =			False
       lowercase_ :	Optional[int]     =			False
       lowercase_ :	List[Any]     =			False
       lowercase_ :	Tuple     =			False
       def 			UpperCamelCase     (					self)       ->   Any:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		MobileViTVaModelTester(self)
           _lowercase       :							Tuple      		=		MobileViTVaConfigTester(self,      config_class=lowerCamelCase,      has_text_modality=lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           self.config_tester.run_common_tests()
       @unittest.skip(reason='MobileViTV2 does not use inputs_embeds')
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

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




           """simple docstring"""

           pass
       @unittest.skip(reason='MobileViTV2 does not output attentions')
       def 			UpperCamelCase     (					self)       ->   List[Any]:




           """simple docstring"""

           pass
       @require_torch_multi_gpu
       @unittest.skip(reason='Got `CUDA error: misaligned address` for tests after this one being run.')
       def 			UpperCamelCase     (					self)       ->   int:




           """simple docstring"""

           pass
       @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.')
       def 			UpperCamelCase     (					self)       ->   List[Any]:




           """simple docstring"""

           pass
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase		,				_lowercase       :							Dict      		=		self.model_tester.prepare_config_and_inputs_for_common()

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

               _lowercase       :							Union[str, Any]      		=		['pixel_values']
               self.assertListEqual(arg_names[:1],      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							Union[str, Any]      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           def check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase):
               _lowercase       :							Optional[Any]      		=		model_class(lowerCamelCase)
               model.to(lowerCamelCase)
               model.eval()

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

               _lowercase       :							List[Any]      		=		outputs.hidden_states

               _lowercase       :							Tuple      		=		5
               self.assertEqual(len(lowerCamelCase),      lowerCamelCase)

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

           _lowercase		,				_lowercase       :							Dict      		=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               _lowercase       :							Tuple      		=		True
               check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)

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

               check_hidden_states_output(lowerCamelCase,      lowerCamelCase,      lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   Union[str, Any]:




           """simple docstring"""

           _lowercase       :							int      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*lowerCamelCase)
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           _lowercase       :							str      		=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase)




       @slow
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _lowercase       :							str      		=		MobileViTVaModel.from_pretrained(lowerCamelCase)
               self.assertIsNotNone(lowerCamelCase)



def 				UpperCamelCase_(      )    ->						Dict:
    _lowercase       :							Tuple      		=		Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
    return image






@require_torch
@require_vision
class _lowerCamelCase(						unittest.TestCase   ):
       @cached_property
       def 			UpperCamelCase     (					self)       ->   List[str]:




           """simple docstring"""

           return (
               MobileViTImageProcessor.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256')
               if is_vision_available()
               else None
           )
       @slow
       def 			UpperCamelCase     (					self)       ->   Tuple:




           """simple docstring"""

           _lowercase       :							List[str]      		=		MobileViTVaForImageClassification.from_pretrained('apple/mobilevitv2-1.0-imagenet1k-256').to(
               lowerCamelCase)

           _lowercase       :							Dict      		=		self.default_image_processor
           _lowercase       :							Union[str, Any]      		=		prepare_img()
           _lowercase       :							Dict      		=		image_processor(images=lowerCamelCase,      return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase       :							Tuple      		=		model(**lowerCamelCase)

           # verify the logits
           _lowercase       :							Optional[int]      		=		torch.Size((1, 10_00))
           self.assertEqual(outputs.logits.shape,      lowerCamelCase)

           _lowercase       :							Union[str, Any]      		=		torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]).to(lowerCamelCase)

           self.assertTrue(torch.allclose(outputs.logits[0, :3],      lowerCamelCase,      atol=1E-4))
       @slow
       def 			UpperCamelCase     (					self)       ->   Optional[Any]:




           """simple docstring"""

           _lowercase       :							Optional[int]      		=		MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')
           _lowercase       :							Optional[int]      		=		model.to(lowerCamelCase)

           _lowercase       :							Optional[int]      		=		MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')

           _lowercase       :							Union[str, Any]      		=		prepare_img()
           _lowercase       :							Tuple      		=		image_processor(images=lowerCamelCase,      return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase       :							List[Any]      		=		model(**lowerCamelCase)
           _lowercase       :							str      		=		outputs.logits

           # verify the logits
           _lowercase       :							Tuple      		=		torch.Size((1, 21, 32, 32))
           self.assertEqual(logits.shape,      lowerCamelCase)

           _lowercase       :							Union[str, Any]      		=		torch.tensor(
               [
                   [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
                   [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
                   [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
               ],      device=lowerCamelCase,      )

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




       @slow
       def 			UpperCamelCase     (					self)       ->   str:




           """simple docstring"""

           _lowercase       :							List[str]      		=		MobileViTVaForSemanticSegmentation.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')
           _lowercase       :							Tuple      		=		model.to(lowerCamelCase)

           _lowercase       :							str      		=		MobileViTImageProcessor.from_pretrained('shehan97/mobilevitv2-1.0-voc-deeplabv3')

           _lowercase       :							int      		=		prepare_img()
           _lowercase       :							Dict      		=		image_processor(images=lowerCamelCase,      return_tensors='pt').to(lowerCamelCase)

           # forward pass
           with torch.no_grad():
               _lowercase       :							Union[str, Any]      		=		model(**lowerCamelCase)

           _lowercase       :							Any      		=		outputs.logits.detach().cpu()

           _lowercase       :							Optional[int]      		=		image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase,      target_sizes=[(50, 60)])
           _lowercase       :							Any      		=		torch.Size((50, 60))
           self.assertEqual(segmentation[0].shape,      lowerCamelCase)

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


