


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





  """simple docstring"""




  def __init__(       self     ,    UpperCamelCase     ,    UpperCamelCase=13     ,    UpperCamelCase=30     ,    UpperCamelCase=2     ,    UpperCamelCase=3     ,    UpperCamelCase=True     ,    UpperCamelCase=True     ,    UpperCamelCase=32     ,    UpperCamelCase=5     ,    UpperCamelCase=4     ,    UpperCamelCase=37     ,    UpperCamelCase="gelu"     ,    UpperCamelCase=0.1     ,    UpperCamelCase=0.1     ,    UpperCamelCase=10     ,    UpperCamelCase=0.02     ,    UpperCamelCase=None     ,    UpperCamelCase=2     ,    ):







   """simple docstring"""
   lowerCamelCase_						=    parent
   lowerCamelCase_						=    batch_size
   lowerCamelCase_						=    image_size
   lowerCamelCase_						=    patch_size
   lowerCamelCase_						=    num_channels
   lowerCamelCase_						=    is_training
   lowerCamelCase_						=    use_labels
   lowerCamelCase_						=    hidden_size
   lowerCamelCase_						=    num_hidden_layers
   lowerCamelCase_						=    num_attention_heads
   lowerCamelCase_						=    intermediate_size
   lowerCamelCase_						=    hidden_act
   lowerCamelCase_						=    hidden_dropout_prob
   lowerCamelCase_						=    attention_probs_dropout_prob
   lowerCamelCase_						=    type_sequence_label_size
   lowerCamelCase_						=    initializer_range
   lowerCamelCase_						=    scope
   lowerCamelCase_						=    encoder_stride

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






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

   lowerCamelCase_						=    self.get_config()

   return config, pixel_values, labels






  def     snake_case						(       self	):







   """simple docstring"""
   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=SCREAMING_SNAKE_CASE__     ,    initializer_range=self.initializer_range     ,    encoder_stride=self.encoder_stride     ,    )






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    ViTModel(config=SCREAMING_SNAKE_CASE__	)
   model.to(SCREAMING_SNAKE_CASE__	)
   model.eval()
   lowerCamelCase_						=    model(SCREAMING_SNAKE_CASE__	)
   self.parent.assertEqual(result.last_hidden_state.shape     ,    (self.batch_size, self.seq_length, self.hidden_size)	)






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    ViTForMaskedImageModeling(config=SCREAMING_SNAKE_CASE__	)
   model.to(SCREAMING_SNAKE_CASE__	)
   model.eval()
   lowerCamelCase_						=    model(SCREAMING_SNAKE_CASE__	)
   self.parent.assertEqual(
       result.reconstruction.shape     ,    (self.batch_size, self.num_channels, self.image_size, self.image_size)	)

   # test greyscale images
   lowerCamelCase_						=    1
   lowerCamelCase_						=    ViTForMaskedImageModeling(SCREAMING_SNAKE_CASE__	)
   model.to(SCREAMING_SNAKE_CASE__	)
   model.eval()

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






  def     snake_case						(       self     ,    UpperCamelCase     ,    UpperCamelCase     ,    UpperCamelCase	):







   """simple docstring"""
   lowerCamelCase_						=    self.type_sequence_label_size
   lowerCamelCase_						=    ViTForImageClassification(SCREAMING_SNAKE_CASE__	)
   model.to(SCREAMING_SNAKE_CASE__	)
   model.eval()
   lowerCamelCase_						=    model(SCREAMING_SNAKE_CASE__     ,    labels=SCREAMING_SNAKE_CASE__	)
   self.parent.assertEqual(result.logits.shape     ,    (self.batch_size, self.type_sequence_label_size)	)

   # test greyscale images
   lowerCamelCase_						=    1
   lowerCamelCase_						=    ViTForImageClassification(SCREAMING_SNAKE_CASE__	)
   model.to(SCREAMING_SNAKE_CASE__	)
   model.eval()

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







  def     snake_case						(       self	):







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





