



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






    """simple docstring"""





    def __init__(  self      :					Optional[Any]  ,						UpperCamelCase__      :					List[str]  ,						UpperCamelCase__      :					Union[str, Any]=1_3  ,						UpperCamelCase__      :					Optional[int]=6_4  ,						UpperCamelCase__      :					int=2  ,						UpperCamelCase__      :					Optional[int]=3  ,						UpperCamelCase__      :					Optional[int]=True  ,						UpperCamelCase__      :					str=True  ,						UpperCamelCase__      :					Tuple=3_2  ,						UpperCamelCase__      :					str=5  ,						UpperCamelCase__      :					List[str]=4  ,						UpperCamelCase__      :					Optional[int]=3_7  ,						UpperCamelCase__      :					List[str]="gelu"  ,						UpperCamelCase__      :					Any=0.1  ,						UpperCamelCase__      :					Optional[int]=0.1  ,						UpperCamelCase__      :					Tuple=1_0  ,						UpperCamelCase__      :					Any=0.0_2  ,						UpperCamelCase__      :					Any=[1, 1_6, 4, 4]  ,						UpperCamelCase__      :					str=None  ,						):


       """simple docstring"""







       UpperCamelCase					=  parent
       UpperCamelCase					=  batch_size
       UpperCamelCase					=  image_size
       UpperCamelCase					=  patch_size
       UpperCamelCase					=  num_channels
       UpperCamelCase					=  is_training
       UpperCamelCase					=  use_labels
       UpperCamelCase					=  hidden_size
       UpperCamelCase					=  num_hidden_layers
       UpperCamelCase					=  num_attention_heads
       UpperCamelCase					=  intermediate_size
       UpperCamelCase					=  hidden_act
       UpperCamelCase					=  hidden_dropout_prob
       UpperCamelCase					=  attention_probs_dropout_prob
       UpperCamelCase					=  type_sequence_label_size
       UpperCamelCase					=  initializer_range
       UpperCamelCase					=  scope
       UpperCamelCase					=  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
       UpperCamelCase					=  (self.image_size // 3_2) ** 2
       UpperCamelCase					=  num_patches + 1






    def  A       (  self      :					Optional[int] ):


       """simple docstring"""







       UpperCamelCase					=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

       UpperCamelCase					=  None
       if self.use_labels:
          UpperCamelCase					=  ids_tensor([self.batch_size]  ,						self.type_sequence_label_size )

       UpperCamelCase					=  self.get_config()

       return config, pixel_values, labels






    def  A       (  self      :					Dict ):


       """simple docstring"""







       UpperCamelCase					=  {
           'global_padding': 'same',
           'layer_type': 'bottleneck',
           'depths': [3, 4, 9],
           'out_features': ['stage1', 'stage2', 'stage3'],
           'embedding_dynamic_padding': True,
           'hidden_sizes': [4, 8, 1_6, 3_2],
           '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  A       (  self      :					Tuple  ,						UpperCamelCase__      :					List[Any]  ,						UpperCamelCase__      :					str  ,						UpperCamelCase__      :					Any ):


       """simple docstring"""







       UpperCamelCase					=  ViTHybridModel(config=UpperCamelCase__ )
       model.to(UpperCamelCase__ )
       model.eval()
       UpperCamelCase					=  model(UpperCamelCase__ )
       self.parent.assertEqual(result.last_hidden_state.shape  ,						(self.batch_size, self.seq_length, self.hidden_size) )






    def  A       (  self      :					Tuple  ,						UpperCamelCase__      :					Dict  ,						UpperCamelCase__      :					Optional[int]  ,						UpperCamelCase__      :					Optional[Any] ):


       """simple docstring"""







       UpperCamelCase					=  self.type_sequence_label_size
       UpperCamelCase					=  ViTHybridForImageClassification(UpperCamelCase__ )
       model.to(UpperCamelCase__ )
       model.eval()
       UpperCamelCase					=  model(UpperCamelCase__  ,						labels=UpperCamelCase__ )
       self.parent.assertEqual(result.logits.shape  ,						(self.batch_size, self.type_sequence_label_size) )






    def  A       (  self      :					Tuple ):


       """simple docstring"""







       UpperCamelCase					=  self.prepare_config_and_inputs()
       UpperCamelCase				,      UpperCamelCase				,      UpperCamelCase					=  config_and_inputs
       UpperCamelCase					=  {'pixel_values': pixel_values}
       return config, inputs_dict

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






    """simple docstring"""





    _SCREAMING_SNAKE_CASE	  =  (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
    _SCREAMING_SNAKE_CASE	  =  (
        {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
        if is_torch_available()
        else {}
    )
    _SCREAMING_SNAKE_CASE	  =  False
    _SCREAMING_SNAKE_CASE	  =  False
    _SCREAMING_SNAKE_CASE	  =  False






    def  A       (  self      :					Dict ):


       """simple docstring"""







       UpperCamelCase					=  ViTHybridModelTester(self )
       UpperCamelCase					=  ConfigTester(self  ,						config_class=UpperCamelCase__  ,						has_text_modality=UpperCamelCase__  ,						hidden_size=3_7 )






    def  A       (  self      :					int ):


       """simple docstring"""







       self.config_tester.run_common_tests()






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


       """simple docstring"""







       pass






    def  A       (  self      :					List[Any] ):


       """simple docstring"""







       UpperCamelCase				,      UpperCamelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
          UpperCamelCase					=  model_class(UpperCamelCase__ )
          self.assertIsInstance(model.get_input_embeddings()  ,						(nn.Module) )
          UpperCamelCase					=  model.get_output_embeddings()
          self.assertTrue(x is None or isinstance(UpperCamelCase__  ,						nn.Linear ) )






    def  A       (  self      :					Tuple ):


       """simple docstring"""







       UpperCamelCase				,      UpperCamelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

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

          UpperCamelCase					=  ['pixel_values']
          self.assertListEqual(arg_names[:1]  ,						UpperCamelCase__ )






    def  A       (  self      :					Any ):


       """simple docstring"""







       UpperCamelCase					=  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCamelCase__ )






    def  A       (  self      :					Optional[Any] ):


       """simple docstring"""







       UpperCamelCase					=  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCamelCase__ )






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


       """simple docstring"""







       UpperCamelCase				,      UpperCamelCase					=  self.model_tester.prepare_config_and_inputs_for_common()

       UpperCamelCase					=  _config_zero_init(UpperCamelCase__ )
       for model_class in self.all_model_classes:
          UpperCamelCase					=  model_class(config=UpperCamelCase__ )
          # Skip the check for the backbone
          for name, module in model.named_modules():
             if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
                UpperCamelCase					=  [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  A       (  self      :					Tuple ):


       """simple docstring"""







       for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          UpperCamelCase					=  ViTHybridModel.from_pretrained(UpperCamelCase__ )
          self.assertIsNotNone(UpperCamelCase__ )







def 				__lowerCamelCase				(   )       ->	Optional[int]:






   """simple docstring"""
   UpperCamelCase					=  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
   return image

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






    """simple docstring"""





    @cached_property
    def  A       (  self      :					Tuple ):


       """simple docstring"""







       return (
           ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
           if is_vision_available()
           else None
       )






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


       """simple docstring"""







       UpperCamelCase					=  ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0] ).to(
           UpperCamelCase__ )

       UpperCamelCase					=  self.default_image_processor
       UpperCamelCase					=  prepare_img()
       UpperCamelCase					=  image_processor(images=UpperCamelCase__  ,						return_tensors='pt' ).to(UpperCamelCase__ )

       # forward pass
       with torch.no_grad():
          UpperCamelCase					=  model(**UpperCamelCase__ )

       # verify the logits
       UpperCamelCase					=  torch.Size((1, 1_0_0_0) )
       self.assertEqual(outputs.logits.shape  ,						UpperCamelCase__ )

       UpperCamelCase					=  torch.tensor([-1.9_0_9_0, -0.4_9_9_3, -0.2_3_8_9] ).to(UpperCamelCase__ )

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






    @slow
    @require_accelerate
    def  A       (  self      :					Optional[int] ):


       """simple docstring"""







       UpperCamelCase					=  ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384' )
       UpperCamelCase					=  ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'  ,						device_map='auto' )

       UpperCamelCase					=  prepare_img()

       UpperCamelCase					=  image_processor(images=UpperCamelCase__  ,						return_tensors='pt' )
       UpperCamelCase					=  model(**UpperCamelCase__ )
       UpperCamelCase					=  outputs.logits
       # model predicts one of the 1000 ImageNet classes
       UpperCamelCase					=  logits.argmax(-1 ).item()

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






'''simple docstring'''


from io import BytesIO
from typing import List, Union

import requests

from ..utils import add_end_docstrings, is_decord_available, is_torch_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_decord_available():
   import numpy as np
   from decord import VideoReader


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

_lowerCamelCase	:       Any      	=	logging.get_logger(__name__)

@add_end_docstrings(_a		)
class  SCREAMING_SNAKE_CASE (  _a		):






    """simple docstring"""





    def __init__(  self      :					Any  ,						*UpperCamelCase__      :					Dict  ,						**UpperCamelCase__      :					Union[str, Any] ):


       """simple docstring"""







       super().__init__(*UpperCamelCase__  ,						**UpperCamelCase__ )
       requires_backends(self  ,						'decord' )
       self.check_model_type(UpperCamelCase__ )






    def  A       (  self      :					Optional[int]  ,						UpperCamelCase__      :					Optional[int]=None  ,						UpperCamelCase__      :					Optional[Any]=None  ,						UpperCamelCase__      :					Optional[Any]=None ):


       """simple docstring"""







       UpperCamelCase					=  {}
       if frame_sampling_rate is not None:
          UpperCamelCase					=  frame_sampling_rate
       if num_frames is not None:
          UpperCamelCase					=  num_frames

       UpperCamelCase					=  {}
       if top_k is not None:
          UpperCamelCase					=  top_k
       return preprocess_params, {}, postprocess_params






    def __call__(  self      :					List[str]  ,						UpperCamelCase__      :					Union[str, List[str]]  ,						**UpperCamelCase__      :					Dict ):


       """simple docstring"""







       return super().__call__(UpperCamelCase__  ,						**UpperCamelCase__ )






    def  A       (  self      :					Tuple  ,						UpperCamelCase__      :					Union[str, Any]  ,						UpperCamelCase__      :					Tuple=None  ,						UpperCamelCase__      :					Tuple=1 ):


       """simple docstring"""







       if num_frames is None:
          UpperCamelCase					=  self.model.config.num_frames

       if video.startswith('http://' ) or video.startswith('https://' ):
          UpperCamelCase					=  BytesIO(requests.get(UpperCamelCase__ ).content )

       UpperCamelCase					=  VideoReader(UpperCamelCase__ )
       videoreader.seek(0 )

       UpperCamelCase					=  0
       UpperCamelCase					=  num_frames * frame_sampling_rate - 1
       UpperCamelCase					=  np.linspace(UpperCamelCase__  ,						UpperCamelCase__  ,						num=UpperCamelCase__  ,						dtype=np.intaa )

       UpperCamelCase					=  videoreader.get_batch(UpperCamelCase__ ).asnumpy()
       UpperCamelCase					=  list(UpperCamelCase__ )

       UpperCamelCase					=  self.image_processor(UpperCamelCase__  ,						return_tensors=self.framework )
       return model_inputs






    def  A       (  self      :					Union[str, Any]  ,						UpperCamelCase__      :					List[str] ):


       """simple docstring"""







       UpperCamelCase					=  self.model(**UpperCamelCase__ )
       return model_outputs






    def  A       (  self      :					int  ,						UpperCamelCase__      :					str  ,						UpperCamelCase__      :					List[Any]=5 ):


       """simple docstring"""







       if top_k > self.model.config.num_labels:
          UpperCamelCase					=  self.model.config.num_labels

       if self.framework == "pt":
          UpperCamelCase					=  model_outputs.logits.softmax(-1 )[0]
          UpperCamelCase				,      UpperCamelCase					=  probs.topk(UpperCamelCase__ )
       else:
          raise ValueError(f"""Unsupported framework: {self.framework}""" )

       UpperCamelCase					=  scores.tolist()
       UpperCamelCase					=  ids.tolist()
       return [{"score": score, "label": self.model.config.idalabel[_id]} for score, _id in zip(UpperCamelCase__  ,						UpperCamelCase__ )]

