


'''simple docstring'''




import inspect
import unittest

from transformers import MobileNetVaConfig
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 transformers import MobileNetVaForImageClassification, MobileNetVaModel
       from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import MobileNetVaImageProcessor




class 			_lowercase (	__lowercase							):
   def a  (						self       :      Any      ) ->							int:
        __snake_case           =						self.config_class(**self.inputs_dict      )
        self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_       ,   'tf_padding'      )      )
        self.parent.assertTrue(hasattr(SCREAMING_SNAKE_CASE_       ,   'depth_multiplier'      )      )




class 			_lowercase :
   def __init__(						self       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      Optional[int]=13       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]=3       ,   SCREAMING_SNAKE_CASE_       :      str=32       ,   SCREAMING_SNAKE_CASE_       :      Tuple=0.2_5       ,   SCREAMING_SNAKE_CASE_       :      Tuple=8       ,   SCREAMING_SNAKE_CASE_       :      Tuple=True       ,   SCREAMING_SNAKE_CASE_       :      Dict=1024       ,   SCREAMING_SNAKE_CASE_       :      Optional[Any]=32       ,   SCREAMING_SNAKE_CASE_       :      Optional[int]="relu6"       ,   SCREAMING_SNAKE_CASE_       :      Any=0.1       ,   SCREAMING_SNAKE_CASE_       :      Tuple=0.0_2       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]=True       ,   SCREAMING_SNAKE_CASE_       :      List[str]=True       ,   SCREAMING_SNAKE_CASE_       :      Any=10       ,   SCREAMING_SNAKE_CASE_       :      List[str]=None       ,   ) ->							int:
        __snake_case           =						parent
        __snake_case           =						batch_size
        __snake_case           =						num_channels
        __snake_case           =						image_size
        __snake_case           =						depth_multiplier
        __snake_case           =						min_depth
        __snake_case           =						tf_padding
        __snake_case           =						int(last_hidden_size * depth_multiplier      )
        __snake_case           =						output_stride
        __snake_case           =						hidden_act
        __snake_case           =						classifier_dropout_prob
        __snake_case           =						use_labels
        __snake_case           =						is_training
        __snake_case           =						num_labels
        __snake_case           =						initializer_range
        __snake_case           =						scope
   def a  (						self       :      int      ) ->							List[str]:
        __snake_case           =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

        __snake_case           =						None
        __snake_case           =						None
        if self.use_labels:
             __snake_case           =						ids_tensor([self.batch_size]       ,   self.num_labels      )
             __snake_case           =						ids_tensor([self.batch_size, self.image_size, self.image_size]       ,   self.num_labels      )

        __snake_case           =						self.get_config()

        return config, pixel_values, labels, pixel_labels
   def a  (						self       :      List[Any]      ) ->							Tuple:
        return MobileNetVaConfig(
            num_channels=self.num_channels       ,   image_size=self.image_size       ,   depth_multiplier=self.depth_multiplier       ,   min_depth=self.min_depth       ,   tf_padding=self.tf_padding       ,   hidden_act=self.hidden_act       ,   classifier_dropout_prob=self.classifier_dropout_prob       ,   initializer_range=self.initializer_range       ,   )
   def a  (						self       :      int       ,   SCREAMING_SNAKE_CASE_       :      Optional[int]       ,   SCREAMING_SNAKE_CASE_       :      Optional[int]       ,   SCREAMING_SNAKE_CASE_       :      List[Any]       ,   SCREAMING_SNAKE_CASE_       :      Tuple      ) ->							Union[str, Any]:
        __snake_case           =						MobileNetVaModel(config=SCREAMING_SNAKE_CASE_      )
        model.to(SCREAMING_SNAKE_CASE_      )
        model.eval()
        __snake_case           =						model(SCREAMING_SNAKE_CASE_      )
        self.parent.assertEqual(
            result.last_hidden_state.shape       ,   (
                self.batch_size,
                self.last_hidden_size,
                self.image_size // self.output_stride,
                self.image_size // self.output_stride,
            )       ,   )
   def a  (						self       :      Union[str, Any]       ,   SCREAMING_SNAKE_CASE_       :      str       ,   SCREAMING_SNAKE_CASE_       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      int       ,   SCREAMING_SNAKE_CASE_       :      Tuple      ) ->							int:
        __snake_case           =						self.num_labels
        __snake_case           =						MobileNetVaForImageClassification(SCREAMING_SNAKE_CASE_      )
        model.to(SCREAMING_SNAKE_CASE_      )
        model.eval()
        __snake_case           =						model(SCREAMING_SNAKE_CASE_       ,   labels=SCREAMING_SNAKE_CASE_      )
        self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)      )





   def a  (						self       :      Optional[Any]      ) ->							Dict:
        __snake_case           =						self.prepare_config_and_inputs()
        __snake_case      ,       __snake_case      ,       __snake_case      ,       __snake_case           =						config_and_inputs
        __snake_case           =						{'pixel_values': pixel_values}
        return config, inputs_dict




