



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


lowerCAmelCase	:		int				=   logging.get_logger(__name__)






class 					UpperCAmelCase__	(		UpperCamelCase__ ):
					a      :     str        =							["""input_values""", """attention_mask"""]



					def __init__(    self			,				UpperCamelCase = 1			,				UpperCamelCase = 1_6000			,				UpperCamelCase = 0.0			,				UpperCamelCase = False			,				UpperCamelCase = 80			,				UpperCamelCase = 16			,				UpperCamelCase = 64			,				UpperCamelCase = "hann_window"			,				UpperCamelCase = 1.0			,				UpperCamelCase = 80			,				UpperCamelCase = 7600			,				UpperCamelCase = 1E-10			,				UpperCamelCase = 2			,				UpperCamelCase = True			,				**UpperCamelCase			,				)     ->			Union[str, Any]:
						super().__init__(feature_size=UpperCamelCase			,				sampling_rate=UpperCamelCase			,				padding_value=UpperCamelCase			,				**UpperCamelCase     )
						__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=UpperCamelCase     )

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



					@staticmethod
					# Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
					def        UpperCAmelCase_ (    UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase = 0.0     )     ->			List[np.ndarray]:
						if attention_mask is not None:
							__lowerCAmelCase												=  np.array(UpperCamelCase			,				np.intaa     )
							__lowerCAmelCase												=  []

							for vector, length in zip(UpperCamelCase			,				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(UpperCamelCase     )
						else:
							__lowerCAmelCase												=  [(x - x.mean()) / np.sqrt(x.var() + 1E-7     ) for x in input_values]

						return normed_input_values



					def        UpperCAmelCase_ (    self			,				UpperCamelCase			,				)     ->			np.ndarray:
						__lowerCAmelCase												=  spectrogram(
						    UpperCamelCase			,				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			,				UpperCamelCase = None			,				UpperCamelCase = None			,				UpperCamelCase = False			,				UpperCamelCase = None			,				UpperCamelCase = False			,				UpperCamelCase = None			,				UpperCamelCase = None			,				UpperCamelCase = None			,				UpperCamelCase = None			,				**UpperCamelCase			,				)     ->			BatchFeature:
						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(
							    UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				UpperCamelCase			,				**UpperCamelCase			,				)
						else:
							__lowerCAmelCase												=  None

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

							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        UpperCAmelCase_ (    self			,				UpperCamelCase			,				UpperCamelCase = False			,				UpperCamelCase = False			,				UpperCamelCase = None			,				UpperCamelCase = False			,				UpperCamelCase = None			,				UpperCamelCase = None			,				UpperCamelCase = None			,				**UpperCamelCase			,				)     ->			BatchFeature:
						__lowerCAmelCase												=  isinstance(UpperCamelCase			,				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(UpperCamelCase			,				(list, tuple)     ) and (isinstance(speech[0]			,				(np.ndarray, tuple, list)     ))
						)

						if is_batched:
							__lowerCAmelCase												=  [np.asarray(UpperCamelCase			,				dtype=np.floataa     ) for speech in speech]
						elif not is_batched and not isinstance(UpperCamelCase			,				np.ndarray     ):
							__lowerCAmelCase												=  np.asarray(UpperCamelCase			,				dtype=np.floataa     )
						elif isinstance(UpperCamelCase			,				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(UpperCamelCase     ) for waveform in speech]
							__lowerCAmelCase												=  BatchFeature({"input_values": features}     )
							__lowerCAmelCase												=  self.num_mel_bins
						else:
							__lowerCAmelCase												=  BatchFeature({"input_values": speech}     )

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

						__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(UpperCamelCase			,				dtype=np.floataa     ) for array in input_values]
						elif (
						    not isinstance(UpperCamelCase			,				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(UpperCamelCase			,				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(UpperCamelCase			,				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(UpperCamelCase			,				max_length=UpperCamelCase     ) is not PaddingStrategy.DO_NOT_PAD
							    else None
							)
							__lowerCAmelCase												=  self.zero_mean_unit_var_norm(
							    padded_inputs["input_values"]			,				attention_mask=UpperCamelCase			,				padding_value=self.padding_value     )

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

						return padded_inputs



					def        UpperCAmelCase_ (    self     )     ->			Dict[str, Any]:
						__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




'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase	:		Union[str, Any]				=   {
    '''configuration_distilbert''': [
        '''DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''DistilBertConfig''',
        '''DistilBertOnnxConfig''',
    ],
    '''tokenization_distilbert''': ['''DistilBertTokenizer'''],
}

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCAmelCase	:		Tuple				=   ['''DistilBertTokenizerFast''']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCAmelCase	:		Tuple				=   [
	    '''DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''DistilBertForMaskedLM''',
	    '''DistilBertForMultipleChoice''',
	    '''DistilBertForQuestionAnswering''',
	    '''DistilBertForSequenceClassification''',
	    '''DistilBertForTokenClassification''',
	    '''DistilBertModel''',
	    '''DistilBertPreTrainedModel''',
	]

try:
	if not is_tf_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCAmelCase	:		List[str]				=   [
	    '''TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST''',
	    '''TFDistilBertForMaskedLM''',
	    '''TFDistilBertForMultipleChoice''',
	    '''TFDistilBertForQuestionAnswering''',
	    '''TFDistilBertForSequenceClassification''',
	    '''TFDistilBertForTokenClassification''',
	    '''TFDistilBertMainLayer''',
	    '''TFDistilBertModel''',
	    '''TFDistilBertPreTrainedModel''',
	]

try:
	if not is_flax_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	lowerCAmelCase	:		Optional[int]				=   [
	    '''FlaxDistilBertForMaskedLM''',
	    '''FlaxDistilBertForMultipleChoice''',
	    '''FlaxDistilBertForQuestionAnswering''',
	    '''FlaxDistilBertForSequenceClassification''',
	    '''FlaxDistilBertForTokenClassification''',
	    '''FlaxDistilBertModel''',
	    '''FlaxDistilBertPreTrainedModel''',
	]


if TYPE_CHECKING:
	from .configuration_distilbert import (
	    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
	    DistilBertConfig,
	    DistilBertOnnxConfig,
	)
	from .tokenization_distilbert import DistilBertTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_distilbert_fast import DistilBertTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_distilbert import (
		    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    DistilBertForMaskedLM,
		    DistilBertForMultipleChoice,
		    DistilBertForQuestionAnswering,
		    DistilBertForSequenceClassification,
		    DistilBertForTokenClassification,
		    DistilBertModel,
		    DistilBertPreTrainedModel,
		)

	try:
		if not is_tf_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_tf_distilbert import (
		    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFDistilBertForMaskedLM,
		    TFDistilBertForMultipleChoice,
		    TFDistilBertForQuestionAnswering,
		    TFDistilBertForSequenceClassification,
		    TFDistilBertForTokenClassification,
		    TFDistilBertMainLayer,
		    TFDistilBertModel,
		    TFDistilBertPreTrainedModel,
		)

	try:
		if not is_flax_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_flax_distilbert import (
		    FlaxDistilBertForMaskedLM,
		    FlaxDistilBertForMultipleChoice,
		    FlaxDistilBertForQuestionAnswering,
		    FlaxDistilBertForSequenceClassification,
		    FlaxDistilBertForTokenClassification,
		    FlaxDistilBertModel,
		    FlaxDistilBertPreTrainedModel,
		)

else:
	import sys

	lowerCAmelCase	:		List[str]				=   _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)