code: def _apply_inverse_epochs_gen(
      epochs,
      inverse_operator,
      lambda2,
      method="dSPM",
      label=None,
      nave=1,
      pick_ori=None,
      prepared=False,
      method_params=None,
      use_cps=True,
      verbose=None,
  ):
      """Generate inverse solutions for epochs. Used in apply_inverse_epochs."""
      _validate_type(epochs, BaseEpochs, "epochs")
      _check_reference(epochs, inverse_operator["info"]["ch_names"])
      _check_option("method", method, INVERSE_METHODS)
      _check_ori(
          pick_ori,
          inverse_operator["source_ori"],
          inverse_operator["src"],
      )
      _check_ch_names(inverse_operator, epochs.info)
  
      #
      #   Set up the inverse according to the parameters
      #
      inv = _check_or_prepare(
          inverse_operator,
          nave,
          lambda2,
          method,
          method_params,
          prepared,
      )
  
      #
      #   Pick the correct channels from the data
      #
      sel = _pick_channels_inverse_operator(epochs.ch_names, inv)
      logger.info("Picked %d channels from the data" % len(sel))
      logger.info("Computing inverse...")
      K, noise_norm, vertno, source_nn = _assemble_kernel(
          inv, label, method, pick_ori, use_cps
      )
  
      tstep = 1.0 / epochs.info["sfreq"]
      tmin = epochs.times[0]
  
      is_free_ori = not (
          is_fixed_orient(inverse_operator) or pick_ori == "normal"
      )
  
      if pick_ori == "vector" and noise_norm is not None:
          noise_norm = noise_norm.repeat(3, axis=0)
  
      if not is_free_ori and noise_norm is not None:
          # premultiply kernel with noise normalization
          K *= noise_norm
  
      subject = _subject_from_inverse(inverse_operator)
      try:
          total = " / %d" % (len(epochs),)  # len not always defined
      except RuntimeError:
          total = " / %d (at most)" % (len(epochs.events),)
      for k, e in enumerate(epochs):
          logger.info("Processing epoch : %d%s" % (k + 1, total))
          if is_free_ori:
              # Compute solution and combine current components (non-linear)
              sol = np.dot(K, e[sel])  # apply imaging kernel
  
              if pick_ori != "vector":
                  logger.info("combining the current components...")
                  sol = combine_xyz(sol)
  
              if noise_norm is not None:
                  sol *= noise_norm
          else:
              # Linear inverse: do computation here or delayed
              if len(sel) < K.shape[1]:
                  sol = (K, e[sel])
              else:
                  sol = np.dot(K, e[sel])
  
          src_type = _get_src_type(inverse_operator["src"], vertno)
          stc = _make_stc(
              sol,
              vertno,
              tmin=tmin,
              tstep=tstep,
              subject=subject,
              vector=(pick_ori == "vector"),
              source_nn=source_nn,
              src_type=src_type,
          )
  
          yield stc
  
      logger.info("[done]")
  
imports: from copy import deepcopy
  from math import sqrt
  import numpy
  from scipy import linalg
  from scipy.stats import chi2
  from .._fiff.constants import FIFF
  from .._fiff.matrix import _read_named_matrix, _transpose_named_matrix, write_named_matrix
  from .._fiff.open import fiff_open
  from .._fiff.pick import channel_type, pick_channels, pick_info, pick_types
  from .._fiff.proj import _electrode_types, _needs_eeg_average_ref_proj, _read_proj, _write_proj, make_projector
  from .._fiff.tag import find_tag
  from .._fiff.tree import dir_tree_find
  from .._fiff.write import end_block, start_and_end_file, start_block, write_coord_trans, write_float, write_float_matrix, write_int, write_string
  from ..cov import Covariance, _read_cov, _write_cov, compute_whitener, prepare_noise_cov
  from ..epochs import BaseEpochs, EpochsArray
  from ..evoked import Evoked, EvokedArray
  from ..fixes import _safe_svd
  from ..forward import _read_forward_meas_info, _select_orient_forward, compute_depth_prior, compute_orient_prior, convert_forward_solution, is_fixed_orient
  from ..forward.forward import _triage_loose, write_forward_meas_info
  from ..html_templates import _get_html_template
  from ..io import BaseRaw
  from ..source_estimate import _get_src_type, _make_stc
  from ..source_space._source_space import _get_src_nn, _get_vertno, _read_source_spaces_from_tree, _write_source_spaces_to_fid, find_source_space_hemi, label_src_vertno_sel
  from ..surface import _normal_orth
  from ..time_frequency.tfr import _check_tfr_complex
  from ..transforms import _ensure_trans, transform_surface_to
  from ..utils import _check_compensation_grade, _check_depth, _check_fname, _check_option, _check_src_normal, _validate_type, _verbose_safe_false, check_fname, logger, repr_html, verbose, warn
  from ._eloreta import _compute_eloreta
label_desc: Use image node_id 17 for calling a global function with example usage: _apply_inverse_epochs_gen(epochs, inverse_operator, lambda2, method, label, nave, pick_ori, prepared, method_params, use_cps, verbose) without return types