


import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


SCREAMING_SNAKE_CASE__					:     List[str]       =     logging.get_logger(__name__)


class 		_SCREAMING_SNAKE_CASE     (						A     ):
     __SCREAMING_SNAKE_CASE     					=    ['''input_features''']


     def __init__(  self							,					A_=80							,					A_=1_60_00							,					A_=1_60							,					A_=30							,					A_=4_00							,					A_=0.0							,					A_=False							,					**A_							,					):
       super().__init__(
           feature_size=A_							,					sampling_rate=A_							,					padding_value=A_							,					return_attention_mask=A_							,					**A_							,					)
       _UpperCAmelCase		:							Optional[Any]							=     n_fft
       _UpperCAmelCase		:							Dict							=     hop_length
       _UpperCAmelCase		:							Union[str, Any]							=     chunk_length
       _UpperCAmelCase		:							List[Any]							=     chunk_length * sampling_rate
       _UpperCAmelCase		:							Any							=     self.n_samples // hop_length
       _UpperCAmelCase		:							Any							=     sampling_rate
       _UpperCAmelCase		:							Union[str, Any]							=     mel_filter_bank(
           num_frequency_bins=1 + n_fft // 2							,					num_mel_filters=A_							,					min_frequency=0.0							,					max_frequency=8_0_0_0.0							,					sampling_rate=A_							,					norm="""slaney"""							,					mel_scale="""slaney"""							,					)


     def        __snake_case(  self							,					A_    ):
       _UpperCAmelCase		:							int							=     spectrogram(
           A_							,					window_function(self.n_fft							,					"""hann"""    )							,					frame_length=self.n_fft							,					hop_length=self.hop_length							,					power=2.0							,					mel_filters=self.mel_filters							,					log_mel="""log10"""							,					)
       _UpperCAmelCase		:							Tuple							=     log_spec[:, :-1]
       _UpperCAmelCase		:							Union[str, Any]							=     np.maximum(A_							,					log_spec.max() - 8.0    )
       _UpperCAmelCase		:							Any							=     (log_spec + 4.0) / 4.0
       return log_spec


     @staticmethod
     # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
     def        __snake_case(  A_							,					A_							,					A_ = 0.0    ):
       if attention_mask is not None:
         _UpperCAmelCase		:							str							=     np.array(A_							,					np.intaa    )
         _UpperCAmelCase		:							Tuple							=     []

         for vector, length in zip(A_							,					attention_mask.sum(-1    )    ):
           _UpperCAmelCase		:							List[str]							=     (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7    )
           if length < normed_slice.shape[0]:
             _UpperCAmelCase		:							List[Any]							=     padding_value

           normed_input_values.append(A_    )
       else:
         _UpperCAmelCase		:							List[Any]							=     [(x - x.mean()) / np.sqrt(x.var() + 1e-7    ) for x in input_values]

       return normed_input_values


     def __call__(  self							,					A_							,					A_ = True							,					A_ = None							,					A_ = None							,					A_ = None							,					A_ = "max_length"							,					A_ = None							,					A_ = None							,					A_ = None							,					**A_							,					):

       if sampling_rate is not None:
         if sampling_rate != self.sampling_rate:
           raise ValueError(
               F'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
               F''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
               F''' was sampled with {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		:							Tuple							=     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}'''    )
       _UpperCAmelCase		:							str							=     is_batched_numpy or (
           isinstance(A_							,					(list, tuple)    ) and (isinstance(raw_speech[0]							,					(np.ndarray, tuple, list)    ))
       )

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

       # always return batch
       if not is_batched:
         _UpperCAmelCase		:							int							=     [np.asarray([raw_speech]    ).T]

       _UpperCAmelCase		:							List[Any]							=     BatchFeature({"""input_features""": raw_speech}    )

       # convert into correct format for padding

       _UpperCAmelCase		:							Dict							=     self.pad(
           A_							,					padding=A_							,					max_length=max_length if max_length else self.n_samples							,					truncation=A_							,					pad_to_multiple_of=A_							,					return_attention_mask=return_attention_mask or do_normalize							,					)

       # zero-mean and unit-variance normalization
       if do_normalize:
         _UpperCAmelCase		:							Union[str, Any]							=     self.zero_mean_unit_var_norm(
             padded_inputs["""input_features"""]							,					attention_mask=padded_inputs["""attention_mask"""]							,					padding_value=self.padding_value							,					)
         _UpperCAmelCase		:							str							=     np.stack(padded_inputs["""input_features"""]							,					axis=0    )

       # make sure list is in array format
       _UpperCAmelCase		:							Union[str, Any]							=     padded_inputs.get("""input_features"""    ).transpose(2							,					0							,					1    )

       _UpperCAmelCase		:							List[Any]							=     [self._np_extract_fbank_features(A_    ) for waveform in input_features[0]]

       if isinstance(input_features[0]							,					A_    ):
         _UpperCAmelCase		:							List[Any]							=     [np.asarray(A_							,					dtype=np.floataa    ) for feature in input_features]
       else:
         _UpperCAmelCase		:							Tuple							=     input_features

       if return_attention_mask:
         # rescale from sample (48000) to feature (3000)
         _UpperCAmelCase		:							Tuple							=     padded_inputs["""attention_mask"""][:, :: self.hop_length]

       if return_tensors is not None:
         _UpperCAmelCase		:							int							=     padded_inputs.convert_to_tensors(A_    )

       return padded_inputs




     def        __snake_case(  self    ):
       _UpperCAmelCase		:							Optional[Any]							=     copy.deepcopy(self.__dict__    )
       _UpperCAmelCase		:							Optional[Any]							=     self.__class__.__name__
       if "mel_filters" in output:
         del output["mel_filters"]
       return output









from __future__ import annotations

from typing import Dict

from ...configuration_utils import PretrainedConfig


SCREAMING_SNAKE_CASE__					:     List[Any]       =     {
    'susnato/ernie-m-base_pytorch': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/config.json',
    'susnato/ernie-m-large_pytorch': 'https://huggingface.co/susnato/ernie-m-large_pytorch/blob/main/config.json',
}


class 		_SCREAMING_SNAKE_CASE     (						A     ):
     __SCREAMING_SNAKE_CASE     					=    '''ernie_m'''
     __SCREAMING_SNAKE_CASE     					=    {"dropout": "classifier_dropout", "num_classes": "num_labels"}


     def __init__(  self							,					A_ = 25_00_02							,					A_ = 7_68							,					A_ = 12							,					A_ = 12							,					A_ = 30_72							,					A_ = "gelu"							,					A_ = 0.1							,					A_ = 0.1							,					A_ = 5_14							,					A_ = 0.0_2							,					A_ = 1							,					A_ = 1e-05							,					A_=None							,					A_=False							,					A_=0.0							,					**A_							,					):
       super().__init__(pad_token_id=A_							,					**A_    )
       _UpperCAmelCase		:							Tuple							=     vocab_size
       _UpperCAmelCase		:							List[str]							=     hidden_size
       _UpperCAmelCase		:							Optional[int]							=     num_hidden_layers
       _UpperCAmelCase		:							Tuple							=     num_attention_heads
       _UpperCAmelCase		:							Dict							=     intermediate_size
       _UpperCAmelCase		:							List[Any]							=     hidden_act
       _UpperCAmelCase		:							Any							=     hidden_dropout_prob
       _UpperCAmelCase		:							Any							=     attention_probs_dropout_prob
       _UpperCAmelCase		:							Tuple							=     max_position_embeddings
       _UpperCAmelCase		:							Dict							=     initializer_range
       _UpperCAmelCase		:							Optional[Any]							=     layer_norm_eps
       _UpperCAmelCase		:							str							=     classifier_dropout
       _UpperCAmelCase		:							Any							=     is_decoder
       _UpperCAmelCase		:							Union[str, Any]							=     act_dropout





