


'''simple docstring'''



from collections import UserDict
from typing import List, Union

from ..utils import (
    add_end_docstrings,
    is_tf_available,
    is_torch_available,
    is_vision_available,
    logging,
    requires_backends,
)
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
      from PIL import Image

      from ..image_utils import load_image

if is_torch_available():
      from ..models.auto.modeling_auto import MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING

if is_tf_available():
      from ..models.auto.modeling_tf_auto import TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
      from ..tf_utils import stable_softmax

A__						:   Optional[int]				=    logging.get_logger(__name__)





@add_end_docstrings(_UpperCAmelCase    )
class   UpperCAmelCase_    (_UpperCAmelCase    ):





    """simple docstring"""






    def __init__(				self     ,	**SCREAMING_SNAKE_CASE_      )							->	int:
         super().__init__(**SCREAMING_SNAKE_CASE_      )

         requires_backends(self     ,	'vision'      )
         self.check_model_type(
             TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING
             if self.framework == 'tf'
             else MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING      )







    def __call__(				self     ,	SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )							->	Optional[Any]:
         return super().__call__(SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self     ,	**SCREAMING_SNAKE_CASE_      )							->	Optional[Any]:
         __lowerCamelCase  :      Dict														=						{}
         if "candidate_labels" in kwargs:
              __lowerCamelCase  :      List[str]														=						kwargs['candidate_labels']
         if "hypothesis_template" in kwargs:
              __lowerCamelCase  :      Tuple														=						kwargs['hypothesis_template']

         return preprocess_params, {}, {}







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=None     ,	SCREAMING_SNAKE_CASE_="This is a photo of {}."      )							->	Tuple:
         __lowerCamelCase  :      Union[str, Any]														=						load_image(SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      int														=						self.image_processor(images=[image]     ,	return_tensors=self.framework      )
         __lowerCamelCase  :      Optional[Any]														=						candidate_labels
         __lowerCamelCase  :      int														=						[hypothesis_template.format(SCREAMING_SNAKE_CASE_      ) for x in candidate_labels]
         __lowerCamelCase  :      Union[str, Any]														=						self.tokenizer(SCREAMING_SNAKE_CASE_     ,	return_tensors=self.framework     ,	padding=SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      List[str]														=						[text_inputs]
         return inputs







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Dict:
         __lowerCamelCase  :      Dict														=						model_inputs.pop('candidate_labels'      )
         __lowerCamelCase  :      int														=						model_inputs.pop('text_inputs'      )
         if isinstance(text_inputs[0]     ,	SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      List[Any]														=						text_inputs[0]
         else:
              # Batching case.
              __lowerCamelCase  :      Optional[Any]														=						text_inputs[0][0]

         __lowerCamelCase  :      Optional[int]														=						self.model(**SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_      )

         __lowerCamelCase  :      int														=						{
             'candidate_labels': candidate_labels,
             'logits': outputs.logits_per_image,
         }
         return model_outputs







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Optional[int]:
         __lowerCamelCase  :      str														=						model_outputs.pop('candidate_labels'      )
         __lowerCamelCase  :      Union[str, Any]														=						model_outputs['logits'][0]
         if self.framework == "pt":
              __lowerCamelCase  :      List[Any]														=						logits.softmax(dim=-1      ).squeeze(-1      )
              __lowerCamelCase  :      Dict														=						probs.tolist()
              if not isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      ):
                   __lowerCamelCase  :      List[Any]														=						[scores]
         elif self.framework == "tf":
              __lowerCamelCase  :      Union[str, Any]														=						stable_softmax(SCREAMING_SNAKE_CASE_     ,	axis=-1      )
              __lowerCamelCase  :      Optional[Any]														=						probs.numpy().tolist()
         else:
              raise ValueError(f'Unsupported framework: {self.framework}'      )

         __lowerCamelCase  :      Optional[Any]														=						[
             {'score': score, 'label': candidate_label}
             for score, candidate_label in sorted(zip(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )     ,	key=lambda SCREAMING_SNAKE_CASE_      : -x[0]      )
         ]
         return result








"""simple docstring"""






import inspect
import unittest

from transformers import MobileViTConfig
from transformers.testing_utils import require_torch, 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 MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
					from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import MobileViTImageProcessor

class 					__a     ( __a       ):



							'''simple docstring'''







							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       self.config_class(**self.inputs_dict       )
										self.parent.assertTrue(hasattr(_lowerCamelCase  ,    "hidden_sizes"       )       )
										self.parent.assertTrue(hasattr(_lowerCamelCase  ,    "neck_hidden_sizes"       )       )
										self.parent.assertTrue(hasattr(_lowerCamelCase  ,    "num_attention_heads"       )       )





class 					__a     :



							'''simple docstring'''







							def __init__(     self  ,    _lowerCamelCase  ,    _lowerCamelCase=13  ,    _lowerCamelCase=32  ,    _lowerCamelCase=2  ,    _lowerCamelCase=3  ,    _lowerCamelCase=640  ,    _lowerCamelCase=4  ,    _lowerCamelCase="silu"  ,    _lowerCamelCase=3  ,    _lowerCamelCase=32  ,    _lowerCamelCase=0.1  ,    _lowerCamelCase=0.1  ,    _lowerCamelCase=0.1  ,    _lowerCamelCase=0.02  ,    _lowerCamelCase=True  ,    _lowerCamelCase=True  ,    _lowerCamelCase=10  ,    _lowerCamelCase=None  ,    )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       parent
										__lowercase       =       batch_size
										__lowercase       =       image_size
										__lowercase       =       patch_size
										__lowercase       =       num_channels
										__lowercase       =       last_hidden_size
										__lowercase       =       num_attention_heads
										__lowercase       =       hidden_act
										__lowercase       =       conv_kernel_size
										__lowercase       =       output_stride
										__lowercase       =       hidden_dropout_prob
										__lowercase       =       attention_probs_dropout_prob
										__lowercase       =       classifier_dropout_prob
										__lowercase       =       use_labels
										__lowercase       =       is_training
										__lowercase       =       num_labels
										__lowercase       =       initializer_range
										__lowercase       =       scope
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

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

										__lowercase       =       self.get_config()

										return config, pixel_values, labels, pixel_labels
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										return MobileViTConfig(
										    image_size=self.image_size  ,    patch_size=self.patch_size  ,    num_channels=self.num_channels  ,    num_attention_heads=self.num_attention_heads  ,    hidden_act=self.hidden_act  ,    conv_kernel_size=self.conv_kernel_size  ,    output_stride=self.output_stride  ,    hidden_dropout_prob=self.hidden_dropout_prob  ,    attention_probs_dropout_prob=self.attention_probs_dropout_prob  ,    classifier_dropout_prob=self.classifier_dropout_prob  ,    initializer_range=self.initializer_range  ,    )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							str:




										'''simple docstring'''
										__lowercase       =       MobileViTModel(config=_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       model(_lowerCamelCase       )
										self.parent.assertEqual(
										    result.last_hidden_state.shape  ,    (
										        self.batch_size,
										        self.last_hidden_size,
										        self.image_size // self.output_stride,
										        self.image_size // self.output_stride,
										    )  ,    )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							int:




										'''simple docstring'''
										__lowercase       =       self.num_labels
										__lowercase       =       MobileViTForImageClassification(_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       model(_lowerCamelCase  ,    labels=_lowerCamelCase       )
										self.parent.assertEqual(result.logits.shape  ,    (self.batch_size, self.num_labels)       )
							def   SCREAMING_SNAKE_CASE						(     self  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )			->							Optional[int]:




										'''simple docstring'''
										__lowercase       =       self.num_labels
										__lowercase       =       MobileViTForSemanticSegmentation(_lowerCamelCase       )
										model.to(_lowerCamelCase       )
										model.eval()
										__lowercase       =       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,
										    )  ,    )
										__lowercase       =       model(_lowerCamelCase  ,    labels=_lowerCamelCase       )
										self.parent.assertEqual(
										    result.logits.shape  ,    (
										        self.batch_size,
										        self.num_labels,
										        self.image_size // self.output_stride,
										        self.image_size // self.output_stride,
										    )  ,    )





							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       self.prepare_config_and_inputs()
										__lowercase   ,					__lowercase   ,					__lowercase   ,					__lowercase       =       config_and_inputs
										__lowercase       =       {"pixel_values": pixel_values}
										return config, inputs_dict





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



							'''simple docstring'''







							_lowerCamelCase					:			str          =   (
							    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							_lowerCamelCase					:			Optional[int]          =   (
							    {
							        """feature-extraction""": MobileViTModel,
							        """image-classification""": MobileViTForImageClassification,
							        """image-segmentation""": MobileViTForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							_lowerCamelCase					:			Tuple          =   False
							_lowerCamelCase					:			Optional[Any]          =   False
							_lowerCamelCase					:			Any          =   False
							_lowerCamelCase					:			List[Any]          =   False
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       MobileViTModelTester(self       )
										__lowercase       =       MobileViTConfigTester(self  ,    config_class=_lowerCamelCase  ,    has_text_modality=_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										self.config_tester.run_common_tests()
							@unittest.skip(reason="MobileViT does not use inputs_embeds"       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''simple docstring'''
										pass
							@unittest.skip(reason="MobileViT does not support input and output embeddings"       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										pass
							@unittest.skip(reason="MobileViT does not output attentions"       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										pass
							def   SCREAMING_SNAKE_CASE						(     self       )			->							int:




										'''simple docstring'''
										__lowercase   ,					__lowercase       =       self.model_tester.prepare_config_and_inputs_for_common()

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

													__lowercase       =       ["pixel_values"]
													self.assertListEqual(arg_names[:1]  ,    _lowerCamelCase       )
							@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Dict:




										'''simple docstring'''
										pass
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[Any]:




										'''simple docstring'''
										def check_hidden_states_output(_lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       ):
													__lowercase       =       model_class(_lowerCamelCase       )
													model.to(_lowerCamelCase       )
													model.eval()

													with torch.no_grad():
																__lowercase       =       model(**self._prepare_for_class(_lowerCamelCase  ,    _lowerCamelCase       )       )

													__lowercase       =       outputs.hidden_states

													__lowercase       =       5
													self.assertEqual(len(_lowerCamelCase       )  ,    _lowerCamelCase       )

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

										__lowercase   ,					__lowercase       =       self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
													__lowercase       =       True
													check_hidden_states_output(_lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )

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

													check_hidden_states_output(_lowerCamelCase  ,    _lowerCamelCase  ,    _lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_lowerCamelCase       )
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Optional[Any]:




										'''simple docstring'''
										__lowercase       =       self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCamelCase       )





							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Tuple:




										'''simple docstring'''
										for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													__lowercase       =       MobileViTModel.from_pretrained(_lowerCamelCase       )
													self.assertIsNotNone(_lowerCamelCase       )





def      lowerCAmelCase__			(		)						->List[Any]:
			__lowercase       =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
			return image







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



							'''simple docstring'''







							@cached_property
							def   SCREAMING_SNAKE_CASE						(     self       )			->							str:




										'''simple docstring'''
										return MobileViTImageProcessor.from_pretrained("apple/mobilevit-xx-small"       ) if is_vision_available() else None
							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							Optional[int]:




										'''simple docstring'''
										__lowercase       =       MobileViTForImageClassification.from_pretrained("apple/mobilevit-xx-small"       ).to(_lowerCamelCase       )

										__lowercase       =       self.default_image_processor
										__lowercase       =       prepare_img()
										__lowercase       =       image_processor(images=_lowerCamelCase  ,    return_tensors="pt"       ).to(_lowerCamelCase       )

										# forward pass
										with torch.no_grad():
													__lowercase       =       model(**_lowerCamelCase       )

										# verify the logits
										__lowercase       =       torch.Size((1, 1_000)       )
										self.assertEqual(outputs.logits.shape  ,    _lowerCamelCase       )

										__lowercase       =       torch.tensor([-1.9364, -1.2327, -0.4653]       ).to(_lowerCamelCase       )

										self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,    _lowerCamelCase  ,    atol=1e-4       )       )
							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       MobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-xx-small"       )
										__lowercase       =       model.to(_lowerCamelCase       )

										__lowercase       =       MobileViTImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-xx-small"       )

										__lowercase       =       prepare_img()
										__lowercase       =       image_processor(images=_lowerCamelCase  ,    return_tensors="pt"       ).to(_lowerCamelCase       )

										# forward pass
										with torch.no_grad():
													__lowercase       =       model(**_lowerCamelCase       )
										__lowercase       =       outputs.logits

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

										__lowercase       =       torch.tensor(
										    [
										        [[6.9713, 6.9786, 7.2422], [7.2893, 7.2825, 7.4446], [7.6580, 7.8797, 7.9420]],
										        [[-10.6869, -10.3250, -10.3471], [-10.4228, -9.9868, -9.7132], [-11.0405, -11.0221, -10.7318]],
										        [[-3.3089, -2.8539, -2.6740], [-3.2706, -2.5621, -2.5108], [-3.2534, -2.6615, -2.6651]],
										    ]  ,    device=_lowerCamelCase  ,    )

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





							@slow
							def   SCREAMING_SNAKE_CASE						(     self       )			->							List[str]:




										'''simple docstring'''
										__lowercase       =       MobileViTForSemanticSegmentation.from_pretrained("apple/deeplabv3-mobilevit-xx-small"       )
										__lowercase       =       model.to(_lowerCamelCase       )

										__lowercase       =       MobileViTImageProcessor.from_pretrained("apple/deeplabv3-mobilevit-xx-small"       )

										__lowercase       =       prepare_img()
										__lowercase       =       image_processor(images=_lowerCamelCase  ,    return_tensors="pt"       ).to(_lowerCamelCase       )

										# forward pass
										with torch.no_grad():
													__lowercase       =       model(**_lowerCamelCase       )

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

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

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





