
"""simple docstring"""





from typing import 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 ....file_utils import PaddingStrategy, TensorType
from ....utils import logging


UpperCamelCase_					:						List[Any]				= logging.get_logger(__name__)



class __lowerCAmelCase				(					_lowercase      ):




			"""simple docstring"""







			snake_case	      =				["input_features", "attention_mask"]




			def __init__(				self						:					List[Any]       ,   _snake_case						:					int=80       ,   _snake_case						:					Optional[int]=16_000       ,   _snake_case						:					Optional[Any]=0.0       ,   _snake_case						:					List[Any]=10       ,   _snake_case						:					str=25       ,   _snake_case						:					Optional[Any]="hamming_window"       ,   _snake_case						:					Optional[int]=3_2_7_6_8.0       ,   _snake_case						:					int=0.9_7       ,   _snake_case						:					Optional[int]=1.0       ,   _snake_case						:					List[str]=True       ,   _snake_case						:					Any=True       ,   _snake_case						:					Optional[int]=False       ,   **_snake_case						:					Tuple       ,   )      -> Union[str, Any]:







								"""simple docstring"""
								super().__init__(feature_size=_snake_case       ,   sampling_rate=_snake_case       ,   padding_value=_snake_case       ,   **_snake_case	)

								A_				 =						feature_size
								A_				 =						sampling_rate
								A_				 =						padding_value
								A_				 =						hop_length
								A_				 =						win_length
								A_				 =						frame_signal_scale
								A_				 =						preemphasis_coeff
								A_				 =						mel_floor
								A_				 =						normalize_means
								A_				 =						normalize_vars
								A_				 =						win_function
								A_				 =						return_attention_mask

								A_				 =						win_length * sampling_rate // 1_000
								A_				 =						hop_length * sampling_rate // 1_000

								A_				 =						optimal_fft_length(self.sample_size	)
								A_				 =						(self.n_fft // 2) + 1




			def      lowerCamelCase__     (				self						:					Tuple       ,   _snake_case						:					np.array	)      -> np.ndarray:







								"""simple docstring"""
								if self.win_function == "hamming_window":
													A_				 =						window_function(window_length=self.sample_size       ,   name=self.win_function       ,   periodic=_snake_case	)
								else:
													A_				 =						window_function(window_length=self.sample_size       ,   name=self.win_function	)

								A_				 =						mel_filter_bank(
								    num_frequency_bins=self.n_freqs       ,   num_mel_filters=self.feature_size       ,   min_frequency=0.0       ,   max_frequency=self.sampling_rate / 2.0       ,   sampling_rate=self.sampling_rate       ,   )

								A_				 =						spectrogram(
								    one_waveform * self.frame_signal_scale       ,   window=_snake_case       ,   frame_length=self.sample_size       ,   hop_length=self.sample_stride       ,   fft_length=self.n_fft       ,   center=_snake_case       ,   preemphasis=self.preemphasis_coeff       ,   mel_filters=_snake_case       ,   mel_floor=self.mel_floor       ,   log_mel="log"       ,   )
								return msfc_features.T




			def      lowerCamelCase__     (				self						:					List[Any]       ,   _snake_case						:					List[str]       ,   _snake_case						:					Union[str, Any]       ,   _snake_case						:					Tuple	)      -> str:







								"""simple docstring"""
								# make sure we normalize float32 arrays
								if self.normalize_means:
													A_				 =						x[:input_length].mean(axis=0	)
													A_				 =						np.subtract(_snake_case       ,   _snake_case	)
								if self.normalize_vars:
													A_				 =						x[:input_length].std(axis=0	)
													A_				 =						np.divide(_snake_case       ,   _snake_case	)

								if input_length < x.shape[0]:
													A_				 =						padding_value

								# make sure array is in float32
								A_				 =						x.astype(np.floataa	)

								return x




			def      lowerCamelCase__     (				self						:					Dict       ,   _snake_case						:					List[np.ndarray]       ,   _snake_case						:					Optional[np.ndarray] = None	)      -> List[np.ndarray]:







								"""simple docstring"""
								A_				 =						attention_mask.sum(-1	) if attention_mask is not None else [x.shape[0] for x in input_features]
								return [self._normalize_one(_snake_case       ,   _snake_case       ,   self.padding_value	) for x, n in zip(_snake_case       ,   _snake_case	)]






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







								"""simple docstring"""

								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 `raw_speech` 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."	)

								A_				 =						isinstance(_snake_case       ,   np.ndarray	) and len(raw_speech.shape	) > 1
								if is_batched_numpy and len(raw_speech.shape	) > 2:
													raise ValueError(F'Only mono-channel audio is supported for input to {self}'	)
								A_				 =						is_batched_numpy or (
								    isinstance(_snake_case       ,   (list, tuple)	) and (isinstance(raw_speech[0]       ,   (np.ndarray, tuple, list)	))
								)

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

								# always return batch
								if not is_batched:
													A_				 =						[raw_speech]

								# extract fbank features
								A_				 =						[self._extract_mfsc_features(_snake_case	) for one_waveform in raw_speech]

								# convert into correct format for padding
								A_				 =						BatchFeature({"input_features": features}	)

								A_				 =						self.pad(
								    _snake_case       ,   padding=_snake_case       ,   max_length=_snake_case       ,   truncation=_snake_case       ,   pad_to_multiple_of=_snake_case       ,   return_attention_mask=_snake_case       ,   **_snake_case       ,   )
								# make sure list is in array format
								A_				 =						padded_inputs.get("input_features"	)
								if isinstance(input_features[0]       ,   _snake_case	):
													A_				 =						[np.asarray(_snake_case       ,   dtype=np.floataa	) for feature in input_features]

								A_				 =						padded_inputs.get("attention_mask"	)
								if attention_mask is not None:
													A_				 =						[np.asarray(_snake_case       ,   dtype=np.intaa	) for array in attention_mask]

								if self.normalize_means or self.normalize_vars:
													A_				 =						(
													    np.array(_snake_case       ,   dtype=np.intaa	)
													    if self._get_padding_strategies(_snake_case       ,   max_length=_snake_case	) is not PaddingStrategy.DO_NOT_PAD
													    and padding
													    else None
													)
													A_				 =						self.normalize(
													    padded_inputs["input_features"]       ,   attention_mask=_snake_case	)

								if return_tensors is not None:
													A_				 =						padded_inputs.convert_to_tensors(_snake_case	)

								return padded_inputs






"""simple docstring"""





import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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 RegNetForImageClassification, RegNetModel
		from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor



class __lowerCAmelCase				:




			"""simple docstring"""







			def __init__(				self						:					Optional[int]       ,   _snake_case						:					Any       ,   _snake_case						:					int=3       ,   _snake_case						:					List[Any]=32       ,   _snake_case						:					str=3       ,   _snake_case						:					Any=10       ,   _snake_case						:					List[Any]=[10, 20, 30, 40]       ,   _snake_case						:					Dict=[1, 1, 2, 1]       ,   _snake_case						:					Dict=True       ,   _snake_case						:					Any=True       ,   _snake_case						:					List[str]="relu"       ,   _snake_case						:					List[Any]=3       ,   _snake_case						:					List[str]=None       ,   )      -> int:







								"""simple docstring"""
								A_				 =						parent
								A_				 =						batch_size
								A_				 =						image_size
								A_				 =						num_channels
								A_				 =						embeddings_size
								A_				 =						hidden_sizes
								A_				 =						depths
								A_				 =						is_training
								A_				 =						use_labels
								A_				 =						hidden_act
								A_				 =						num_labels
								A_				 =						scope
								A_				 =						len(_snake_case	)




			def      lowerCamelCase__     (				self						:					Any	)      -> Optional[int]:







								"""simple docstring"""
								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.num_labels	)

								A_				 =						self.get_config()

								return config, pixel_values, labels




			def      lowerCamelCase__     (				self						:					List[str]	)      -> Union[str, Any]:







								"""simple docstring"""
								return RegNetConfig(
								    num_channels=self.num_channels       ,   embeddings_size=self.embeddings_size       ,   hidden_sizes=self.hidden_sizes       ,   depths=self.depths       ,   hidden_act=self.hidden_act       ,   num_labels=self.num_labels       ,   )




			def      lowerCamelCase__     (				self						:					Union[str, Any]       ,   _snake_case						:					str       ,   _snake_case						:					Tuple       ,   _snake_case						:					Tuple	)      -> List[str]:







								"""simple docstring"""
								A_				 =						RegNetModel(config=_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case	)
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape       ,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)       ,   )




			def      lowerCamelCase__     (				self						:					Dict       ,   _snake_case						:					Tuple       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					Optional[Any]	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						self.num_labels
								A_				 =						RegNetForImageClassification(_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case       ,   labels=_snake_case	)
								self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)	)






			def      lowerCamelCase__     (				self						:					int	)      -> Optional[Any]:







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





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




			"""simple docstring"""







			snake_case	      =				(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
			snake_case	      =				(
			    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False




			def      lowerCamelCase__     (				self						:					str	)      -> str:







								"""simple docstring"""
								A_				 =						RegNetModelTester(self	)
								A_				 =						ConfigTester(self       ,   config_class=_snake_case       ,   has_text_modality=_snake_case	)




			def      lowerCamelCase__     (				self						:					Tuple	)      -> List[Any]:







								"""simple docstring"""
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()




			def      lowerCamelCase__     (				self						:					int	)      -> List[Any]:







								"""simple docstring"""
								return




			@unittest.skip(reason="RegNet does not use inputs_embeds"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Optional[Any]:







								"""simple docstring"""
								pass




			@unittest.skip(reason="RegNet does not support input and output embeddings"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Union[str, Any]:







								"""simple docstring"""
								pass




			def      lowerCamelCase__     (				self						:					Optional[int]	)      -> List[Any]:







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_				 =						model_class(_snake_case	)
													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]       ,   _snake_case	)




			def      lowerCamelCase__     (				self						:					Any	)      -> int:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case	)




			def      lowerCamelCase__     (				self						:					List[str]	)      -> int:







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_				 =						model_class(config=_snake_case	)
													for name, module in model.named_modules():
																		if isinstance(_snake_case       ,   (nn.BatchNormad, nn.GroupNorm)	):
																							self.assertTrue(
																							    torch.all(module.weight == 1	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )
																							self.assertTrue(
																							    torch.all(module.bias == 0	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )




			def      lowerCamelCase__     (				self						:					List[Any]	)      -> List[str]:







								"""simple docstring"""
								def check_hidden_states_output(_snake_case						:					Tuple       ,   _snake_case						:					Optional[int]       ,   _snake_case						:					Optional[int]	):
													A_				 =						model_class(_snake_case	)
													model.to(_snake_case	)
													model.eval()

													with torch.no_grad():
																		A_				 =						model(**self._prepare_for_class(_snake_case       ,   _snake_case	)	)

													A_				 =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													A_				 =						self.model_tester.num_stages
													self.assertEqual(len(_snake_case	)       ,   expected_num_stages + 1	)

													# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]	)       ,   [self.model_tester.image_size // 2, self.model_tester.image_size // 2]       ,   )

								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()
								A_				 =						["basic", "bottleneck"]
								for model_class in self.all_model_classes:
													for layer_type in layers_type:
																		A_				 =						layer_type
																		A_				 =						True
																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)

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

																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)




			def      lowerCamelCase__     (				self						:					str	)      -> List[str]:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case	)






			@slow
			def      lowerCamelCase__     (				self						:					Optional[Any]	)      -> int:







								"""simple docstring"""
								for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A_				 =						RegNetModel.from_pretrained(_snake_case	)
													self.assertIsNotNone(_snake_case	)





def 							A_     ():

					'''simple docstring'''





					A_				 =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
					return image




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




			"""simple docstring"""







			@cached_property
			def      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> int:







								"""simple docstring"""
								return (
								    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
								    if is_vision_available()
								    else None
								)






			@slow
			def      lowerCamelCase__     (				self						:					str	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(_snake_case	)

								A_				 =						self.default_image_processor
								A_				 =						prepare_img()
								A_				 =						image_processor(images=_snake_case       ,   return_tensors="pt"	).to(_snake_case	)

								# forward pass
								with torch.no_grad():
													A_				 =						model(**_snake_case	)

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

								A_				 =						torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]	).to(_snake_case	)

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




