





'''simple docstring'''






from typing import List, Optional, Union

import numpy as np
import torch
import torchaudio.compliance.kaldi as ta_kaldi

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


__UpperCamelCase					    =	logging.get_logger(__name__)




class  _A (					__lowercase		):
		lowercase__:   Optional[int]				     =   ['''input_features''', '''attention_mask''']

		def __init__(   self					:   Union[str, Any]  ,      __magic_name__					:   str=80  ,      __magic_name__					:   Any=1_60_00  ,      __magic_name__					:   Dict=80  ,      __magic_name__					:   Optional[int]=0.0  ,      __magic_name__					:   List[str]=True  ,      __magic_name__					:   List[Any]=True  ,      __magic_name__					:   Optional[int]=True  ,      **__magic_name__					:   int  ,      )					->    Optional[Any]:


					"""simple docstring"""

					super().__init__(feature_size=__magic_name__  ,      sampling_rate=__magic_name__  ,      padding_value=__magic_name__  ,      **__magic_name__			)
					__snake_case					:      Optional[int]							      =     num_mel_bins
					__snake_case					:      int							      =     do_ceptral_normalize
					__snake_case					:      Union[str, Any]							      =     normalize_means
					__snake_case					:      Dict							      =     normalize_vars
					__snake_case					:      Union[str, Any]							      =     True

		def 	lowercase__     (   self					:   Dict  ,      __magic_name__					:   np.ndarray  ,      )					->    np.ndarray:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
					__snake_case					:      Union[str, Any]							      =     torch.from_numpy(__magic_name__			).unsqueeze(0			)
					__snake_case					:      Any							      =     ta_kaldi.fbank(__magic_name__  ,      num_mel_bins=self.num_mel_bins  ,      sample_frequency=self.sampling_rate			)
					return features.numpy()

		@staticmethod
		def 	lowercase__     (   __magic_name__					:   np.ndarray  ,      __magic_name__					:   int  ,      __magic_name__					:   Optional[bool] = True  ,      __magic_name__					:   Optional[bool] = True  ,      __magic_name__					:   float = 0.0  ,      )					->    np.ndarray:


					"""simple docstring"""

					if normalize_means:
								__snake_case					:      Optional[Any]							      =     x[:input_length].mean(axis=0			)
								__snake_case					:      Tuple							      =     np.subtract(__magic_name__  ,      __magic_name__			)
					if normalize_vars:
								__snake_case					:      Optional[Any]							      =     x[:input_length].std(axis=0			)
								__snake_case					:      Tuple							      =     np.divide(__magic_name__  ,      __magic_name__			)

					if input_length < x.shape[0]:
								__snake_case					:      Optional[Any]							      =     padding_value

					# make sure array is in float32
					__snake_case					:      Union[str, Any]							      =     x.astype(np.floataa			)

					return x

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


					"""simple docstring"""

					__snake_case					:      Union[str, Any]							      =     attention_mask.sum(-1			) if attention_mask is not None else [x.shape[0] for x in input_features]
					return [
					    self.utterance_cmvn(__magic_name__  ,      __magic_name__  ,      self.normalize_means  ,      self.normalize_vars  ,      self.padding_value			)
					    for x, n in zip(__magic_name__  ,      __magic_name__			)
					]

		def __call__(   self					:   Optional[int]  ,      __magic_name__					:   Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]  ,      __magic_name__					:   Union[bool, str, PaddingStrategy] = False  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   bool = False  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   Optional[Union[str, TensorType]] = None  ,      __magic_name__					:   Optional[int] = None  ,      __magic_name__					:   Optional[bool] = None  ,      **__magic_name__					:   Dict  ,      )					->    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."""			)

					__snake_case					:      Any							      =     isinstance(__magic_name__  ,      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}'''			)
					__snake_case					:      Dict							      =     is_batched_numpy or (
					    isinstance(__magic_name__  ,      (list, tuple)			) and (isinstance(raw_speech[0]  ,      (np.ndarray, tuple, list)			))
					)

					if is_batched:
								__snake_case					:      Optional[int]							      =     [np.asarray(__magic_name__  ,      dtype=np.floataa			) for speech in raw_speech]
					elif not is_batched and not isinstance(__magic_name__  ,      np.ndarray			):
								__snake_case					:      str							      =     np.asarray(__magic_name__  ,      dtype=np.floataa			)
					elif isinstance(__magic_name__  ,      np.ndarray			) and raw_speech.dtype is np.dtype(np.floataa			):
								__snake_case					:      Optional[Any]							      =     raw_speech.astype(np.floataa			)

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

					# extract fbank features
					__snake_case					:      Optional[int]							      =     [self._extract_fbank_features(__magic_name__			) for waveform in raw_speech]

					# convert into correct format for padding
					__snake_case					:      List[str]							      =     BatchFeature({"""input_features""": features}			)

					__snake_case					:      Optional[Any]							      =     self.pad(
					    __magic_name__  ,      padding=__magic_name__  ,      max_length=__magic_name__  ,      truncation=__magic_name__  ,      pad_to_multiple_of=__magic_name__  ,      return_attention_mask=__magic_name__  ,      **__magic_name__  ,      )

					# make sure list is in array format
					__snake_case					:      List[Any]							      =     padded_inputs.get("""input_features"""			)
					if isinstance(input_features[0]  ,      __magic_name__			):
								__snake_case					:      Dict							      =     [np.asarray(__magic_name__  ,      dtype=np.floataa			) for feature in input_features]

					__snake_case					:      Optional[Any]							      =     padded_inputs.get("""attention_mask"""			)
					if attention_mask is not None:
								__snake_case					:      Union[str, Any]							      =     [np.asarray(__magic_name__  ,      dtype=np.intaa			) for array in attention_mask]

					# Utterance-level cepstral mean and variance normalization
					if self.do_ceptral_normalize:
								__snake_case					:      List[Any]							      =     (
								    np.array(__magic_name__  ,      dtype=np.intaa			)
								    if self._get_padding_strategies(__magic_name__  ,      max_length=__magic_name__			) is not PaddingStrategy.DO_NOT_PAD
								    else None
								)
								__snake_case					:      int							      =     self.normalize(
								    padded_inputs["""input_features"""]  ,      attention_mask=__magic_name__			)

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

					return padded_inputs





"""simple docstring"""
from .glue import glue_convert_examples_to_features, glue_output_modes, glue_processors, glue_tasks_num_labels
from .squad import SquadExample, SquadFeatures, SquadVaProcessor, SquadVaProcessor, squad_convert_examples_to_features
from .utils import DataProcessor, InputExample, InputFeatures, SingleSentenceClassificationProcessor
from .xnli import xnli_output_modes, xnli_processors, xnli_tasks_num_labels

