

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      lowerCamelCase_      (	snake_case_	):




	def        lowerCAmelCase_       (     self						:     List[str]							):
		__A :			Optional[Any]		    =			self.config_class(**self.inputs_dict							)
		self.parent.assertTrue(hasattr(A_					,      """width_multiplier"""							)							)






class      lowerCamelCase_      :




	def __init__(     self						:     Optional[Any]					,      __A						:     Optional[int]					,      __A						:     Dict=13					,      __A						:     Union[str, Any]=64					,      __A						:     List[Any]=2					,      __A						:     Union[str, Any]=3					,      __A						:     Optional[Any]="swish"					,      __A						:     List[str]=3					,      __A						:     List[Any]=32					,      __A						:     Optional[int]=0.1					,      __A						:     Union[str, Any]=0.0_2					,      __A						:     Any=True					,      __A						:     Optional[int]=True					,      __A						:     Any=10					,      __A						:     Optional[Any]=None					,      __A						:     Optional[int]=0.2_5					,      __A						:     Tuple=0.0					,      __A						:     List[str]=0.0					,      ):
		__A :			int		    =			parent
		__A :			Tuple		    =			batch_size
		__A :			Optional[int]		    =			image_size
		__A :			List[str]		    =			patch_size
		__A :			Dict		    =			num_channels
		__A :			int		    =			make_divisible(512 * width_multiplier					,      divisor=8							)
		__A :			int		    =			hidden_act
		__A :			List[Any]		    =			conv_kernel_size
		__A :			int		    =			output_stride
		__A :			Dict		    =			classifier_dropout_prob
		__A :			Dict		    =			use_labels
		__A :			int		    =			is_training
		__A :			Union[str, Any]		    =			num_labels
		__A :			Any		    =			initializer_range
		__A :			List[Any]		    =			scope
		__A :			Any		    =			width_multiplier
		__A :			Any		    =			ffn_dropout
		__A :			List[Any]		    =			attn_dropout




	def        lowerCAmelCase_       (     self						:     Dict							):
		__A :			int		    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

		__A :			Optional[int]		    =			None
		__A :			Dict		    =			None
		if self.use_labels:
			__A :			int		    =			ids_tensor([self.batch_size]					,      self.num_labels							)
			__A :			int		    =			ids_tensor([self.batch_size, self.image_size, self.image_size]					,      self.num_labels							)

		__A :			str		    =			self.get_config()

		return config, pixel_values, labels, pixel_labels




	def        lowerCAmelCase_       (     self						:     List[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        lowerCAmelCase_       (     self						:     Optional[int]					,      __A						:     Any					,      __A						:     str					,      __A						:     int					,      __A						:     List[str]							):
		__A :			Any		    =			MobileViTVaModel(config=A_							)
		model.to(A_							)
		model.eval()
		__A :			str		    =			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        lowerCAmelCase_       (     self						:     int					,      __A						:     int					,      __A						:     List[Any]					,      __A						:     str					,      __A						:     List[str]							):
		__A :			Tuple		    =			self.num_labels
		__A :			Union[str, Any]		    =			MobileViTVaForImageClassification(A_							)
		model.to(A_							)
		model.eval()
		__A :			int		    =			model(A_					,      labels=A_							)
		self.parent.assertEqual(result.logits.shape					,      (self.batch_size, self.num_labels)							)




	def        lowerCAmelCase_       (     self						:     List[Any]					,      __A						:     Tuple					,      __A						:     Dict					,      __A						:     int					,      __A						:     Dict							):
		__A :			Optional[int]		    =			self.num_labels
		__A :			List[Any]		    =			MobileViTVaForSemanticSegmentation(A_							)
		model.to(A_							)
		model.eval()
		__A :			Optional[Any]		    =			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 :			Optional[int]		    =			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        lowerCAmelCase_       (     self						:     str							):
		__A :			List[Any]		    =			self.prepare_config_and_inputs()
		__A    ,				__A    ,				__A    ,				__A :			int		    =			config_and_inputs
		__A :			str		    =			{"""pixel_values""": pixel_values}
		return config, inputs_dict






@require_torch
class      lowerCamelCase_      (	snake_case_						,      snake_case_						,      unittest.TestCase	):
	_lowercase		:   List[Any]     					=				(
	    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
	    if is_torch_available()
	    else ()
	)

	_lowercase		:   List[str]     					=				(
	    {
	        '''feature-extraction''': MobileViTVaModel,
	        '''image-classification''': MobileViTVaForImageClassification,
	        '''image-segmentation''': MobileViTVaForSemanticSegmentation,
	    }
	    if is_torch_available()
	    else {}
	)

	_lowercase		:   List[Any]     					=				False
	_lowercase		:   Any     					=				False
	_lowercase		:   List[Any]     					=				False
	_lowercase		:   Any     					=				False




	def        lowerCAmelCase_       (     self						:     str							):
		__A :			str		    =			MobileViTVaModelTester(self							)
		__A :			Tuple		    =			MobileViTVaConfigTester(self					,      config_class=A_					,      has_text_modality=A_							)




	def        lowerCAmelCase_       (     self						:     List[str]							):
		self.config_tester.run_common_tests()




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




	@unittest.skip(reason="""MobileViTV2 does not support input and output embeddings"""							)
	def        lowerCAmelCase_       (     self						:     Optional[Any]							):
		pass




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




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




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




	def        lowerCAmelCase_       (     self						:     str							):
		__A    ,				__A :			Dict		    =			self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			__A :			Optional[int]		    =			model_class(A_							)
			__A :			Dict		    =			inspect.signature(model.forward							)
			# signature.parameters is an OrderedDict => so arg_names order is deterministic
			__A :			Tuple		    =			[*signature.parameters.keys()]

			__A :			Optional[Any]		    =			["""pixel_values"""]
			self.assertListEqual(arg_names[:1]					,      A_							)




	def        lowerCAmelCase_       (     self						:     List[Any]							):
		__A :			Any		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*A_							)




	def        lowerCAmelCase_       (     self						:     Any							):






		def check_hidden_states_output(__A						:     Union[str, Any]					,      __A						:     Dict					,      __A						:     Dict							):
			__A :			Any		    =			model_class(A_							)
			model.to(A_							)
			model.eval()

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

			__A :			Tuple		    =			outputs.hidden_states

			__A :			List[str]		    =			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 :			str		    =			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 :			int		    =			self.model_tester.prepare_config_and_inputs_for_common()

		for model_class in self.all_model_classes:
			__A :			str		    =			True
			check_hidden_states_output(A_					,      A_					,      A_							)

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

			check_hidden_states_output(A_					,      A_					,      A_							)




	def        lowerCAmelCase_       (     self						:     Union[str, Any]							):
		__A :			Union[str, Any]		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_image_classification(*A_							)




	def        lowerCAmelCase_       (     self						:     int							):
		__A :			str		    =			self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_for_semantic_segmentation(*A_							)




	@slow
	def        lowerCAmelCase_       (     self						:     List[Any]							):






		for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
			__A :			Dict		    =			MobileViTVaModel.from_pretrained(A_							)
			self.assertIsNotNone(A_							)






def 							__SCREAMING_SNAKE_CASE     (   )					->				Optional[Any]:
	__A :			List[str]		    =			Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
	return image







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




	@cached_property
	def        lowerCAmelCase_       (     self						:     Union[str, Any]							):
		return (
		    MobileViTImageProcessor.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""							)
		    if is_vision_available()
		    else None
		)




	@slow
	def        lowerCAmelCase_       (     self						:     Tuple							):
		__A :			Optional[int]		    =			MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""							).to(
		    A_							)

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

		# forward pass
		with torch.no_grad():
			__A :			List[Any]		    =			model(**A_							)

		# verify the logits
		__A :			int		    =			torch.Size((1, 1000)							)
		self.assertEqual(outputs.logits.shape					,      A_							)

		__A :			Tuple		    =			torch.tensor([-1.6_3_3_6e0_0, -7.3_2_0_4e-0_2, -5.1_8_8_3e-0_1]							).to(A_							)

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




	@slow
	def        lowerCAmelCase_       (     self						:     Dict							):
		__A :			Dict		    =			MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)
		__A :			Union[str, Any]		    =			model.to(A_							)

		__A :			List[Any]		    =			MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)

		__A :			Optional[Any]		    =			prepare_img()
		__A :			int		    =			image_processor(images=A_					,      return_tensors="""pt"""							).to(A_							)

		# forward pass
		with torch.no_grad():
			__A :			Dict		    =			model(**A_							)
		__A :			Optional[Any]		    =			outputs.logits

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

		__A :			Any		    =			torch.tensor(
		    [
		        [[7.0_8_6_3, 7.1_5_2_5, 6.8_2_0_1], [6.6_9_3_1, 6.8_7_7_0, 6.8_9_3_3], [6.2_9_7_8, 7.0_3_6_6, 6.9_6_3_6]],
		        [[-3.7_1_3_4, -3.6_7_1_2, -3.6_6_7_5], [-3.5_8_2_5, -3.3_5_4_9, -3.4_7_7_7], [-3.3_4_3_5, -3.3_9_7_9, -3.2_8_5_7]],
		        [[-2.9_3_2_9, -2.8_0_0_3, -2.7_3_6_9], [-3.0_5_6_4, -2.4_7_8_0, -2.0_2_0_7], [-2.6_8_8_9, -1.9_2_9_8, -1.7_6_4_0]],
		    ]					,      device=A_					,      )

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




	@slow
	def        lowerCAmelCase_       (     self						:     Union[str, Any]							):
		__A :			str		    =			MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)
		__A :			Dict		    =			model.to(A_							)

		__A :			Dict		    =			MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""							)

		__A :			str		    =			prepare_img()
		__A :			str		    =			image_processor(images=A_					,      return_tensors="""pt"""							).to(A_							)

		# forward pass
		with torch.no_grad():
			__A :			List[Any]		    =			model(**A_							)

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

		__A :			Any		    =			image_processor.post_process_semantic_segmentation(outputs=A_					,      target_sizes=[(50, 60)]							)
		__A :			Union[str, Any]		    =			torch.Size((50, 60)							)
		self.assertEqual(segmentation[0].shape					,      A_							)

		__A :			List[Any]		    =			image_processor.post_process_semantic_segmentation(outputs=A_							)
		__A :			Optional[Any]		    =			torch.Size((32, 32)							)
		self.assertEqual(segmentation[0].shape					,      A_							)







'''simple docstring'''
import numpy as np







def 		A_(     A						:		str		,     A						:		Optional[Any]		,     A						:		Tuple		,     A						:		Optional[int]		,     A						:		str):
							UpperCamelCase   			=     int(np.ceil((x_end - xa) / h))
							UpperCamelCase   			=     np.zeros((n + 1,))
							UpperCamelCase   			=     ya
							UpperCamelCase   			=     xa

							for k in range(A):
														UpperCamelCase   			=     f(A		,     y[k])
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + 0.5 * h		,     y[k] + 0.5 * h * ka)
														UpperCamelCase   			=     f(x + h		,     y[k] + h * ka)
														UpperCamelCase   			=     y[k] + (1 / 6) * h * (ka + 2 * ka + 2 * ka + ka)
														x += h

							return y


if __name__ == "__main__":
						import doctest

						doctest.testmod()




