




"""simple docstring"""


import warnings
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, optimal_fft_length, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


A_						=				logging.get_logger(__name__)






class 					lowercase(     __a ):







 '''simple docstring'''





 lowercase__ 					=					["input_values", "attention_mask"]


 def __init__(				self:		Union[str, Any],      a_:		int = 1,      a_:		int = 16_000,      a_:		float = 0.0,      a_:		bool = False,      a_:		int = 80,      a_:		int = 16,      a_:		int = 64,      a_:		str = "hann_window",      a_:		float = 1.0,      a_:		float = 80,      a_:		float = 7_600,      a_:		float = 1E-10,      a_:		int = 2,      a_:		bool = True,      **a_:		Optional[Any],      ):




   '''simple docstring'''



   super().__init__(feature_size=a_,      sampling_rate=a_,      padding_value=a_,      **a_		)
   _snake_case							:		Any								=  do_normalize
   _snake_case							:		Optional[int]								=  return_attention_mask

   _snake_case							:		Optional[Any]								=  num_mel_bins
   _snake_case							:		Optional[Any]								=  hop_length
   _snake_case							:		List[Any]								=  win_length
   _snake_case							:		int								=  win_function
   _snake_case							:		Dict								=  frame_signal_scale
   _snake_case							:		Union[str, Any]								=  fmin
   _snake_case							:		Union[str, Any]								=  fmax
   _snake_case							:		Optional[Any]								=  mel_floor
   _snake_case							:		Optional[int]								=  reduction_factor

   _snake_case							:		List[str]								=  win_length * sampling_rate // 1_000
   _snake_case							:		str								=  hop_length * sampling_rate // 1_000
   _snake_case							:		Optional[int]								=  optimal_fft_length(self.sample_size		)
   _snake_case							:		List[str]								=  (self.n_fft // 2) + 1

   _snake_case							:		int								=  window_function(window_length=self.sample_size,      name=self.win_function,      periodic=a_		)

   _snake_case							:		Optional[Any]								=  mel_filter_bank(
       num_frequency_bins=self.n_freqs,      num_mel_filters=self.num_mel_bins,      min_frequency=self.fmin,      max_frequency=self.fmax,      sampling_rate=self.sampling_rate,      norm="""slaney""",      mel_scale="""slaney""",      )

   if frame_signal_scale != 1.0:
     warnings.warn(
         """The argument `frame_signal_scale` is deprecated and will be removed in version 4.30.0 of Transformers""",      a_,      )
   if reduction_factor != 2.0:
     warnings.warn(
         """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers""",      a_,      )


 @staticmethod
 # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
 def  UpperCamelCase_   (				a_:		List[np.ndarray],      a_:		List[np.ndarray],      a_:		float = 0.0		):




   '''simple docstring'''



   if attention_mask is not None:
     _snake_case							:		Union[str, Any]								=  np.array(a_,      np.intaa		)
     _snake_case							:		Optional[int]								=  []

     for vector, length in zip(a_,      attention_mask.sum(-1		)		):
       _snake_case							:		str								=  (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7		)
       if length < normed_slice.shape[0]:
         _snake_case							:		Union[str, Any]								=  padding_value

       normed_input_values.append(a_		)
   else:
     _snake_case							:		List[str]								=  [(x - x.mean()) / np.sqrt(x.var() + 1E-7		) for x in input_values]

   return normed_input_values


 def  UpperCamelCase_   (				self:		str,      a_:		np.ndarray,      ):




   '''simple docstring'''



   _snake_case							:		Tuple								=  spectrogram(
       a_,      window=self.window,      frame_length=self.sample_size,      hop_length=self.sample_stride,      fft_length=self.n_fft,      mel_filters=self.mel_filters,      mel_floor=self.mel_floor,      log_mel="""log10""",      )
   return log_mel_spec.T


 def __call__(				self:		Tuple,      a_:		Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None,      a_:		Optional[Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]] = None,      a_:		Union[bool, str, PaddingStrategy] = False,      a_:		Optional[int] = None,      a_:		bool = False,      a_:		Optional[int] = None,      a_:		Optional[bool] = None,      a_:		Optional[Union[str, TensorType]] = None,      a_:		Optional[int] = None,      **a_:		Any,      ):




   '''simple docstring'''



   if audio is None and audio_target is None:
     raise ValueError("""You must provide either `audio` or `audio_target` values."""		)

   if sampling_rate is not None:
     if sampling_rate != self.sampling_rate:
       raise ValueError(
           f"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
           f" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
           f" {self.sampling_rate} and not {sampling_rate}."		)
   else:
     logger.warning(
         """It is strongly recommended to pass the ``sampling_rate`` argument to this function. """
         """Failing to do so can result in silent errors that might be hard to debug."""		)

   if audio is not None:
     _snake_case							:		Optional[Any]								=  self._process_audio(
         a_,      a_,      a_,      a_,      a_,      a_,      a_,      a_,      **a_,      )
   else:
     _snake_case							:		Optional[int]								=  None

   if audio_target is not None:
     _snake_case							:		List[Any]								=  self._process_audio(
         a_,      a_,      a_,      a_,      a_,      a_,      a_,      a_,      **a_,      )

     if inputs is None:
       return inputs_target
     else:
       _snake_case							:		Tuple								=  inputs_target["""input_values"""]
       _snake_case							:		Any								=  inputs_target.get("""attention_mask"""		)
       if decoder_attention_mask is not None:
         _snake_case							:		Optional[Any]								=  decoder_attention_mask

   return inputs


 def  UpperCamelCase_   (				self:		Dict,      a_:		Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]],      a_:		bool = False,      a_:		Union[bool, str, PaddingStrategy] = False,      a_:		Optional[int] = None,      a_:		bool = False,      a_:		Optional[int] = None,      a_:		Optional[bool] = None,      a_:		Optional[Union[str, TensorType]] = None,      **a_:		List[str],      ):




   '''simple docstring'''



   _snake_case							:		Any								=  isinstance(a_,      np.ndarray		) and len(speech.shape		) > 1
   if is_batched_numpy and len(speech.shape		) > 2:
     raise ValueError(f"Only mono-channel audio is supported for input to {self}"		)
   _snake_case							:		Optional[int]								=  is_batched_numpy or (
       isinstance(a_,      (list, tuple)		) and (isinstance(speech[0],      (np.ndarray, tuple, list)		))
   )

   if is_batched:
     _snake_case							:		Tuple								=  [np.asarray(a_,      dtype=np.floataa		) for speech in speech]
   elif not is_batched and not isinstance(a_,      np.ndarray		):
     _snake_case							:		Union[str, Any]								=  np.asarray(a_,      dtype=np.floataa		)
   elif isinstance(a_,      np.ndarray		) and speech.dtype is np.dtype(np.floataa		):
     _snake_case							:		Union[str, Any]								=  speech.astype(np.floataa		)

   # always return batch
   if not is_batched:
     _snake_case							:		Optional[int]								=  [speech]

   # needed to make pad() work on spectrogram inputs
   _snake_case							:		Any								=  self.feature_size

   # convert into correct format for padding
   if is_target:
     _snake_case							:		str								=  [self._extract_mel_features(a_		) for waveform in speech]
     _snake_case							:		Dict								=  BatchFeature({"""input_values""": features}		)
     _snake_case							:		Tuple								=  self.num_mel_bins
   else:
     _snake_case							:		Tuple								=  BatchFeature({"""input_values""": speech}		)

   _snake_case							:		Union[str, Any]								=  self.pad(
       a_,      padding=a_,      max_length=a_,      truncation=a_,      pad_to_multiple_of=a_,      return_attention_mask=a_,      **a_,      )

   _snake_case							:		int								=  feature_size_hack

   # convert input values to correct format
   _snake_case							:		List[str]								=  padded_inputs["""input_values"""]
   if not isinstance(input_values[0],      np.ndarray		):
     _snake_case							:		Optional[Any]								=  [np.asarray(a_,      dtype=np.floataa		) for array in input_values]
   elif (
       not isinstance(a_,      np.ndarray		)
       and isinstance(input_values[0],      np.ndarray		)
       and input_values[0].dtype is np.dtype(np.floataa		)
   ):
     _snake_case							:		str								=  [array.astype(np.floataa		) for array in input_values]
   elif isinstance(a_,      np.ndarray		) and input_values.dtype is np.dtype(np.floataa		):
     _snake_case							:		Optional[Any]								=  input_values.astype(np.floataa		)

   # convert attention_mask to correct format
   _snake_case							:		Optional[Any]								=  padded_inputs.get("""attention_mask"""		)
   if attention_mask is not None:
     _snake_case							:		Dict								=  [np.asarray(a_,      dtype=np.intaa		) for array in attention_mask]

   # zero-mean and unit-variance normalization
   if not is_target and self.do_normalize:
     _snake_case							:		str								=  (
         attention_mask
         if self._get_padding_strategies(a_,      max_length=a_		) is not PaddingStrategy.DO_NOT_PAD
         else None
     )
     _snake_case							:		List[str]								=  self.zero_mean_unit_var_norm(
         padded_inputs["""input_values"""],      attention_mask=a_,      padding_value=self.padding_value		)

   if return_tensors is not None:
     _snake_case							:		Union[str, Any]								=  padded_inputs.convert_to_tensors(a_		)

   return padded_inputs


 def  UpperCamelCase_   (				self:		Dict		):




   '''simple docstring'''



   _snake_case							:		List[Any]								=  super().to_dict()

   # Don't serialize these as they are derived from the other properties.
   _snake_case							:		List[str]								=  ["""window""", """mel_filters""", """sample_size""", """sample_stride""", """n_fft""", """n_freqs"""]
   for name in names:
     if name in output:
       del output[name]

   return output









