code: 
  
  from typing import List, Optional, Union
  
  import numpy as np
  
  from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
  from ...feature_extraction_utils import BatchFeature
  from ...utils import PaddingStrategy, TensorType, logging
  
  
  __A   :     Any      =			logging.get_logger(__name__)
  
  
  
  
  
  
  class    __A				(							lowerCAmelCase ):
      lowerCAmelCase_							:		str						=							["input_values", "attention_mask"]
  
  
  
  
  
  
      def __init__(	self			:    str    ,				UpperCAmelCase_			:    str=1    ,				UpperCAmelCase_			:    List[str]=16000    ,				UpperCAmelCase_			:    Dict=0.0    ,				UpperCAmelCase_			:    Union[str, Any]=False    ,				UpperCAmelCase_			:    int=True    ,				**UpperCAmelCase_			:    Any    ,				):
          super().__init__(feature_size=UpperCAmelCase_    ,				sampling_rate=UpperCAmelCase_    ,				padding_value=UpperCAmelCase_    ,				**UpperCAmelCase_    )
          lowerCAmelCase				:			Optional[Any]    			=      return_attention_mask
          lowerCAmelCase				:			List[str]    			=      do_normalize
  
  
  
  
  
  
      @staticmethod
      def 	lowercase__ (	UpperCAmelCase_			:    List[np.ndarray]    ,				UpperCAmelCase_			:    List[np.ndarray]    ,				UpperCAmelCase_			:    float = 0.0    ):
          if attention_mask is not None:
              lowerCAmelCase				:			int    			=      np.array(UpperCAmelCase_    ,				np.intaa    )
              lowerCAmelCase				:			List[Any]    			=      []
  
              for vector, length in zip(UpperCAmelCase_    ,				attention_mask.sum(-1    )    ):
                  lowerCAmelCase				:			List[str]    			=      (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1E-7    )
                  if length < normed_slice.shape[0]:
                      lowerCAmelCase				:			List[Any]    			=      padding_value
  
                  normed_input_values.append(UpperCAmelCase_    )
          else:
              lowerCAmelCase				:			int    			=      [(x - x.mean()) / np.sqrt(x.var() + 1E-7    ) for x in input_values]
  
          return normed_input_values
  
  
  
  
  
  
      def __call__(	self			:    Optional[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[bool] = None    ,				UpperCAmelCase_			:    Optional[Union[str, TensorType]] = None    ,				UpperCAmelCase_			:    Optional[int] = None    ,				**UpperCAmelCase_			:    int    ,				):
  
          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.'    )
  
          lowerCAmelCase				:			Union[str, Any]    			=      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}"    )
          lowerCAmelCase				:			str    			=      is_batched_numpy or (
              isinstance(UpperCAmelCase_    ,				(list, tuple)    ) and (isinstance(raw_speech[0]    ,				(np.ndarray, tuple, list)    ))
          )
  
          # always return batch
          if not is_batched:
              lowerCAmelCase				:			Union[str, Any]    			=      [raw_speech]
  
          # convert into correct format for padding
          lowerCAmelCase				:			List[str]    			=      BatchFeature({'input_values': raw_speech}    )
  
          lowerCAmelCase				:			Tuple    			=      self.pad(
              UpperCAmelCase_    ,				padding=UpperCAmelCase_    ,				max_length=UpperCAmelCase_    ,				truncation=UpperCAmelCase_    ,				pad_to_multiple_of=UpperCAmelCase_    ,				return_attention_mask=UpperCAmelCase_    ,				)
  
          # convert input values to correct format
          lowerCAmelCase				:			Optional[int]    			=      padded_inputs['input_values']
          if not isinstance(input_values[0]    ,				np.ndarray    ):
              lowerCAmelCase				:			Dict    			=      [np.asarray(UpperCAmelCase_    ,				dtype=np.floataa    ) for array in input_values]
          elif (
              not isinstance(UpperCAmelCase_    ,				np.ndarray    )
              and isinstance(input_values[0]    ,				np.ndarray    )
              and input_values[0].dtype is np.dtype(np.floataa    )
          ):
              lowerCAmelCase				:			int    			=      [array.astype(np.floataa    ) for array in input_values]
          elif isinstance(UpperCAmelCase_    ,				np.ndarray    ) and input_values.dtype is np.dtype(np.floataa    ):
              lowerCAmelCase				:			int    			=      input_values.astype(np.floataa    )
  
          # convert attention_mask to correct format
          lowerCAmelCase				:			List[Any]    			=      padded_inputs.get('attention_mask'    )
          if attention_mask is not None:
              lowerCAmelCase				:			Tuple    			=      [np.asarray(UpperCAmelCase_    ,				dtype=np.intaa    ) for array in attention_mask]
  
          # zero-mean and unit-variance normalization
          if self.do_normalize:
              lowerCAmelCase				:			Optional[int]    			=      (
                  attention_mask
                  if self._get_padding_strategies(UpperCAmelCase_    ,				max_length=UpperCAmelCase_    ) is not PaddingStrategy.DO_NOT_PAD
                  else None
              )
              lowerCAmelCase				:			Tuple    			=      self.zero_mean_unit_var_norm(
                  padded_inputs['input_values']    ,				attention_mask=UpperCAmelCase_    ,				padding_value=self.padding_value    )
  
          if return_tensors is not None:
              lowerCAmelCase				:			str    			=      padded_inputs.convert_to_tensors(UpperCAmelCase_    )
  
          return padded_inputs
  
  
  
  
  
  
style_context: 
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  __A   :     List[Any]      =			{'''configuration_umt5''': ['''UMT5Config''', '''UMT5OnnxConfig''']}
  
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   __A   :     Tuple      =			[
       '''UMT5EncoderModel''',
       '''UMT5ForConditionalGeneration''',
       '''UMT5ForQuestionAnswering''',
       '''UMT5Model''',
       '''UMT5PreTrainedModel''',
   ]
  
  if TYPE_CHECKING:
   from .configuration_umta import UMTaConfig, UMTaOnnxConfig
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_umta import (
        UMTaEncoderModel,
        UMTaForConditionalGeneration,
        UMTaForQuestionAnswering,
        UMTaModel,
        UMTaPreTrainedModel,
    )
  else:
   import sys
  
   __A   :     Any      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
  
  
  
  
  
  