



import argparse
import re

import requests
import torch

# git clone https://github.com/salesforce/BLIP.git
from models.blip import blip_decoder
from models.blip_itm import blip_itm
from models.blip_vqa import blip_vqa
from PIL import Image
from torchvision import transforms
from torchvision.transforms.functional import InterpolationMode

from transformers import (
    BertTokenizer,
    BlipConfig,
    BlipForConditionalGeneration,
    BlipForImageTextRetrieval,
    BlipForQuestionAnswering,
)






def 			lowerCAmelCase__	(					lowerCamelCase_	:	Any ,lowerCamelCase_	:	List[Any]):





				'''simple docstring'''

				lowerCAmelCase__  :       List[str]				=  '''https://storage.googleapis.com/sfr-vision-language-research/BLIP/demo.jpg'''
				lowerCAmelCase__  :       List[str]				=  Image.open(requests.get(lowerCamelCase_ ,stream=lowerCamelCase_).raw).convert('''RGB''')

				lowerCAmelCase__  :       List[str]				=  transforms.Compose(
				    [
				        transforms.Resize((image_size, image_size) ,interpolation=InterpolationMode.BICUBIC),
				        transforms.ToTensor(),
				        transforms.Normalize((0.48145466, 0.4578275, 0.40821073) ,(0.26862954, 0.26130258, 0.27577711)),
				    ])
				lowerCAmelCase__  :       List[Any]				=  transform(lowerCamelCase_).unsqueeze(0).to(lowerCamelCase_)
				return image






def 			lowerCAmelCase__	(					lowerCamelCase_	:	str):





				'''simple docstring'''

				if "visual_encoder" in key:
								lowerCAmelCase__  :       int				=  re.sub('''visual_encoder*''' ,'''vision_model.encoder''' ,lowerCamelCase_)
				if "blocks" in key:
								lowerCAmelCase__  :       Optional[Any]				=  re.sub(r'''blocks''' ,'''layers''' ,lowerCamelCase_)
				if "attn" in key:
								lowerCAmelCase__  :       Tuple				=  re.sub(r'''attn''' ,'''self_attn''' ,lowerCamelCase_)
				if "norm1" in key:
								lowerCAmelCase__  :       Optional[Any]				=  re.sub(r'''norm1''' ,'''layer_norm1''' ,lowerCamelCase_)
				if "norm2" in key:
								lowerCAmelCase__  :       Optional[Any]				=  re.sub(r'''norm2''' ,'''layer_norm2''' ,lowerCamelCase_)
				if "encoder.norm" in key:
								lowerCAmelCase__  :       Dict				=  re.sub(r'''encoder.norm''' ,'''post_layernorm''' ,lowerCamelCase_)
				if "encoder.patch_embed.proj" in key:
								lowerCAmelCase__  :       int				=  re.sub(r'''encoder.patch_embed.proj''' ,'''embeddings.patch_embedding''' ,lowerCamelCase_)

				if "encoder.pos_embed" in key:
								lowerCAmelCase__  :       Optional[int]				=  re.sub(r'''encoder.pos_embed''' ,'''embeddings.position_embedding''' ,lowerCamelCase_)
				if "encoder.cls_token" in key:
								lowerCAmelCase__  :       List[str]				=  re.sub(r'''encoder.cls_token''' ,'''embeddings.class_embedding''' ,lowerCamelCase_)

				if "self_attn" in key:
								lowerCAmelCase__  :       int				=  re.sub(r'''self_attn.proj''' ,'''self_attn.projection''' ,lowerCamelCase_)

				return key






