



'''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]		,     __snake_case					:    Union[str, Any]		,     __snake_case					:    int=13		,     __snake_case					:    Tuple=64		,     __snake_case					:    str=2		,     __snake_case					:    Tuple=3		,     __snake_case					:    Tuple=True		,     __snake_case					:    Tuple=True		,     __snake_case					:    Dict=32		,     __snake_case					:    int=5		,     __snake_case					:    str=4		,     __snake_case					:    Optional[int]=37		,     __snake_case					:    str="gelu"		,     __snake_case					:    str=0.1		,     __snake_case					:    Optional[int]=0.1		,     __snake_case					:    Union[str, Any]=10		,     __snake_case					:    Optional[int]=0.02		,     __snake_case					:    str=[1, 16, 4, 4]		,     __snake_case					:    Tuple=None		,     ):
      a		:   Union[str, Any]	  =	parent
      a		:   List[str]	  =	batch_size
      a		:   Optional[int]	  =	image_size
      a		:   Any	  =	patch_size
      a		:   List[str]	  =	num_channels
      a		:   Optional[int]	  =	is_training
      a		:   str	  =	use_labels
      a		:   Optional[int]	  =	hidden_size
      a		:   Dict	  =	num_hidden_layers
      a		:   Optional[int]	  =	num_attention_heads
      a		:   Any	  =	intermediate_size
      a		:   Tuple	  =	hidden_act
      a		:   List[Any]	  =	hidden_dropout_prob
      a		:   Tuple	  =	attention_probs_dropout_prob
      a		:   List[Any]	  =	type_sequence_label_size
      a		:   Dict	  =	initializer_range
      a		:   Tuple	  =	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		:   Union[str, Any]	  =	(self.image_size // 32) ** 2
      a		:   Union[str, Any]	  =	num_patches + 1







    def      lowercase_			( self					:    int      ):
      a		:   List[str]	  =	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

      a		:   Tuple	  =	None
      if self.use_labels:
        a		:   Union[str, Any]	  =	ids_tensor([self.batch_size]		,     self.type_sequence_label_size      )

      a		:   Dict	  =	self.get_config()

      return config, pixel_values, labels







    def      lowercase_			( self					:    Union[str, Any]      ):
      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=__snake_case		,     initializer_range=self.initializer_range		,     backbone_featmap_shape=self.backbone_featmap_shape		,     backbone_config=__snake_case		,     )







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







    def      lowercase_			( self					:    Dict		,     __snake_case					:    Tuple		,     __snake_case					:    Tuple		,     __snake_case					:    Union[str, Any]      ):
      a		:   Optional[int]	  =	self.type_sequence_label_size
      a		:   List[str]	  =	ViTHybridForImageClassification(__snake_case      )
      model.to(__snake_case      )
      model.eval()
      a		:   Any	  =	model(__snake_case		,     labels=__snake_case      )
      self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.type_sequence_label_size)      )







    def      lowercase_			( self					:    Optional[int]      ):
      a		:   int	  =	self.prepare_config_and_inputs()
      a  ,      a  ,      a		:   Any	  =	config_and_inputs
      a		:   List[Any]	  =	{'pixel_values': pixel_values}
      return config, inputs_dict

@require_torch
class 				a__(   lowerCamelCase__						,					lowerCamelCase__						,					unittest.TestCase      ):
    lowercase__					=       (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
    lowercase__					=       (
        {"""feature-extraction""": ViTHybridModel, """image-classification""": ViTHybridForImageClassification}
        if is_torch_available()
        else {}
    )
    lowercase__					=       False
    lowercase__					=       False
    lowercase__					=       False







    def      lowercase_			( self					:    Optional[int]      ):
      a		:   Union[str, Any]	  =	ViTHybridModelTester(self      )
      a		:   Optional[Any]	  =	ConfigTester(self		,     config_class=__snake_case		,     has_text_modality=__snake_case		,     hidden_size=37      )







    def      lowercase_			( self					:    int      ):
      self.config_tester.run_common_tests()







    @unittest.skip(reason='ViT does not use inputs_embeds'      )
    def      lowercase_			( self					:    int      ):
      pass







    def      lowercase_			( self					:    Dict      ):
      a  ,      a		:   Tuple	  =	self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        a		:   List[Any]	  =	model_class(__snake_case      )
        self.assertIsInstance(model.get_input_embeddings()		,     (nn.Module)      )
        a		:   Optional[int]	  =	model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(__snake_case		,     nn.Linear      )      )







    def      lowercase_			( self					:    Any      ):
      a  ,      a		:   Tuple	  =	self.model_tester.prepare_config_and_inputs_for_common()

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

        a		:   int	  =	['pixel_values']
        self.assertListEqual(arg_names[:1]		,     __snake_case      )







    def      lowercase_			( self					:    Any      ):
      a		:   Dict	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__snake_case      )







    def      lowercase_			( self					:    str      ):
      a		:   int	  =	self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*__snake_case      )







    def      lowercase_			( self					:    int      ):
      a  ,      a		:   Dict	  =	self.model_tester.prepare_config_and_inputs_for_common()

      a		:   Optional[Any]	  =	_config_zero_init(__snake_case      )
      for model_class in self.all_model_classes:
        a		:   Union[str, Any]	  =	model_class(config=__snake_case      )
        # Skip the check for the backbone
        for name, module in model.named_modules():
          if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
            a		:   Any	  =	[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					:    Any      ):
      for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        a		:   int	  =	ViTHybridModel.from_pretrained(__snake_case      )
        self.assertIsNotNone(__snake_case      )
def  lowerCamelCase__			(		):
  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					:    List[Any]      ):
      return (
          ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )
          if is_vision_available()
          else None
      )







    @slow
    def      lowercase_			( self					:    Any      ):
      a		:   Dict	  =	ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]      ).to(
          __snake_case      )

      a		:   Any	  =	self.default_image_processor
      a		:   Optional[int]	  =	prepare_img()
      a		:   str	  =	image_processor(images=__snake_case		,     return_tensors='pt'      ).to(__snake_case      )

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

      # verify the logits
      a		:   List[str]	  =	torch.Size((1, 10_00)      )
      self.assertEqual(outputs.logits.shape		,     __snake_case      )

      a		:   Any	  =	torch.tensor([-1.9090, -0.4993, -0.2389]      ).to(__snake_case      )

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







    @slow
    @require_accelerate
    def      lowercase_			( self					:    List[Any]      ):
      a		:   int	  =	ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'      )
      a		:   List[str]	  =	ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'		,     device_map='auto'      )

      a		:   List[Any]	  =	prepare_img()

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

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




'''simple docstring'''






import numpy as np
def  lowerCamelCase__			(		_A							):
  return 1 / (1 + np.exp(-vector							))
def  lowerCamelCase__			(		_A							):
  return vector * sigmoid(1.702 * vector							)


if __name__ == "__main__":
     import doctest

     doctest.testmod()