
"""simple docstring"""





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(    lowerCamelCase	):



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.config_class(**self.inputs_dict)
							self.parent.assertTrue(hasattr(__a				,		'''width_multiplier'''))






class     _UpperCAmelCase:



		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				,		)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  parent
							_UpperCamelCase							 =  batch_size
							_UpperCamelCase							 =  image_size
							_UpperCamelCase							 =  patch_size
							_UpperCamelCase							 =  num_channels
							_UpperCamelCase							 =  make_divisible(5_12 * width_multiplier				,		divisor=8)
							_UpperCamelCase							 =  hidden_act
							_UpperCamelCase							 =  conv_kernel_size
							_UpperCamelCase							 =  output_stride
							_UpperCamelCase							 =  classifier_dropout_prob
							_UpperCamelCase							 =  use_labels
							_UpperCamelCase							 =  is_training
							_UpperCamelCase							 =  num_labels
							_UpperCamelCase							 =  initializer_range
							_UpperCamelCase							 =  scope
							_UpperCamelCase							 =  width_multiplier
							_UpperCamelCase							 =  ffn_dropout
							_UpperCamelCase							 =  attn_dropout



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






							'''simple docstring'''
							_UpperCamelCase							 =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

							_UpperCamelCase							 =  self.get_config()

							return config, pixel_values, labels, pixel_labels



		def 						UpperCAmelCase							(					self)       ->       List[str]:






							'''simple docstring'''
							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)       ->       List[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  MobileViTVaModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  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)       ->       List[str]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.num_labels
							_UpperCamelCase							 =  MobileViTVaForImageClassification(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  model(__a				,		labels=__a)
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, self.num_labels))



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a				,		__a)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.num_labels
							_UpperCamelCase							 =  MobileViTVaForSemanticSegmentation(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  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,
							    )				,		)
							_UpperCamelCase							 =  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)       ->       Optional[Any]:






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






@require_torch
class     _UpperCAmelCase(    lowerCamelCase      ,     lowerCamelCase      ,     unittest.TestCase	):
		lowercase__						=      (
		    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)

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

		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							_UpperCamelCase							 =  MobileViTVaModelTester(self)
							_UpperCamelCase							 =  MobileViTVaConfigTester(self				,		config_class=__a				,		has_text_modality=__a)



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






							'''simple docstring'''
							self.config_tester.run_common_tests()



		@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds''')
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							pass



		@unittest.skip(reason='''MobileViTV2 does not support input and output embeddings''')
		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							pass



		@unittest.skip(reason='''MobileViTV2 does not output attentions''')
		def 						UpperCAmelCase							(					self)       ->       Union[str, Any]:






							'''simple docstring'''
							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]:






							'''simple docstring'''
							pass



		@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
		def 						UpperCAmelCase							(					self)       ->       List[str]:






							'''simple docstring'''
							pass



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






							'''simple docstring'''
							_UpperCamelCase ,  _UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

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

												_UpperCamelCase							 =  ['''pixel_values''']
												self.assertListEqual(arg_names[:1]				,		__a)



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






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							(					self)       ->       Dict:






							'''simple docstring'''
							def check_hidden_states_output(__a				,		__a				,		__a):
												_UpperCamelCase							 =  model_class(__a)
												model.to(__a)
												model.eval()

												with torch.no_grad():
																	_UpperCamelCase							 =  model(**self._prepare_for_class(__a				,		__a))

												_UpperCamelCase							 =  outputs.hidden_states

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

							_UpperCamelCase ,  _UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  True
												check_hidden_states_output(__a				,		__a				,		__a)

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

												check_hidden_states_output(__a				,		__a				,		__a)



		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__a)



		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_semantic_segmentation(*__a)




		@slow
		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase							 =  MobileViTVaModel.from_pretrained(__a)
												self.assertIsNotNone(__a)





def       lowerCamelCase__		(			)							->		Optional[Any]:


					"""simple docstring"""





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






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



		@cached_property
		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							return (
							    MobileViTImageProcessor.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256''')
							    if is_vision_available()
							    else None
							)



		@slow
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256''').to(
							    __a)

							_UpperCamelCase							 =  self.default_image_processor
							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=__a				,		return_tensors='''pt''').to(__a)

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**__a)

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

							_UpperCamelCase							 =  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)       ->       List[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3''')
							_UpperCamelCase							 =  model.to(__a)

							_UpperCamelCase							 =  MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3''')

							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=__a				,		return_tensors='''pt''').to(__a)

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**__a)
							_UpperCamelCase							 =  outputs.logits

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

							_UpperCamelCase							 =  torch.tensor(
							    [
							        [[7.0863, 7.1525, 6.8201], [6.6931, 6.8770, 6.8933], [6.2978, 7.0366, 6.9636]],
							        [[-3.7134, -3.6712, -3.6675], [-3.5825, -3.3549, -3.4777], [-3.3435, -3.3979, -3.2857]],
							        [[-2.9329, -2.8003, -2.7369], [-3.0564, -2.4780, -2.0207], [-2.6889, -1.9298, -1.7640]],
							    ]				,		device=__a				,		)

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




		@slow
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3''')
							_UpperCamelCase							 =  model.to(__a)

							_UpperCamelCase							 =  MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3''')

							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=__a				,		return_tensors='''pt''').to(__a)

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**__a)

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

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

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








"""simple docstring"""





from __future__ import annotations



def       lowerCamelCase__		(			__snake_case,     __snake_case	)							->		float:


					"""simple docstring"""





					_UpperCamelCase							 =  sorted(numsa + numsa	)
					_UpperCamelCase ,  _UpperCamelCase							 =  divmod(len(__snake_case	),     2	)
					if mod == 1:
										return all_numbers[div]
					else:
										return (all_numbers[div] + all_numbers[div - 1]) / 2


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				_a														=		[float(x) for x in input("""Enter the elements of first array: """).split()]
				_a														=		[float(x) for x in input("""Enter the elements of second array: """).split()]
				print(F"""The median of two arrays is: {median_of_two_arrays(array_a, array_a)}""")






