code: def filter_data(
      data,
      sfreq,
      l_freq,
      h_freq,
      picks=None,
      filter_length="auto",
      l_trans_bandwidth="auto",
      h_trans_bandwidth="auto",
      n_jobs=None,
      method="fir",
      iir_params=None,
      copy=True,
      phase="zero",
      fir_window="hamming",
      fir_design="firwin",
      pad="reflect_limited",
      *,
      verbose=None,
  ):
      """Filter a subset of channels.
  
      Parameters
      ----------
      data : ndarray, shape (..., n_times)
          The data to filter.
      sfreq : float
          The sample frequency in Hz.
      %(l_freq)s
      %(h_freq)s
      %(picks_nostr)s
          Currently this is only supported for 2D (n_channels, n_times) and
          3D (n_epochs, n_channels, n_times) arrays.
      %(filter_length)s
      %(l_trans_bandwidth)s
      %(h_trans_bandwidth)s
      %(n_jobs_fir)s
      %(method_fir)s
      %(iir_params)s
      copy : bool
          If True, a copy of x, filtered, is returned. Otherwise, it operates
          on x in place.
      %(phase)s
      %(fir_window)s
      %(fir_design)s
      %(pad_fir)s
          The default is ``'reflect_limited'``.
  
          .. versionadded:: 0.15
      %(verbose)s
  
      Returns
      -------
      data : ndarray, shape (..., n_times)
          The filtered data.
  
      See Also
      --------
      construct_iir_filter
      create_filter
      mne.io.Raw.filter
      notch_filter
      resample
  
      Notes
      -----
      Applies a zero-phase low-pass, high-pass, band-pass, or band-stop
      filter to the channels selected by ``picks``.
  
      ``l_freq`` and ``h_freq`` are the frequencies below which and above
      which, respectively, to filter out of the data. Thus the uses are:
  
          * ``l_freq < h_freq``: band-pass filter
          * ``l_freq > h_freq``: band-stop filter
          * ``l_freq is not None and h_freq is None``: high-pass filter
          * ``l_freq is None and h_freq is not None``: low-pass filter
  
      .. note:: If n_jobs > 1, more memory is required as
                ``len(picks) * n_times`` additional time points need to
                be temporarily stored in memory.
  
      For more information, see the tutorials
      :ref:`disc-filtering` and :ref:`tut-filter-resample` and
      :func:`mne.filter.create_filter`.
      """
      data = _check_filterable(data)
      iir_params, method = _check_method(method, iir_params)
      filt = create_filter(
          data,
          sfreq,
          l_freq,
          h_freq,
          filter_length,
          l_trans_bandwidth,
          h_trans_bandwidth,
          method,
          iir_params,
          phase,
          fir_window,
          fir_design,
      )
      if method in ("fir", "fft"):
          data = _overlap_add_filter(
              data, filt, None, phase, picks, n_jobs, copy, pad
          )
      else:
          data = _iir_filter(data, filt, picks, n_jobs, copy, phase)
      return data
  
imports: from collections import Counter
  from copy import deepcopy
  from functools import partial
  from math import gcd
  import numpy
  from scipy import fft, signal
  from scipy.stats import f
  from ._fiff.pick import _picks_to_idx
  from ._ola import _COLA
  from .cuda import _fft_multiply_repeated, _fft_resample, _setup_cuda_fft_multiply_repeated, _setup_cuda_fft_resample, _smart_pad
  from .parallel import parallel_func
  from .utils import _check_option, _check_preload, _ensure_int, _pl, _validate_type, logger, sum_squared, verbose, warn
label_desc: Use image node_id 15 for calling a global function with example usage: filter_data(data, sfreq, l_freq, h_freq, picks, filter_length, l_trans_bandwidth, h_trans_bandwidth, n_jobs, method, iir_params, copy, phase, fir_window, fir_design, pad) and returns: data