

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


lowerCamelCase			:				List[Any] 			=					logging.get_logger(__name__)







class 							A__   (	A__  ):
  A__					=    ['input_features', 'attention_mask']





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





       '''simple docstring'''






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





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





       '''simple docstring'''






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





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





       '''simple docstring'''






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

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

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

       return x





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





       '''simple docstring'''






       _SCREAMING_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(_a							, _a							, self.normalize_means							, self.normalize_vars							, self.padding_value			)
           for x, n in zip(_a							, _a			)
       ]





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

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

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

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

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

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

       _SCREAMING_SNAKE_CASE							   =self.pad(
           _a							, padding=_a							, max_length=_a							, truncation=_a							, pad_to_multiple_of=_a							, return_attention_mask=_a							, **_a							, )

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

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

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

       if return_tensors is not None:
            _SCREAMING_SNAKE_CASE							   =padded_inputs.convert_to_tensors(_a			)

       return padded_inputs



'''simple docstring'''
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCamelCase			:				List[str] 			=					{"configuration_ibert": ["IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP", "IBertConfig", "IBertOnnxConfig"]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     lowerCamelCase			:				Union[str, Any] 			=					[
         "IBERT_PRETRAINED_MODEL_ARCHIVE_LIST",
         "IBertForMaskedLM",
         "IBertForMultipleChoice",
         "IBertForQuestionAnswering",
         "IBertForSequenceClassification",
         "IBertForTokenClassification",
         "IBertModel",
         "IBertPreTrainedModel",
     ]

if TYPE_CHECKING:
     from .configuration_ibert import IBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, IBertConfig, IBertOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_ibert import (
              IBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
              IBertForMaskedLM,
              IBertForMultipleChoice,
              IBertForQuestionAnswering,
              IBertForSequenceClassification,
              IBertForTokenClassification,
              IBertModel,
              IBertPreTrainedModel,
          )

else:
     import sys

     lowerCamelCase			:				str 			=					_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
