



# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from ..models.auto import AutoModelForSeqaSeqLM, AutoTokenizer
from .base import PipelineTool


_lowercase     							=						{
    '''Acehnese Arabic''': '''ace_Arab''',
    '''Acehnese Latin''': '''ace_Latn''',
    '''Mesopotamian Arabic''': '''acm_Arab''',
    '''Ta\'izzi-Adeni Arabic''': '''acq_Arab''',
    '''Tunisian Arabic''': '''aeb_Arab''',
    '''Afrikaans''': '''afr_Latn''',
    '''South Levantine Arabic''': '''ajp_Arab''',
    '''Akan''': '''aka_Latn''',
    '''Amharic''': '''amh_Ethi''',
    '''North Levantine Arabic''': '''apc_Arab''',
    '''Modern Standard Arabic''': '''arb_Arab''',
    '''Modern Standard Arabic Romanized''': '''arb_Latn''',
    '''Najdi Arabic''': '''ars_Arab''',
    '''Moroccan Arabic''': '''ary_Arab''',
    '''Egyptian Arabic''': '''arz_Arab''',
    '''Assamese''': '''asm_Beng''',
    '''Asturian''': '''ast_Latn''',
    '''Awadhi''': '''awa_Deva''',
    '''Central Aymara''': '''ayr_Latn''',
    '''South Azerbaijani''': '''azb_Arab''',
    '''North Azerbaijani''': '''azj_Latn''',
    '''Bashkir''': '''bak_Cyrl''',
    '''Bambara''': '''bam_Latn''',
    '''Balinese''': '''ban_Latn''',
    '''Belarusian''': '''bel_Cyrl''',
    '''Bemba''': '''bem_Latn''',
    '''Bengali''': '''ben_Beng''',
    '''Bhojpuri''': '''bho_Deva''',
    '''Banjar Arabic''': '''bjn_Arab''',
    '''Banjar Latin''': '''bjn_Latn''',
    '''Standard Tibetan''': '''bod_Tibt''',
    '''Bosnian''': '''bos_Latn''',
    '''Buginese''': '''bug_Latn''',
    '''Bulgarian''': '''bul_Cyrl''',
    '''Catalan''': '''cat_Latn''',
    '''Cebuano''': '''ceb_Latn''',
    '''Czech''': '''ces_Latn''',
    '''Chokwe''': '''cjk_Latn''',
    '''Central Kurdish''': '''ckb_Arab''',
    '''Crimean Tatar''': '''crh_Latn''',
    '''Welsh''': '''cym_Latn''',
    '''Danish''': '''dan_Latn''',
    '''German''': '''deu_Latn''',
    '''Southwestern Dinka''': '''dik_Latn''',
    '''Dyula''': '''dyu_Latn''',
    '''Dzongkha''': '''dzo_Tibt''',
    '''Greek''': '''ell_Grek''',
    '''English''': '''eng_Latn''',
    '''Esperanto''': '''epo_Latn''',
    '''Estonian''': '''est_Latn''',
    '''Basque''': '''eus_Latn''',
    '''Ewe''': '''ewe_Latn''',
    '''Faroese''': '''fao_Latn''',
    '''Fijian''': '''fij_Latn''',
    '''Finnish''': '''fin_Latn''',
    '''Fon''': '''fon_Latn''',
    '''French''': '''fra_Latn''',
    '''Friulian''': '''fur_Latn''',
    '''Nigerian Fulfulde''': '''fuv_Latn''',
    '''Scottish Gaelic''': '''gla_Latn''',
    '''Irish''': '''gle_Latn''',
    '''Galician''': '''glg_Latn''',
    '''Guarani''': '''grn_Latn''',
    '''Gujarati''': '''guj_Gujr''',
    '''Haitian Creole''': '''hat_Latn''',
    '''Hausa''': '''hau_Latn''',
    '''Hebrew''': '''heb_Hebr''',
    '''Hindi''': '''hin_Deva''',
    '''Chhattisgarhi''': '''hne_Deva''',
    '''Croatian''': '''hrv_Latn''',
    '''Hungarian''': '''hun_Latn''',
    '''Armenian''': '''hye_Armn''',
    '''Igbo''': '''ibo_Latn''',
    '''Ilocano''': '''ilo_Latn''',
    '''Indonesian''': '''ind_Latn''',
    '''Icelandic''': '''isl_Latn''',
    '''Italian''': '''ita_Latn''',
    '''Javanese''': '''jav_Latn''',
    '''Japanese''': '''jpn_Jpan''',
    '''Kabyle''': '''kab_Latn''',
    '''Jingpho''': '''kac_Latn''',
    '''Kamba''': '''kam_Latn''',
    '''Kannada''': '''kan_Knda''',
    '''Kashmiri Arabic''': '''kas_Arab''',
    '''Kashmiri Devanagari''': '''kas_Deva''',
    '''Georgian''': '''kat_Geor''',
    '''Central Kanuri Arabic''': '''knc_Arab''',
    '''Central Kanuri Latin''': '''knc_Latn''',
    '''Kazakh''': '''kaz_Cyrl''',
    '''Kabiyè''': '''kbp_Latn''',
    '''Kabuverdianu''': '''kea_Latn''',
    '''Khmer''': '''khm_Khmr''',
    '''Kikuyu''': '''kik_Latn''',
    '''Kinyarwanda''': '''kin_Latn''',
    '''Kyrgyz''': '''kir_Cyrl''',
    '''Kimbundu''': '''kmb_Latn''',
    '''Northern Kurdish''': '''kmr_Latn''',
    '''Kikongo''': '''kon_Latn''',
    '''Korean''': '''kor_Hang''',
    '''Lao''': '''lao_Laoo''',
    '''Ligurian''': '''lij_Latn''',
    '''Limburgish''': '''lim_Latn''',
    '''Lingala''': '''lin_Latn''',
    '''Lithuanian''': '''lit_Latn''',
    '''Lombard''': '''lmo_Latn''',
    '''Latgalian''': '''ltg_Latn''',
    '''Luxembourgish''': '''ltz_Latn''',
    '''Luba-Kasai''': '''lua_Latn''',
    '''Ganda''': '''lug_Latn''',
    '''Luo''': '''luo_Latn''',
    '''Mizo''': '''lus_Latn''',
    '''Standard Latvian''': '''lvs_Latn''',
    '''Magahi''': '''mag_Deva''',
    '''Maithili''': '''mai_Deva''',
    '''Malayalam''': '''mal_Mlym''',
    '''Marathi''': '''mar_Deva''',
    '''Minangkabau Arabic ''': '''min_Arab''',
    '''Minangkabau Latin''': '''min_Latn''',
    '''Macedonian''': '''mkd_Cyrl''',
    '''Plateau Malagasy''': '''plt_Latn''',
    '''Maltese''': '''mlt_Latn''',
    '''Meitei Bengali''': '''mni_Beng''',
    '''Halh Mongolian''': '''khk_Cyrl''',
    '''Mossi''': '''mos_Latn''',
    '''Maori''': '''mri_Latn''',
    '''Burmese''': '''mya_Mymr''',
    '''Dutch''': '''nld_Latn''',
    '''Norwegian Nynorsk''': '''nno_Latn''',
    '''Norwegian Bokmål''': '''nob_Latn''',
    '''Nepali''': '''npi_Deva''',
    '''Northern Sotho''': '''nso_Latn''',
    '''Nuer''': '''nus_Latn''',
    '''Nyanja''': '''nya_Latn''',
    '''Occitan''': '''oci_Latn''',
    '''West Central Oromo''': '''gaz_Latn''',
    '''Odia''': '''ory_Orya''',
    '''Pangasinan''': '''pag_Latn''',
    '''Eastern Panjabi''': '''pan_Guru''',
    '''Papiamento''': '''pap_Latn''',
    '''Western Persian''': '''pes_Arab''',
    '''Polish''': '''pol_Latn''',
    '''Portuguese''': '''por_Latn''',
    '''Dari''': '''prs_Arab''',
    '''Southern Pashto''': '''pbt_Arab''',
    '''Ayacucho Quechua''': '''quy_Latn''',
    '''Romanian''': '''ron_Latn''',
    '''Rundi''': '''run_Latn''',
    '''Russian''': '''rus_Cyrl''',
    '''Sango''': '''sag_Latn''',
    '''Sanskrit''': '''san_Deva''',
    '''Santali''': '''sat_Olck''',
    '''Sicilian''': '''scn_Latn''',
    '''Shan''': '''shn_Mymr''',
    '''Sinhala''': '''sin_Sinh''',
    '''Slovak''': '''slk_Latn''',
    '''Slovenian''': '''slv_Latn''',
    '''Samoan''': '''smo_Latn''',
    '''Shona''': '''sna_Latn''',
    '''Sindhi''': '''snd_Arab''',
    '''Somali''': '''som_Latn''',
    '''Southern Sotho''': '''sot_Latn''',
    '''Spanish''': '''spa_Latn''',
    '''Tosk Albanian''': '''als_Latn''',
    '''Sardinian''': '''srd_Latn''',
    '''Serbian''': '''srp_Cyrl''',
    '''Swati''': '''ssw_Latn''',
    '''Sundanese''': '''sun_Latn''',
    '''Swedish''': '''swe_Latn''',
    '''Swahili''': '''swh_Latn''',
    '''Silesian''': '''szl_Latn''',
    '''Tamil''': '''tam_Taml''',
    '''Tatar''': '''tat_Cyrl''',
    '''Telugu''': '''tel_Telu''',
    '''Tajik''': '''tgk_Cyrl''',
    '''Tagalog''': '''tgl_Latn''',
    '''Thai''': '''tha_Thai''',
    '''Tigrinya''': '''tir_Ethi''',
    '''Tamasheq Latin''': '''taq_Latn''',
    '''Tamasheq Tifinagh''': '''taq_Tfng''',
    '''Tok Pisin''': '''tpi_Latn''',
    '''Tswana''': '''tsn_Latn''',
    '''Tsonga''': '''tso_Latn''',
    '''Turkmen''': '''tuk_Latn''',
    '''Tumbuka''': '''tum_Latn''',
    '''Turkish''': '''tur_Latn''',
    '''Twi''': '''twi_Latn''',
    '''Central Atlas Tamazight''': '''tzm_Tfng''',
    '''Uyghur''': '''uig_Arab''',
    '''Ukrainian''': '''ukr_Cyrl''',
    '''Umbundu''': '''umb_Latn''',
    '''Urdu''': '''urd_Arab''',
    '''Northern Uzbek''': '''uzn_Latn''',
    '''Venetian''': '''vec_Latn''',
    '''Vietnamese''': '''vie_Latn''',
    '''Waray''': '''war_Latn''',
    '''Wolof''': '''wol_Latn''',
    '''Xhosa''': '''xho_Latn''',
    '''Eastern Yiddish''': '''ydd_Hebr''',
    '''Yoruba''': '''yor_Latn''',
    '''Yue Chinese''': '''yue_Hant''',
    '''Chinese Simplified''': '''zho_Hans''',
    '''Chinese Traditional''': '''zho_Hant''',
    '''Standard Malay''': '''zsm_Latn''',
    '''Zulu''': '''zul_Latn''',
}
class 				__A					( A_      ):
			UpperCamelCase					:Union[str, Any]     =			'''facebook/nllb-200-distilled-600M'''
			UpperCamelCase					:Tuple     =			(
			    '''This is a tool that translates text from a language to another. It takes three inputs: `text`, which should '''
			    '''be the text to translate, `src_lang`, which should be the language of the text to translate and `tgt_lang`, '''
			    '''which should be the language for the desired ouput language. Both `src_lang` and `tgt_lang` are written in '''
			    '''plain English, such as \'Romanian\', or \'Albanian\'. It returns the text translated in `tgt_lang`.'''
			)
			UpperCamelCase					:Dict     =			'''translator'''
			UpperCamelCase					:List[Any]     =			AutoTokenizer
			UpperCamelCase					:List[str]     =			AutoModelForSeqaSeqLM
			UpperCamelCase					:Optional[Any]     =			LANGUAGE_CODES

			UpperCamelCase					:Optional[int]     =			['''text''', '''text''', '''text''']
			UpperCamelCase					:Optional[int]     =			['''text''']





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						if src_lang not in self.lang_to_code:
									raise ValueError(f"{src_lang} is not a supported language."				)
						if tgt_lang not in self.lang_to_code:
									raise ValueError(f"{tgt_lang} is not a supported language."				)
						lowerCamelCase__ :      Optional[Any]								=		self.lang_to_code[src_lang]
						lowerCamelCase__ :      int								=		self.lang_to_code[tgt_lang]
						return self.pre_processor._build_translation_inputs(
						    __magic_name__							,    return_tensors="""pt"""							,    src_lang=__magic_name__							,    tgt_lang=__magic_name__				)





			def        _snake_case    (self							,    __magic_name__				):
						return self.model.generate(**__magic_name__				)





			def        _snake_case    (self							,    __magic_name__				):
						return self.post_processor.decode(outputs[0].tolist()							,    skip_special_tokens=__magic_name__				)








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_      ):





			def        _snake_case    (self				):
						lowerCamelCase__ :      Dict								=		self.config_class(**self.inputs_dict				)
						self.parent.assertTrue(hasattr(__magic_name__							,    """width_multiplier"""				)				)







