code: def source_induced_power(
      epochs,
      inverse_operator,
      freqs,
      label=None,
      lambda2=1.0 / 9.0,
      method="dSPM",
      nave=1,
      n_cycles=5,
      decim=1,
      use_fft=False,
      pick_ori=None,
      baseline=None,
      baseline_mode="logratio",
      pca=True,
      n_jobs=None,
      *,
      return_plv=True,
      zero_mean=False,
      prepared=False,
      method_params=None,
      use_cps=True,
      verbose=None,
  ):
      """Compute induced power and phase lock.
  
      Computation can optionally be restricted in a label.
  
      Parameters
      ----------
      epochs : instance of Epochs
          The epochs.
      inverse_operator : instance of InverseOperator
          The inverse operator.
      freqs : array
          Array of frequencies of interest.
      label : Label | list of Label
          Restricts the source estimates to a given label or list of labels. If
          labels are provided in a list, power will be averaged over vertices within each
          label.
      lambda2 : float
          The regularization parameter of the minimum norm.
      method : "MNE" | "dSPM" | "sLORETA" | "eLORETA"
          Use minimum norm, dSPM (default), sLORETA, or eLORETA.
      nave : int
          The number of averages used to scale the noise covariance matrix.
      n_cycles : float | array of float
          Number of cycles. Fixed number or one per frequency.
      decim : int
          Temporal decimation factor.
      use_fft : bool
          Do convolutions in time or frequency domain with FFT.
      pick_ori : None | "normal"
          If "normal", rather than pooling the orientations by taking the norm,
          only the radial component is kept. This is only implemented
          when working with loose orientations.
      baseline : None (default) or tuple of length 2
          The time interval to apply baseline correction.
          If None do not apply it. If baseline is (a, b)
          the interval is between "a (s)" and "b (s)".
          If a is None the beginning of the data is used
          and if b is None then b is set to the end of the interval.
          If baseline is equal to (None, None) all the time
          interval is used.
      baseline_mode : 'mean' | 'ratio' | 'logratio' | 'percent' | 'zscore' | 'zlogratio'
          Perform baseline correction by
  
          - subtracting the mean of baseline values ('mean')
          - dividing by the mean of baseline values ('ratio')
          - dividing by the mean of baseline values and taking the log
            ('logratio')
          - subtracting the mean of baseline values followed by dividing by
            the mean of baseline values ('percent')
          - subtracting the mean of baseline values and dividing by the
            standard deviation of baseline values ('zscore')
          - dividing by the mean of baseline values, taking the log, and
            dividing by the standard deviation of log baseline values
            ('zlogratio')
  
      pca : bool
          If True, the true dimension of data is estimated before running
          the time-frequency transforms. It reduces the computation times
          e.g. with a dataset that was maxfiltered (true dim is 64).
      %(n_jobs)s
      return_plv : bool
          If True, return the phase-locking value array. Else, only return power.
  
          .. versionadded:: 1.6
      zero_mean : bool
          Make sure the wavelets are zero mean.
      prepared : bool
          If True, do not call :func:`prepare_inverse_operator`.
      method_params : dict | None
          Additional options for eLORETA. See Notes of :func:`apply_inverse`.
      %(use_cps_restricted)s
  
          .. versionadded:: 0.20
      %(verbose)s
  
      Returns
      -------
      power : array
          The induced power array with shape (n_sources, n_freqs, n_samples) if
          label=None or label=label. For lists of one or more labels, the induced
          power estimate has shape (n_labels, n_frequencies, n_samples).
      plv : array
          The phase-locking value array with shape (n_sources, n_freqs,
          n_samples). Only returned if ``return_plv=True``.
      """  # noqa: E501
      _check_option("method", method, INVERSE_METHODS)
      _check_ori(
          pick_ori,
          inverse_operator["source_ori"],
          inverse_operator["src"],
      )
  
      power, plv, vertno = _source_induced_power(
          epochs,
          inverse_operator,
          freqs,
          label=label,
          lambda2=lambda2,
          method=method,
          nave=nave,
          n_cycles=n_cycles,
          decim=decim,
          use_fft=use_fft,
          pick_ori=pick_ori,
          pca=pca,
          n_jobs=n_jobs,
          with_plv=return_plv,
          method_params=method_params,
          zero_mean=zero_mean,
          prepared=prepared,
          use_cps=use_cps,
      )
  
      # Run baseline correction
      power = rescale(
          power,
          epochs.times[::decim],
          baseline,
          baseline_mode,
          copy=False,
      )
  
      outs = (power, plv) if return_plv else power
      return outs
  
imports: import numpy
  from .._fiff.constants import FIFF
  from .._fiff.pick import pick_info
  from ..baseline import _log_rescale, rescale
  from ..epochs import Epochs
  from ..event import make_fixed_length_events
  from ..evoked import EvokedArray
  from ..fixes import _safe_svd
  from ..label import BiHemiLabel, Label
  from ..parallel import parallel_func
  from ..source_estimate import _make_stc
  from ..time_frequency.multitaper import _compute_mt_params, _mt_spectra, _psd_from_mt, _psd_from_mt_adaptive
  from ..time_frequency.tfr import cwt, morlet
  from ..utils import ProgressBar, _check_option, _pl, _validate_type, logger, verbose
  from .inverse import INVERSE_METHODS, _assemble_kernel, _check_or_prepare, _check_ori, _pick_channels_inverse_operator, _subject_from_inverse, combine_xyz
label_desc: Use image node_id 9 for calling a global function with example usage: source_induced_power(epochs, inverse_operator, freqs, label, lambda2, method, nave, n_cycles, decim, use_fft, pick_ori, baseline, baseline_mode, pca, n_jobs) and returns: outs