class_docstr: Constructs a Wav2Vec2 feature extractor.
  
  This feature extractor inherits from [`~feature_extraction_sequence_utils.SequenceFeatureExtractor`] which contains
  most of the main methods. Users should refer to this superclass for more information regarding those methods.
  
  Args:
      feature_size (`int`, defaults to 1):
          The feature dimension of the extracted features.
      sampling_rate (`int`, defaults to 16000):
          The sampling rate at which the audio files should be digitalized expressed in hertz (Hz).
      padding_value (`float`, defaults to 0.0):
          The value that is used to fill the padding values.
      do_normalize (`bool`, *optional*, defaults to `True`):
          Whether or not to zero-mean unit-variance normalize the input. Normalizing can help to significantly
          improve the performance for some models, *e.g.*,
          [wav2vec2-lv60](https://huggingface.co/models?search=lv60).
      return_attention_mask (`bool`, *optional*, defaults to `False`):
          Whether or not [`~Wav2Vec2FeatureExtractor.__call__`] should return `attention_mask`.
  
          <Tip>
  
          Wav2Vec2 models that have set `config.feat_extract_norm == "group"`, such as
          [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), have **not** been trained using
          `attention_mask`. For such models, `input_values` should simply be padded with 0 and no `attention_mask`
          should be passed.
  
          For Wav2Vec2 models that have set `config.feat_extract_norm == "layer"`, such as
          [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` should be
          passed for batched inference.
  
          </Tip>
docstr: Main method to featurize and prepare for the model one or several sequence(s).
  
  Args:
      raw_speech (`np.ndarray`, `List[float]`, `List[np.ndarray]`, `List[List[float]]`):
          The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float
          values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not
          stereo, i.e. single float per timestep.
      padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
          Select a strategy to pad the returned sequences (according to the model's padding side and padding
          index) among:
  
          - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
            sequence if provided).
          - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
            acceptable input length for the model if that argument is not provided.
          - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
            lengths).
      max_length (`int`, *optional*):
          Maximum length of the returned list and optionally padding length (see above).
      truncation (`bool`):
          Activates truncation to cut input sequences longer than *max_length* to *max_length*.
      pad_to_multiple_of (`int`, *optional*):
          If set will pad the sequence to a multiple of the provided value.
  
          This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
          `>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
      return_attention_mask (`bool`, *optional*):
          Whether to return the attention mask. If left to the default, will return the attention mask according
          to the specific feature_extractor's default.
  
          [What are attention masks?](../glossary#attention-mask)
  
          <Tip>
  
          Wav2Vec2 models that have set `config.feat_extract_norm == "group"`, such as
          [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), have **not** been trained using
          `attention_mask`. For such models, `input_values` should simply be padded with 0 and no
          `attention_mask` should be passed.
  
          For Wav2Vec2 models that have set `config.feat_extract_norm == "layer"`, such as
          [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` should
          be passed for batched inference.
  
          </Tip>
  
      return_tensors (`str` or [`~utils.TensorType`], *optional*):
          If set, will return tensors instead of list of python integers. Acceptable values are:
  
          - `'tf'`: Return TensorFlow `tf.constant` objects.
          - `'pt'`: Return PyTorch `torch.Tensor` objects.
          - `'np'`: Return Numpy `np.ndarray` objects.
      sampling_rate (`int`, *optional*):
          The sampling rate at which the `raw_speech` input was sampled. It is strongly recommended to pass
          `sampling_rate` at the forward call to prevent silent errors.
      padding_value (`float`, defaults to 0.0):
code: def __call__(
      self,
      raw_speech: Union[
          np.ndarray, List[float], List[np.ndarray], List[List[float]]
      ],
      padding: Union[bool, str, PaddingStrategy] = False,
      max_length: Optional[int] = None,
      truncation: bool = False,
      pad_to_multiple_of: Optional[int] = None,
      return_attention_mask: Optional[bool] = None,
      return_tensors: Optional[Union[str, TensorType]] = None,
      sampling_rate: Optional[int] = None,
      **kwargs,
  ) -> BatchFeature:
      """
      Main method to featurize and prepare for the model one or several sequence(s).
  
      Args:
          raw_speech (`np.ndarray`, `List[float]`, `List[np.ndarray]`, `List[List[float]]`):
              The sequence or batch of sequences to be padded. Each sequence can be a numpy array, a list of float
              values, a list of numpy arrays or a list of list of float values. Must be mono channel audio, not
              stereo, i.e. single float per timestep.
          padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):
              Select a strategy to pad the returned sequences (according to the model's padding side and padding
              index) among:
  
              - `True` or `'longest'`: Pad to the longest sequence in the batch (or no padding if only a single
                sequence if provided).
              - `'max_length'`: Pad to a maximum length specified with the argument `max_length` or to the maximum
                acceptable input length for the model if that argument is not provided.
              - `False` or `'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of different
                lengths).
          max_length (`int`, *optional*):
              Maximum length of the returned list and optionally padding length (see above).
          truncation (`bool`):
              Activates truncation to cut input sequences longer than *max_length* to *max_length*.
          pad_to_multiple_of (`int`, *optional*):
              If set will pad the sequence to a multiple of the provided value.
  
              This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability
              `>= 7.5` (Volta), or on TPUs which benefit from having sequence lengths be a multiple of 128.
          return_attention_mask (`bool`, *optional*):
              Whether to return the attention mask. If left to the default, will return the attention mask according
              to the specific feature_extractor's default.
  
              [What are attention masks?](../glossary#attention-mask)
  
              <Tip>
  
              Wav2Vec2 models that have set `config.feat_extract_norm == "group"`, such as
              [wav2vec2-base](https://huggingface.co/facebook/wav2vec2-base-960h), have **not** been trained using
              `attention_mask`. For such models, `input_values` should simply be padded with 0 and no
              `attention_mask` should be passed.
  
              For Wav2Vec2 models that have set `config.feat_extract_norm == "layer"`, such as
              [wav2vec2-lv60](https://huggingface.co/facebook/wav2vec2-large-960h-lv60-self), `attention_mask` should
              be passed for batched inference.
  
              </Tip>
  
          return_tensors (`str` or [`~utils.TensorType`], *optional*):
              If set, will return tensors instead of list of python integers. Acceptable values are:
  
              - `'tf'`: Return TensorFlow `tf.constant` objects.
              - `'pt'`: Return PyTorch `torch.Tensor` objects.
              - `'np'`: Return Numpy `np.ndarray` objects.
          sampling_rate (`int`, *optional*):
              The sampling rate at which the `raw_speech` input was sampled. It is strongly recommended to pass
              `sampling_rate` at the forward call to prevent silent errors.
          padding_value (`float`, defaults to 0.0):
      """
  
      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."
          )
  
      is_batched_numpy = (
          isinstance(raw_speech, 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}"
          )
      is_batched = is_batched_numpy or (
          isinstance(raw_speech, (list, tuple))
          and (isinstance(raw_speech[0], (np.ndarray, tuple, list)))
      )
  
      # always return batch
      if not is_batched:
          raw_speech = [raw_speech]
  
      # convert into correct format for padding
      encoded_inputs = BatchFeature({"input_values": raw_speech})
  
      padded_inputs = self.pad(
          encoded_inputs,
          padding=padding,
          max_length=max_length,
          truncation=truncation,
          pad_to_multiple_of=pad_to_multiple_of,
          return_attention_mask=return_attention_mask,
      )
  
      # convert input values to correct format
      input_values = padded_inputs["input_values"]
      if not isinstance(input_values[0], np.ndarray):
          padded_inputs["input_values"] = [
              np.asarray(array, dtype=np.float32)
              for array in input_values
          ]
      elif (
          not isinstance(input_values, np.ndarray)
          and isinstance(input_values[0], np.ndarray)
          and input_values[0].dtype is np.dtype(np.float64)
      ):
          padded_inputs["input_values"] = [
              array.astype(np.float32) for array in input_values
          ]
      elif isinstance(
          input_values, np.ndarray
      ) and input_values.dtype is np.dtype(np.float64):
          padded_inputs["input_values"] = input_values.astype(
              np.float32
          )
  
      # convert attention_mask to correct format
      attention_mask = padded_inputs.get("attention_mask")
      if attention_mask is not None:
          padded_inputs["attention_mask"] = [
              np.asarray(array, dtype=np.int32)
              for array in attention_mask
          ]
  
      # zero-mean and unit-variance normalization
      if self.do_normalize:
          attention_mask = (
              attention_mask
              if self._get_padding_strategies(
                  padding, max_length=max_length
              )
              is not PaddingStrategy.DO_NOT_PAD
              else None
          )
          padded_inputs["input_values"] = self.zero_mean_unit_var_norm(
              padded_inputs["input_values"],
              attention_mask=attention_mask,
              padding_value=self.padding_value,
          )
  
      if return_tensors is not None:
          padded_inputs = padded_inputs.convert_to_tensors(
              return_tensors
          )
  
      return padded_inputs
  
file_path: transformers/src/transformers/models/wav2vec2/feature_extraction_wav2vec2.py
imports: from typing import List, Optional, Union
  import numpy
  from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
  from ...feature_extraction_utils import BatchFeature
  from ...utils import PaddingStrategy, TensorType, logging
label_desc: Use image node_id 3 for calling the Wav2Vec2FeatureExtractor obj's underlying member method code with example usage: obj.__call__(raw_speech, padding, max_length, truncation, pad_to_multiple_of, return_attention_mask, return_tensors, sampling_rate) and returns: padded_inputs