



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


A:   str								=		logging.get_logger(__name__)



class       SCREAMING_SNAKE_CASE__  (					UpperCAmelCase__ ):
   __lowerCAmelCase  :   Optional[Any]						=						['input_features', 'attention_mask']

   def __init__(   self      ,     _SCREAMING_SNAKE_CASE=80      ,     _SCREAMING_SNAKE_CASE=16000      ,     _SCREAMING_SNAKE_CASE=80      ,     _SCREAMING_SNAKE_CASE=0.0      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     _SCREAMING_SNAKE_CASE=True      ,     **_SCREAMING_SNAKE_CASE      ,     )  ->      Dict:





    '''simple docstring'''




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

   def 	SCREAMING_SNAKE_CASE     (   self      ,     _SCREAMING_SNAKE_CASE      ,     )  ->      np.ndarray:





    '''simple docstring'''




    UpperCAmelCase	:					Optional[int]	=	waveform * (2**15)  # Kaldi compliance: 16-bit signed integers
    UpperCAmelCase	:					List[Any]	=	torch.from_numpy(_SCREAMING_SNAKE_CASE						).unsqueeze(0						)
    UpperCAmelCase	:					Dict	=	ta_kaldi.fbank(_SCREAMING_SNAKE_CASE      ,     num_mel_bins=self.num_mel_bins      ,     sample_frequency=self.sampling_rate						)
    return features.numpy()

   @staticmethod
   def 	SCREAMING_SNAKE_CASE     (   _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:
     UpperCAmelCase	:					Tuple	=	x[:input_length].mean(axis=0						)
     UpperCAmelCase	:					Optional[Any]	=	np.subtract(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)
    if normalize_vars:
     UpperCAmelCase	:					Tuple	=	x[:input_length].std(axis=0						)
     UpperCAmelCase	:					Dict	=	np.divide(_SCREAMING_SNAKE_CASE      ,     _SCREAMING_SNAKE_CASE						)

    if input_length < x.shape[0]:
     UpperCAmelCase	:					Optional[int]	=	padding_value

    # make sure array is in float32
    UpperCAmelCase	:					Any	=	x.astype(np.floataa						)

    return x

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





    '''simple docstring'''




    UpperCAmelCase	:					Any	=	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."""						)

    UpperCAmelCase	:					Union[str, Any]	=	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}"						)
    UpperCAmelCase	:					Union[str, Any]	=	is_batched_numpy or (
        isinstance(_SCREAMING_SNAKE_CASE      ,     (list, tuple)						) and (isinstance(raw_speech[0]      ,     (np.ndarray, tuple, list)						))
    )

    if is_batched:
     UpperCAmelCase	:					Any	=	[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						):
     UpperCAmelCase	:					Union[str, Any]	=	np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.floataa						)
    elif isinstance(_SCREAMING_SNAKE_CASE      ,     np.ndarray						) and raw_speech.dtype is np.dtype(np.floataa						):
     UpperCAmelCase	:					Tuple	=	raw_speech.astype(np.floataa						)

    # always return batch
    if not is_batched:
     UpperCAmelCase	:					List[str]	=	[raw_speech]

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

    # convert into correct format for padding
    UpperCAmelCase	:					Optional[Any]	=	BatchFeature({"""input_features""": features}						)

    UpperCAmelCase	:					Tuple	=	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
    UpperCAmelCase	:					str	=	padded_inputs.get("""input_features"""						)
    if isinstance(input_features[0]      ,     _SCREAMING_SNAKE_CASE						):
     UpperCAmelCase	:					Optional[int]	=	[np.asarray(_SCREAMING_SNAKE_CASE      ,     dtype=np.floataa						) for feature in input_features]

    UpperCAmelCase	:					Optional[Any]	=	padded_inputs.get("""attention_mask"""						)
    if attention_mask is not None:
     UpperCAmelCase	:					int	=	[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:
     UpperCAmelCase	:					List[str]	=	(
         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
     )
     UpperCAmelCase	:					Optional[int]	=	self.normalize(
         padded_inputs["""input_features"""]      ,     attention_mask=_SCREAMING_SNAKE_CASE						)

    if return_tensors is not None:
     UpperCAmelCase	:					List[str]	=	padded_inputs.convert_to_tensors(_SCREAMING_SNAKE_CASE						)

    return padded_inputs





"""simple docstring"""
from typing import TYPE_CHECKING

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


__a      =				{
    "configuration_mobilebert": [
        "MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "MobileBertConfig",
        "MobileBertOnnxConfig",
    ],
    "tokenization_mobilebert": ["MobileBertTokenizer"],
}

try:
						if not is_tokenizers_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a      =				["MobileBertTokenizerFast"]

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a      =				[
						    "MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "MobileBertForMaskedLM",
						    "MobileBertForMultipleChoice",
						    "MobileBertForNextSentencePrediction",
						    "MobileBertForPreTraining",
						    "MobileBertForQuestionAnswering",
						    "MobileBertForSequenceClassification",
						    "MobileBertForTokenClassification",
						    "MobileBertLayer",
						    "MobileBertModel",
						    "MobileBertPreTrainedModel",
						    "load_tf_weights_in_mobilebert",
						]

try:
						if not is_tf_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						__a      =				[
						    "TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "TFMobileBertForMaskedLM",
						    "TFMobileBertForMultipleChoice",
						    "TFMobileBertForNextSentencePrediction",
						    "TFMobileBertForPreTraining",
						    "TFMobileBertForQuestionAnswering",
						    "TFMobileBertForSequenceClassification",
						    "TFMobileBertForTokenClassification",
						    "TFMobileBertMainLayer",
						    "TFMobileBertModel",
						    "TFMobileBertPreTrainedModel",
						]


if TYPE_CHECKING:
						from .configuration_mobilebert import (
						    MOBILEBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    MobileBertConfig,
						    MobileBertOnnxConfig,
						)
						from .tokenization_mobilebert import MobileBertTokenizer

						try:
												if not is_tokenizers_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .tokenization_mobilebert_fast import MobileBertTokenizerFast

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_mobilebert import (
												    MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    MobileBertForMaskedLM,
												    MobileBertForMultipleChoice,
												    MobileBertForNextSentencePrediction,
												    MobileBertForPreTraining,
												    MobileBertForQuestionAnswering,
												    MobileBertForSequenceClassification,
												    MobileBertForTokenClassification,
												    MobileBertLayer,
												    MobileBertModel,
												    MobileBertPreTrainedModel,
												    load_tf_weights_in_mobilebert,
												)

						try:
												if not is_tf_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_tf_mobilebert import (
												    TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
												    TFMobileBertForMaskedLM,
												    TFMobileBertForMultipleChoice,
												    TFMobileBertForNextSentencePrediction,
												    TFMobileBertForPreTraining,
												    TFMobileBertForQuestionAnswering,
												    TFMobileBertForSequenceClassification,
												    TFMobileBertForTokenClassification,
												    TFMobileBertMainLayer,
												    TFMobileBertModel,
												    TFMobileBertPreTrainedModel,
												)

else:
						import sys

						__a      =				_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
