

'''simple docstring'''


import collections
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_flax_cross_test,
    require_flax,
    require_torch,
    require_vision,
    slow,
    torch_device,
)
from transformers.utils import is_flax_available, is_torch_available, is_vision_available

from ...test_modeling_flax_common import floats_tensor, ids_tensor, random_attention_mask
from ..bert.test_modeling_flax_bert import FlaxBertModelTester
from ..clip.test_modeling_flax_clip import FlaxCLIPVisionModelTester
from ..vit.test_modeling_flax_vit import FlaxViTModelTester


if is_flax_available():
					from transformers import (
					    FlaxBertModel,
					    FlaxCLIPVisionModel,
					    FlaxVisionTextDualEncoderModel,
					    FlaxViTModel,
					    VisionTextDualEncoderConfig,
					    VisionTextDualEncoderProcessor,
					)
					from transformers.modeling_flax_pytorch_utils import (
					    convert_pytorch_state_dict_to_flax,
					    load_flax_weights_in_pytorch_model,
					)


if is_torch_available():
					import torch

					from transformers import VisionTextDualEncoderModel

if is_vision_available():
					from PIL import Image




def 	_a       (				__lowerCAmelCase		:      List[str]     ):

		"""simple docstring"""

		if isinstance(__lowerCAmelCase   ,							collections.abc.Iterable     ):
				return x
		return (x, x)




