
'''simple docstring'''
import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch
 from torch import nn

 from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
 from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image







class  __A				:
 def __init__(   self			:    Optional[int]				,   lowerCamelCase			:    str				,   lowerCamelCase			:    str=13				,   lowerCamelCase			:    Any=64				,   lowerCamelCase			:    List[str]=2				,   lowerCamelCase			:    Dict=3				,   lowerCamelCase			:    List[Any]=True				,   lowerCamelCase			:    Optional[Any]=True				,   lowerCamelCase			:    Optional[int]=32				,   lowerCamelCase			:    List[str]=5				,   lowerCamelCase			:    int=4				,   lowerCamelCase			:    Dict=37				,   lowerCamelCase			:    List[Any]="gelu"				,   lowerCamelCase			:    Any=0.1				,   lowerCamelCase			:    Optional[Any]=0.1				,   lowerCamelCase			:    int=10				,   lowerCamelCase			:    Optional[int]=0.02				,   lowerCamelCase			:    Dict=[1, 16, 4, 4]				,   lowerCamelCase			:    Optional[int]=None				,   ):



   """simple docstring"""





   __A		:     List[Any]												=		parent
   __A		:     Optional[int]												=		batch_size
   __A		:     Tuple												=		image_size
   __A		:     int												=		patch_size
   __A		:     List[Any]												=		num_channels
   __A		:     Dict												=		is_training
   __A		:     int												=		use_labels
   __A		:     Optional[Any]												=		hidden_size
   __A		:     Union[str, Any]												=		num_hidden_layers
   __A		:     Any												=		num_attention_heads
   __A		:     Optional[int]												=		intermediate_size
   __A		:     Dict												=		hidden_act
   __A		:     Optional[int]												=		hidden_dropout_prob
   __A		:     List[str]												=		attention_probs_dropout_prob
   __A		:     Dict												=		type_sequence_label_size
   __A		:     List[str]												=		initializer_range
   __A		:     List[str]												=		scope
   __A		:     int												=		backbone_featmap_shape

   # in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
   # the number of patches is based on the feature map of the backbone, which by default uses an output stride
   # of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
   __A		:     List[Any]												=		(self.image_size // 32) ** 2
   __A		:     List[Any]												=		num_patches + 1
 def 		lowercase_(   self			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     Dict												=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]       )

   __A		:     Optional[Any]												=		None
   if self.use_labels:
     __A		:     Any												=		ids_tensor([self.batch_size]				,   self.type_sequence_label_size       )

   __A		:     List[Any]												=		self.get_config()

   return config, pixel_values, labels
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Optional[Any]												=		{
       """global_padding""": """same""",
       """layer_type""": """bottleneck""",
       """depths""": [3, 4, 9],
       """out_features""": ["""stage1""", """stage2""", """stage3"""],
       """embedding_dynamic_padding""": True,
       """hidden_sizes""": [4, 8, 16, 32],
       """num_groups""": 2,
   }

   return ViTHybridConfig(
       image_size=self.image_size				,   patch_size=self.patch_size				,   num_channels=self.num_channels				,   hidden_size=self.hidden_size				,   num_hidden_layers=self.num_hidden_layers				,   num_attention_heads=self.num_attention_heads				,   intermediate_size=self.intermediate_size				,   hidden_act=self.hidden_act				,   hidden_dropout_prob=self.hidden_dropout_prob				,   attention_probs_dropout_prob=self.attention_probs_dropout_prob				,   is_decoder=__UpperCamelCase				,   initializer_range=self.initializer_range				,   backbone_featmap_shape=self.backbone_featmap_shape				,   backbone_config=__UpperCamelCase				,   )
 def 		lowercase_(   self			:    int				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    List[Any]				,   lowerCamelCase			:    Union[str, Any]       ):



   """simple docstring"""





   __A		:     Optional[int]												=		ViTHybridModel(config=__UpperCamelCase       )
   model.to(__UpperCamelCase       )
   model.eval()
   __A		:     int												=		model(__UpperCamelCase       )
   self.parent.assertEqual(result.last_hidden_state.shape				,   (self.batch_size, self.seq_length, self.hidden_size)       )
 def 		lowercase_(   self			:    Any				,   lowerCamelCase			:    str				,   lowerCamelCase			:    int				,   lowerCamelCase			:    Dict       ):



   """simple docstring"""





   __A		:     Optional[int]												=		self.type_sequence_label_size
   __A		:     Optional[Any]												=		ViTHybridForImageClassification(__UpperCamelCase       )
   model.to(__UpperCamelCase       )
   model.eval()
   __A		:     Any												=		model(__UpperCamelCase				,   labels=__UpperCamelCase       )
   self.parent.assertEqual(result.logits.shape				,   (self.batch_size, self.type_sequence_label_size)       )






 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





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







