
'''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 		__UpperCAmelCase   (      _lowerCamelCase		):


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.config_class(**self.inputs_dict						)
								self.parent.assertTrue(hasattr(lowerCAmelCase_					,     'hidden_sizes'						)						)
								self.parent.assertTrue(hasattr(lowerCAmelCase_					,     'neck_hidden_sizes'						)						)
								self.parent.assertTrue(hasattr(lowerCAmelCase_					,     'num_attention_heads'						)						)


class 		__UpperCAmelCase   :


							def __init__( self					,     lowerCAmelCase_					,     lowerCAmelCase_=13					,     lowerCAmelCase_=32					,     lowerCAmelCase_=2					,     lowerCAmelCase_=3					,     lowerCAmelCase_=6_40					,     lowerCAmelCase_=4					,     lowerCAmelCase_="silu"					,     lowerCAmelCase_=3					,     lowerCAmelCase_=32					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.1					,     lowerCAmelCase_=0.02					,     lowerCAmelCase_=True					,     lowerCAmelCase_=True					,     lowerCAmelCase_=10					,     lowerCAmelCase_=None					,     ):





								"""simple docstring"""






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


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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

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

								_snake_case     		=	self.get_config()

								return config, pixel_values, labels, pixel_labels


							def 				lowerCamelCase       ( 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 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	MobileViTModel(config=lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	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_						):





								"""simple docstring"""






								_snake_case     		=	self.num_labels
								_snake_case     		=	MobileViTForImageClassification(lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	model(lowerCAmelCase_					,     labels=lowerCAmelCase_						)
								self.parent.assertEqual(result.logits.shape					,     (self.batch_size, self.num_labels)						)


							def 				lowerCamelCase       ( self					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):





								"""simple docstring"""






								_snake_case     		=	self.num_labels
								_snake_case     		=	MobileViTForSemanticSegmentation(lowerCAmelCase_						)
								model.to(lowerCAmelCase_						)
								model.eval()
								_snake_case     		=	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,
								    )					,     )
								_snake_case     		=	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						):





								"""simple docstring"""






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


@require_torch
class 		__UpperCAmelCase   (      _lowerCamelCase		,     _lowerCamelCase		,     unittest.TestCase		):
							__lowercase   	= (
							    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							__lowercase   	= (
							    {
							        """feature-extraction""": MobileViTModel,
							        """image-classification""": MobileViTForImageClassification,
							        """image-segmentation""": MobileViTForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							__lowercase   	= False
							__lowercase   	= False
							__lowercase   	= False
							__lowercase   	= False


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MobileViTModelTester(self						)
								_snake_case     		=	MobileViTConfigTester(self					,     config_class=lowerCAmelCase_					,     has_text_modality=lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								self.config_tester.run_common_tests()


							@unittest.skip(reason='MobileViT does not use inputs_embeds'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@unittest.skip(reason='MobileViT does not support input and output embeddings'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							@unittest.skip(reason='MobileViT does not output attentions'						)
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								pass


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case		,				_snake_case     		=	self.model_tester.prepare_config_and_inputs_for_common()

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

									_snake_case     		=	['pixel_values']
									self.assertListEqual(arg_names[:1]					,     lowerCAmelCase_						)


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





								"""simple docstring"""






								pass


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								def check_hidden_states_output(lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						):
									_snake_case     		=	model_class(lowerCAmelCase_						)
									model.to(lowerCAmelCase_						)
									model.eval()

									with torch.no_grad():
										_snake_case     		=	model(**self._prepare_for_class(lowerCAmelCase_					,     lowerCAmelCase_						)						)

									_snake_case     		=	outputs.hidden_states

									_snake_case     		=	5
									self.assertEqual(len(lowerCAmelCase_						)					,     lowerCAmelCase_						)

									# MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
									# with the width and height being successively divided by 2.
									_snake_case     		=	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						)

								_snake_case		,				_snake_case     		=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
									_snake_case     		=	True
									check_hidden_states_output(lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						)

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

									check_hidden_states_output(lowerCAmelCase_					,     lowerCAmelCase_					,     lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_						)


							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_						)




							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_snake_case     		=	MobileViTModel.from_pretrained(lowerCAmelCase_						)
									self.assertIsNotNone(lowerCAmelCase_						)







def        SCREAMING_SNAKE_CASE__			(     ) ->			Any:
	_snake_case     		=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
	return image





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


							@cached_property
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






								_snake_case     		=	MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'						).to(lowerCAmelCase_						)

								_snake_case     		=	self.default_image_processor
								_snake_case     		=	prepare_img()
								_snake_case     		=	image_processor(images=lowerCAmelCase_					,     return_tensors='pt'						).to(lowerCAmelCase_						)

								# forward pass
								with torch.no_grad():
									_snake_case     		=	model(**lowerCAmelCase_						)

								# verify the logits
								_snake_case     		=	torch.Size((1, 10_00)						)
								self.assertEqual(outputs.logits.shape					,     lowerCAmelCase_						)

								_snake_case     		=	torch.tensor([-1.9364, -1.2327, -0.4653]						).to(lowerCAmelCase_						)

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


							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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

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

								_snake_case     		=	prepare_img()
								_snake_case     		=	image_processor(images=lowerCAmelCase_					,     return_tensors='pt'						).to(lowerCAmelCase_						)

								# forward pass
								with torch.no_grad():
									_snake_case     		=	model(**lowerCAmelCase_						)
								_snake_case     		=	outputs.logits

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

								_snake_case     		=	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=lowerCAmelCase_					,     )

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




							@slow
							def 				lowerCamelCase       ( self						):





								"""simple docstring"""






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

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

								_snake_case     		=	prepare_img()
								_snake_case     		=	image_processor(images=lowerCAmelCase_					,     return_tensors='pt'						).to(lowerCAmelCase_						)

								# forward pass
								with torch.no_grad():
									_snake_case     		=	model(**lowerCAmelCase_						)

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

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

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



'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


lowercase					:							str   =      {
    "configuration_nezha": ["NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP", "NezhaConfig"],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					lowercase					:							Any   =      [
					    "NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST",
					    "NezhaForNextSentencePrediction",
					    "NezhaForMaskedLM",
					    "NezhaForPreTraining",
					    "NezhaForMultipleChoice",
					    "NezhaForQuestionAnswering",
					    "NezhaForSequenceClassification",
					    "NezhaForTokenClassification",
					    "NezhaModel",
					    "NezhaPreTrainedModel",
					]


if TYPE_CHECKING:
					from .configuration_nezha import NEZHA_PRETRAINED_CONFIG_ARCHIVE_MAP, NezhaConfig

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_nezha import (
										    NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST,
										    NezhaForMaskedLM,
										    NezhaForMultipleChoice,
										    NezhaForNextSentencePrediction,
										    NezhaForPreTraining,
										    NezhaForQuestionAnswering,
										    NezhaForSequenceClassification,
										    NezhaForTokenClassification,
										    NezhaModel,
										    NezhaPreTrainedModel,
										)


else:
					import sys

					lowercase					:							Union[str, Any]   =      _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)

