




"""simple docstring"""

import inspect
import unittest

from transformers import ViTConfig
from transformers.testing_utils import (
    require_accelerate,
    require_torch,
    require_torch_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 torch import nn

       from transformers import ViTForImageClassification, ViTForMaskedImageModeling, ViTModel
       from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import ViTImageProcessor





class 							lowercase_			:



 '''simple docstring'''

 def __init__(					self			:			List[str]       ,				_UpperCAmelCase			:			List[str]       ,				_UpperCAmelCase			:			Dict=13       ,				_UpperCAmelCase			:			Dict=30       ,				_UpperCAmelCase			:			Optional[Any]=2       ,				_UpperCAmelCase			:			Any=3       ,				_UpperCAmelCase			:			Tuple=True       ,				_UpperCAmelCase			:			Optional[Any]=True       ,				_UpperCAmelCase			:			int=32       ,				_UpperCAmelCase			:			Dict=5       ,				_UpperCAmelCase			:			Optional[Any]=4       ,				_UpperCAmelCase			:			Union[str, Any]=37       ,				_UpperCAmelCase			:			Dict="gelu"       ,				_UpperCAmelCase			:			int=0.1       ,				_UpperCAmelCase			:			int=0.1       ,				_UpperCAmelCase			:			List[str]=10       ,				_UpperCAmelCase			:			Optional[int]=0.02       ,				_UpperCAmelCase			:			Tuple=None       ,				_UpperCAmelCase			:			Any=2       ,				):
       _A     =  parent
       _A     =  batch_size
       _A     =  image_size
       _A     =  patch_size
       _A     =  num_channels
       _A     =  is_training
       _A     =  use_labels
       _A     =  hidden_size
       _A     =  num_hidden_layers
       _A     =  num_attention_heads
       _A     =  intermediate_size
       _A     =  hidden_act
       _A     =  hidden_dropout_prob
       _A     =  attention_probs_dropout_prob
       _A     =  type_sequence_label_size
       _A     =  initializer_range
       _A     =  scope
       _A     =  encoder_stride

       # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
       _A     =  (image_size // patch_size) ** 2
       _A     =  num_patches + 1

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

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

       _A     =  self.get_config()

       return config, pixel_values, labels

 def      lowerCAmelCase_				(					self			:			Optional[int]						):
       return ViTConfig(
           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       ,				encoder_stride=self.encoder_stride       ,				)

 def      lowerCAmelCase_				(					self			:			str       ,				_UpperCAmelCase			:			Any       ,				_UpperCAmelCase			:			List[str]       ,				_UpperCAmelCase			:			Any						):
       _A     =  ViTModel(config=_UpperCAmelCase						)
       model.to(_UpperCAmelCase						)
       model.eval()
       _A     =  model(_UpperCAmelCase						)
       self.parent.assertEqual(result.last_hidden_state.shape       ,				(self.batch_size, self.seq_length, self.hidden_size)						)

 def      lowerCAmelCase_				(					self			:			List[str]       ,				_UpperCAmelCase			:			int       ,				_UpperCAmelCase			:			str       ,				_UpperCAmelCase			:			int						):
       _A     =  ViTForMaskedImageModeling(config=_UpperCAmelCase						)
       model.to(_UpperCAmelCase						)
       model.eval()
       _A     =  model(_UpperCAmelCase						)
       self.parent.assertEqual(
           result.reconstruction.shape       ,				(self.batch_size, self.num_channels, self.image_size, self.image_size)						)

       # test greyscale images
       _A     =  1
       _A     =  ViTForMaskedImageModeling(_UpperCAmelCase						)
       model.to(_UpperCAmelCase						)
       model.eval()

       _A     =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       _A     =  model(_UpperCAmelCase						)
       self.parent.assertEqual(result.reconstruction.shape       ,				(self.batch_size, 1, self.image_size, self.image_size)						)

 def      lowerCAmelCase_				(					self			:			List[Any]       ,				_UpperCAmelCase			:			str       ,				_UpperCAmelCase			:			int       ,				_UpperCAmelCase			:			Any						):
       _A     =  self.type_sequence_label_size
       _A     =  ViTForImageClassification(_UpperCAmelCase						)
       model.to(_UpperCAmelCase						)
       model.eval()
       _A     =  model(_UpperCAmelCase       ,				labels=_UpperCAmelCase						)
       self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.type_sequence_label_size)						)

       # test greyscale images
       _A     =  1
       _A     =  ViTForImageClassification(_UpperCAmelCase						)
       model.to(_UpperCAmelCase						)
       model.eval()

       _A     =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       _A     =  model(_UpperCAmelCase						)
       self.parent.assertEqual(result.logits.shape       ,				(self.batch_size, self.type_sequence_label_size)						)



 def      lowerCAmelCase_				(					self			:			Any						):
       _A     =  self.prepare_config_and_inputs()
       (
           _A			
       )     =  config_and_inputs
       _A     =  {'pixel_values': pixel_values}
       return config, inputs_dict





