


'''simple docstring'''





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


UpperCAmelCase__  			=				{
    '''configuration_time_series_transformer''': [
        '''TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''TimeSeriesTransformerConfig''',
    ],
}

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					UpperCAmelCase__  			=				[
					    '''TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
					    '''TimeSeriesTransformerForPrediction''',
					    '''TimeSeriesTransformerModel''',
					    '''TimeSeriesTransformerPreTrainedModel''',
					]


if TYPE_CHECKING:
					from .configuration_time_series_transformer import (
					    TIME_SERIES_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
					    TimeSeriesTransformerConfig,
					)

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_time_series_transformer import (
										    TIME_SERIES_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TimeSeriesTransformerForPrediction,
										    TimeSeriesTransformerModel,
										    TimeSeriesTransformerPreTrainedModel,
										)

else:
					import sys

					UpperCAmelCase__  			=				_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)







'''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 						a__					(					a_   ):





			'''simple docstring'''

			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Optional[int]:
						__A=	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 						a__					:





			'''simple docstring'''

			def __init__(  self							:			str			,    lowerCAmelCase_							:			str			,    lowerCAmelCase_							:			str=13			,    lowerCAmelCase_							:			Dict=32			,    lowerCAmelCase_							:			Tuple=2			,    lowerCAmelCase_							:			List[str]=3			,    lowerCAmelCase_							:			str=640			,    lowerCAmelCase_							:			str=4			,    lowerCAmelCase_							:			Dict="silu"			,    lowerCAmelCase_							:			List[str]=3			,    lowerCAmelCase_							:			str=32			,    lowerCAmelCase_							:			List[Any]=0.1			,    lowerCAmelCase_							:			str=0.1			,    lowerCAmelCase_							:			str=0.1			,    lowerCAmelCase_							:			str=0.02			,    lowerCAmelCase_							:			Optional[int]=True			,    lowerCAmelCase_							:			Optional[int]=True			,    lowerCAmelCase_							:			Any=10			,    lowerCAmelCase_							:			Dict=None			,    )      ->		Optional[Any]:
						__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 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		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 					lowerCAmelCase     (  self							:			List[Any]	)      ->		List[Any]:
						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							:			Any			,    lowerCAmelCase_							:			List[Any]			,    lowerCAmelCase_							:			Any			,    lowerCAmelCase_							:			Tuple			,    lowerCAmelCase_							:			Optional[Any]	)      ->		Dict:
						__A=	MobileViTModel(config=lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	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							:			List[str]			,    lowerCAmelCase_							:			List[str]			,    lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			List[Any]			,    lowerCAmelCase_							:			Any	)      ->		Optional[Any]:
						__A=	self.num_labels
						__A=	MobileViTForImageClassification(lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	model(lowerCAmelCase_			,    labels=lowerCAmelCase_	)
						self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_labels)	)
			def 					lowerCAmelCase     (  self							:			Optional[int]			,    lowerCAmelCase_							:			Optional[Any]			,    lowerCAmelCase_							:			Optional[Any]			,    lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			int	)      ->		int:
						__A=	self.num_labels
						__A=	MobileViTForSemanticSegmentation(lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	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,
						    )			,    )
						__A=	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							:			Optional[int]	)      ->		Optional[int]:
						__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 						a__					(					a_      ,  a_      ,  unittest.TestCase   ):





			'''simple docstring'''

			A						:				Union[str, Any]					      =			(
			    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)
			A						:				Any					      =			(
			    {
			        '''feature-extraction''': MobileViTModel,
			        '''image-classification''': MobileViTForImageClassification,
			        '''image-segmentation''': MobileViTForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			A						:				int					      =			False
			A						:				Dict					      =			False
			A						:				Dict					      =			False
			A						:				str					      =			False
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Union[str, Any]:
						__A=	MobileViTModelTester(self	)
						__A=	MobileViTConfigTester(self			,    config_class=lowerCAmelCase_			,    has_text_modality=lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Any	)      ->		str:
						self.config_tester.run_common_tests()
			@unittest.skip(reason='MobileViT does not use inputs_embeds'	)
			def 					lowerCAmelCase     (  self							:			int	)      ->		Any:
						pass
			@unittest.skip(reason='MobileViT does not support input and output embeddings'	)
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		List[Any]:
						pass
			@unittest.skip(reason='MobileViT does not output attentions'	)
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		Optional[int]:
						pass
			def 					lowerCAmelCase     (  self							:			Optional[int]	)      ->		Optional[Any]:
						__A,	__A=	self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__A=	model_class(lowerCAmelCase_	)
									__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]			,    lowerCAmelCase_	)
			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
			def 					lowerCAmelCase     (  self							:			str	)      ->		int:
						pass
			def 					lowerCAmelCase     (  self							:			str	)      ->		Any:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		str:
						def check_hidden_states_output(lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			int			,    lowerCAmelCase_							:			List[str]	):
									__A=	model_class(lowerCAmelCase_	)
									model.to(lowerCAmelCase_	)
									model.eval()

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

									__A=	outputs.hidden_states

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

						__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(lowerCAmelCase_			,    lowerCAmelCase_			,    lowerCAmelCase_	)

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

									check_hidden_states_output(lowerCAmelCase_			,    lowerCAmelCase_			,    lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Optional[Any]:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Union[str, Any]:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_	)

			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Optional[Any]:
						for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	MobileViTModel.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)






def 						UpperCAmelCase__(				):






			"""simple docstring"""




			__A=	Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
			return image






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





			'''simple docstring'''

			@cached_property
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Tuple:
						return MobileViTImageProcessor.from_pretrained('apple/mobilevit-xx-small'	) if is_vision_available() else None
			@slow
			def 					lowerCAmelCase     (  self							:			int	)      ->		str:
						__A=	MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'	).to(lowerCAmelCase_	)

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

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

						# verify the logits
						__A=	torch.Size((1, 1_000)	)
						self.assertEqual(outputs.logits.shape			,    lowerCAmelCase_	)

						__A=	torch.tensor([-1.93_64, -1.23_27, -0.46_53]	).to(lowerCAmelCase_	)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]			,    lowerCAmelCase_			,    atol=1E-4	)	)
			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		List[str]:
						__A=	MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)
						__A=	model.to(lowerCAmelCase_	)

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

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

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

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

						__A=	torch.tensor(
						    [
						        [[6.97_13, 6.97_86, 7.24_22], [7.28_93, 7.28_25, 7.44_46], [7.65_80, 7.87_97, 7.94_20]],
						        [[-10.68_69, -10.32_50, -10.34_71], [-10.42_28, -9.98_68, -9.71_32], [-11.04_05, -11.02_21, -10.73_18]],
						        [[-3.30_89, -2.85_39, -2.67_40], [-3.27_06, -2.56_21, -2.51_08], [-3.25_34, -2.66_15, -2.66_51]],
						    ]			,    device=lowerCAmelCase_			,    )

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

			@slow
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		str:
						__A=	MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)
						__A=	model.to(lowerCAmelCase_	)

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

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

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

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

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

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