class 				__A					:





			def __init__(self							,    __magic_name__							,    __magic_name__=13							,    __magic_name__=64							,    __magic_name__=2							,    __magic_name__=3							,    __magic_name__="swish"							,    __magic_name__=3							,    __magic_name__=32							,    __magic_name__=0.1							,    __magic_name__=0.02							,    __magic_name__=True							,    __magic_name__=True							,    __magic_name__=10							,    __magic_name__=None							,    __magic_name__=0.25							,    __magic_name__=0.0							,    __magic_name__=0.0							,    ):
						lowerCamelCase__ :      Optional[Any]								=		parent
						lowerCamelCase__ :      List[Any]								=		batch_size
						lowerCamelCase__ :      Optional[Any]								=		image_size
						lowerCamelCase__ :      Union[str, Any]								=		patch_size
						lowerCamelCase__ :      Dict								=		num_channels
						lowerCamelCase__ :      Optional[Any]								=		make_divisible(512 * width_multiplier							,    divisor=8				)
						lowerCamelCase__ :      str								=		hidden_act
						lowerCamelCase__ :      Union[str, Any]								=		conv_kernel_size
						lowerCamelCase__ :      int								=		output_stride
						lowerCamelCase__ :      Tuple								=		classifier_dropout_prob
						lowerCamelCase__ :      Optional[Any]								=		use_labels
						lowerCamelCase__ :      Tuple								=		is_training
						lowerCamelCase__ :      List[Any]								=		num_labels
						lowerCamelCase__ :      str								=		initializer_range
						lowerCamelCase__ :      Optional[Any]								=		scope
						lowerCamelCase__ :      Tuple								=		width_multiplier
						lowerCamelCase__ :      List[Any]								=		ffn_dropout
						lowerCamelCase__ :      Union[str, Any]								=		attn_dropout





			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

						lowerCamelCase__ :      int								=		self.get_config()

						return config, pixel_values, labels, pixel_labels





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





			def        _snake_case    (self							,    __magic_name__							,    __magic_name__							,    __magic_name__							,    __magic_name__				):
						lowerCamelCase__ :      Dict								=		self.num_labels
						lowerCamelCase__ :      Any								=		MobileViTVaForSemanticSegmentation(__magic_name__				)
						model.to(__magic_name__				)
						model.eval()
						lowerCamelCase__ :      Optional[int]								=		model(__magic_name__				)
						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__ :      Dict								=		model(__magic_name__							,    labels=__magic_name__				)
						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        _snake_case    (self				):
						lowerCamelCase__ :      Any								=		self.prepare_config_and_inputs()
						lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__							,lowerCamelCase__ :      List[str]								=		config_and_inputs
						lowerCamelCase__ :      str								=		{"""pixel_values""": pixel_values}
						return config, inputs_dict







