






"""simple docstring"""






import inspect
import unittest

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

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


if is_torch_available():
					import torch

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


if is_vision_available():
					from PIL import Image

					from transformers import MobileViTImageProcessor





class       snake_case_       (    _lowerCamelCase       ):



	"""simple docstring"""

	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       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       snake_case_       :



	"""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"""

					A__							 =       parent
					A__							 =       batch_size
					A__							 =       image_size
					A__							 =       patch_size
					A__							 =       num_channels
					A__							 =       last_hidden_size
					A__							 =       num_attention_heads
					A__							 =       hidden_act
					A__							 =       conv_kernel_size
					A__							 =       output_stride
					A__							 =       hidden_dropout_prob
					A__							 =       attention_probs_dropout_prob
					A__							 =       classifier_dropout_prob
					A__							 =       use_labels
					A__							 =       is_training
					A__							 =       num_labels
					A__							 =       initializer_range
					A__							 =       scope


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

					A__							 =       None
					A__							 =       None
					if self.use_labels:
									A__							 =       ids_tensor([self.batch_size]  ,					self.num_labels						)
									A__							 =       ids_tensor([self.batch_size, self.image_size, self.image_size]  ,					self.num_labels						)

					A__							 =       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"""

					A__							 =       MobileViTModel(config=__a						)
					model.to(__a						)
					model.eval()
					A__							 =       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"""

					A__							 =       self.num_labels
					A__							 =       MobileViTForImageClassification(__a						)
					model.to(__a						)
					model.eval()
					A__							 =       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"""

					A__							 =       self.num_labels
					A__							 =       MobileViTForSemanticSegmentation(__a						)
					model.to(__a						)
					model.eval()
					A__							 =       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,
					    )  ,					)
					A__							 =       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"""

					A__							 =       self.prepare_config_and_inputs()
					A__ ,			A__ ,			A__ ,			A__							 =       config_and_inputs
					A__							 =       {'pixel_values': pixel_values}
					return config, inputs_dict





@require_torch
class       snake_case_       (    _lowerCamelCase    ,							_lowerCamelCase    ,							unittest.TestCase       ):



	"""simple docstring"""

	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					(
	    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
	    if is_torch_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE_:							Tuple   			=					(
	    {
	        """feature-extraction""": MobileViTModel,
	        """image-classification""": MobileViTForImageClassification,
	        """image-segmentation""": MobileViTForSemanticSegmentation,
	    }
	    if is_torch_available()
	    else {}
	)

	SCREAMING_SNAKE_CASE_:							Tuple   			=					False
	SCREAMING_SNAKE_CASE_:							List[Any]   			=					False
	SCREAMING_SNAKE_CASE_:							Optional[int]   			=					False
	SCREAMING_SNAKE_CASE_:							List[str]   			=					False


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       MobileViTModelTester(self						)
					A__							 =       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"""

					A__ ,			A__							 =       self.model_tester.prepare_config_and_inputs_for_common()

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

									A__							 =       ['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"""

					A__							 =       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						):
									A__							 =       model_class(__a						)
									model.to(__a						)
									model.eval()

									with torch.no_grad():
													A__							 =       model(**self._prepare_for_class(__a  ,					__a						)						)

									A__							 =       outputs.hidden_states

									A__							 =       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.
									A__							 =       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						)

					A__ ,			A__							 =       self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
									A__							 =       True
									check_hidden_states_output(__a  ,					__a  ,					__a						)

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									A__							 =       True

									check_hidden_states_output(__a  ,					__a  ,					__a						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*__a						)


	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       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]:
									A__							 =       MobileViTModel.from_pretrained(__a						)
									self.assertIsNotNone(__a						)





def  __lowerCamelCase					(					):
				A__							 =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
				return image







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



	"""simple docstring"""

	@cached_property
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

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


	@slow
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'						).to(__a						)

					A__							 =       self.default_image_processor
					A__							 =       prepare_img()
					A__							 =       image_processor(images=__a  ,					return_tensors='pt'						).to(__a						)

					# forward pass
					with torch.no_grad():
									A__							 =       model(**__a						)

					# verify the logits
					A__							 =       torch.Size((1, 1000)						)
					self.assertEqual(outputs.logits.shape  ,					__a						)

					A__							 =       torch.tensor([-1.9364, -1.2327, -0.4653]						).to(__a						)

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


	@slow
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'						)
					A__							 =       model.to(__a						)

					A__							 =       MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'						)

					A__							 =       prepare_img()
					A__							 =       image_processor(images=__a  ,					return_tensors='pt'						).to(__a						)

					# forward pass
					with torch.no_grad():
									A__							 =       model(**__a						)
					A__							 =       outputs.logits

					# verify the logits
					A__							 =       torch.Size((1, 21, 32, 32)						)
					self.assertEqual(logits.shape  ,					__a						)

					A__							 =       torch.tensor(
					    [
					        [[6.9713, 6.9786, 7.2422], [7.2893, 7.2825, 7.4446], [7.6580, 7.8797, 7.9420]],
					        [[-10.6869, -10.3250, -10.3471], [-10.4228, -9.9868, -9.7132], [-11.0405, -11.0221, -10.7318]],
					        [[-3.3089, -2.8539, -2.6740], [-3.2706, -2.5621, -2.5108], [-3.2534, -2.6615, -2.6651]],
					    ]  ,					device=__a  ,					)

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






	@slow
	def       _UpperCAmelCase						(      self						):


					"""simple docstring"""

					A__							 =       MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'						)
					A__							 =       model.to(__a						)

					A__							 =       MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'						)

					A__							 =       prepare_img()
					A__							 =       image_processor(images=__a  ,					return_tensors='pt'						).to(__a						)

					# forward pass
					with torch.no_grad():
									A__							 =       model(**__a						)

					A__							 =       outputs.logits.detach().cpu()

					A__							 =       image_processor.post_process_semantic_segmentation(outputs=__a  ,					target_sizes=[(50, 60)]						)
					A__							 =       torch.Size((50, 60)						)
					self.assertEqual(segmentation[0].shape  ,					__a						)

					A__							 =       image_processor.post_process_semantic_segmentation(outputs=__a						)
					A__							 =       torch.Size((32, 32)						)
					self.assertEqual(segmentation[0].shape  ,					__a						)










"""simple docstring"""






from maths.prime_check import is_prime



def  __lowerCamelCase					(					lowerCAmelCase__				):
				if not isinstance(lowerCAmelCase__       ,lowerCAmelCase__				):
								A__							 =       f'''Input value of [number={number}] must be an integer'''
								raise TypeError(lowerCAmelCase__				)
				if is_prime(lowerCAmelCase__				) and is_prime(number + 2				):
								return number + 2
				else:
								return -1


if __name__ == "__main__":
					import doctest

					doctest.testmod()