@require_torch
class 	snake_case       (       lowerCamelCase__     ,		lowerCamelCase__     ,		unittest.TestCase     ):





  """simple docstring"""




  _lowerCamelCase						       =    (
      (
          ViTModel,
          ViTForImageClassification,
          ViTForMaskedImageModeling,
      )
      if is_torch_available()
      else ()
  )
  _lowerCamelCase						       =    (
      {"feature-extraction": ViTModel, "image-classification": ViTForImageClassification}
      if is_torch_available()
      else {}
  )
  _lowerCamelCase						       =    True

  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False
  _lowerCamelCase						       =    False






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    ViTModelTester(self	)
   lowerCamelCase_						=    ConfigTester(self     ,    config_class=SCREAMING_SNAKE_CASE__     ,    has_text_modality=SCREAMING_SNAKE_CASE__     ,    hidden_size=37	)






  def     snake_case						(       self	):







   """simple docstring"""
   self.config_tester.run_common_tests()






  @unittest.skip(reason="ViT does not use inputs_embeds"	)
  def     snake_case						(       self	):







   """simple docstring"""
   pass






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()

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






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs_for_common()

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

    lowerCamelCase_						=    ['''pixel_values''']
    self.assertListEqual(arg_names[:1]     ,    SCREAMING_SNAKE_CASE__	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE__	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE__	)






  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE__	)







  @slow
  def     snake_case						(       self	):







   """simple docstring"""



   for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
    lowerCamelCase_						=    ViTModel.from_pretrained(SCREAMING_SNAKE_CASE__	)
    self.assertIsNotNone(SCREAMING_SNAKE_CASE__	)





def __snake_case   ( ):
 lowerCamelCase_						=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						)
 return image







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





  """simple docstring"""




  @cached_property
  def     snake_case						(       self	):







   """simple docstring"""
   return ViTImageProcessor.from_pretrained("google/vit-base-patch16-224"	) if is_vision_available() else None






  @slow
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    ViTForImageClassification.from_pretrained("google/vit-base-patch16-224"	).to(SCREAMING_SNAKE_CASE__	)

   lowerCamelCase_						=    self.default_image_processor
   lowerCamelCase_						=    prepare_img()
   lowerCamelCase_						=    image_processor(images=SCREAMING_SNAKE_CASE__     ,    return_tensors="pt"	).to(SCREAMING_SNAKE_CASE__	)

   # forward pass
   with torch.no_grad():
    lowerCamelCase_						=    model(**SCREAMING_SNAKE_CASE__	)

   # verify the logits
   lowerCamelCase_						=    torch.Size((1, 1000)	)
   self.assertEqual(outputs.logits.shape     ,    SCREAMING_SNAKE_CASE__	)

   lowerCamelCase_						=    torch.tensor([-0.2_744, 0.8_215, -0.0_836]	).to(SCREAMING_SNAKE_CASE__	)

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






  @slow
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    ViTModel.from_pretrained("facebook/dino-vits8"	).to(SCREAMING_SNAKE_CASE__	)

   lowerCamelCase_						=    ViTImageProcessor.from_pretrained("facebook/dino-vits8"     ,    size=480	)
   lowerCamelCase_						=    prepare_img()
   lowerCamelCase_						=    image_processor(images=SCREAMING_SNAKE_CASE__     ,    return_tensors="pt"	)
   lowerCamelCase_						=    inputs.pixel_values.to(SCREAMING_SNAKE_CASE__	)

   # forward pass
   with torch.no_grad():
    lowerCamelCase_						=    model(SCREAMING_SNAKE_CASE__     ,    interpolate_pos_encoding=SCREAMING_SNAKE_CASE__	)

   # verify the logits
   lowerCamelCase_						=    torch.Size((1, 3601, 384)	)
   self.assertEqual(outputs.last_hidden_state.shape     ,    SCREAMING_SNAKE_CASE__	)

   lowerCamelCase_						=    torch.tensor(
       [[4.2_340, 4.3_906, -6.6_692], [4.5_463, 1.8_928, -6.7_257], [4.4_429, 0.8_496, -5.8_585]]	).to(SCREAMING_SNAKE_CASE__	)

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







  @slow
  @require_accelerate
  @require_torch_gpu
  def     snake_case						(       self	):







   """simple docstring"""
   lowerCamelCase_						=    ViTModel.from_pretrained("facebook/dino-vits8"     ,    torch_dtype=torch.floataa     ,    device_map="auto"	)
   lowerCamelCase_						=    self.default_image_processor

   lowerCamelCase_						=    prepare_img()
   lowerCamelCase_						=    image_processor(images=SCREAMING_SNAKE_CASE__     ,    return_tensors="pt"	)
   lowerCamelCase_						=    inputs.pixel_values.to(SCREAMING_SNAKE_CASE__	)

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







