


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)






def 				UpperCamelCase_(      lowerCamelCase_ )    ->						int:
    if not numbers:
        return 0

    if not isinstance(lowerCamelCase_							, (list, tuple) ) or not all(
        isinstance(lowerCamelCase_							, lowerCamelCase_ ) for number in numbers ):
        raise ValueError('numbers must be an iterable of integers' )

    _lowercase       :							int      		=		numbers[0]

    for i in range(1							, len(lowerCamelCase_ ) ):
        # update the maximum and minimum subarray products
        _lowercase       :							Union[str, Any]      		=		numbers[i]
        if number < 0:
            _lowercase		,				_lowercase       :							Any      		=		min_till_now, max_till_now
        _lowercase       :							Union[str, Any]      		=		max(lowerCamelCase_							, max_till_now * number )
        _lowercase       :							Union[str, Any]      		=		min(lowerCamelCase_							, min_till_now * number )

        # update the maximum product found till now
        _lowercase       :							Optional[Any]      		=		max(lowerCamelCase_							, lowerCamelCase_ )

    return max_prod


