

import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase_									=   logging.get_logger(__name__)

lowercase_									=   {
    'asapp/sew-tiny-100k': 'https://huggingface.co/asapp/sew-tiny-100k/resolve/main/config.json',
    # See all SEW models at https://huggingface.co/models?filter=sew
}





class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE							):
  _a									=  """sew"""




  def __init__(				self							,   lowerCAmelCase=32							,   lowerCAmelCase=768							,   lowerCAmelCase=12							,   lowerCAmelCase=12							,   lowerCAmelCase=3_072							,   lowerCAmelCase=2							,   lowerCAmelCase="gelu"							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.0							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.1							,   lowerCAmelCase=0.02							,   lowerCAmelCase=1e-5							,   lowerCAmelCase="group"							,   lowerCAmelCase="gelu"							,   lowerCAmelCase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)							,   lowerCAmelCase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)							,   lowerCAmelCase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)							,   lowerCAmelCase=False							,   lowerCAmelCase=128							,   lowerCAmelCase=16							,   lowerCAmelCase=True							,   lowerCAmelCase=0.05							,   lowerCAmelCase=10							,   lowerCAmelCase=2							,   lowerCAmelCase=0.0							,   lowerCAmelCase=10							,   lowerCAmelCase=0							,   lowerCAmelCase="mean"							,   lowerCAmelCase=False							,   lowerCAmelCase=False							,   lowerCAmelCase=256							,   lowerCAmelCase=0							,   lowerCAmelCase=1							,   lowerCAmelCase=2							,   **lowerCAmelCase							,   )  -> Dict:
        '''simple docstring'''






        super().__init__(**lowerCAmelCase							,   pad_token_id=lowerCAmelCase							,   bos_token_id=lowerCAmelCase							,   eos_token_id=lowerCAmelCase					)
        _lowercase	       =hidden_size
        _lowercase	       =feat_extract_norm
        _lowercase	       =feat_extract_activation
        _lowercase	       =list(lowerCAmelCase					)
        _lowercase	       =list(lowerCAmelCase					)
        _lowercase	       =list(lowerCAmelCase					)
        _lowercase	       =conv_bias
        _lowercase	       =num_conv_pos_embeddings
        _lowercase	       =num_conv_pos_embedding_groups
        _lowercase	       =len(self.conv_dim					)
        _lowercase	       =num_hidden_layers
        _lowercase	       =intermediate_size
        _lowercase	       =squeeze_factor
        _lowercase	       =hidden_act
        _lowercase	       =num_attention_heads
        _lowercase	       =hidden_dropout
        _lowercase	       =attention_dropout
        _lowercase	       =activation_dropout
        _lowercase	       =feat_proj_dropout
        _lowercase	       =final_dropout
        _lowercase	       =layerdrop
        _lowercase	       =layer_norm_eps
        _lowercase	       =initializer_range
        _lowercase	       =vocab_size

        if (
            (len(self.conv_stride					) != self.num_feat_extract_layers)
            or (len(self.conv_kernel					) != self.num_feat_extract_layers)
            or (len(self.conv_dim					) != self.num_feat_extract_layers)
        ):
              raise ValueError(
                  'Configuration for convolutional layers is incorrect.'
                  'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
                  F'''but is `len(config.conv_dim) = {len(self.conv_dim					)}`, `len(config.conv_stride)'''
                  F'''= {len(self.conv_stride					)}`, `len(config.conv_kernel) = {len(self.conv_kernel					)}`.'''					)

        # fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
        _lowercase	       =apply_spec_augment
        _lowercase	       =mask_time_prob
        _lowercase	       =mask_time_length
        _lowercase	       =mask_time_min_masks
        _lowercase	       =mask_feature_prob
        _lowercase	       =mask_feature_length
        _lowercase	       =mask_feature_min_masks

        # ctc loss
        _lowercase	       =ctc_loss_reduction
        _lowercase	       =ctc_zero_infinity

        # sequence classification
        _lowercase	       =use_weighted_layer_sum
        _lowercase	       =classifier_proj_size




  @property
  def   A__     (				self					)  -> int:
        '''simple docstring'''






        return functools.reduce(operator.mul							,   self.conv_stride							,   1					)





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


lowercase_									=   logging.get_logger(__name__)





