




'''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_							:	List[Any]	     =		logging.get_logger(__name__)





class      lowerCAmelCase (			__lowerCAmelCase):
       __lowercase	:   str										=      ['''input_features''', '''attention_mask''']


       def __init__( self     ,	__SCREAMING_SNAKE_CASE=80     ,	__SCREAMING_SNAKE_CASE=1_6000     ,	__SCREAMING_SNAKE_CASE=80     ,	__SCREAMING_SNAKE_CASE=0.0     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=True     ,	**__SCREAMING_SNAKE_CASE     ,	)   ->	Optional[Any]:



            '''simple docstring'''




            super().__init__(feature_size=__SCREAMING_SNAKE_CASE     ,	sampling_rate=__SCREAMING_SNAKE_CASE     ,	padding_value=__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE	)
            __snake_case            =	num_mel_bins
            __snake_case            =	do_ceptral_normalize
            __snake_case            =	normalize_means
            __snake_case            =	normalize_vars
            __snake_case            =	True


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	)   ->	np.ndarray:



            '''simple docstring'''




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


       @staticmethod
       def    lowerCAmelCase   ( __SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = 0.0     ,	)   ->	np.ndarray:



            '''simple docstring'''




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

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

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

            return x


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = None	)   ->	List[np.ndarray]:



            '''simple docstring'''




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




       def __call__( self     ,	__SCREAMING_SNAKE_CASE     ,	__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     ,	)   ->	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            =	isinstance(__SCREAMING_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}'''	)
            __snake_case            =	is_batched_numpy or (
                isinstance(__SCREAMING_SNAKE_CASE     ,	(list, tuple)	) and (isinstance(raw_speech[0]     ,	(np.ndarray, tuple, list)	))
            )

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

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

            # extract fbank features
            __snake_case            =	[self._extract_fbank_features(__SCREAMING_SNAKE_CASE	) for waveform in raw_speech]

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

            __snake_case            =	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     ,	)

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

            __snake_case            =	padded_inputs.get('''attention_mask'''	)
            if attention_mask is not None:
                 __snake_case            =	[np.asarray(__SCREAMING_SNAKE_CASE     ,	dtype=np.intaa	) for array in attention_mask]

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

            if return_tensors is not None:
                 __snake_case            =	padded_inputs.convert_to_tensors(__SCREAMING_SNAKE_CASE	)

            return padded_inputs












'''simple docstring'''



from typing import Optional

import pyspark

from .. import Features, NamedSplit
from ..download import DownloadMode
from ..packaged_modules.spark.spark import Spark
from .abc import AbstractDatasetReader





class      lowerCAmelCase (			__lowerCAmelCase):


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = False     ,	__SCREAMING_SNAKE_CASE = None     ,	__SCREAMING_SNAKE_CASE = True     ,	__SCREAMING_SNAKE_CASE = "arrow"     ,	**__SCREAMING_SNAKE_CASE     ,	)   ->	Union[str, Any]:



            '''simple docstring'''




            super().__init__(
                split=__SCREAMING_SNAKE_CASE     ,	features=__SCREAMING_SNAKE_CASE     ,	cache_dir=__SCREAMING_SNAKE_CASE     ,	keep_in_memory=__SCREAMING_SNAKE_CASE     ,	streaming=__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE     ,	)
            __snake_case            =	load_from_cache_file
            __snake_case            =	file_format
            __snake_case            =	Spark(
                df=__SCREAMING_SNAKE_CASE     ,	features=__SCREAMING_SNAKE_CASE     ,	cache_dir=__SCREAMING_SNAKE_CASE     ,	working_dir=__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE     ,	)




       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            if self.streaming:
                 return self.builder.as_streaming_dataset(split=self.split	)
            __snake_case            =	None if self._load_from_cache_file else DownloadMode.FORCE_REDOWNLOAD
            self.builder.download_and_prepare(
                download_mode=__SCREAMING_SNAKE_CASE     ,	file_format=self._file_format     ,	)
            return self.builder.as_dataset(split=self.split	)