@require_torch
class 				__A					( A_					, A_					, unittest.TestCase      ):
			UpperCamelCase					:Optional[Any]     =			(
			    (MobileViTVaModel, MobileViTVaForImageClassification, MobileViTVaForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)

			UpperCamelCase					:List[Any]     =			(
			    {
			        '''feature-extraction''': MobileViTVaModel,
			        '''image-classification''': MobileViTVaForImageClassification,
			        '''image-segmentation''': MobileViTVaForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			UpperCamelCase					:List[Any]     =			False
			UpperCamelCase					:int     =			False
			UpperCamelCase					:Optional[int]     =			False
			UpperCamelCase					:int     =			False





			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaModelTester(self				)
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaConfigTester(self							,    config_class=__magic_name__							,    has_text_modality=__magic_name__				)





			def        _snake_case    (self				):
						self.config_tester.run_common_tests()





			@unittest.skip(reason="""MobileViTV2 does not use inputs_embeds"""				)
			def        _snake_case    (self				):
						pass





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





			@unittest.skip(reason="""MobileViTV2 does not output attentions"""				)
			def        _snake_case    (self				):
						pass





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





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





			def        _snake_case    (self				):
						lowerCamelCase__							,lowerCamelCase__ :      Union[str, Any]								=		self.model_tester.prepare_config_and_inputs_for_common()

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

									lowerCamelCase__ :      Union[str, Any]								=		["""pixel_values"""]
									self.assertListEqual(arg_names[:1]							,    __magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      int								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*__magic_name__				)





			def        _snake_case    (self				):
						def check_hidden_states_output(__magic_name__							,    __magic_name__							,    __magic_name__				):
									lowerCamelCase__ :      Dict								=		model_class(__magic_name__				)
									model.to(__magic_name__				)
									model.eval()

									with torch.no_grad():
												lowerCamelCase__ :      Optional[int]								=		model(**self._prepare_for_class(__magic_name__							,    __magic_name__				)				)

									lowerCamelCase__ :      str								=		outputs.hidden_states

									lowerCamelCase__ :      Dict								=		5
									self.assertEqual(len(__magic_name__				)							,    __magic_name__				)

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

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

									check_hidden_states_output(__magic_name__							,    __magic_name__							,    __magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      Tuple								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*__magic_name__				)





			def        _snake_case    (self				):
						lowerCamelCase__ :      List[Any]								=		self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*__magic_name__				)





			@slow
			def        _snake_case    (self				):
						for model_name in MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowerCamelCase__ :      int								=		MobileViTVaModel.from_pretrained(__magic_name__				)
									self.assertIsNotNone(__magic_name__				)







def      _A				()  ->List[Any]:



			'''simple docstring'''







			lowerCamelCase__ :      Tuple								=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
			return image
@require_torch
@require_vision
class 				__A					( unittest.TestCase      ):





			@cached_property
			def        _snake_case    (self				):
						return (
						    MobileViTImageProcessor.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""				)
						    if is_vision_available()
						    else None
						)





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      str								=		MobileViTVaForImageClassification.from_pretrained("""apple/mobilevitv2-1.0-imagenet1k-256"""				).to(
						    __magic_name__				)

						lowerCamelCase__ :      Union[str, Any]								=		self.default_image_processor
						lowerCamelCase__ :      Any								=		prepare_img()
						lowerCamelCase__ :      Optional[Any]								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      List[str]								=		model(**__magic_name__				)

						# verify the logits
						lowerCamelCase__ :      List[Any]								=		torch.Size((1, 1000)				)
						self.assertEqual(outputs.logits.shape							,    __magic_name__				)

						lowerCamelCase__ :      Optional[Any]								=		torch.tensor([-1.63_36E00, -7.32_04E-02, -5.18_83E-01]				).to(__magic_name__				)

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





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      Optional[int]								=		MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)
						lowerCamelCase__ :      Dict								=		model.to(__magic_name__				)

						lowerCamelCase__ :      str								=		MobileViTImageProcessor.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)

						lowerCamelCase__ :      str								=		prepare_img()
						lowerCamelCase__ :      str								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      Dict								=		model(**__magic_name__				)
						lowerCamelCase__ :      List[str]								=		outputs.logits

						# verify the logits
						lowerCamelCase__ :      Tuple								=		torch.Size((1, 21, 32, 32)				)
						self.assertEqual(logits.shape							,    __magic_name__				)

						lowerCamelCase__ :      Any								=		torch.tensor(
						    [
						        [[7.08_63, 7.15_25, 6.82_01], [6.69_31, 6.87_70, 6.89_33], [6.29_78, 7.03_66, 6.96_36]],
						        [[-3.71_34, -3.67_12, -3.66_75], [-3.58_25, -3.35_49, -3.47_77], [-3.34_35, -3.39_79, -3.28_57]],
						        [[-2.93_29, -2.80_03, -2.73_69], [-3.05_64, -2.47_80, -2.02_07], [-2.68_89, -1.92_98, -1.76_40]],
						    ]							,    device=__magic_name__							,    )

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





			@slow
			def        _snake_case    (self				):
						lowerCamelCase__ :      Union[str, Any]								=		MobileViTVaForSemanticSegmentation.from_pretrained("""shehan97/mobilevitv2-1.0-voc-deeplabv3"""				)
						lowerCamelCase__ :      List[Any]								=		model.to(__magic_name__				)

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

						lowerCamelCase__ :      Union[str, Any]								=		prepare_img()
						lowerCamelCase__ :      Dict								=		image_processor(images=__magic_name__							,    return_tensors="""pt"""				).to(__magic_name__				)

						# forward pass
						with torch.no_grad():
									lowerCamelCase__ :      List[str]								=		model(**__magic_name__				)

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

						lowerCamelCase__ :      Optional[int]								=		image_processor.post_process_semantic_segmentation(outputs=__magic_name__							,    target_sizes=[(50, 60)]				)
						lowerCamelCase__ :      List[Any]								=		torch.Size((50, 60)				)
						self.assertEqual(segmentation[0].shape							,    __magic_name__				)

						lowerCamelCase__ :      List[str]								=		image_processor.post_process_semantic_segmentation(outputs=__magic_name__				)
						lowerCamelCase__ :      int								=		torch.Size((32, 32)				)
						self.assertEqual(segmentation[0].shape							,    __magic_name__				)