"""simple docstring"""
import inspect
import unittest

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


if is_torch_available():
		import torch
		from torch import nn

		from transformers import ViTMSNForImageClassification, ViTMSNModel
		from transformers.models.vit_msn.modeling_vit_msn import VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import ViTImageProcessor






class 					_UpperCAmelCase   :


					def __init__(					self			:List[Any]     ,       __UpperCamelCase			:Tuple     ,       __UpperCamelCase			:List[str]=13     ,       __UpperCamelCase			:Any=30     ,       __UpperCamelCase			:int=2     ,       __UpperCamelCase			:Union[str, Any]=3     ,       __UpperCamelCase			:Union[str, Any]=True     ,       __UpperCamelCase			:Optional[int]=True     ,       __UpperCamelCase			:List[str]=32     ,       __UpperCamelCase			:List[Any]=5     ,       __UpperCamelCase			:Dict=4     ,       __UpperCamelCase			:List[str]=37     ,       __UpperCamelCase			:str="gelu"     ,       __UpperCamelCase			:Union[str, Any]=0.1     ,       __UpperCamelCase			:List[Any]=0.1     ,       __UpperCamelCase			:Tuple=10     ,       __UpperCamelCase			:Tuple=0.02     ,       __UpperCamelCase			:int=None     ,       ):
												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

												# in ViT MSN, 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			:Any		):
												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			:Union[str, Any]		):
												return ViTMSNConfig(
												    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     ,       initializer_range=self.initializer_range     ,       )


					def 	lowerCamelCase       (					self			:Dict     ,       __UpperCamelCase			:Dict     ,       __UpperCamelCase			:Any     ,       __UpperCamelCase			:Any		):
												A		=  ViTMSNModel(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			:Optional[int]     ,       __UpperCamelCase			:List[str]     ,       __UpperCamelCase			:Union[str, Any]     ,       __UpperCamelCase			:Optional[Any]		):
												A		=  self.type_sequence_label_size
												A		=  ViTMSNForImageClassification(__UpperCamelCase		)
												model.to(__UpperCamelCase		)
												model.eval()
												A		=  model(__UpperCamelCase     ,       labels=__UpperCamelCase		)
												print("Pixel and labels shape: {pixel_values.shape}, {labels.shape}"		)
												print("Labels: {labels}"		)
												self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.type_sequence_label_size)		)

												# test greyscale images
												A		=  1
												A		=  ViTMSNForImageClassification(__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			:Optional[Any]		):
												A		=  self.prepare_config_and_inputs()
												A,	A,	A		=  config_and_inputs
												A		=  {"pixel_values": pixel_values}
												return config, inputs_dict