@torch.no_grad()
def 			lowerCAmelCase__	(					lowerCamelCase_	:	Optional[Any] ,lowerCamelCase_	:	Dict=None):





				'''simple docstring'''

				if config_path is not None:
								lowerCAmelCase__  :       Union[str, Any]				=  BlipConfig.from_pretrained(lowerCamelCase_)
				else:
								lowerCAmelCase__  :       Dict				=  BlipConfig(projection_dim=512 ,text_config={} ,vision_config={})

				lowerCAmelCase__  :       Optional[Any]				=  BlipForConditionalGeneration(lowerCamelCase_).eval()

				lowerCAmelCase__  :       Any				=  '''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_capfilt_large.pth'''

				lowerCAmelCase__  :       int				=  blip_decoder(pretrained=lowerCamelCase_ ,image_size=384 ,vit='''base''')
				lowerCAmelCase__  :       List[str]				=  pt_model.eval()

				lowerCAmelCase__  :       str				=  pt_model.state_dict()
				for key in modified_state_dict.copy():
								lowerCAmelCase__  :       int				=  modified_state_dict.pop(lowerCamelCase_)
								lowerCAmelCase__  :       List[Any]				=  rename_key(lowerCamelCase_)
								lowerCAmelCase__  :       Tuple				=  value

				hf_model.load_state_dict(lowerCamelCase_)

				lowerCAmelCase__  :       Any				=  384
				lowerCAmelCase__  :       List[Any]				=  load_demo_image(image_size=lowerCamelCase_ ,device='''cpu''')
				lowerCAmelCase__  :       Tuple				=  BertTokenizer.from_pretrained('''bert-base-uncased''')
				lowerCAmelCase__  :       Union[str, Any]				=  tokenizer(['''a picture of''']).input_ids

				lowerCAmelCase__  :       int				=  hf_model.generate(lowerCamelCase_ ,lowerCamelCase_)

				assert out[0].tolist() == [30522, 1037, 3861, 1997, 1037, 2450, 3564, 2006, 1996, 3509, 2007, 2014, 3899, 102]

				lowerCAmelCase__  :       Optional[int]				=  hf_model.generate(lowerCamelCase_)

				assert out[0].tolist() == [30522, 1037, 2450, 3564, 2006, 1996, 3509, 2007, 2014, 3899, 102]

				if pytorch_dump_folder_path is not None:
								hf_model.save_pretrained(lowerCamelCase_)

				# model_url = 'https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_vqa.pth'
				lowerCAmelCase__  :       Any				=  (
				    '''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_vqa_capfilt_large.pth'''
				)

				lowerCAmelCase__  :       str				=  blip_vqa(pretrained=lowerCamelCase_ ,image_size=lowerCamelCase_ ,vit='''base''')
				vqa_model.eval()

				lowerCAmelCase__  :       Any				=  vqa_model.state_dict()
				for key in modified_state_dict.copy():
								lowerCAmelCase__  :       List[str]				=  modified_state_dict.pop(lowerCamelCase_)
								lowerCAmelCase__  :       Any				=  rename_key(lowerCamelCase_)
								lowerCAmelCase__  :       Union[str, Any]				=  value

				lowerCAmelCase__  :       Any				=  BlipForQuestionAnswering(lowerCamelCase_)

				hf_vqa_model.load_state_dict(lowerCamelCase_)

				lowerCAmelCase__  :       List[str]				=  ['''How many dogs are in this image?''']
				lowerCAmelCase__  :       List[str]				=  tokenizer(lowerCamelCase_ ,return_tensors='''pt''').input_ids

				lowerCAmelCase__  :       List[Any]				=  hf_vqa_model.generate(lowerCamelCase_ ,lowerCamelCase_)
				print(tokenizer.decode(answer[0]))

				assert tokenizer.decode(answer[0]) == "[UNK] 1 [SEP]"
				if pytorch_dump_folder_path is not None:
								hf_vqa_model.save_pretrained(pytorch_dump_folder_path + '''_vqa''')

				lowerCAmelCase__  :       Any				=  '''https://storage.googleapis.com/sfr-vision-language-research/BLIP/models/model_base_retrieval_coco.pth'''

				lowerCAmelCase__  :       Union[str, Any]				=  blip_itm(pretrained=lowerCamelCase_ ,image_size=lowerCamelCase_ ,vit='''base''')
				itm_model.eval()

				lowerCAmelCase__  :       Union[str, Any]				=  itm_model.state_dict()
				for key in modified_state_dict.copy():
								lowerCAmelCase__  :       Any				=  modified_state_dict.pop(lowerCamelCase_)
								lowerCAmelCase__  :       List[Any]				=  rename_key(lowerCamelCase_)
								lowerCAmelCase__  :       List[str]				=  value

				lowerCAmelCase__  :       List[Any]				=  BlipForImageTextRetrieval(lowerCamelCase_)

				lowerCAmelCase__  :       Any				=  ['''A picture of a woman with a dog sitting in a beach''']
				lowerCAmelCase__  :       int				=  tokenizer(
				    lowerCamelCase_ ,return_tensors='''pt''' ,padding='''max_length''' ,truncation=lowerCamelCase_ ,max_length=35 ,).input_ids

				hf_itm_model.load_state_dict(lowerCamelCase_)
				hf_itm_model.eval()

				lowerCAmelCase__  :       Dict				=  hf_itm_model(lowerCamelCase_ ,lowerCamelCase_ ,use_itm_head=lowerCamelCase_)
				lowerCAmelCase__  :       Optional[int]				=  hf_itm_model(lowerCamelCase_ ,lowerCamelCase_ ,use_itm_head=lowerCamelCase_)

				assert out[0].item() == 0.2110687494277954
				assert torch.nn.functional.softmax(out_itm[0] ,dim=1)[:, 1].item() == 0.45698845386505127

				if pytorch_dump_folder_path is not None:
								hf_itm_model.save_pretrained(pytorch_dump_folder_path + '''_itm''')