@require_torch
class  __A				( _SCREAMING_SNAKE_CASE    ,						_SCREAMING_SNAKE_CASE    ,						unittest.TestCase			):
 lowerCamelCase				       =(ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
 lowerCamelCase				       =(
     {'''feature-extraction''': ViTHybridModel, '''image-classification''': ViTHybridForImageClassification}
     if is_torch_available()
     else {}
 )
 lowerCamelCase				       =False
 lowerCamelCase				       =False
 lowerCamelCase				       =False
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   __A		:     Optional[Any]												=		ViTHybridModelTester(self       )
   __A		:     Optional[int]												=		ConfigTester(self				,   config_class=__UpperCamelCase				,   has_text_modality=__UpperCamelCase				,   hidden_size=37       )
 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





   self.config_tester.run_common_tests()
 @unittest.skip(reason="""ViT does not use inputs_embeds"""       )
 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   pass
 def 		lowercase_(   self			:    Tuple       ):



   """simple docstring"""





   __A							,					__A		:     Dict												=		self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     __A		:     Tuple												=		model_class(__UpperCamelCase       )
     self.assertIsInstance(model.get_input_embeddings()				,   (nn.Module)       )
     __A		:     Dict												=		model.get_output_embeddings()
     self.assertTrue(x is None or isinstance(__UpperCamelCase				,   nn.Linear       )       )
 def 		lowercase_(   self			:    Optional[int]       ):



   """simple docstring"""





   __A							,					__A		:     Any												=		self.model_tester.prepare_config_and_inputs_for_common()

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

     __A		:     Union[str, Any]												=		["""pixel_values"""]
     self.assertListEqual(arg_names[:1]				,   __UpperCamelCase       )
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     List[str]												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*__UpperCamelCase       )
 def 		lowercase_(   self			:    Any       ):



   """simple docstring"""





   __A		:     Any												=		self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase       )
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





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

   __A		:     int												=		_config_zero_init(__UpperCamelCase       )
   for model_class in self.all_model_classes:
     __A		:     Optional[Any]												=		model_class(config=__UpperCamelCase       )
     # Skip the check for the backbone
     for name, module in model.named_modules():
       if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
         __A		:     Dict												=		[f"{name}.{key}" for key in module.state_dict().keys()]
         break

     for name, param in model.named_parameters():
       if param.requires_grad:
         if name in backbone_params:
           continue
         self.assertIn(
             ((param.data.mean() * 1e9).round() / 1e9).item()				,   [0.0, 1.0]				,   msg=f"Parameter {name} of model {model_class} seems not properly initialized"				,   )






 @slow
 def 		lowercase_(   self			:    List[str]       ):



   """simple docstring"""





   for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     __A		:     Tuple												=		ViTHybridModel.from_pretrained(__UpperCamelCase       )
     self.assertIsNotNone(__UpperCamelCase       )







def        A_     (						)				->       Tuple:





  """simple docstring"""

  __A		:     List[Any]												=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
  return image







@require_torch
@require_vision
class  __A				( unittest.TestCase			):
 @cached_property
 def 		lowercase_(   self			:    Dict       ):



   """simple docstring"""





   return (
       ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]       )
       if is_vision_available()
       else None
   )
 @slow
 def 		lowercase_(   self			:    int       ):



   """simple docstring"""





   __A		:     Union[str, Any]												=		ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]       ).to(
       __UpperCamelCase       )

   __A		:     Dict												=		self.default_image_processor
   __A		:     Optional[Any]												=		prepare_img()
   __A		:     Optional[Any]												=		image_processor(images=__UpperCamelCase				,   return_tensors="""pt"""       ).to(__UpperCamelCase       )

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

   # verify the logits
   __A		:     Dict												=		torch.Size((1, 10_00)       )
   self.assertEqual(outputs.logits.shape				,   __UpperCamelCase       )

   __A		:     Optional[int]												=		torch.tensor([-1.9_090, -0.4_993, -0.2_389]       ).to(__UpperCamelCase       )

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






 @slow
 @require_accelerate
 def 		lowercase_(   self			:    str       ):



   """simple docstring"""





   __A		:     Optional[int]												=		ViTHybridImageProcessor.from_pretrained("""google/vit-hybrid-base-bit-384"""       )
   __A		:     Union[str, Any]												=		ViTHybridForImageClassification.from_pretrained("""google/vit-hybrid-base-bit-384"""				,   device_map="""auto"""       )

   __A		:     str												=		prepare_img()

   __A		:     Optional[Any]												=		image_processor(images=__UpperCamelCase				,   return_tensors="""pt"""       )
   __A		:     Tuple												=		model(**__UpperCamelCase       )
   __A		:     Optional[Any]												=		outputs.logits
   # model predicts one of the 1000 ImageNet classes
   __A		:     Optional[int]												=		logits.argmax(-1       ).item()

   self.assertTrue(model.config.idalabel[predicted_class_idx]				,   """tabby, tabby cat"""       )





