


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    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				def   _UpperCAmelCase       (    self )						->					Tuple:
					A             =					self.config_class(**self.inputs_dict )
					self.parent.assertTrue(hasattr(a__					, """width_multiplier""" ) )






class    _UpperCamelCase     :

				"""simple docstring"""







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

				def   _UpperCAmelCase       (    self )						->					Dict:
					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 )						->					Union[str, Any]:
					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					, a__					, a__					, a__					, a__ )						->					int:
					A             =					MobileViTVaModel(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__ )						->					Dict:
					A             =					self.num_labels
					A             =					MobileViTVaForImageClassification(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__ )						->					str:
					A             =					self.num_labels
					A             =					MobileViTVaForSemanticSegmentation(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 )						->					List[str]:
					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    _UpperCamelCase     (       __snake_case     ,		__snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(
				    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
				    if is_torch_available()
				    else ()
				)

				lowerCAmelCase					=			(
				    {
				        'feature-extraction': MobileViTVaModel,
				        'image-classification': MobileViTVaForImageClassification,
				        'image-segmentation': MobileViTVaForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False
				lowerCAmelCase					=			False

				def   _UpperCAmelCase       (    self )						->					int:
					A             =					MobileViTVaModelTester(self )
					A             =					MobileViTVaConfigTester(self					, config_class=a__					, has_text_modality=a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					self.config_tester.run_common_tests()

				@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds""" )
				def   _UpperCAmelCase       (    self )						->					Any:
					pass

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

				@unittest.skip(reason="""MobileViTV2 does not output attentions""" )
				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					pass

				@require_torch_multi_gpu
				@unittest.skip(reason="""Got `CUDA error: misaligned address` for tests after this one being run.""" )
				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					pass

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

				def   _UpperCAmelCase       (    self )						->					str:
					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__ )

				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*a__ )

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					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__ )

						# MobileViTV2'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 )						->					Optional[int]:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_image_classification(*a__ )

				def   _UpperCAmelCase       (    self )						->					Dict:
					A             =					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_semantic_segmentation(*a__ )

				@slow
				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						A             =					MobileViTVaModel.from_pretrained(a__ )
						self.assertIsNotNone(a__ )





def 	_lowerCAmelCase					( )			-> List[Any]:





	"""simple docstring"""







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






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

				"""simple docstring"""







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

				@slow
				def   _UpperCAmelCase       (    self )						->					Union[str, Any]:
					A             =					MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256""" ).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.6_336e00, -7.3_204e-02, -5.1_883e-01] ).to(a__ )

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

				@slow
				def   _UpperCAmelCase       (    self )						->					str:
					A             =					MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3""" )
					A             =					model.to(a__ )

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

					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(
					    [
					        [[7.08_63, 7.15_25, 6.82_01], [6.69_31, 6.87_70, 6.89_33], [6.29_78, 7.03_66, 6.96_36]],
					        [[-3.71_34, -3.67_12, -3.66_75], [-3.58_25, -3.35_49, -3.47_77], [-3.34_35, -3.39_79, -3.28_57]],
					        [[-2.93_29, -2.80_03, -2.73_69], [-3.05_64, -2.47_80, -2.02_07], [-2.68_89, -1.92_98, -1.76_40]],
					    ]					, device=a__					, )

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

				@slow
				def   _UpperCAmelCase       (    self )						->					int:
					A             =					MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3""" )
					A             =					model.to(a__ )

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

					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__ )







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


_lowercase							:   int						=						{
    "configuration_roberta_prelayernorm": [
        "ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "RobertaPreLayerNormConfig",
        "RobertaPreLayerNormOnnxConfig",
    ],
}

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase							:   List[Any]						=						[
				    "ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "RobertaPreLayerNormForCausalLM",
				    "RobertaPreLayerNormForMaskedLM",
				    "RobertaPreLayerNormForMultipleChoice",
				    "RobertaPreLayerNormForQuestionAnswering",
				    "RobertaPreLayerNormForSequenceClassification",
				    "RobertaPreLayerNormForTokenClassification",
				    "RobertaPreLayerNormModel",
				    "RobertaPreLayerNormPreTrainedModel",
				]

try:
				if not is_tf_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase							:   Optional[int]						=						[
				    "TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST",
				    "TFRobertaPreLayerNormForCausalLM",
				    "TFRobertaPreLayerNormForMaskedLM",
				    "TFRobertaPreLayerNormForMultipleChoice",
				    "TFRobertaPreLayerNormForQuestionAnswering",
				    "TFRobertaPreLayerNormForSequenceClassification",
				    "TFRobertaPreLayerNormForTokenClassification",
				    "TFRobertaPreLayerNormMainLayer",
				    "TFRobertaPreLayerNormModel",
				    "TFRobertaPreLayerNormPreTrainedModel",
				]

try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_lowercase							:   str						=						[
				    "FlaxRobertaPreLayerNormForCausalLM",
				    "FlaxRobertaPreLayerNormForMaskedLM",
				    "FlaxRobertaPreLayerNormForMultipleChoice",
				    "FlaxRobertaPreLayerNormForQuestionAnswering",
				    "FlaxRobertaPreLayerNormForSequenceClassification",
				    "FlaxRobertaPreLayerNormForTokenClassification",
				    "FlaxRobertaPreLayerNormModel",
				    "FlaxRobertaPreLayerNormPreTrainedModel",
				]


if TYPE_CHECKING:
				from .configuration_roberta_prelayernorm import (
				    ROBERTA_PRELAYERNORM_PRETRAINED_CONFIG_ARCHIVE_MAP,
				    RobertaPreLayerNormConfig,
				    RobertaPreLayerNormOnnxConfig,
				)

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_roberta_prelayernorm import (
								    ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
								    RobertaPreLayerNormForCausalLM,
								    RobertaPreLayerNormForMaskedLM,
								    RobertaPreLayerNormForMultipleChoice,
								    RobertaPreLayerNormForQuestionAnswering,
								    RobertaPreLayerNormForSequenceClassification,
								    RobertaPreLayerNormForTokenClassification,
								    RobertaPreLayerNormModel,
								    RobertaPreLayerNormPreTrainedModel,
								)

				try:
								if not is_tf_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_tf_roberta_prelayernorm import (
								    TF_ROBERTA_PRELAYERNORM_PRETRAINED_MODEL_ARCHIVE_LIST,
								    TFRobertaPreLayerNormForCausalLM,
								    TFRobertaPreLayerNormForMaskedLM,
								    TFRobertaPreLayerNormForMultipleChoice,
								    TFRobertaPreLayerNormForQuestionAnswering,
								    TFRobertaPreLayerNormForSequenceClassification,
								    TFRobertaPreLayerNormForTokenClassification,
								    TFRobertaPreLayerNormMainLayer,
								    TFRobertaPreLayerNormModel,
								    TFRobertaPreLayerNormPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_roberta_prelayernorm import (
								    FlaxRobertaPreLayerNormForCausalLM,
								    FlaxRobertaPreLayerNormForMaskedLM,
								    FlaxRobertaPreLayerNormForMultipleChoice,
								    FlaxRobertaPreLayerNormForQuestionAnswering,
								    FlaxRobertaPreLayerNormForSequenceClassification,
								    FlaxRobertaPreLayerNormForTokenClassification,
								    FlaxRobertaPreLayerNormModel,
								    FlaxRobertaPreLayerNormPreTrainedModel,
								)

else:
				import sys

				_lowercase							:   List[Any]						=						_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)



