code: def csd_multitaper(
      epochs,
      fmin=0,
      fmax=np.inf,
      tmin=None,
      tmax=None,
      picks=None,
      n_fft=None,
      bandwidth=None,
      adaptive=False,
      low_bias=True,
      projs=None,
      n_jobs=None,
      *,
      verbose=None,
  ):
      """Estimate cross-spectral density from epochs using a multitaper method.
  
      Parameters
      ----------
      epochs : instance of Epochs
          The epochs to compute the CSD for.
      fmin : float | None
          Minimum frequency of interest, in Hertz.
      fmax : float | np.inf
          Maximum frequency of interest, in Hertz.
      tmin : float
          Minimum time instant to consider, in seconds. If ``None`` start at
          first sample.
      tmax : float | None
          Maximum time instant to consider, in seconds. If ``None`` end at last
          sample.
      %(picks_good_data_noref)s
      n_fft : int | None
          Length of the FFT. If ``None``, the exact number of samples between
          ``tmin`` and ``tmax`` will be used.
      bandwidth : float | None
          The bandwidth of the multitaper windowing function in Hz.
      adaptive : bool
          Use adaptive weights to combine the tapered spectra into PSD.
      low_bias : bool
          Only use tapers with more than 90%% spectral concentration within
          bandwidth.
      projs : list of Projection | None
          List of projectors to store in the CSD object. Defaults to ``None``,
          which means the projectors defined in the Epochs object will by copied.
      %(n_jobs)s
      %(verbose)s
  
      Returns
      -------
      csd : instance of CrossSpectralDensity
          The computed cross-spectral density.
  
      See Also
      --------
      csd_array_fourier
      csd_array_morlet
      csd_array_multitaper
      csd_fourier
      csd_morlet
      """
      epochs, projs = _prepare_csd(epochs, tmin, tmax, picks, projs)
      return csd_array_multitaper(
          epochs.get_data(copy=False),
          sfreq=epochs.info["sfreq"],
          t0=epochs.tmin,
          fmin=fmin,
          fmax=fmax,
          tmin=tmin,
          tmax=tmax,
          ch_names=epochs.ch_names,
          n_fft=n_fft,
          bandwidth=bandwidth,
          adaptive=adaptive,
          low_bias=low_bias,
          projs=projs,
          n_jobs=n_jobs,
          verbose=verbose,
      )
  
imports: import copy
  import numbers
  import numpy
  from scipy.fft import rfftfreq
  from .._fiff.pick import _picks_to_idx, pick_channels
  from ..parallel import parallel_func
  from ..time_frequency.multitaper import _compute_mt_params, _csd_from_mt, _mt_spectra, _psd_from_mt_adaptive
  from ..utils import ProgressBar, _check_fname, _import_h5io_funcs, _validate_type, copy_function_doc_to_method_doc, logger, verbose, warn
  from ..viz.misc import plot_csd
  from .tfr import EpochsTFR, _cwt_array, _get_nfft, morlet
label_desc: Use image node_id 8 for calling a global function with example usage: csd_multitaper(epochs, fmin, fmax, tmin, tmax, picks, n_fft, bandwidth, adaptive, low_bias, projs, n_jobs) and returns: csd_array_multitaper