

"""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 				SCREAMING_SNAKE_CASE					(		a_       ):






					"""simple docstring"""



					def        __lowerCAmelCase (       self			:				List[Any]		):
						lowerCAmelCase__	:						List[Any]  				=	self.config_class(**self.inputs_dict		)
						self.parent.assertTrue(hasattr(lowercase_   ,'''width_multiplier'''		)		)







class 				SCREAMING_SNAKE_CASE					:






					"""simple docstring"""



					def __init__(       self			:				Tuple   ,lowercase_			:				Dict   ,lowercase_			:				List[Any]=1_3   ,lowercase_			:				Tuple=6_4   ,lowercase_			:				Optional[int]=2   ,lowercase_			:				Any=3   ,lowercase_			:				List[Any]="swish"   ,lowercase_			:				Optional[Any]=3   ,lowercase_			:				Dict=3_2   ,lowercase_			:				Union[str, Any]=0.1   ,lowercase_			:				int=0.02   ,lowercase_			:				List[Any]=True   ,lowercase_			:				Union[str, Any]=True   ,lowercase_			:				Optional[int]=1_0   ,lowercase_			:				List[str]=None   ,lowercase_			:				List[Any]=0.25   ,lowercase_			:				List[Any]=0.0   ,lowercase_			:				Dict=0.0   ,):
						lowerCAmelCase__	:						Tuple  				=	parent
						lowerCAmelCase__	:						Any  				=	batch_size
						lowerCAmelCase__	:						Any  				=	image_size
						lowerCAmelCase__	:						int  				=	patch_size
						lowerCAmelCase__	:						Optional[Any]  				=	num_channels
						lowerCAmelCase__	:						List[str]  				=	make_divisible(5_1_2 * width_multiplier   ,divisor=8		)
						lowerCAmelCase__	:						Union[str, Any]  				=	hidden_act
						lowerCAmelCase__	:						List[Any]  				=	conv_kernel_size
						lowerCAmelCase__	:						Tuple  				=	output_stride
						lowerCAmelCase__	:						Union[str, Any]  				=	classifier_dropout_prob
						lowerCAmelCase__	:						Optional[Any]  				=	use_labels
						lowerCAmelCase__	:						List[Any]  				=	is_training
						lowerCAmelCase__	:						List[Any]  				=	num_labels
						lowerCAmelCase__	:						int  				=	initializer_range
						lowerCAmelCase__	:						Tuple  				=	scope
						lowerCAmelCase__	:						int  				=	width_multiplier
						lowerCAmelCase__	:						Any  				=	ffn_dropout
						lowerCAmelCase__	:						Tuple  				=	attn_dropout







					def        __lowerCAmelCase (       self			:				List[str]		):
						lowerCAmelCase__	:						str  				=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]		)

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

						lowerCAmelCase__	:						Optional[Any]  				=	self.get_config()

						return config, pixel_values, labels, pixel_labels







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







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







@require_torch
class 				SCREAMING_SNAKE_CASE					(		a_    ,							a_    ,							unittest.TestCase       ):






					"""simple docstring"""



					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        __lowerCAmelCase (       self			:				str		):
						lowerCAmelCase__	:						Optional[int]  				=	MobileViTVaModelTester(self		)
						lowerCAmelCase__	:						Optional[int]  				=	MobileViTVaConfigTester(self   ,config_class=lowercase_   ,has_text_modality=lowercase_		)







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







					@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''		)
					def        __lowerCAmelCase (       self			:				List[str]		):
						pass







					@unittest.skip(reason='''MobileViTV2 does not support input and output embeddings'''		)
					def        __lowerCAmelCase (       self			:				Dict		):
						pass







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







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







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







					def        __lowerCAmelCase (       self			:				Tuple		):
						lowerCAmelCase__				,lowerCAmelCase__	:						Any  				=	self.model_tester.prepare_config_and_inputs_for_common()

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

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







					def        __lowerCAmelCase (       self			:				Optional[int]		):
						lowerCAmelCase__	:						List[Any]  				=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowercase_		)







					def        __lowerCAmelCase (       self			:				int		):
						def check_hidden_states_output(lowercase_			:				int   ,lowercase_			:				List[Any]   ,lowercase_			:				Any		):
							lowerCAmelCase__	:						List[str]  				=	model_class(lowercase_		)
							model.to(lowercase_		)
							model.eval()

							with torch.no_grad():
								lowerCAmelCase__	:						List[str]  				=	model(**self._prepare_for_class(lowercase_   ,lowercase_		)		)

							lowerCAmelCase__	:						str  				=	outputs.hidden_states

							lowerCAmelCase__	:						List[Any]  				=	5
							self.assertEqual(len(lowercase_		)   ,lowercase_		)

							# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
							# with the width and height being successively divided by 2.
							lowerCAmelCase__	:						Optional[Any]  				=	2
							for i in range(len(lowercase_		)		):
								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__	:						List[str]  				=	self.model_tester.prepare_config_and_inputs_for_common()

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

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

							check_hidden_states_output(lowercase_   ,lowercase_   ,lowercase_		)







					def        __lowerCAmelCase (       self			:				int		):
						lowerCAmelCase__	:						Dict  				=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowercase_		)







					def        __lowerCAmelCase (       self			:				Any		):
						lowerCAmelCase__	:						Optional[int]  				=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*lowercase_		)







					@slow
					def        __lowerCAmelCase (       self			:				Union[str, Any]		):
						for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCAmelCase__	:						Any  				=	MobileViTVaModel.from_pretrained(lowercase_		)
							self.assertIsNotNone(lowercase_		)

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







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






					"""simple docstring"""



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







					@slow
					def        __lowerCAmelCase (       self			:				List[str]		):
						lowerCAmelCase__	:						int  				=	MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''		).to(
						    lowercase_		)

						lowerCAmelCase__	:						Optional[int]  				=	self.default_image_processor
						lowerCAmelCase__	:						Optional[Any]  				=	prepare_img()
						lowerCAmelCase__	:						int  				=	image_processor(images=lowercase_   ,return_tensors='''pt'''		).to(lowercase_		)

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

						# verify the logits
						lowerCAmelCase__	:						int  				=	torch.Size((1, 1_0_0_0)		)
						self.assertEqual(outputs.logits.shape   ,lowercase_		)

						lowerCAmelCase__	:						List[Any]  				=	torch.tensor([-1.6_336E00, -7.3_204E-02, -5.1_883E-01]		).to(lowercase_		)

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







					@slow
					def        __lowerCAmelCase (       self			:				str		):
						lowerCAmelCase__	:						Union[str, Any]  				=	MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''		)
						lowerCAmelCase__	:						int  				=	model.to(lowercase_		)

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

						lowerCAmelCase__	:						int  				=	prepare_img()
						lowerCAmelCase__	:						int  				=	image_processor(images=lowercase_   ,return_tensors='''pt'''		).to(lowercase_		)

						# forward pass
						with torch.no_grad():
							lowerCAmelCase__	:						Optional[Any]  				=	model(**lowercase_		)
						lowerCAmelCase__	:						List[Any]  				=	outputs.logits

						# verify the logits
						lowerCAmelCase__	:						str  				=	torch.Size((1, 2_1, 3_2, 3_2)		)
						self.assertEqual(logits.shape   ,lowercase_		)

						lowerCAmelCase__	:						str  				=	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=lowercase_   ,)

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







					@slow
					def        __lowerCAmelCase (       self			:				Dict		):
						lowerCAmelCase__	:						Dict  				=	MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''		)
						lowerCAmelCase__	:						int  				=	model.to(lowercase_		)

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

						lowerCAmelCase__	:						Optional[Any]  				=	prepare_img()
						lowerCAmelCase__	:						str  				=	image_processor(images=lowercase_   ,return_tensors='''pt'''		).to(lowercase_		)

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

						lowerCAmelCase__	:						Union[str, Any]  				=	outputs.logits.detach().cpu()

						lowerCAmelCase__	:						str  				=	image_processor.post_process_semantic_segmentation(outputs=lowercase_   ,target_sizes=[(5_0, 6_0)]		)
						lowerCAmelCase__	:						Optional[int]  				=	torch.Size((5_0, 6_0)		)
						self.assertEqual(segmentation[0].shape   ,lowercase_		)

						lowerCAmelCase__	:						Union[str, Any]  				=	image_processor.post_process_semantic_segmentation(outputs=lowercase_		)
						lowerCAmelCase__	:						int  				=	torch.Size((3_2, 3_2)		)
						self.assertEqual(segmentation[0].shape   ,lowercase_		)










"""simple docstring"""


from __future__ import annotations


def 					UpperCAmelCase__       (snake_case__							:					list[int]		,   snake_case__							:					int    ):
  """simple docstring"""

  if len(snake_case__    ) < k or k < 0:
    raise ValueError("""Invalid Input"""    )
  _snake_case							:		Optional[int]								=  sum(array[:k]    )
  for i in range(len(snake_case__    ) - k    ):
    _snake_case							:		Optional[Any]								=  current_sum - array[i] + array[i + k]
    _snake_case							:		List[str]								=  max(snake_case__		,   snake_case__    )
  return max_sum


if __name__ == "__main__":
     from doctest import testmod
     from random import randint

     testmod()
     A_						=				[randint(-10_00, 10_00) for i in range(1_00)]
     A_						=				randint(0, 1_10)
     print(F'''The maximum sum of {k} consecutive elements is {max_sum_in_array(array,k)}''')