@require_torch
class 							lowercase_			(	__lowerCAmelCase     ,      __lowerCAmelCase     ,      unittest.TestCase				):



 '''simple docstring'''
 UpperCAmelCase       :	str     =      (
     (
         ViTModel,
         ViTForImageClassification,
         ViTForMaskedImageModeling,
     )
     if is_torch_available()
     else ()
 )
 UpperCAmelCase       :	str     =      (
     {'''feature-extraction''': ViTModel, '''image-classification''': ViTForImageClassification}
     if is_torch_available()
     else {}
 )
 UpperCAmelCase       :	str     =      True

 UpperCAmelCase       :	str     =      False
 UpperCAmelCase       :	Tuple     =      False
 UpperCAmelCase       :	Any     =      False

 def      lowerCAmelCase_				(					self			:			Dict						):
       _A     =  ViTModelTester(self						)
       _A     =  ConfigTester(self       ,				config_class=_UpperCAmelCase       ,				has_text_modality=_UpperCAmelCase       ,				hidden_size=37						)

 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       self.config_tester.run_common_tests()

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

 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       _A     =  self.model_tester.prepare_config_and_inputs_for_common()

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

 def      lowerCAmelCase_				(					self			:			List[str]						):
       _A     =  self.model_tester.prepare_config_and_inputs_for_common()

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

             _A     =  ['pixel_values']
             self.assertListEqual(arg_names[:1]       ,				_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			List[Any]						):
       _A     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			str						):
       _A     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			Union[str, Any]						):
       _A     =  self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase						)



 @slow
 def      lowerCAmelCase_				(					self			:			str						):
       for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _A     =  ViTModel.from_pretrained(_UpperCAmelCase						)
             self.assertIsNotNone(_UpperCAmelCase						)






def 		_snake_case	(   )       ->   Tuple:






      '''simple docstring'''


      _A     =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
      return image







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



 '''simple docstring'''

 @cached_property
 def      lowerCAmelCase_				(					self			:			Optional[Any]						):
       return ViTImageProcessor.from_pretrained('google/vit-base-patch16-224'						) if is_vision_available() else None

 @slow
 def      lowerCAmelCase_				(					self			:			Dict						):
       _A     =  ViTForImageClassification.from_pretrained('google/vit-base-patch16-224'						).to(_UpperCAmelCase						)

       _A     =  self.default_image_processor
       _A     =  prepare_img()
       _A     =  image_processor(images=_UpperCAmelCase       ,				return_tensors='pt'						).to(_UpperCAmelCase						)

       # forward pass
       with torch.no_grad():
             _A     =  model(**_UpperCAmelCase						)

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

       _A     =  torch.tensor([-0.2744, 0.8215, -0.0836]						).to(_UpperCAmelCase						)

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

 @slow
 def      lowerCAmelCase_				(					self			:			List[str]						):
       _A     =  ViTModel.from_pretrained('facebook/dino-vits8'						).to(_UpperCAmelCase						)

       _A     =  ViTImageProcessor.from_pretrained('facebook/dino-vits8'       ,				size=480						)
       _A     =  prepare_img()
       _A     =  image_processor(images=_UpperCAmelCase       ,				return_tensors='pt'						)
       _A     =  inputs.pixel_values.to(_UpperCAmelCase						)

       # forward pass
       with torch.no_grad():
             _A     =  model(_UpperCAmelCase       ,				interpolate_pos_encoding=_UpperCAmelCase						)

       # verify the logits
       _A     =  torch.Size((1, 3_601, 384)						)
       self.assertEqual(outputs.last_hidden_state.shape       ,				_UpperCAmelCase						)

       _A     =  torch.tensor(
           [[4.2340, 4.3906, -6.6692], [4.5463, 1.8928, -6.7257], [4.4429, 0.8496, -5.8585]]						).to(_UpperCAmelCase						)

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



 @slow
 @require_accelerate
 @require_torch_gpu
 def      lowerCAmelCase_				(					self			:			str						):
       _A     =  ViTModel.from_pretrained('facebook/dino-vits8'       ,				torch_dtype=torch.floataa       ,				device_map='auto'						)
       _A     =  self.default_image_processor

       _A     =  prepare_img()
       _A     =  image_processor(images=_UpperCAmelCase       ,				return_tensors='pt'						)
       _A     =  inputs.pixel_values.to(_UpperCAmelCase						)

       # forward pass to make sure inference works in fp16
       with torch.no_grad():
             _A     =  model(_UpperCAmelCase						)





'''simple docstring'''






from typing import Any

import numpy as np





def lowerCamelCase__     (		__lowerCamelCase			:				np.ndarray				):







   '''simple docstring'''




   return np.array_equal(__lowerCamelCase			,       matrix.conjugate().T				)





def lowerCamelCase__     (		__lowerCamelCase			:				np.ndarray			,       __lowerCamelCase			:				np.ndarray				):







   '''simple docstring'''




   _UpperCAmelCase  :  str				       =v.conjugate().T
   _UpperCAmelCase  :  Optional[int]				       =v_star.dot(__lowerCamelCase				)
   assert isinstance(__lowerCamelCase			,       np.ndarray				)
   return (v_star_dot.dot(__lowerCamelCase				)) / (v_star.dot(__lowerCamelCase				))





def lowerCamelCase__     (		):







   '''simple docstring'''




   _UpperCAmelCase  :  Optional[Any]				       =np.array([[2, 2 + 1J, 4], [2 - 1J, 3, 1J], [4, -1J, 1]]				)
   _UpperCAmelCase  :  List[str]				       =np.array([[1], [2], [3]]				)
   assert is_hermitian(__lowerCamelCase				), f"{a} is not hermitian."
   print(rayleigh_quotient(__lowerCamelCase			,       __lowerCamelCase				)				)

   _UpperCAmelCase  :  List[str]				       =np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]				)
   assert is_hermitian(__lowerCamelCase				), f"{a} is not hermitian."
   assert rayleigh_quotient(__lowerCamelCase			,       __lowerCamelCase				) == float(3				)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 tests()