if __name__ == "__main__":
							__snake_case       :	List[Any]            =argparse.ArgumentParser()
							parser.add_argument('--pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
							parser.add_argument('--config_path', default=None, type=str, help='Path to hf config.json of model to convert')
							__snake_case       :	str            =parser.parse_args()

							convert_blip_checkpoint(args.checkpoint_path, args.pytorch_dump_folder_path, args.config_path)






import inspect
import unittest

from transformers import MobileViTVaConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation, MobileViTVaModel
							from transformers.models.mobilevitva.modeling_mobilevitva import (
							    MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
							    make_divisible,
							)


if is_vision_available():
							from PIL import Image

							from transformers import MobileViTImageProcessor



class  lowerCamelCase__    (							lowerCamelCase__):




		'''simple docstring'''



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

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  self.config_class(**self.inputs_dict				)
						self.parent.assertTrue(hasattr(__lowerCamelCase	,'''width_multiplier'''				)				)



class  lowerCamelCase__    :




		'''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	,)  ->    Union[str, Any]:

						"""simple docstring"""






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



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






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

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

						lowerCAmelCase__  :       Tuple				=  self.get_config()

						return config, pixel_values, labels, pixel_labels



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

						"""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 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       int				=  MobileViTVaModel(config=__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       Dict				=  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 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       List[str]				=  self.num_labels
						lowerCAmelCase__  :       Union[str, Any]				=  MobileViTVaForImageClassification(__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       Dict				=  model(__lowerCamelCase	,labels=__lowerCamelCase				)
						self.parent.assertEqual(result.logits.shape	,(self.batch_size, self.num_labels)				)



		def 	lowerCAmelCase__   (self	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)  ->    List[str]:

						"""simple docstring"""






						lowerCAmelCase__  :       Any				=  self.num_labels
						lowerCAmelCase__  :       Optional[int]				=  MobileViTVaForSemanticSegmentation(__lowerCamelCase				)
						model.to(__lowerCamelCase				)
						model.eval()
						lowerCAmelCase__  :       Optional[Any]				=  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__  :       List[str]				=  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 	lowerCAmelCase__   (self				)  ->    Any:

						"""simple docstring"""






						lowerCAmelCase__  :       Union[str, Any]				=  self.prepare_config_and_inputs()
						lowerCAmelCase__		,	lowerCAmelCase__		,	lowerCAmelCase__		,	lowerCAmelCase__  :       Optional[int]				=  config_and_inputs
						lowerCAmelCase__  :       Dict				=  {'''pixel_values''': pixel_values}
						return config, inputs_dict



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




		'''simple docstring'''



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

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

		snake_case_			=False
		snake_case_			=False
		snake_case_			=False
		snake_case_			=False



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

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  MobileViTVaModelTester(self				)
						lowerCAmelCase__  :       Optional[int]				=  MobileViTVaConfigTester(self	,config_class=__lowerCamelCase	,has_text_modality=__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    List[Any]:

						"""simple docstring"""






						self.config_tester.run_common_tests()



		@unittest.skip(reason='''MobileViTV2 does not use inputs_embeds'''				)
		def 	lowerCAmelCase__   (self				)  ->    Union[str, Any]:

						"""simple docstring"""






						pass



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

						"""simple docstring"""






						pass



		@unittest.skip(reason='''MobileViTV2 does not output attentions'''				)
		def 	lowerCAmelCase__   (self				)  ->    List[str]:

						"""simple docstring"""






						pass



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

						"""simple docstring"""






						pass



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

						"""simple docstring"""






						pass



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						lowerCAmelCase__		,	lowerCAmelCase__  :       List[Any]				=  self.model_tester.prepare_config_and_inputs_for_common()

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

										lowerCAmelCase__  :       Union[str, Any]				=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]	,__lowerCamelCase				)



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

						"""simple docstring"""






						lowerCAmelCase__  :       List[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						def check_hidden_states_output(__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				):
										lowerCAmelCase__  :       Union[str, Any]				=  model_class(__lowerCamelCase				)
										model.to(__lowerCamelCase				)
										model.eval()

										with torch.no_grad():
														lowerCAmelCase__  :       Optional[Any]				=  model(**self._prepare_for_class(__lowerCamelCase	,__lowerCamelCase				)				)

										lowerCAmelCase__  :       Dict				=  outputs.hidden_states

										lowerCAmelCase__  :       Any				=  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__  :       Optional[Any]				=  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__  :       Union[str, Any]				=  self.model_tester.prepare_config_and_inputs_for_common()

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

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

										check_hidden_states_output(__lowerCamelCase	,__lowerCamelCase	,__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[Any]				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase				)



		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*__lowerCamelCase				)



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Dict:

						"""simple docstring"""






						for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase__  :       Optional[int]				=  MobileViTVaModel.from_pretrained(__lowerCamelCase				)
										self.assertIsNotNone(__lowerCamelCase				)






def 			lowerCAmelCase__	(					):





				'''simple docstring'''

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



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




		'''simple docstring'''



		@cached_property
		def 	lowerCAmelCase__   (self				)  ->    Optional[Any]:

						"""simple docstring"""






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



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       str				=  MobileViTVaForImageClassification.from_pretrained('''apple/mobilevitv2-1.0-imagenet1k-256'''				).to(
						    __lowerCamelCase				)

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

						# forward pass
						with torch.no_grad():
										lowerCAmelCase__  :       Union[str, Any]				=  model(**__lowerCamelCase				)

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

						lowerCAmelCase__  :       Dict				=  torch.tensor([-1.6336e00, -7.3204e-02, -5.1883e-01]				).to(__lowerCamelCase				)

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



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Optional[int]				=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''				)
						lowerCAmelCase__  :       Optional[Any]				=  model.to(__lowerCamelCase				)

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

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

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

						# verify the logits
						lowerCAmelCase__  :       Optional[int]				=  torch.Size((1, 21, 32, 32)				)
						self.assertEqual(logits.shape	,__lowerCamelCase				)

						lowerCAmelCase__  :       List[Any]				=  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=__lowerCamelCase	,)

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



		@slow
		def 	lowerCAmelCase__   (self				)  ->    Tuple:

						"""simple docstring"""






						lowerCAmelCase__  :       Dict				=  MobileViTVaForSemanticSegmentation.from_pretrained('''shehan97/mobilevitv2-1.0-voc-deeplabv3'''				)
						lowerCAmelCase__  :       Dict				=  model.to(__lowerCamelCase				)

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

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

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

						lowerCAmelCase__  :       Optional[Any]				=  outputs.logits.detach().cpu()

						lowerCAmelCase__  :       Optional[Any]				=  image_processor.post_process_semantic_segmentation(outputs=__lowerCamelCase	,target_sizes=[(50, 60)]				)
						lowerCAmelCase__  :       Tuple				=  torch.Size((50, 60)				)
						self.assertEqual(segmentation[0].shape	,__lowerCamelCase				)

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

