
"""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 	lowerCAmelCase_						(a__  ):


				"""simple docstring"""



				def 	__magic_name__    (self    )					->		Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       str           =   self.config_class(**self.inputs_dict    )
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE__   ,       """hidden_sizes"""    )    )
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE__   ,       """neck_hidden_sizes"""    )    )
											self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE__   ,       """num_attention_heads"""    )    )






class 	lowerCAmelCase_						:


				"""simple docstring"""



				def __init__(self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__=13   ,       SCREAMING_SNAKE_CASE__=32   ,       SCREAMING_SNAKE_CASE__=2   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=6_40   ,       SCREAMING_SNAKE_CASE__=4   ,       SCREAMING_SNAKE_CASE__="silu"   ,       SCREAMING_SNAKE_CASE__=3   ,       SCREAMING_SNAKE_CASE__=32   ,       SCREAMING_SNAKE_CASE__=0.1   ,       SCREAMING_SNAKE_CASE__=0.1   ,       SCREAMING_SNAKE_CASE__=0.1   ,       SCREAMING_SNAKE_CASE__=0.02   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=True   ,       SCREAMING_SNAKE_CASE__=10   ,       SCREAMING_SNAKE_CASE__=None   ,       )					->		Union[str, Any]:



											"""simple docstring"""




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



				def 	__magic_name__    (self    )					->		str:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

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

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   self.get_config()

											return config, pixel_values, labels, pixel_labels



				def 	__magic_name__    (self    )					->		str:



											"""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 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[Any]           =   MobileViTModel(config=SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model(SCREAMING_SNAKE_CASE__    )
											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 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		List[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   self.num_labels
											SCREAMING_SNAKE_CASE__						:       Dict           =   MobileViTForImageClassification(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       Any           =   model(SCREAMING_SNAKE_CASE__   ,       labels=SCREAMING_SNAKE_CASE__    )
											self.parent.assertEqual(result.logits.shape   ,       (self.batch_size, self.num_labels)    )



				def 	__magic_name__    (self   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[Any]           =   self.num_labels
											SCREAMING_SNAKE_CASE__						:       int           =   MobileViTForSemanticSegmentation(SCREAMING_SNAKE_CASE__    )
											model.to(SCREAMING_SNAKE_CASE__    )
											model.eval()
											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   model(SCREAMING_SNAKE_CASE__    )
											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__						:       Union[str, Any]           =   model(SCREAMING_SNAKE_CASE__   ,       labels=SCREAMING_SNAKE_CASE__    )
											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 	__magic_name__    (self    )					->		str:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[str]           =   self.prepare_config_and_inputs()
											SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__      ,      SCREAMING_SNAKE_CASE__						:       Any           =   config_and_inputs
											SCREAMING_SNAKE_CASE__						:       Dict           =   {"""pixel_values""": pixel_values}
											return config, inputs_dict






@require_torch
class 	lowerCAmelCase_						(a__ ,					a__ ,					unittest.TestCase  ):


				"""simple docstring"""



				__UpperCamelCase      :						Dict					       =   (
				    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
				    if is_torch_available()
				    else ()
				)
				__UpperCamelCase      :						List[str]					       =   (
				    {
				        '''feature-extraction''': MobileViTModel,
				        '''image-classification''': MobileViTForImageClassification,
				        '''image-segmentation''': MobileViTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				__UpperCamelCase      :						str					       =   False
				__UpperCamelCase      :						List[Any]					       =   False
				__UpperCamelCase      :						Any					       =   False
				__UpperCamelCase      :						int					       =   False



				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       int           =   MobileViTModelTester(self    )
											SCREAMING_SNAKE_CASE__						:       Dict           =   MobileViTConfigTester(self   ,       config_class=SCREAMING_SNAKE_CASE__   ,       has_text_modality=SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		List[Any]:



											"""simple docstring"""




											self.config_tester.run_common_tests()



				@unittest.skip(reason="""MobileViT does not use inputs_embeds"""    )
				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											pass



				@unittest.skip(reason="""MobileViT does not support input and output embeddings"""    )
				def 	__magic_name__    (self    )					->		Union[str, Any]:



											"""simple docstring"""




											pass



				@unittest.skip(reason="""MobileViT does not output attentions"""    )
				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											pass



				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											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__						:       Optional[int]           =   model_class(SCREAMING_SNAKE_CASE__    )
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   inspect.signature(model.forward    )
																		# signature.parameters is an OrderedDict => so arg_names order is deterministic
																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   [*signature.parameters.keys()]

																		SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   ["""pixel_values"""]
																		self.assertListEqual(arg_names[:1]   ,       SCREAMING_SNAKE_CASE__    )



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



											"""simple docstring"""




											pass



				def 	__magic_name__    (self    )					->		Optional[Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Tuple           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											def check_hidden_states_output(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    ):
																		SCREAMING_SNAKE_CASE__						:       List[Any]           =   model_class(SCREAMING_SNAKE_CASE__    )
																		model.to(SCREAMING_SNAKE_CASE__    )
																		model.eval()

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

																		SCREAMING_SNAKE_CASE__						:       Dict           =   outputs.hidden_states

																		SCREAMING_SNAKE_CASE__						:       str           =   5
																		self.assertEqual(len(SCREAMING_SNAKE_CASE__    )   ,       SCREAMING_SNAKE_CASE__    )

																		# 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__						:       Tuple           =   2
																		for i in range(len(SCREAMING_SNAKE_CASE__    )    ):
																									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__						:       int           =   self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																		SCREAMING_SNAKE_CASE__						:       Optional[int]           =   True
																		check_hidden_states_output(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )

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

																		check_hidden_states_output(SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__   ,       SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Tuple:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__    )



				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*SCREAMING_SNAKE_CASE__    )



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



											"""simple docstring"""




											for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   MobileViTModel.from_pretrained(SCREAMING_SNAKE_CASE__    )
																		self.assertIsNotNone(SCREAMING_SNAKE_CASE__    )






def lowercase_  (   ):
							SCREAMING_SNAKE_CASE__						:       List[str]           =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""						)
							return image



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


				"""simple docstring"""



				@cached_property
				def 	__magic_name__    (self    )					->		Dict:



											"""simple docstring"""




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



				@slow
				def 	__magic_name__    (self    )					->		int:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Any           =   MobileViTForImageClassification.from_pretrained("""apple/mobilevit-xx-small"""    ).to(SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   self.default_image_processor
											SCREAMING_SNAKE_CASE__						:       List[str]           =   prepare_img()
											SCREAMING_SNAKE_CASE__						:       int           =   image_processor(images=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    ).to(SCREAMING_SNAKE_CASE__    )

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

											# verify the logits
											SCREAMING_SNAKE_CASE__						:       Dict           =   torch.Size((1, 10_00)    )
											self.assertEqual(outputs.logits.shape   ,       SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   torch.tensor([-1.9364, -1.2327, -0.4653]    ).to(SCREAMING_SNAKE_CASE__    )

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



				@slow
				def 	__magic_name__    (self    )					->		Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Tuple           =   MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""    )
											SCREAMING_SNAKE_CASE__						:       Tuple           =   model.to(SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       Dict           =   MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""    )

											SCREAMING_SNAKE_CASE__						:       Union[str, Any]           =   prepare_img()
											SCREAMING_SNAKE_CASE__						:       str           =   image_processor(images=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    ).to(SCREAMING_SNAKE_CASE__    )

											# forward pass
											with torch.no_grad():
																		SCREAMING_SNAKE_CASE__						:       Tuple           =   model(**SCREAMING_SNAKE_CASE__    )
											SCREAMING_SNAKE_CASE__						:       Optional[Any]           =   outputs.logits

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

											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   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=SCREAMING_SNAKE_CASE__   ,       )

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



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



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   MobileViTForSemanticSegmentation.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   model.to(SCREAMING_SNAKE_CASE__    )

											SCREAMING_SNAKE_CASE__						:       int           =   MobileViTImageProcessor.from_pretrained("""apple/deeplabv3-mobilevit-xx-small"""    )

											SCREAMING_SNAKE_CASE__						:       List[Any]           =   prepare_img()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   image_processor(images=SCREAMING_SNAKE_CASE__   ,       return_tensors="""pt"""    ).to(SCREAMING_SNAKE_CASE__    )

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

											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   outputs.logits.detach().cpu()

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

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






"""simple docstring"""




import pickle
import unittest

import torch

from accelerate import Accelerator
from accelerate.state import AcceleratorState
from accelerate.test_utils import require_cpu



@require_cpu
class 	lowerCAmelCase_						(unittest.TestCase  ):


				"""simple docstring"""



				def 	__magic_name__    (self    )					->		Union[str, Any]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__						:       List[Any]           =   torch.nn.Linear(10   ,       10    )
											SCREAMING_SNAKE_CASE__						:       Optional[int]           =   torch.optim.SGD(model.parameters()   ,       0.1    )
											SCREAMING_SNAKE_CASE__						:       int           =   Accelerator()
											SCREAMING_SNAKE_CASE__						:       List[Any]           =   accelerator.prepare(SCREAMING_SNAKE_CASE__    )
											try:
																		pickle.loads(pickle.dumps(SCREAMING_SNAKE_CASE__    )    )
											except Exception as e:
																		self.fail(F'''Accelerated optimizer pickling failed with {e}'''    )
											AcceleratorState._reset_state()




