





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






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     self.config_class(**self.inputs_dict					)
											self.parent.assertTrue(hasattr(__lowerCAmelCase					,	"""width_multiplier"""					)					)






class     __SCREAMING_SNAKE_CASE   :






							def __init__(  self					,	__lowerCAmelCase					,	__lowerCAmelCase=13					,	__lowerCAmelCase=64					,	__lowerCAmelCase=2					,	__lowerCAmelCase=3					,	__lowerCAmelCase="swish"					,	__lowerCAmelCase=3					,	__lowerCAmelCase=32					,	__lowerCAmelCase=0.1					,	__lowerCAmelCase=0.02					,	__lowerCAmelCase=True					,	__lowerCAmelCase=True					,	__lowerCAmelCase=10					,	__lowerCAmelCase=None					,	__lowerCAmelCase=0.25					,	__lowerCAmelCase=0.0					,	__lowerCAmelCase=0.0					,	):
											UpperCamelCase__			       =     parent
											UpperCamelCase__			       =     batch_size
											UpperCamelCase__			       =     image_size
											UpperCamelCase__			       =     patch_size
											UpperCamelCase__			       =     num_channels
											UpperCamelCase__			       =     make_divisible(512 * width_multiplier					,	divisor=8					)
											UpperCamelCase__			       =     hidden_act
											UpperCamelCase__			       =     conv_kernel_size
											UpperCamelCase__			       =     output_stride
											UpperCamelCase__			       =     classifier_dropout_prob
											UpperCamelCase__			       =     use_labels
											UpperCamelCase__			       =     is_training
											UpperCamelCase__			       =     num_labels
											UpperCamelCase__			       =     initializer_range
											UpperCamelCase__			       =     scope
											UpperCamelCase__			       =     width_multiplier
											UpperCamelCase__			       =     ffn_dropout
											UpperCamelCase__			       =     attn_dropout






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

											UpperCamelCase__			       =     self.get_config()

											return config, pixel_values, labels, pixel_labels






							def 			_lowerCamelCase						(  self					):
											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 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
											UpperCamelCase__			       =     MobileViTVaModel(config=__lowerCAmelCase					)
											model.to(__lowerCAmelCase					)
											model.eval()
											UpperCamelCase__			       =     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 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
											UpperCamelCase__			       =     self.num_labels
											UpperCamelCase__			       =     MobileViTVaForImageClassification(__lowerCAmelCase					)
											model.to(__lowerCAmelCase					)
											model.eval()
											UpperCamelCase__			       =     model(__lowerCAmelCase					,	labels=__lowerCAmelCase					)
											self.parent.assertEqual(result.logits.shape					,	(self.batch_size, self.num_labels)					)






							def 			_lowerCamelCase						(  self					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
											UpperCamelCase__			       =     self.num_labels
											UpperCamelCase__			       =     MobileViTVaForSemanticSegmentation(__lowerCAmelCase					)
											model.to(__lowerCAmelCase					)
											model.eval()
											UpperCamelCase__			       =     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,
											    )					,	)
											UpperCamelCase__			       =     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 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     self.prepare_config_and_inputs()
											UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__       ,       UpperCamelCase__			       =     config_and_inputs
											UpperCamelCase__			       =     {"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_torch
class     __SCREAMING_SNAKE_CASE   (       _a				,						_a				,						unittest.TestCase    ):
							snake_case       : str         =    (
							    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)

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

							snake_case       : str         =    False
							snake_case       : Optional[Any]         =    False
							snake_case       : Dict         =    False
							snake_case       : int         =    False






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     MobileViTVaModelTester(self					)
											UpperCamelCase__			       =     MobileViTVaConfigTester(self					,	config_class=__lowerCAmelCase					,	has_text_modality=__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
											self.config_tester.run_common_tests()






							@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds"""					)
							def 			_lowerCamelCase						(  self					):
											pass






							@unittest.skip(reason="""MobileViTV2 does not support input and output embeddings"""					)
							def 			_lowerCamelCase						(  self					):
											pass






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






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






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






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs_for_common()

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

															UpperCamelCase__			       =     ["""pixel_values"""]
															self.assertListEqual(arg_names[:1]					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
											def check_hidden_states_output(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					):
															UpperCamelCase__			       =     model_class(__lowerCAmelCase					)
															model.to(__lowerCAmelCase					)
															model.eval()

															with torch.no_grad():
																			UpperCamelCase__			       =     model(**self._prepare_for_class(__lowerCAmelCase					,	__lowerCAmelCase					)					)

															UpperCamelCase__			       =     outputs.hidden_states

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

											UpperCamelCase__       ,       UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															UpperCamelCase__			       =     True
															check_hidden_states_output(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)

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

															check_hidden_states_output(__lowerCAmelCase					,	__lowerCAmelCase					,	__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*__lowerCAmelCase					)






							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*__lowerCAmelCase					)







							@slow
							def 			_lowerCamelCase						(  self					):
											for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															UpperCamelCase__			       =     MobileViTVaModel.from_pretrained(__lowerCAmelCase					)
															self.assertIsNotNone(__lowerCAmelCase					)






def       _UpperCamelCase       ():






				"""simple docstring"""





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

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






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






							@slow
							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""					).to(
											    __lowerCAmelCase					)

											UpperCamelCase__			       =     self.default_image_processor
											UpperCamelCase__			       =     prepare_img()
											UpperCamelCase__			       =     image_processor(images=__lowerCAmelCase					,	return_tensors="""pt"""					).to(__lowerCAmelCase					)

											# forward pass
											with torch.no_grad():
															UpperCamelCase__			       =     model(**__lowerCAmelCase					)

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

											UpperCamelCase__			       =     torch.tensor([-1.6336E00, -7.3204E-02, -5.1883E-01]					).to(__lowerCAmelCase					)

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






							@slow
							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)
											UpperCamelCase__			       =     model.to(__lowerCAmelCase					)

											UpperCamelCase__			       =     MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)

											UpperCamelCase__			       =     prepare_img()
											UpperCamelCase__			       =     image_processor(images=__lowerCAmelCase					,	return_tensors="""pt"""					).to(__lowerCAmelCase					)

											# forward pass
											with torch.no_grad():
															UpperCamelCase__			       =     model(**__lowerCAmelCase					)
											UpperCamelCase__			       =     outputs.logits

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

											UpperCamelCase__			       =     torch.tensor(
											    [
											        [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
											        [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
											        [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
											    ]					,	device=__lowerCAmelCase					,	)

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







							@slow
							def 			_lowerCamelCase						(  self					):
											UpperCamelCase__			       =     MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)
											UpperCamelCase__			       =     model.to(__lowerCAmelCase					)

											UpperCamelCase__			       =     MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""					)

											UpperCamelCase__			       =     prepare_img()
											UpperCamelCase__			       =     image_processor(images=__lowerCAmelCase					,	return_tensors="""pt"""					).to(__lowerCAmelCase					)

											# forward pass
											with torch.no_grad():
															UpperCamelCase__			       =     model(**__lowerCAmelCase					)

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

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

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











def       _UpperCamelCase       (a__				:dict    ):






							"""simple docstring"""





							UpperCamelCase__			       =     set()
							# To detect a back edge, keep track of vertices currently in the recursion stack
							UpperCamelCase__			       =     set()
							return any(
							    node not in visited and depth_first_search(a__				,     a__				,     a__				,     a__    )
							    for node in graph    )





def       _UpperCamelCase       (a__				:dict				,     a__				:int				,     a__				:set				,     a__				:set    ):






							"""simple docstring"""





							visited.add(a__    )
							rec_stk.add(a__    )

							for node in graph[vertex]:
														if node not in visited:
																					if depth_first_search(a__				,     a__				,     a__				,     a__    ):
																												return True
														elif node in rec_stk:
																					return True

    # The node needs to be removed from recursion stack before function ends
							rec_stk.remove(a__    )
							return False


if __name__ == "__main__":
					from doctest import testmod

					testmod()