class  __lowerCAmelCase     (					SCREAMING_SNAKE_CASE							):
  _a									=  ["""input_features"""]




  def __init__(				self							,   lowerCAmelCase=80							,   lowerCAmelCase=16_000							,   lowerCAmelCase=160							,   lowerCAmelCase=30							,   lowerCAmelCase=400							,   lowerCAmelCase=0.0							,   lowerCAmelCase=False							,   **lowerCAmelCase							,   )  -> Any:
        '''simple docstring'''






        super().__init__(
            feature_size=lowerCAmelCase							,   sampling_rate=lowerCAmelCase							,   padding_value=lowerCAmelCase							,   return_attention_mask=lowerCAmelCase							,   **lowerCAmelCase							,   )
        _lowercase	       =n_fft
        _lowercase	       =hop_length
        _lowercase	       =chunk_length
        _lowercase	       =chunk_length * sampling_rate
        _lowercase	       =self.n_samples // hop_length
        _lowercase	       =sampling_rate
        _lowercase	       =mel_filter_bank(
            num_frequency_bins=1 + n_fft // 2							,   num_mel_filters=lowerCAmelCase							,   min_frequency=0.0							,   max_frequency=8000.0							,   sampling_rate=lowerCAmelCase							,   norm='slaney'							,   mel_scale='slaney'							,   )




  def   A__     (				self							,   lowerCAmelCase					)  -> np.ndarray:
        '''simple docstring'''






        _lowercase	       =spectrogram(
            lowerCAmelCase							,   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'							,   )
        _lowercase	       =log_spec[:, :-1]
        _lowercase	       =np.maximum(lowerCAmelCase							,   log_spec.max() - 8.0					)
        _lowercase	       =(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   A__     (				lowerCAmelCase							,   lowerCAmelCase							,   lowerCAmelCase = 0.0					)  -> List[np.ndarray]:
        '''simple docstring'''






        if attention_mask is not None:
              _lowercase	       =np.array(lowerCAmelCase							,   np.intaa					)
              _lowercase	       =[]

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

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

        return normed_input_values




  def __call__(				self							,   lowerCAmelCase							,   lowerCAmelCase = True							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = "max_length"							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   lowerCAmelCase = None							,   **lowerCAmelCase							,   )  -> 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.__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.'					)

        _lowercase	       =isinstance(lowerCAmelCase							,   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(lowerCAmelCase							,   (list, tuple)					) and (isinstance(raw_speech[0]							,   (np.ndarray, tuple, list)					))
        )

        if is_batched:
              _lowercase	       =[np.asarray([speech]							,   dtype=np.floataa					).T for speech in raw_speech]
        elif not is_batched and not isinstance(lowerCAmelCase							,   np.ndarray					):
              _lowercase	       =np.asarray(lowerCAmelCase							,   dtype=np.floataa					)
        elif isinstance(lowerCAmelCase							,   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	       =[np.asarray([raw_speech]					).T]

        _lowercase	       =BatchFeature({'input_features': raw_speech}					)

        # convert into correct format for padding

        _lowercase	       =self.pad(
            lowerCAmelCase							,   padding=lowerCAmelCase							,   max_length=max_length if max_length else self.n_samples							,   truncation=lowerCAmelCase							,   pad_to_multiple_of=lowerCAmelCase							,   return_attention_mask=return_attention_mask or do_normalize							,   )

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

        # make sure list is in array format
        _lowercase	       =padded_inputs.get('input_features'					).transpose(2							,   0							,   1					)

        _lowercase	       =[self._np_extract_fbank_features(lowerCAmelCase					) for waveform in input_features[0]]

        if isinstance(input_features[0]							,   lowerCAmelCase					):
              _lowercase	       =[np.asarray(lowerCAmelCase							,   dtype=np.floataa					) for feature in input_features]
        else:
              _lowercase	       =input_features

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

        if return_tensors is not None:
              _lowercase	       =padded_inputs.convert_to_tensors(lowerCAmelCase					)

        return padded_inputs




  def   A__     (				self					)  -> Dict[str, Any]:
        '''simple docstring'''






        _lowercase	       =copy.deepcopy(self.__dict__					)
        _lowercase	       =self.__class__.__name__
        if "mel_filters" in output:
              del output["mel_filters"]
        return output