@require_flax
class     a			:






						"""simple docstring"""




						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      Union[str, Any]  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      List[str]			,			snake_case_					:      np.ndarray			,			snake_case_					:      np.ndarray			,			snake_case_					:      float  ):



								'''simple docstring'''



								snake_case__						:       str       						=  np.abs((a - b)  ).max()
								self.assertLessEqual(snake_case_			,			snake_case_			,			F"""Difference between torch and flax is {diff} (>= {tol})."""  )







						def       __magic_name__							(							self					:      Tuple			,			snake_case_					:      List[Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Tuple			,			snake_case_					:      Any			,			snake_case_					:      Tuple=None			,			**snake_case_					:      str  ):



								'''simple docstring'''



								snake_case__						:       str       						=  VisionTextDualEncoderConfig.from_vision_text_configs(snake_case_			,			snake_case_  )

								snake_case__						:       Any       						=  FlaxVisionTextDualEncoderModel(snake_case_  )

								snake_case__						:       Union[str, Any]       						=  model(input_ids=snake_case_			,			pixel_values=snake_case_			,			attention_mask=snake_case_  )

								self.assertEqual(output['''text_embeds'''].shape			,			(input_ids.shape[0], config.projection_dim)  )
								self.assertEqual(output['''image_embeds'''].shape			,			(pixel_values.shape[0], config.projection_dim)  )







						def       __magic_name__							(							self					:      Dict			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      Dict			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Tuple=None			,			**snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       str       						=  self.get_vision_text_model(snake_case_			,			snake_case_  )
								snake_case__						:       Dict       						=  {'''vision_model''': vision_model, '''text_model''': text_model}
								snake_case__						:       Optional[int]       						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**snake_case_  )

								snake_case__						:       Any       						=  model(input_ids=snake_case_			,			pixel_values=snake_case_			,			attention_mask=snake_case_  )

								self.assertEqual(output['''text_embeds'''].shape			,			(input_ids.shape[0], model.config.projection_dim)  )
								self.assertEqual(output['''image_embeds'''].shape			,			(pixel_values.shape[0], model.config.projection_dim)  )







						def       __magic_name__							(							self					:      Tuple			,			snake_case_					:      Any			,			snake_case_					:      Dict			,			snake_case_					:      str			,			snake_case_					:      Any			,			snake_case_					:      int=None			,			**snake_case_					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.get_vision_text_model(snake_case_			,			snake_case_  )
								snake_case__						:       Union[str, Any]       						=  {'''vision_model''': vision_model, '''text_model''': text_model}
								snake_case__						:       Tuple       						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**snake_case_  )

								snake_case__						:       int       						=  model(input_ids=snake_case_			,			pixel_values=snake_case_			,			attention_mask=snake_case_  )
								snake_case__						:       str       						=  output[0]

								with tempfile.TemporaryDirectory() as tmpdirname:
										model.save_pretrained(snake_case_  )
										snake_case__						:       Any       						=  FlaxVisionTextDualEncoderModel.from_pretrained(snake_case_  )

										snake_case__						:       str       						=  model(input_ids=snake_case_			,			pixel_values=snake_case_			,			attention_mask=snake_case_  )
										snake_case__						:       Dict       						=  after_output[0]
										snake_case__						:       int       						=  np.amax(np.abs(out_a - out_a  )  )
										self.assertLessEqual(snake_case_			,			1e-3  )







						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Tuple			,			snake_case_					:      int			,			snake_case_					:      Optional[int]			,			snake_case_					:      List[Any]			,			snake_case_					:      Optional[Any]=None			,			**snake_case_					:      Optional[int]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       str       						=  self.get_vision_text_model(snake_case_			,			snake_case_  )
								snake_case__						:       Tuple       						=  {'''vision_model''': vision_model, '''text_model''': text_model}
								snake_case__						:       str       						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(**snake_case_  )

								snake_case__						:       Dict       						=  model(
								    input_ids=snake_case_			,			pixel_values=snake_case_			,			attention_mask=snake_case_			,			output_attentions=snake_case_  )

								snake_case__						:       Tuple       						=  output.vision_model_output.attentions
								self.assertEqual(len(snake_case_  )			,			vision_config.num_hidden_layers  )

								# in ViT, the seq_len equals the number of patches + 1 (we add 1 for the [CLS] token)
								snake_case__						:       Optional[int]       						=  to_atuple(vision_model.config.image_size  )
								snake_case__						:       Union[str, Any]       						=  to_atuple(vision_model.config.patch_size  )
								snake_case__						:       Optional[Any]       						=  (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])
								snake_case__						:       List[Any]       						=  num_patches + 1
								self.assertEqual(vision_attentions[0].shape[-3:]			,			(vision_config.num_attention_heads, seq_len, seq_len)  )

								snake_case__						:       str       						=  output.text_model_output.attentions
								self.assertEqual(len(snake_case_  )			,			text_config.num_hidden_layers  )

								self.assertEqual(
								    text_attentions[0].shape[-3:]			,			(text_config.num_attention_heads, input_ids.shape[-1], input_ids.shape[-1])			,			)







						def       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Any			,			snake_case_					:      Tuple  ):



								'''simple docstring'''



								pt_model.to(snake_case_  )
								pt_model.eval()

								# prepare inputs
								snake_case__						:       Union[str, Any]       						=  inputs_dict
								snake_case__						:       Any       						=  {k: torch.tensor(v.tolist()  ) for k, v in flax_inputs.items()}

								with torch.no_grad():
										snake_case__						:       Dict       						=  pt_model(**snake_case_  ).to_tuple()

								snake_case__						:       str       						=  fx_model(**snake_case_  ).to_tuple()
								self.assertEqual(len(snake_case_  )			,			len(snake_case_  )			,			'''Output lengths differ between Flax and PyTorch'''  )
								for fx_output, pt_output in zip(fx_outputs[:4]			,			pt_outputs[:4]  ):
										self.assert_almost_equals(snake_case_			,			pt_output.numpy()			,			4e-2  )

								# PT -> Flax
								with tempfile.TemporaryDirectory() as tmpdirname:
										pt_model.save_pretrained(snake_case_  )
										snake_case__						:       Union[str, Any]       						=  FlaxVisionTextDualEncoderModel.from_pretrained(snake_case_			,			from_pt=snake_case_  )

								snake_case__						:       Any       						=  fx_model_loaded(**snake_case_  ).to_tuple()
								self.assertEqual(len(snake_case_  )			,			len(snake_case_  )			,			'''Output lengths differ between Flax and PyTorch'''  )
								for fx_output_loaded, pt_output in zip(fx_outputs_loaded[:4]			,			pt_outputs[:4]  ):
										self.assert_almost_equals(snake_case_			,			pt_output.numpy()			,			4e-2  )

								# Flax -> PT
								with tempfile.TemporaryDirectory() as tmpdirname:
										fx_model.save_pretrained(snake_case_  )
										snake_case__						:       str       						=  VisionTextDualEncoderModel.from_pretrained(snake_case_			,			from_flax=snake_case_  )

								pt_model_loaded.to(snake_case_  )
								pt_model_loaded.eval()

								with torch.no_grad():
										snake_case__						:       Optional[int]       						=  pt_model_loaded(**snake_case_  ).to_tuple()

								self.assertEqual(len(snake_case_  )			,			len(snake_case_  )			,			'''Output lengths differ between Flax and PyTorch'''  )
								for fx_output, pt_output_loaded in zip(fx_outputs[:4]			,			pt_outputs_loaded[:4]  ):
										self.assert_almost_equals(snake_case_			,			pt_output_loaded.numpy()			,			4e-2  )







						def       __magic_name__							(							self					:      int			,			snake_case_					:      Dict			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      str  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  VisionTextDualEncoderConfig.from_vision_text_configs(snake_case_			,			snake_case_  )

								snake_case__						:       List[str]       						=  VisionTextDualEncoderModel(snake_case_  )
								snake_case__						:       Union[str, Any]       						=  FlaxVisionTextDualEncoderModel(snake_case_  )

								snake_case__						:       Union[str, Any]       						=  convert_pytorch_state_dict_to_flax(pt_model.state_dict()			,			snake_case_  )
								snake_case__						:       Optional[int]       						=  fx_state

								self.check_pt_flax_equivalence(snake_case_			,			snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      Tuple			,			snake_case_					:      Dict			,			snake_case_					:      Tuple			,			snake_case_					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  VisionTextDualEncoderConfig.from_vision_text_configs(snake_case_			,			snake_case_  )

								snake_case__						:       Dict       						=  VisionTextDualEncoderModel(snake_case_  )
								snake_case__						:       Dict       						=  FlaxVisionTextDualEncoderModel(snake_case_  )

								snake_case__						:       List[Any]       						=  load_flax_weights_in_pytorch_model(snake_case_			,			fx_model.params  )

								self.check_pt_flax_equivalence(snake_case_			,			snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       int       						=  self.prepare_config_and_inputs()
								self.check_model_from_pretrained_configs(**snake_case_  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  self.prepare_config_and_inputs()
								self.check_vision_text_dual_encoder_from_pretrained(**snake_case_  )







						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       str       						=  self.prepare_config_and_inputs()
								self.check_save_load(**snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Any       						=  self.prepare_config_and_inputs()
								self.check_vision_text_output_attention(**snake_case_  )







						@is_pt_flax_cross_test
						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  self.prepare_config_and_inputs()
								snake_case__						:       Any       						=  config_inputs_dict.pop('''vision_config'''  )
								snake_case__						:       Tuple       						=  config_inputs_dict.pop('''text_config'''  )

								snake_case__						:       Union[str, Any]       						=  config_inputs_dict

								self.check_equivalence_pt_to_flax(snake_case_			,			snake_case_			,			snake_case_  )
								self.check_equivalence_flax_to_pt(snake_case_			,			snake_case_			,			snake_case_  )







						@slow
						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       List[Any]       						=  self.get_pretrained_model_and_inputs()

								snake_case__						:       List[Any]       						=  model_a(**snake_case_  )
								snake_case__						:       Dict       						=  outputs[0]

								with tempfile.TemporaryDirectory() as tmp_dirname:
										model_a.save_pretrained(snake_case_  )
										snake_case__						:       Optional[Any]       						=  FlaxVisionTextDualEncoderModel.from_pretrained(snake_case_  )

										snake_case__						:       Dict       						=  model_a(**snake_case_  )
										snake_case__						:       Optional[Any]       						=  after_outputs[0]
										snake_case__						:       Optional[int]       						=  np.amax(np.abs(out_a - out_a  )  )
										self.assertLessEqual(snake_case_			,			1e-5  )





@require_flax
class     a			(				SCREAMING_SNAKE_CASE			,			unittest.TestCase       ):






						"""simple docstring"""




						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       int       						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
								    '''hf-internal-testing/tiny-random-vit'''			,			'''hf-internal-testing/tiny-bert'''			,			vision_from_pt=snake_case_			,			text_from_pt=snake_case_			,			)
								snake_case__						:       List[Any]       						=  1_3
								snake_case__						:       List[Any]       						=  floats_tensor(
								    [
								        batch_size,
								        model.config.vision_config.num_channels,
								        model.config.vision_config.image_size,
								        model.config.vision_config.image_size,
								    ]  )
								snake_case__						:       str       						=  ids_tensor([batch_size, 4]			,			model.config.text_config.vocab_size  )
								snake_case__						:       Optional[Any]       						=  random_attention_mask([batch_size, 4]  )
								snake_case__						:       Optional[int]       						=  {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

								return model, inputs







						def       __magic_name__							(							self					:      int			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  FlaxViTModel(snake_case_  )
								snake_case__						:       Any       						=  FlaxBertModel(snake_case_  )
								return vision_model, text_model







						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  FlaxViTModelTester(self  )
								snake_case__						:       Dict       						=  FlaxBertModelTester(self  )
								snake_case__						:       List[Any]       						=  vit_model_tester.prepare_config_and_inputs()
								snake_case__						:       Optional[Any]       						=  bert_model_tester.prepare_config_and_inputs()

								snake_case__						,       snake_case__						:       str       						=  vision_config_and_inputs

								snake_case__						,       snake_case__						,       snake_case__						,       snake_case__						:       str       						=  text_config_and_inputs

								# make sure that cross attention layers are added
								return {
								    "text_config": text_config,
								    "vision_config": vision_config,
								    "pixel_values": pixel_values,
								    "attention_mask": attention_mask,
								    "input_ids": input_ids,
								    "token_type_ids": token_type_ids,
								}





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






						"""simple docstring"""




						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						:       str       						=  FlaxVisionTextDualEncoderModel.from_vision_text_pretrained(
								    '''hf-internal-testing/tiny-random-clip'''			,			'''hf-internal-testing/tiny-bert'''			,			vision_from_pt=snake_case_			,			text_from_pt=snake_case_			,			)
								snake_case__						:       str       						=  1_3
								snake_case__						:       Any       						=  floats_tensor(
								    [
								        batch_size,
								        model.config.vision_config.num_channels,
								        model.config.vision_config.image_size,
								        model.config.vision_config.image_size,
								    ]  )
								snake_case__						:       Any       						=  ids_tensor([batch_size, 4]			,			model.config.text_config.vocab_size  )
								snake_case__						:       str       						=  random_attention_mask([batch_size, 4]  )
								snake_case__						:       Optional[Any]       						=  {'''pixel_values''': pixel_values, '''input_ids''': input_ids, '''attention_mask''': attention_mask}

								return model, inputs







						def       __magic_name__							(							self					:      Tuple			,			snake_case_					:      str			,			snake_case_					:      str  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  FlaxCLIPVisionModel(snake_case_  )
								snake_case__						:       Dict       						=  FlaxBertModel(snake_case_  )
								return vision_model, text_model







						def       __magic_name__							(							self					:      List[Any]  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  FlaxCLIPVisionModelTester(self  )
								snake_case__						:       str       						=  FlaxBertModelTester(self  )
								snake_case__						:       Optional[Any]       						=  clip_model_tester.prepare_config_and_inputs()
								snake_case__						:       Any       						=  bert_model_tester.prepare_config_and_inputs()

								snake_case__						,       snake_case__						:       Union[str, Any]       						=  vision_config_and_inputs

								snake_case__						,       snake_case__						,       snake_case__						,       snake_case__						:       Optional[int]       						=  text_config_and_inputs

								# make sure that cross attention layers are added
								return {
								    "text_config": text_config,
								    "vision_config": vision_config,
								    "pixel_values": pixel_values,
								    "attention_mask": attention_mask,
								    "input_ids": input_ids,
								    "token_type_ids": token_type_ids,
								}





@require_flax
@require_vision
class     a			(				unittest.TestCase       ):






						"""simple docstring"""




						@slow
						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  FlaxVisionTextDualEncoderModel.from_pretrained('''clip-italian/clip-italian'''			,			logit_scale_init_value=1.0  )
								snake_case__						:       List[Any]       						=  VisionTextDualEncoderProcessor.from_pretrained('''clip-italian/clip-italian'''  )

								snake_case__						:       Union[str, Any]       						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
								snake_case__						:       List[Any]       						=  processor(
								    text=['''una foto di un gatto''', '''una foto di un cane''']			,			images=snake_case_			,			padding=snake_case_			,			return_tensors='''np'''  )

								snake_case__						:       Dict       						=  model(**snake_case_  )

								# verify the logits
								self.assertEqual(outputs.logits_per_image.shape			,			(inputs.pixel_values.shape[0], inputs.input_ids.shape[0])  )
								self.assertEqual(
								    outputs.logits_per_text.shape			,			(inputs.input_ids.shape[0], inputs.pixel_values.shape[0])			,			)

								snake_case__						:       Optional[Any]       						=  np.array([[1.2_2_8_4_7_2_7, 0.3_1_0_4_1_2_2]]  )

								self.assertTrue(np.allclose(outputs.logits_per_image			,			snake_case_			,			atol=1e-3  )  )






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






						"""simple docstring"""




						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       str       						=  self.config_class(**self.inputs_dict  )
								self.parent.assertTrue(hasattr(snake_case_			,			'''width_multiplier'''  )  )





class     a			:






						"""simple docstring"""




						def __init__(							self					:      List[str]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Dict=1_3			,			snake_case_					:      Any=6_4			,			snake_case_					:      Dict=2			,			snake_case_					:      Optional[int]=3			,			snake_case_					:      str="swish"			,			snake_case_					:      str=3			,			snake_case_					:      Union[str, Any]=3_2			,			snake_case_					:      Optional[Any]=0.1			,			snake_case_					:      Any=0.0_2			,			snake_case_					:      int=True			,			snake_case_					:      Tuple=True			,			snake_case_					:      Dict=1_0			,			snake_case_					:      Optional[int]=None			,			snake_case_					:      str=0.2_5			,			snake_case_					:      List[Any]=0.0			,			snake_case_					:      Optional[Any]=0.0			,			):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  parent
								snake_case__						:       Dict       						=  batch_size
								snake_case__						:       Dict       						=  image_size
								snake_case__						:       Tuple       						=  patch_size
								snake_case__						:       Tuple       						=  num_channels
								snake_case__						:       Tuple       						=  make_divisible(5_1_2 * width_multiplier			,			divisor=8  )
								snake_case__						:       Optional[int]       						=  hidden_act
								snake_case__						:       int       						=  conv_kernel_size
								snake_case__						:       Optional[int]       						=  output_stride
								snake_case__						:       List[Any]       						=  classifier_dropout_prob
								snake_case__						:       int       						=  use_labels
								snake_case__						:       Optional[Any]       						=  is_training
								snake_case__						:       int       						=  num_labels
								snake_case__						:       str       						=  initializer_range
								snake_case__						:       Dict       						=  scope
								snake_case__						:       Tuple       						=  width_multiplier
								snake_case__						:       Optional[Any]       						=  ffn_dropout
								snake_case__						:       Dict       						=  attn_dropout







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       int       						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								snake_case__						:       List[str]       						=  None
								snake_case__						:       Union[str, Any]       						=  None
								if self.use_labels:
										snake_case__						:       Tuple       						=  ids_tensor([self.batch_size]			,			self.num_labels  )
										snake_case__						:       Optional[Any]       						=  ids_tensor([self.batch_size, self.image_size, self.image_size]			,			self.num_labels  )

								snake_case__						:       Optional[int]       						=  self.get_config()

								return config, pixel_values, labels, pixel_labels







						def       __magic_name__							(							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       __magic_name__							(							self					:      Optional[Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Optional[int]			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  MobileViTVaModel(config=snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       Dict       						=  model(snake_case_  )
								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       __magic_name__							(							self					:      Union[str, Any]			,			snake_case_					:      Optional[int]			,			snake_case_					:      List[Any]			,			snake_case_					:      Tuple			,			snake_case_					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  self.num_labels
								snake_case__						:       Optional[Any]       						=  MobileViTVaForImageClassification(snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       int       						=  model(snake_case_			,			labels=snake_case_  )
								self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_labels)  )







						def       __magic_name__							(							self					:      int			,			snake_case_					:      List[Any]			,			snake_case_					:      Dict			,			snake_case_					:      Any			,			snake_case_					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.num_labels
								snake_case__						:       Any       						=  MobileViTVaForSemanticSegmentation(snake_case_  )
								model.to(snake_case_  )
								model.eval()
								snake_case__						:       str       						=  model(snake_case_  )
								self.parent.assertEqual(
								    result.logits.shape			,			(
								        self.batch_size,
								        self.num_labels,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    )			,			)
								snake_case__						:       Optional[int]       						=  model(snake_case_			,			labels=snake_case_  )
								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       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.prepare_config_and_inputs()
								snake_case__						,       snake_case__						,       snake_case__						,       snake_case__						:       List[str]       						=  config_and_inputs
								snake_case__						:       List[str]       						=  {'''pixel_values''': pixel_values}
								return config, inputs_dict





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






						"""simple docstring"""




						__UpperCAmelCase			     =    (
						    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
						    if is_torch_available()
						    else ()
						)

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

						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       str       						=  MobileViTVaModelTester(self  )
								snake_case__						:       Union[str, Any]       						=  MobileViTVaConfigTester(self			,			config_class=snake_case_			,			has_text_modality=snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								self.config_tester.run_common_tests()







						@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''  )
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								pass







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



								'''simple docstring'''



								pass







						@unittest.skip(reason='''MobileViTV2 does not output attentions'''  )
						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								pass







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



								'''simple docstring'''



								pass







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



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

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

										snake_case__						:       Optional[int]       						=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]			,			snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_  )







						def       __magic_name__							(							self					:      List[str]  ):



								'''simple docstring'''



								def check_hidden_states_output(snake_case_					:      Tuple			,			snake_case_					:      Optional[Any]			,			snake_case_					:      Tuple  ):
										snake_case__						:       Optional[Any]       						=  model_class(snake_case_  )
										model.to(snake_case_  )
										model.eval()

										with torch.no_grad():
												snake_case__						:       Tuple       						=  model(**self._prepare_for_class(snake_case_			,			snake_case_  )  )

										snake_case__						:       Union[str, Any]       						=  outputs.hidden_states

										snake_case__						:       Any       						=  5
										self.assertEqual(len(snake_case_  )			,			snake_case_  )

										# MobileViTV2's feature maps are of shape (batch_size, num_channels, height, width)
										# with the width and height being successively divided by 2.
										snake_case__						:       Dict       						=  2
										for i in range(len(snake_case_  )  ):
												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  )

								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case__						:       List[str]       						=  True
										check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )

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

										check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      int  ):



								'''simple docstring'''



								snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case_  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       Dict       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*snake_case_  )







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



								'''simple docstring'''



								for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case__						:       Any       						=  MobileViTVaModel.from_pretrained(snake_case_  )
										self.assertIsNotNone(snake_case_  )





def 	_a       (				):

		"""simple docstring"""

		snake_case__						:       Optional[Any]       						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
		return image





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






						"""simple docstring"""




						@cached_property
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



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







						@slow
						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''  ).to(
								    snake_case_  )

								snake_case__						:       Any       						=  self.default_image_processor
								snake_case__						:       Tuple       						=  prepare_img()
								snake_case__						:       str       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Any       						=  model(**snake_case_  )

								# verify the logits
								snake_case__						:       Dict       						=  torch.Size((1, 1_0_0_0)  )
								self.assertEqual(outputs.logits.shape			,			snake_case_  )

								snake_case__						:       Tuple       						=  torch.tensor([-1.6_336e00, -7.3_204e-02, -5.1_883e-01]  ).to(snake_case_  )

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







						@slow
						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								snake_case__						:       List[Any]       						=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
								snake_case__						:       Any       						=  model.to(snake_case_  )

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

								snake_case__						:       str       						=  prepare_img()
								snake_case__						:       Union[str, Any]       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Union[str, Any]       						=  model(**snake_case_  )
								snake_case__						:       Tuple       						=  outputs.logits

								# verify the logits
								snake_case__						:       Optional[Any]       						=  torch.Size((1, 2_1, 3_2, 3_2)  )
								self.assertEqual(logits.shape			,			snake_case_  )

								snake_case__						:       List[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=snake_case_			,			)

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







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



								'''simple docstring'''



								snake_case__						:       Optional[int]       						=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )
								snake_case__						:       List[str]       						=  model.to(snake_case_  )

								snake_case__						:       Optional[int]       						=  MobileViTImageProcessor.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''  )

								snake_case__						:       str       						=  prepare_img()
								snake_case__						:       str       						=  image_processor(images=snake_case_			,			return_tensors='''pt'''  ).to(snake_case_  )

								# forward pass
								with torch.no_grad():
										snake_case__						:       Any       						=  model(**snake_case_  )

								snake_case__						:       str       						=  outputs.logits.detach().cpu()

								snake_case__						:       int       						=  image_processor.post_process_semantic_segmentation(outputs=snake_case_			,			target_sizes=[(5_0, 6_0)]  )
								snake_case__						:       int       						=  torch.Size((5_0, 6_0)  )
								self.assertEqual(segmentation[0].shape			,			snake_case_  )

								snake_case__						:       str       						=  image_processor.post_process_semantic_segmentation(outputs=snake_case_  )
								snake_case__						:       Any       						=  torch.Size((3_2, 3_2)  )
								self.assertEqual(segmentation[0].shape			,			snake_case_  )



