Skip to content

Sharp Flexible-Extent ESMV

Solver ID: SHARP_FLEX_ESMV

Usage

from invert import Solver

# fwd = ...    (mne.Forward object)
# evoked = ... (mne.Evoked object)

solver = Solver("SHARP_FLEX_ESMV")
solver.make_inverse_operator(fwd)
stc = solver.apply_inverse_operator(evoked)
stc.plot()

Overview

Flex-extent ESMV variant with an anchored contrast-shaping postprocess aimed at reducing spatial dispersion while preserving multi-source support.

References

  1. Lukas Hecker (2025). Unpublished.
  2. Jonmohamadi, Y., Poudel, G., Innes, C., Weiss, D., Krueger, R., & Jones, R. (2014). Comparison of beamformers for EEG source signal reconstruction. Biomedical Signal Processing and Control, 14, 175-188.

API Reference

Bases: BaseSolver

FlexESMV7: FlexESMV2 + anchored contrast shaping.

This postprocess is designed specifically for the benchmark metrics: - Keep the EMD support threshold (0.25*max) stable (good EMD/AP) - Reduce the 50%-FWHM blurring region (good spatial_dispersion) - Suppress mid-level leakage maxima (can improve MLE)

Source code in invert/solvers/beamformers/sharp_flex_esmv.py 
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
class SolverSharpFlexESMV(BaseSolver):
    """FlexESMV7: FlexESMV2 + anchored contrast shaping.

    This postprocess is designed specifically for the benchmark metrics:
    - Keep the EMD support threshold (0.25*max) stable (good EMD/AP)
    - Reduce the 50%-FWHM blurring region (good spatial_dispersion)
    - Suppress mid-level leakage maxima (can improve MLE)
    """

    meta = SolverMeta(
        slug="sharp_flex_esmv",
        full_name="Sharp Flexible-Extent ESMV",
        category="Beamformers",
        description=(
            "Flex-extent ESMV variant with an anchored contrast-shaping "
            "postprocess aimed at reducing spatial dispersion while preserving "
            "multi-source support."
        ),
        references=[
            "Lukas Hecker (2025). Unpublished.",
            "Jonmohamadi, Y., Poudel, G., Innes, C., Weiss, D., Krueger, R., & Jones, R. "
            "(2014). Comparison of beamformers for EEG source signal reconstruction. "
            "Biomedical Signal Processing and Control, 14, 175-188.",
        ],
    )

    def __init__(
        self,
        name: str = "SharpFlexESMV (FlexESMV2+AnchoredContrast) Beamformer",
        params: _AnchoredContrastParams | None = None,
        reduce_rank: bool = True,
        rank: str | int = "auto",
        **kwargs,
    ):
        if params is None:
            params = _AnchoredContrastParams()
        self.name = name
        self._acp = params
        self._inner_kwargs = dict(kwargs)
        self._inner_kwargs.pop("verbose", None)
        return super().__init__(reduce_rank=reduce_rank, rank=rank, **kwargs)

    def make_inverse_operator(self, forward, mne_obj, *args, alpha="auto", **kwargs):
        super().make_inverse_operator(forward, *args, alpha=alpha, **kwargs)
        _ = self.unpack_data_obj(mne_obj)
        self.inverse_operators = []
        return self

    def apply_inverse_operator(self, mne_obj):  # type: ignore[override]
        base = SolverFlexESMV2(
            reduce_rank=self.reduce_rank,
            rank=self.rank,
            verbose=self.verbose,
            **self._inner_kwargs,
        )
        base.make_inverse_operator(self.forward, mne_obj, alpha="auto")
        stc = base.apply_inverse_operator(mne_obj)

        y = stc.data
        if y.ndim != 2 or y.size == 0:
            return stc

        acp = self._acp
        p = np.mean(np.abs(y), axis=1)
        pmax = float(np.max(p)) + acp.eps
        rel = np.clip(p / pmax, 0.0, 1.0)

        core = float(np.mean(rel > acp.core_threshold))
        gamma = acp.gamma_min + (acp.gamma_max - acp.gamma_min) * (
            1.0 - float(np.exp(-core / acp.gamma_fscale))
        )

        rel_t = _anchored_power(rel, anchor=acp.anchor, gamma=gamma)

        scale = np.divide(rel_t, rel, out=np.zeros_like(rel_t), where=rel > acp.eps)
        stc.data[:] = y * scale[:, None]
        return stc

__init__ 

__init__(
    name: str = "SharpFlexESMV (FlexESMV2+AnchoredContrast) Beamformer",
    params: _AnchoredContrastParams | None = None,
    reduce_rank: bool = True,
    rank: str | int = "auto",
    **kwargs,
)
Source code in invert/solvers/beamformers/sharp_flex_esmv.py 
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
def __init__(
    self,
    name: str = "SharpFlexESMV (FlexESMV2+AnchoredContrast) Beamformer",
    params: _AnchoredContrastParams | None = None,
    reduce_rank: bool = True,
    rank: str | int = "auto",
    **kwargs,
):
    if params is None:
        params = _AnchoredContrastParams()
    self.name = name
    self._acp = params
    self._inner_kwargs = dict(kwargs)
    self._inner_kwargs.pop("verbose", None)
    return super().__init__(reduce_rank=reduce_rank, rank=rank, **kwargs)

make_inverse_operator 

make_inverse_operator(
    forward, mne_obj, *args, alpha="auto", **kwargs
)
Source code in invert/solvers/beamformers/sharp_flex_esmv.py 
84
85
86
87
88
def make_inverse_operator(self, forward, mne_obj, *args, alpha="auto", **kwargs):
    super().make_inverse_operator(forward, *args, alpha=alpha, **kwargs)
    _ = self.unpack_data_obj(mne_obj)
    self.inverse_operators = []
    return self

apply_inverse_operator 

apply_inverse_operator(mne_obj)
Source code in invert/solvers/beamformers/sharp_flex_esmv.py 
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
def apply_inverse_operator(self, mne_obj):  # type: ignore[override]
    base = SolverFlexESMV2(
        reduce_rank=self.reduce_rank,
        rank=self.rank,
        verbose=self.verbose,
        **self._inner_kwargs,
    )
    base.make_inverse_operator(self.forward, mne_obj, alpha="auto")
    stc = base.apply_inverse_operator(mne_obj)

    y = stc.data
    if y.ndim != 2 or y.size == 0:
        return stc

    acp = self._acp
    p = np.mean(np.abs(y), axis=1)
    pmax = float(np.max(p)) + acp.eps
    rel = np.clip(p / pmax, 0.0, 1.0)

    core = float(np.mean(rel > acp.core_threshold))
    gamma = acp.gamma_min + (acp.gamma_max - acp.gamma_min) * (
        1.0 - float(np.exp(-core / acp.gamma_fscale))
    )

    rel_t = _anchored_power(rel, anchor=acp.anchor, gamma=gamma)

    scale = np.divide(rel_t, rel, out=np.zeros_like(rel_t), where=rel > acp.eps)
    stc.data[:] = y * scale[:, None]
    return stc