




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       _A				(		__lowercase     ):
		__a					    =       ["""input_values""", """attention_mask"""]






		def __init__(    self						,		_SCREAMING_SNAKE_CASE = 1						,		_SCREAMING_SNAKE_CASE = 1_6000						,		_SCREAMING_SNAKE_CASE = 0.0						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = 80						,		_SCREAMING_SNAKE_CASE = 16						,		_SCREAMING_SNAKE_CASE = 64						,		_SCREAMING_SNAKE_CASE = "hann_window"						,		_SCREAMING_SNAKE_CASE = 1.0						,		_SCREAMING_SNAKE_CASE = 80						,		_SCREAMING_SNAKE_CASE = 7600						,		_SCREAMING_SNAKE_CASE = 1e-10						,		_SCREAMING_SNAKE_CASE = 2						,		_SCREAMING_SNAKE_CASE = True						,		**_SCREAMING_SNAKE_CASE						,		):
								super().__init__(feature_size=_SCREAMING_SNAKE_CASE						,		sampling_rate=_SCREAMING_SNAKE_CASE						,		padding_value=_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)
								_UpperCAmelCase      =			do_normalize
								_UpperCAmelCase      =			return_attention_mask

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

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

								_UpperCAmelCase      =			window_function(window_length=self.sample_size						,		name=self.win_function						,		periodic=_SCREAMING_SNAKE_CASE			)

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






		@staticmethod
		# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
		def 				UpperCAmelCase (    _SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE = 0.0			):
								if attention_mask is not None:
														_UpperCAmelCase      =			np.array(_SCREAMING_SNAKE_CASE						,		np.intaa			)
														_UpperCAmelCase      =			[]

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

																				normed_input_values.append(_SCREAMING_SNAKE_CASE			)
								else:
														_UpperCAmelCase      =			[(x - x.mean()) / np.sqrt(x.var() + 1e-7			) for x in input_values]

								return normed_input_values






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		):
								_UpperCAmelCase      =			spectrogram(
								    _SCREAMING_SNAKE_CASE						,		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						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		**_SCREAMING_SNAKE_CASE						,		):
								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:
														_UpperCAmelCase      =			self._process_audio(
														    _SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE						,		)
								else:
														_UpperCAmelCase      =			None

								if audio_target is not None:
														_UpperCAmelCase      =			self._process_audio(
														    _SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE						,		)

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

								return inputs






		def 				UpperCAmelCase (    self						,		_SCREAMING_SNAKE_CASE						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = False						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		_SCREAMING_SNAKE_CASE = None						,		**_SCREAMING_SNAKE_CASE						,		):
								_UpperCAmelCase      =			isinstance(_SCREAMING_SNAKE_CASE						,		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}"			)
								_UpperCAmelCase      =			is_batched_numpy or (
								    isinstance(_SCREAMING_SNAKE_CASE						,		(list, tuple)			) and (isinstance(speech[0]						,		(np.ndarray, tuple, list)			))
								)

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

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

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

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

								_UpperCAmelCase      =			self.pad(
								    _SCREAMING_SNAKE_CASE						,		padding=_SCREAMING_SNAKE_CASE						,		max_length=_SCREAMING_SNAKE_CASE						,		truncation=_SCREAMING_SNAKE_CASE						,		pad_to_multiple_of=_SCREAMING_SNAKE_CASE						,		return_attention_mask=_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE						,		)

								_UpperCAmelCase      =			feature_size_hack

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

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

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

								if return_tensors is not None:
														_UpperCAmelCase      =			padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE			)

								return padded_inputs






		def 				UpperCAmelCase (    self			):
								_UpperCAmelCase      =			super().to_dict()

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

								return output





import logging

from transformers.configuration_utils import PretrainedConfig


a													=			logging.getLogger(__name__)




class       _A				(		__lowercase     ):
		__a					    =       """masked_bert"""






		def __init__(    self						,		_SCREAMING_SNAKE_CASE=3_0522						,		_SCREAMING_SNAKE_CASE=768						,		_SCREAMING_SNAKE_CASE=12						,		_SCREAMING_SNAKE_CASE=12						,		_SCREAMING_SNAKE_CASE=3072						,		_SCREAMING_SNAKE_CASE="gelu"						,		_SCREAMING_SNAKE_CASE=0.1						,		_SCREAMING_SNAKE_CASE=0.1						,		_SCREAMING_SNAKE_CASE=512						,		_SCREAMING_SNAKE_CASE=2						,		_SCREAMING_SNAKE_CASE=0.02						,		_SCREAMING_SNAKE_CASE=1e-12						,		_SCREAMING_SNAKE_CASE=0						,		_SCREAMING_SNAKE_CASE="topK"						,		_SCREAMING_SNAKE_CASE="constant"						,		_SCREAMING_SNAKE_CASE=0.0						,		**_SCREAMING_SNAKE_CASE						,		):
								super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE						,		**_SCREAMING_SNAKE_CASE			)

								_UpperCAmelCase      =			vocab_size
								_UpperCAmelCase      =			hidden_size
								_UpperCAmelCase      =			num_hidden_layers
								_UpperCAmelCase      =			num_attention_heads
								_UpperCAmelCase      =			hidden_act
								_UpperCAmelCase      =			intermediate_size
								_UpperCAmelCase      =			hidden_dropout_prob
								_UpperCAmelCase      =			attention_probs_dropout_prob
								_UpperCAmelCase      =			max_position_embeddings
								_UpperCAmelCase      =			type_vocab_size
								_UpperCAmelCase      =			initializer_range
								_UpperCAmelCase      =			layer_norm_eps
								_UpperCAmelCase      =			pruning_method
								_UpperCAmelCase      =			mask_init
								_UpperCAmelCase      =			mask_scale