@require_torch
class 					_UpperCAmelCase   (	lowercase_     ,							lowercase_     ,							unittest.TestCase ):
					UpperCamelCase      =							(ViTMSNModel, ViTMSNForImageClassification) if is_torch_available() else ()
					UpperCamelCase      =							(
					    {'''feature-extraction''': ViTMSNModel, '''image-classification''': ViTMSNForImageClassification}
					    if is_torch_available()
					    else {}
					)

					UpperCamelCase      =							False
					UpperCamelCase      =							False
					UpperCamelCase      =							False
					UpperCamelCase      =							False


					def 	lowerCamelCase       (					self			:Optional[int]		):
												A		=  ViTMSNModelTester(self		)
												A		=  ConfigTester(self     ,       config_class=__UpperCamelCase     ,       has_text_modality=__UpperCamelCase     ,       hidden_size=37		)


					def 	lowerCamelCase       (					self			:Any		):
												self.config_tester.run_common_tests()


					@unittest.skip(reason="ViTMSN does not use inputs_embeds"		)
					def 	lowerCamelCase       (					self			:Union[str, Any]		):
												pass


					def 	lowerCamelCase       (					self			:int		):
												A,	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			:Tuple		):
												A,	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[str]		):
												A		=  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase		)


					def 	lowerCamelCase       (					self			:Dict		):
												A		=  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*__UpperCamelCase		)


					@slow
					def 	lowerCamelCase       (					self			:List[Any]		):
												for model_name in VIT_MSN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			A		=  ViTMSNModel.from_pretrained(__UpperCamelCase		)
																			self.assertIsNotNone(__UpperCamelCase		)







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






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


					@cached_property
					def 	lowerCamelCase       (					self			:Union[str, Any]		):
												return ViTImageProcessor.from_pretrained("facebook/vit-msn-small"		) if is_vision_available() else None


					@slow
					def 	lowerCamelCase       (					self			:Any		):
												torch.manual_seed(2		)
												A		=  ViTMSNForImageClassification.from_pretrained("facebook/vit-msn-small"		).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, 10_00)		)
												self.assertEqual(outputs.logits.shape     ,       __UpperCamelCase		)

												A		=  torch.tensor([-0.0_803, -0.4_454, -0.2_375]		).to(__UpperCamelCase		)

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