'''simple docstring'''
from typing import Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging
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_VISUAL_QUESTION_ANSWERING_MAPPING

A__   :		Any 		=logging.get_logger(__name__)







@add_end_docstrings(_SCREAMING_SNAKE_CASE			)
class  __A				( _SCREAMING_SNAKE_CASE			):
 def __init__(   self			:    Union[str, Any]				,   *lowerCamelCase			:    int				,   **lowerCamelCase			:    Optional[int]       ):



   """simple docstring"""





   super().__init__(*lowerCamelCase				,   **lowerCamelCase       )
   self.check_model_type(lowerCamelCase       )
 def 		lowercase_(   self			:    Any				,   lowerCamelCase			:    Dict=None				,   lowerCamelCase			:    Union[str, Any]=None				,   lowerCamelCase			:    int=None				,   **lowerCamelCase			:    int       ):



   """simple docstring"""





   __A							,					__A		:     Tuple												=		{}, {}
   if padding is not None:
     __A		:     Any												=		padding
   if truncation is not None:
     __A		:     Optional[Any]												=		truncation
   if top_k is not None:
     __A		:     List[str]												=		top_k
   return preprocess_params, {}, postprocess_params
 def __call__(   self			:    Any				,   lowerCamelCase			:    Union["Image.Image", str]				,   lowerCamelCase			:    str = None				,   **lowerCamelCase			:    Tuple       ):



   """simple docstring"""





   if isinstance(lowerCamelCase				,   (Image.Image, str)       ) and isinstance(lowerCamelCase				,   lowerCamelCase       ):
     __A		:     Tuple												=		{"""image""": image, """question""": question}
   else:
     __A		:     List[Any]												=		image
   __A		:     Any												=		super().__call__(lowerCamelCase				,   **lowerCamelCase       )
   return results
 def 		lowercase_(   self			:    int				,   lowerCamelCase			:    Optional[int]				,   lowerCamelCase			:    Dict=False				,   lowerCamelCase			:    str=False       ):



   """simple docstring"""





   __A		:     List[str]												=		load_image(inputs["""image"""]       )
   __A		:     Optional[Any]												=		self.tokenizer(
       inputs["""question"""]				,   return_tensors=self.framework				,   padding=lowerCamelCase				,   truncation=lowerCamelCase       )
   __A		:     Union[str, Any]												=		self.image_processor(images=lowerCamelCase				,   return_tensors=self.framework       )
   model_inputs.update(lowerCamelCase       )
   return model_inputs
 def 		lowercase_(   self			:    List[str]				,   lowerCamelCase			:    Tuple       ):



   """simple docstring"""





   __A		:     List[str]												=		self.model(**lowerCamelCase       )
   return model_outputs






 def 		lowercase_(   self			:    str				,   lowerCamelCase			:    Optional[Any]				,   lowerCamelCase			:    List[Any]=5       ):



   """simple docstring"""





   if top_k > self.model.config.num_labels:
     __A		:     str												=		self.model.config.num_labels

   if self.framework == "pt":
     __A		:     Optional[Any]												=		model_outputs.logits.sigmoid()[0]
     __A							,					__A		:     int												=		probs.topk(lowerCamelCase       )
   else:
     raise ValueError(f"Unsupported framework: {self.framework}"       )

   __A		:     Optional[Any]												=		scores.tolist()
   __A		:     Dict												=		ids.tolist()
   return [{"score": score, "answer": self.model.config.idalabel[_id]} for score, _id in zip(lowerCamelCase				,   lowerCamelCase       )]