@require_torch
class 			_lowercase (	__lowercase						,					__lowercase						,					unittest.TestCase							):
   _SCREAMING_SNAKE_CASE  :  Any          =	(MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
   _SCREAMING_SNAKE_CASE  :  str          =	(
       {"feature-extraction": MobileNetVaModel, "image-classification": MobileNetVaForImageClassification}
       if is_torch_available()
       else {}
   )

   _SCREAMING_SNAKE_CASE  :  List[str]          =	False
   _SCREAMING_SNAKE_CASE  :  Any          =	False
   _SCREAMING_SNAKE_CASE  :  List[Any]          =	False
   _SCREAMING_SNAKE_CASE  :  Optional[int]          =	False
   def a  (						self       :      str      ) ->							str:
        __snake_case           =						MobileNetVaModelTester(self      )
        __snake_case           =						MobileNetVaConfigTester(self       ,   config_class=SCREAMING_SNAKE_CASE_       ,   has_text_modality=SCREAMING_SNAKE_CASE_      )
   def a  (						self       :      List[Any]      ) ->							List[str]:
        self.config_tester.run_common_tests()
   @unittest.skip(reason='MobileNetV1 does not use inputs_embeds'      )
   def a  (						self       :      Tuple      ) ->							Dict:
        pass
   @unittest.skip(reason='MobileNetV1 does not support input and output embeddings'      )
   def a  (						self       :      Any      ) ->							Dict:
        pass
   @unittest.skip(reason='MobileNetV1 does not output attentions'      )
   def a  (						self       :      Dict      ) ->							Any:
        pass
   def a  (						self       :      int      ) ->							Any:
        __snake_case      ,       __snake_case           =						self.model_tester.prepare_config_and_inputs_for_common()

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

             __snake_case           =						['pixel_values']
             self.assertListEqual(arg_names[:1]       ,   SCREAMING_SNAKE_CASE_      )
   def a  (						self       :      List[Any]      ) ->							List[str]:
        __snake_case           =						self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )
   def a  (						self       :      List[Any]      ) ->							List[str]:
        def check_hidden_states_output(SCREAMING_SNAKE_CASE_       :      Tuple       ,   SCREAMING_SNAKE_CASE_       :      Union[str, Any]       ,   SCREAMING_SNAKE_CASE_       :      List[Any]      ):
             __snake_case           =						model_class(SCREAMING_SNAKE_CASE_      )
             model.to(SCREAMING_SNAKE_CASE_      )
             model.eval()

             with torch.no_grad():
                  __snake_case           =						model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )      )

             __snake_case           =						outputs.hidden_states

             __snake_case           =						26
             self.assertEqual(len(SCREAMING_SNAKE_CASE_      )       ,   SCREAMING_SNAKE_CASE_      )

        __snake_case      ,       __snake_case           =						self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             __snake_case           =						True
             check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __snake_case           =						True

             check_hidden_states_output(SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_       ,   SCREAMING_SNAKE_CASE_      )
   def a  (						self       :      List[Any]      ) ->							List[Any]:
        __snake_case           =						self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_      )





   @slow
   def a  (						self       :      Union[str, Any]      ) ->							List[Any]:
        for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __snake_case           =						MobileNetVaModel.from_pretrained(SCREAMING_SNAKE_CASE_      )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE_      )





def   _a		()			->			int:






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




@require_torch
@require_vision
class 			_lowercase (	unittest.TestCase							):
   @cached_property
   def a  (						self       :      List[Any]      ) ->							int:
        return (
            MobileNetVaImageProcessor.from_pretrained('google/mobilenet_v1_1.0_224'      ) if is_vision_available() else None
        )





   @slow
   def a  (						self       :      Dict      ) ->							List[str]:
        __snake_case           =						MobileNetVaForImageClassification.from_pretrained('google/mobilenet_v1_1.0_224'      ).to(SCREAMING_SNAKE_CASE_      )

        __snake_case           =						self.default_image_processor
        __snake_case           =						prepare_img()
        __snake_case           =						image_processor(images=SCREAMING_SNAKE_CASE_       ,   return_tensors='pt'      ).to(SCREAMING_SNAKE_CASE_      )

        # forward pass
        with torch.no_grad():
             __snake_case           =						model(**SCREAMING_SNAKE_CASE_      )

        # verify the logits
        __snake_case           =						torch.Size((1, 1001)      )
        self.assertEqual(outputs.logits.shape       ,   SCREAMING_SNAKE_CASE_      )

        __snake_case           =						torch.tensor([-4.1_7_3_9, -1.1_2_3_3, 3.1_2_0_5]      ).to(SCREAMING_SNAKE_CASE_      )

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





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


__lowercase        =    logging.get_logger(__name__)