"""simple docstring"""






from __future__ import annotations

from math import pi
from typing import Protocol

import matplotlib.pyplot as plt
import numpy as np






class      A(  lowerCamelCase__		):

		"""simple docstring"""





		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	float:

					"""simple docstring"""



					return 0.0





def 				A_       ( snake_case__       ,					snake_case__		)					->  tuple[int | float, int | float]:
			_UpperCamelCase					:Union[str, Any]					     =	min([-20, np.min(fft_results[1 : samplerate // 2 - 1]		)]		)
			_UpperCamelCase					:Optional[int]					     =	max([20, np.max(fft_results[1 : samplerate // 2 - 1]		)]		)
			return lowest, highest





def 				A_       ( snake_case__       ,					snake_case__		)					->  None:
			_UpperCamelCase					:List[str]					     =	5_12
			_UpperCamelCase					:int					     =	[1] + [0] * (size - 1)
			_UpperCamelCase					:Union[str, Any]					     =	[filter_type.process(snake_case__		) for item in inputs]

			_UpperCamelCase					:Any					     =	[0] * (samplerate - size)  # zero-padding
			outputs += filler
			_UpperCamelCase					:int					     =	np.abs(np.fft.fft(snake_case__		)		)
			_UpperCamelCase					:str					     =	20 * np.logaa(snake_case__		)

			# Frequencies on log scale from 24 to nyquist frequency
			plt.xlim(24       ,					samplerate / 2 - 1		)
			plt.xlabel('''Frequency (Hz)'''		)
			plt.xscale('''log'''		)

			# Display within reasonable bounds
			_UpperCamelCase					:Tuple					     =	get_bounds(snake_case__       ,					snake_case__		)
			plt.ylim(max([-80, bounds[0]]		)       ,					min([80, bounds[1]]		)		)
			plt.ylabel('''Gain (dB)'''		)

			plt.plot(snake_case__		)
			plt.show()





def 				A_       ( snake_case__       ,					snake_case__		)					->  None:
			_UpperCamelCase					:Tuple					     =	5_12
			_UpperCamelCase					:Union[str, Any]					     =	[1] + [0] * (size - 1)
			_UpperCamelCase					:List[Any]					     =	[filter_type.process(snake_case__		) for item in inputs]

			_UpperCamelCase					:str					     =	[0] * (samplerate - size)  # zero-padding
			outputs += filler
			_UpperCamelCase					:Tuple					     =	np.angle(np.fft.fft(snake_case__		)		)

			# Frequencies on log scale from 24 to nyquist frequency
			plt.xlim(24       ,					samplerate / 2 - 1		)
			plt.xlabel('''Frequency (Hz)'''		)
			plt.xscale('''log'''		)

			plt.ylim(-2 * pi       ,					2 * pi		)
			plt.ylabel('''Phase shift (Radians)'''		)
			plt.plot(np.unwrap(snake_case__       ,					-2 * pi		)		)
			plt.show()

