


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


lowerCAmelCase			=				logging.get_logger(__name__)


class 			_a				(     UpperCamelCase__     ):
							_lowercase      :     Any     =					['''input_features''', '''attention_mask''']

							def __init__(				self:      Dict       ,		UpperCamelCase_:      str=80       ,		UpperCamelCase_:      Any=16_000       ,		UpperCamelCase_:      Union[str, Any]=80       ,		UpperCamelCase_:      List[str]=0.0       ,		UpperCamelCase_:      int=True       ,		UpperCamelCase_:      Optional[Any]=True       ,		UpperCamelCase_:      Optional[Any]=True       ,		**UpperCamelCase_:      List[str]       ,		)     ->  int:





									"""simple docstring"""







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

							def  lowerCamelCase_					(				self:      Union[str, Any]       ,		UpperCamelCase_:      np.ndarray       ,		)     ->  np.ndarray:





									"""simple docstring"""







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

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





									"""simple docstring"""







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

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

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

									return x

							def  lowerCamelCase_					(				self:      int       ,		UpperCamelCase_:      List[np.ndarray]       ,		UpperCamelCase_:      Optional[np.ndarray] = None				)     ->  List[np.ndarray]:





									"""simple docstring"""







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


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

									lowercase__				= isinstance(UpperCamelCase_       ,		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}'				)
									lowercase__				= is_batched_numpy or (
									    isinstance(UpperCamelCase_       ,		(list, tuple)				) and (isinstance(raw_speech[0]       ,		(np.ndarray, tuple, list)				))
									)

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

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

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

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

									lowercase__				= self.pad(
									    UpperCamelCase_       ,		padding=UpperCamelCase_       ,		max_length=UpperCamelCase_       ,		truncation=UpperCamelCase_       ,		pad_to_multiple_of=UpperCamelCase_       ,		return_attention_mask=UpperCamelCase_       ,		**UpperCamelCase_       ,		)

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

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

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

									if return_tensors is not None:
											lowercase__				= padded_inputs.convert_to_tensors(UpperCamelCase_				)

									return padded_inputs








import warnings

from ...utils import logging
from .image_processing_layoutlmva import LayoutLMvaImageProcessor


lowerCamelCase__					:  Union[str, Any]      							=				logging.get_logger(__name__)





class 			lowerCamelCase_				( _SCREAMING_SNAKE_CASE   ):


 '''simple docstring'''







 def __init__(				self    :						Dict							,							*_lowerCAmelCase    :						Optional[Any]							,							**_lowerCAmelCase    :						Any		):
       warnings.warn(
           'The class LayoutLMv2FeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
           ' Please use LayoutLMv2ImageProcessor instead.'							,							_lowerCAmelCase							,							)
       super().__init__(*_lowerCAmelCase							,							**_lowerCAmelCase		)