class 							a__(   lowerCAmelCase__      ):


			'''simple docstring'''






			UpperCAmelCase_     :	Dict						=			['''input_values''', '''attention_mask''']



			def __init__(  self			,       __lowerCAmelCase = 1			,       __lowerCAmelCase = 16000			,       __lowerCAmelCase = 0.0			,       __lowerCAmelCase = False			,       __lowerCAmelCase = 80			,       __lowerCAmelCase = 16			,       __lowerCAmelCase = 64			,       __lowerCAmelCase = "hann_window"			,       __lowerCAmelCase = 1.0			,       __lowerCAmelCase = 80			,       __lowerCAmelCase = 7600			,       __lowerCAmelCase = 1E-1_0			,       __lowerCAmelCase = 2			,       __lowerCAmelCase = True			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					super().__init__(feature_size=__lowerCAmelCase			,       sampling_rate=__lowerCAmelCase			,       padding_value=__lowerCAmelCase			,       **__lowerCAmelCase)
					lowerCAmelCase     =    do_normalize
					lowerCAmelCase     =    return_attention_mask

					lowerCAmelCase     =    num_mel_bins
					lowerCAmelCase     =    hop_length
					lowerCAmelCase     =    win_length
					lowerCAmelCase     =    win_function
					lowerCAmelCase     =    frame_signal_scale
					lowerCAmelCase     =    fmin
					lowerCAmelCase     =    fmax
					lowerCAmelCase     =    mel_floor
					lowerCAmelCase     =    reduction_factor

					lowerCAmelCase     =    win_length * sampling_rate // 1000
					lowerCAmelCase     =    hop_length * sampling_rate // 1000
					lowerCAmelCase     =    optimal_fft_length(self.sample_size)
					lowerCAmelCase     =    (self.n_fft // 2) + 1

					lowerCAmelCase     =    window_function(window_length=self.sample_size			,       name=self.win_function			,       periodic=__lowerCAmelCase)

					lowerCAmelCase     =    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"""			,       __lowerCAmelCase			,       )
					if reduction_factor != 2.0:
							warnings.warn(
							    """The argument `reduction_factor` is deprecated and will be removed in version 4.30.0 of Transformers"""			,       __lowerCAmelCase			,       )



			@staticmethod
			# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
			def 				a_			(  __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase = 0.0):




					"""simple docstring"""


					if attention_mask is not None:
							lowerCAmelCase     =    np.array(__lowerCAmelCase			,       np.intaa)
							lowerCAmelCase     =    []

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

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

					return normed_input_values



			def 				a_			(  self			,       __lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    spectrogram(
					    __lowerCAmelCase			,       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			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""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:
							lowerCAmelCase     =    self._process_audio(
							    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       **__lowerCAmelCase			,       )
					else:
							lowerCAmelCase     =    None

					if audio_target is not None:
							lowerCAmelCase     =    self._process_audio(
							    __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       __lowerCAmelCase			,       **__lowerCAmelCase			,       )

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

					return inputs



			def 				a_			(  self			,       __lowerCAmelCase			,       __lowerCAmelCase = False			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = False			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       __lowerCAmelCase = None			,       **__lowerCAmelCase			,       ):




					"""simple docstring"""


					lowerCAmelCase     =    isinstance(__lowerCAmelCase			,       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}")
					lowerCAmelCase     =    is_batched_numpy or (
					    isinstance(__lowerCAmelCase			,       (list, tuple)) and (isinstance(speech[0]			,       (np.ndarray, tuple, list)))
					)

					if is_batched:
							lowerCAmelCase     =    [np.asarray(__lowerCAmelCase			,       dtype=np.floataa) for speech in speech]
					elif not is_batched and not isinstance(__lowerCAmelCase			,       np.ndarray):
							lowerCAmelCase     =    np.asarray(__lowerCAmelCase			,       dtype=np.floataa)
					elif isinstance(__lowerCAmelCase			,       np.ndarray) and speech.dtype is np.dtype(np.floataa):
							lowerCAmelCase     =    speech.astype(np.floataa)

					# always return batch
					if not is_batched:
							lowerCAmelCase     =    [speech]

					# needed to make pad() work on spectrogram inputs
					lowerCAmelCase     =    self.feature_size

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

					lowerCAmelCase     =    self.pad(
					    __lowerCAmelCase			,       padding=__lowerCAmelCase			,       max_length=__lowerCAmelCase			,       truncation=__lowerCAmelCase			,       pad_to_multiple_of=__lowerCAmelCase			,       return_attention_mask=__lowerCAmelCase			,       **__lowerCAmelCase			,       )

					lowerCAmelCase     =    feature_size_hack

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

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

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

					if return_tensors is not None:
							lowerCAmelCase     =    padded_inputs.convert_to_tensors(__lowerCAmelCase)

					return padded_inputs







			def 				a_			(  self):




					"""simple docstring"""


					lowerCAmelCase     =    super().to_dict()

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

					return output




