


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





							'''simple docstring'''






							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      self.config_class(**self.inputs_dict  )
														self.parent.assertTrue(hasattr(lowerCamelCase_   ,       '''width_multiplier'''  )  )




class 						a__							:





							'''simple docstring'''






							def __init__(						self   ,       lowerCamelCase_   ,       lowerCamelCase_=13   ,       lowerCamelCase_=64   ,       lowerCamelCase_=2   ,       lowerCamelCase_=3   ,       lowerCamelCase_="swish"   ,       lowerCamelCase_=3   ,       lowerCamelCase_=32   ,       lowerCamelCase_=0.1   ,       lowerCamelCase_=0.02   ,       lowerCamelCase_=True   ,       lowerCamelCase_=True   ,       lowerCamelCase_=10   ,       lowerCamelCase_=None   ,       lowerCamelCase_=0.25   ,       lowerCamelCase_=0.0   ,       lowerCamelCase_=0.0   ,       )			->				Tuple:
														lowerCAmelCase__			  =      parent
														lowerCAmelCase__			  =      batch_size
														lowerCAmelCase__			  =      image_size
														lowerCAmelCase__			  =      patch_size
														lowerCAmelCase__			  =      num_channels
														lowerCAmelCase__			  =      make_divisible(5_12 * width_multiplier   ,       divisor=8  )
														lowerCAmelCase__			  =      hidden_act
														lowerCAmelCase__			  =      conv_kernel_size
														lowerCAmelCase__			  =      output_stride
														lowerCAmelCase__			  =      classifier_dropout_prob
														lowerCAmelCase__			  =      use_labels
														lowerCAmelCase__			  =      is_training
														lowerCAmelCase__			  =      num_labels
														lowerCAmelCase__			  =      initializer_range
														lowerCAmelCase__			  =      scope
														lowerCAmelCase__			  =      width_multiplier
														lowerCAmelCase__			  =      ffn_dropout
														lowerCAmelCase__			  =      attn_dropout







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

														lowerCAmelCase__			  =      self.get_config()

														return config, pixel_values, labels, pixel_labels







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







							def     __SCREAMING_SNAKE_CASE				(						self   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )			->				List[Any]:
														lowerCAmelCase__			  =      self.num_labels
														lowerCAmelCase__			  =      MobileViTVaForSemanticSegmentation(lowerCamelCase_  )
														model.to(lowerCamelCase_  )
														model.eval()
														lowerCAmelCase__			  =      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,
														    )   ,       )
														lowerCAmelCase__			  =      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     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      self.prepare_config_and_inputs()
														lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__  ,   lowerCAmelCase__			  =      config_and_inputs
														lowerCAmelCase__			  =      {'''pixel_values''': pixel_values}
														return config, inputs_dict




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





							'''simple docstring'''






							lowercase__     :  Tuple      		= (
							    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)

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

							lowercase__     :  Dict      		= False
							lowercase__     :  Optional[int]      		= False
							lowercase__     :  int      		= False
							lowercase__     :  List[str]      		= False







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														lowerCAmelCase__			  =      MobileViTVaModelTester(self  )
														lowerCAmelCase__			  =      MobileViTVaConfigTester(self   ,       config_class=lowerCamelCase_   ,       has_text_modality=lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Any:
														self.config_tester.run_common_tests()







							@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														pass







							@unittest.skip(reason='''MobileViTV2 does not support input and output embeddings'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														pass







							@unittest.skip(reason='''MobileViTV2 does not output attentions'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														pass







							@require_torch_multi_gpu
							@unittest.skip(reason='''Got `CUDA error: misaligned address` for tests after this one being run.'''  )
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														pass







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







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()

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

																					lowerCAmelCase__			  =      ['''pixel_values''']
																					self.assertListEqual(arg_names[:1]   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														def check_hidden_states_output(lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  ):
																					lowerCAmelCase__			  =      model_class(lowerCamelCase_  )
																					model.to(lowerCamelCase_  )
																					model.eval()

																					with torch.no_grad():
																												lowerCAmelCase__			  =      model(**self._prepare_for_class(lowerCamelCase_   ,       lowerCamelCase_  )  )

																					lowerCAmelCase__			  =      outputs.hidden_states

																					lowerCAmelCase__			  =      5
																					self.assertEqual(len(lowerCamelCase_  )   ,       lowerCamelCase_  )

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

														lowerCAmelCase__  ,   lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs_for_common()

														for model_class in self.all_model_classes:
																					lowerCAmelCase__			  =      True
																					check_hidden_states_output(lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )

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

																					check_hidden_states_output(lowerCamelCase_   ,       lowerCamelCase_   ,       lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Optional[int]:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_image_classification(*lowerCamelCase_  )







							def     __SCREAMING_SNAKE_CASE				(						self  )			->				int:
														lowerCAmelCase__			  =      self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase_  )







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Dict:
														for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					lowerCAmelCase__			  =      MobileViTVaModel.from_pretrained(lowerCamelCase_  )
																					self.assertIsNotNone(lowerCamelCase_  )


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






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





							'''simple docstring'''






							@cached_property
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[Any]:
														return (
														    MobileViTImageProcessor.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''  )
														    if is_vision_available()
														    else None
														)







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Union[str, Any]:
														lowerCAmelCase__			  =      MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''  ).to(
														    lowerCamelCase_  )

														lowerCAmelCase__			  =      self.default_image_processor
														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )

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

														lowerCAmelCase__			  =      torch.tensor([-1.63_36e00, -7.32_04e-02, -5.18_83e-01]  ).to(lowerCamelCase_  )

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







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				List[str]:
														lowerCAmelCase__			  =      MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
														lowerCAmelCase__			  =      model.to(lowerCamelCase_  )

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

														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )
														lowerCAmelCase__			  =      outputs.logits

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

														lowerCAmelCase__			  =      torch.tensor(
														    [
														        [[7.0_863, 7.1_525, 6.8_201], [6.6_931, 6.8_770, 6.8_933], [6.2_978, 7.0_366, 6.9_636]],
														        [[-3.7_134, -3.6_712, -3.6_675], [-3.5_825, -3.3_549, -3.4_777], [-3.3_435, -3.3_979, -3.2_857]],
														        [[-2.9_329, -2.8_003, -2.7_369], [-3.0_564, -2.4_780, -2.0_207], [-2.6_889, -1.9_298, -1.7_640]],
														    ]   ,       device=lowerCamelCase_   ,       )

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







							@slow
							def     __SCREAMING_SNAKE_CASE				(						self  )			->				Tuple:
														lowerCAmelCase__			  =      MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
														lowerCAmelCase__			  =      model.to(lowerCamelCase_  )

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

														lowerCAmelCase__			  =      prepare_img()
														lowerCAmelCase__			  =      image_processor(images=lowerCamelCase_   ,       return_tensors='''pt'''  ).to(lowerCamelCase_  )

														# forward pass
														with torch.no_grad():
																					lowerCAmelCase__			  =      model(**lowerCamelCase_  )

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

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

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


from math import sqrt
def 							__SCREAMING_SNAKE_CASE     (   a__    :   int = 1000000       )					->				int:
	__A :			int		    =			0
	__A :			int		    =			0
	__A :			int

	while num_cuboids <= limit:
		max_cuboid_size += 1
		for sum_shortest_sides in range(2			,2 * max_cuboid_size + 1       ):
			if sqrt(sum_shortest_sides**2 + max_cuboid_size**2       ).is_integer():
				num_cuboids += (
				    min(a__			,sum_shortest_sides // 2       )
				    - max(1			,sum_shortest_sides - max_cuboid_size       )
				    + 1
				)

	return max_cuboid_size


if __name__ == "__main__":
			print(f"""{solution() = }""")





