Kernel param for apply inverse

mne/minimum_norm/inverse.py

@@ -1069,7 +1069,7 @@ def apply_inverse_raw(raw, inverse_operator, lambda2, method="dSPM",
 def _apply_inverse_epochs_gen(epochs, inverse_operator, lambda2, method='dSPM',
                               label=None, nave=1, pick_ori=None,
                               prepared=False, method_params=None,
-                              verbose=None):
+                              delayed=False, verbose=None):
     """Generate inverse solutions for epochs. Used in apply_inverse_epochs."""
     _check_option('method', method, INVERSE_METHODS)
     _check_ori(pick_ori, inverse_operator['source_ori'])
@@ -1122,7 +1122,7 @@ def _apply_inverse_epochs_gen(epochs, inverse_operator, lambda2, method='dSPM',
                 sol *= noise_norm
         else:
             # Linear inverse: do computation here or delayed
-            if len(sel) < K.shape[1]:
+            if delayed:
                 sol = (K, e[sel])
             else:
                 sol = np.dot(K, e[sel])
@@ -1141,7 +1141,7 @@ def _apply_inverse_epochs_gen(epochs, inverse_operator, lambda2, method='dSPM',
 def apply_inverse_epochs(epochs, inverse_operator, lambda2, method="dSPM",
                          label=None, nave=1, pick_ori=None,
                          return_generator=False, prepared=False,
-                         method_params=None, verbose=None):
+                         method_params=None, delayed=False, verbose=None):
     """Apply inverse operator to Epochs.
 
     Parameters
@@ -1177,6 +1177,14 @@ def apply_inverse_epochs(epochs, inverse_operator, lambda2, method="dSPM",
         Additional options for eLORETA. See Notes of :func:`apply_inverse`.
 
         .. versionadded:: 0.16
+    delayed : bool
+        If False, the full data is returned. If True, data is stored as a tuple
+        of smaller arrays in order to save memory. In this case, the full data
+        field will be automatically constructed when stc.data is called for the
+        first time. `delayed=True` is only implemented for fixed
+        orientations. Defaults to False.
+
+        .. versionadded:: 0.19
     %(verbose)s
 
     Returns
@@ -1192,7 +1200,7 @@ def apply_inverse_epochs(epochs, inverse_operator, lambda2, method="dSPM",
     stcs = _apply_inverse_epochs_gen(
         epochs, inverse_operator, lambda2, method=method, label=label,
         nave=nave, pick_ori=pick_ori, verbose=verbose, prepared=prepared,
-        method_params=method_params)
+        method_params=method_params, delayed=delayed)
 
     if not return_generator:
         # return a list

mne/minimum_norm/tests/test_inverse.py

@@ -781,12 +781,9 @@ def test_apply_mne_inverse_fixed_raw():
     assert_array_almost_equal(stc.data, stc3.data)
 
 
-@testing.requires_testing_data
-def test_apply_mne_inverse_epochs():
-    """Test MNE with precomputed inverse operator on Epochs."""
-    inverse_operator = read_inverse_operator(fname_full)
-    label_lh = read_label(fname_label % 'Aud-lh')
-    label_rh = read_label(fname_label % 'Aud-rh')
+@pytest.fixture
+def get_epochs():
+    """Create an epochs object used for testing."""
     event_id, tmin, tmax = 1, -0.2, 0.5
     raw = read_raw_fif(fname_raw)
 
@@ -799,14 +796,24 @@ def test_apply_mne_inverse_epochs():
     epochs = Epochs(raw, events, event_id, tmin, tmax, picks=picks,
                     baseline=(None, 0), reject=reject, flat=flat)
 
+    return epochs
+
+
+@testing.requires_testing_data
+def test_apply_mne_inverse_epochs(get_epochs):
+    """Test MNE with precomputed inverse operator on Epochs."""
+    inverse_operator = read_inverse_operator(fname_full)
+    label_lh = read_label(fname_label % 'Aud-lh')
+    label_rh = read_label(fname_label % 'Aud-rh')
+
     inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
                                                 lambda2=lambda2,
                                                 method="dSPM")
     for pick_ori in [None, "normal", "vector"]:
-        stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
-                                    label=label_lh, pick_ori=pick_ori)
-        stcs2 = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
-                                     label=label_lh, pick_ori=pick_ori,
+        stcs = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                    "dSPM", label=label_lh, pick_ori=pick_ori)
+        stcs2 = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                     "dSPM", label=label_lh, pick_ori=pick_ori,
                                      prepared=True)
         # test if using prepared and not prepared inverse operator give the
         # same result
@@ -818,7 +825,7 @@ def test_apply_mne_inverse_epochs():
         assert (stcs[0].subject == 'sample')
     inverse_operator = read_inverse_operator(fname_full)
 
-    stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
+    stcs = apply_inverse_epochs(get_epochs, inverse_operator, lambda2, "dSPM",
                                 label=label_lh, pick_ori='normal')
     data = sum(stc.data for stc in stcs) / len(stcs)
     flip = label_sign_flip(label_lh, inverse_operator['src'])
@@ -832,11 +839,11 @@ def test_apply_mne_inverse_epochs():
     inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
                                                 lambda2=lambda2,
                                                 method="dSPM")
-    stcs_rh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
-                                   label=label_rh, pick_ori="normal",
+    stcs_rh = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                   "dSPM", label=label_rh, pick_ori="normal",
                                    prepared=True)
-    stcs_bh = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
-                                   label=label_lh + label_rh,
+    stcs_bh = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                   "dSPM", label=label_lh + label_rh,
                                    pick_ori="normal",
                                    prepared=True)
 
@@ -845,7 +852,7 @@ def test_apply_mne_inverse_epochs():
     assert_array_almost_equal(stcs_rh[0].data, stcs_bh[0].data[n_lh:])
 
     # test without using a label (so delayed computation is used)
-    stcs = apply_inverse_epochs(epochs, inverse_operator, lambda2, "dSPM",
+    stcs = apply_inverse_epochs(get_epochs, inverse_operator, lambda2, "dSPM",
                                 pick_ori="normal", prepared=True)
     assert (stcs[0].subject == 'sample')
     label_stc = stcs[0].in_label(label_rh)
@@ -891,4 +898,35 @@ def test_inverse_ctf_comp():
         apply_inverse_raw(raw, inv, 1. / 9.)
 
 
+def _check_delayed_data(inst, delayed):
+    """Check whether data is represented as kernel or not."""
+    if delayed:
+        assert isinstance(inst._kernel, np.ndarray)
+        assert isinstance(inst._sens_data, np.ndarray)
+        assert inst._data is None
+        assert not inst._kernel_removed
+    else:
+        assert inst._kernel is None
+        assert inst._sens_data is None
+        assert isinstance(inst._data, np.ndarray)
+
+
+@testing.requires_testing_data
+def test_delayed_data(get_epochs):
+    """Test if kernel in apply_inverse_epochs was properly applied."""
+    inverse_operator = read_inverse_operator(fname_full)
+    inverse_operator = prepare_inverse_operator(inverse_operator, nave=1,
+                                                lambda2=lambda2,
+                                                method="dSPM")
+    full_stcs = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                     pick_ori="normal", delayed=False)
+    kernel_stcs = apply_inverse_epochs(get_epochs, inverse_operator, lambda2,
+                                       pick_ori="normal", delayed=True)
+
+    for full_stc, kern_stc in zip(full_stcs, kernel_stcs):
+        _check_delayed_data(full_stc, delayed=False)
+        _check_delayed_data(kern_stc, delayed=True)
+        assert_allclose(kern_stc.data, full_stc.data)
+
+
 run_tests_if_main()