def test_make_inverse_operator():
"""Test MNE inverse computation (precomputed and non-precomputed)."""
# Test old version of inverse computation starting from forward operator
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
inverse_operator = read_inverse_operator(fname_inv)
fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd),
surf_ori=True, copy=False)
with catch_logging() as log:
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False, verbose=True)
log = log.getvalue()
assert 'rank 302 (3 small eigenvalues omitted)' in log
_compare_io(my_inv_op)
assert_equal(inverse_operator['units'], 'Am')
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-2, atol=1e-5, depth_atol=1e-3)
# Test MNE inverse computation starting from forward operator
with catch_logging() as log:
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8, verbose=True)
log = log.getvalue()
assert 'rank 302 (3 small eigenvalues omitted)' in log
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-3, atol=1e-5)
assert ('dev_head_t' in my_inv_op['info'])
assert ('mri_head_t' in my_inv_op)
def test_make_inverse_operator_fixed(self):
"""Test MNE inverse computation w/ fixed orientation (& no depth
weighting)
"""
# can't make fixed inv without surf ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info,
self.fwd_1, noise_cov, depth=0.8, loose=None, fixed=True)
# can't make fixed inv with depth weighting without free ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info,
self.fwd_2, noise_cov, depth=0.8, loose=None, fixed=True)
inv_op = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
depth=0.8, loose=None, fixed=True)
_compare_io(inv_op)
inverse_operator_fixed = read_inverse_operator(fname_inv_fixed)
_compare_inverses_approx(inverse_operator_fixed, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
# Now without depth weighting, these should be equivalent
inv_op = make_inverse_operator(evoked.info, self.fwd_2, noise_cov,
depth=None, loose=None, fixed=True)
inv_2 = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
depth=None, loose=None, fixed=True)
_compare_inverses_approx(inv_op, inv_2, evoked, 2)
_compare_io(inv_op)
# now compare to C solution
inverse_operator_nodepth = read_inverse_operator(fname_inv_nodepth)
_compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
def test_make_inverse_operator_free():
"""Test MNE inverse computation (free orientation)
"""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
fwd_1 = read_forward_solution_meg(fname_fwd, surf_ori=False,
force_fixed=False)
fwd_2 = read_forward_solution_meg(fname_fwd, surf_ori=False,
force_fixed=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# can't make free inv with fixed fwd
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_2,
noise_cov, depth=None)
# for free ori inv, loose=None and loose=1 should be equivalent
inv_1 = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=None)
inv_2 = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=1)
_compare_inverses_approx(inv_1, inv_2, evoked, 0, 1e-2)
# for depth=None, surf_ori of the fwd should not matter
inv_3 = make_inverse_operator(evoked.info, fwd_op, noise_cov, depth=None,
loose=None)
inv_4 = make_inverse_operator(evoked.info, fwd_1, noise_cov, depth=None,
loose=None)
_compare_inverses_approx(inv_3, inv_4, evoked, 0, 1e-2)
def test_make_inverse_operator_fixed():
"""Test MNE inverse computation (fixed orientation)
"""
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
fwd_1 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=False)
fwd_2 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# can't make depth-weighted fixed inv without surf ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_1,
noise_cov, depth=0.8, loose=None, fixed=True)
# can't make fixed inv with depth weighting without free ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_2,
noise_cov, depth=0.8, loose=None, fixed=True)
# compare to C solution w/fixed
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, depth=0.8,
loose=None, fixed=True)
_compare_io(inv_op)
inverse_operator_fixed = read_inverse_operator(fname_inv_fixed)
_compare_inverses_approx(inverse_operator_fixed, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
# now compare to C solution
# note that the forward solution must not be surface-oriented
# to get equivalency (surf_ori=True changes the normals)
inv_op = make_inverse_operator(evoked.info, fwd_2, noise_cov, depth=None,
loose=None, fixed=True)
inverse_operator_nodepth = read_inverse_operator(fname_inv_nodepth)
_compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
def test_make_inverse_operator_loose(evoked):
"""Test MNE inverse computation (precomputed and non-precomputed)."""
# Test old version of inverse computation starting from forward operator
noise_cov = read_cov(fname_cov)
inverse_operator = read_inverse_operator(fname_inv)
fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd),
surf_ori=True, copy=False)
with catch_logging() as log:
with pytest.deprecated_call(): # limit_depth_chs
my_inv_op = make_inverse_operator(
evoked.info, fwd_op, noise_cov, loose=0.2, depth=0.8,
limit_depth_chs=False, verbose=True)
log = log.getvalue()
assert 'MEG: rank 302 computed' in log
assert 'limit = 1/%d' % fwd_op['nsource'] in log
_compare_io(my_inv_op)
assert_equal(inverse_operator['units'], 'Am')
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-2, atol=1e-5, depth_atol=1e-3)
# Test MNE inverse computation starting from forward operator
with catch_logging() as log:
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose='auto', depth=0.8,
fixed=False, verbose=True)
log = log.getvalue()
assert 'MEG: rank 302 computed from 305' in log
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-3, atol=1e-5)
assert ('dev_head_t' in my_inv_op['info'])
assert ('mri_head_t' in my_inv_op)
def test_warn_inverse_operator():
"""Test MNE inverse warning without average EEG projection."""
bad_info = copy.deepcopy(_get_evoked().info)
bad_info['projs'] = list()
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
noise_cov = read_cov(fname_cov)
with warnings.catch_warnings(record=True) as w:
make_inverse_operator(bad_info, fwd_op, noise_cov)
assert_equal(len(w), 1)
def test_warn_inverse_operator(evoked, noise_cov):
"""Test MNE inverse warning without average EEG projection."""
bad_info = evoked.info
bad_info['projs'] = list()
fwd_op = convert_forward_solution(read_forward_solution(fname_fwd),
surf_ori=True, copy=False)
noise_cov['projs'].pop(-1) # get rid of avg EEG ref proj
with pytest.warns(RuntimeWarning, match='reference'):
make_inverse_operator(bad_info, fwd_op, noise_cov)
def test_inverse_operator_channel_ordering():
"""Test MNE inverse computation is immune to channel reorderings
"""
# These are with original ordering
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
fwd_orig = make_forward_solution(evoked.info, fname_trans, src_fname,
fname_bem, eeg=True, mindist=5.0)
fwd_orig = convert_forward_solution(fwd_orig, surf_ori=True)
inv_orig = make_inverse_operator(evoked.info, fwd_orig, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
stc_1 = apply_inverse(evoked, inv_orig, lambda2, "dSPM")
# Assume that a raw reordering applies to both evoked and noise_cov,
# so we don't need to create those from scratch. Just reorder them,
# then try to apply the original inverse operator
new_order = np.arange(len(evoked.info['ch_names']))
randomiser = np.random.RandomState(42)
randomiser.shuffle(new_order)
evoked.data = evoked.data[new_order]
evoked.info['chs'] = [evoked.info['chs'][n] for n in new_order]
evoked.info._update_redundant()
evoked.info._check_consistency()
cov_ch_reorder = [c for c in evoked.info['ch_names']
if (c in noise_cov.ch_names)]
new_order_cov = [noise_cov.ch_names.index(name) for name in cov_ch_reorder]
noise_cov['data'] = noise_cov.data[np.ix_(new_order_cov, new_order_cov)]
noise_cov['names'] = [noise_cov['names'][idx] for idx in new_order_cov]
fwd_reorder = make_forward_solution(evoked.info, fname_trans, src_fname,
fname_bem, eeg=True, mindist=5.0)
fwd_reorder = convert_forward_solution(fwd_reorder, surf_ori=True)
inv_reorder = make_inverse_operator(evoked.info, fwd_reorder, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
stc_2 = apply_inverse(evoked, inv_reorder, lambda2, "dSPM")
assert_equal(stc_1.subject, stc_2.subject)
assert_array_equal(stc_1.times, stc_2.times)
assert_allclose(stc_1.data, stc_2.data, rtol=1e-5, atol=1e-5)
assert_true(inv_orig['units'] == inv_reorder['units'])
# Reload with original ordering & apply reordered inverse
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
stc_3 = apply_inverse(evoked, inv_reorder, lambda2, "dSPM")
assert_allclose(stc_1.data, stc_3.data, rtol=1e-5, atol=1e-5)
def test_apply_inverse_operator():
"""Test MNE inverse computation (precomputed and non-precomputed)
"""
inverse_operator = read_inverse_operator(fname_inv)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# Test old version of inverse computation starting from forward operator
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
_compare_io(my_inv_op)
assert_true(inverse_operator['units'] == 'Am')
_compare_inverses_approx(my_inv_op, inverse_operator, evoked, 2,
check_depth=False)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
# Test MNE inverse computation starting from forward operator
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10e-10)
assert_true(stc.data.mean() > 1e-11)
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10.0)
assert_true(stc.data.mean() > 0.1)
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 35)
assert_true(stc.data.mean() > 0.1)
my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM")
assert_true('dev_head_t' in my_inv_op['info'])
assert_true('mri_head_t' in my_inv_op)
assert_true(my_stc.subject == 'sample')
assert_equal(stc.times, my_stc.times)
assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_inverse_operator_noise_cov_rank():
"""Test MNE inverse operator with a specified noise cov rank."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
inv = make_inverse_operator(evoked.info, fwd_op, noise_cov, rank=64)
assert (compute_rank_inverse(inv) == 64)
fwd_op = read_forward_solution_eeg(fname_fwd, surf_ori=True)
inv = make_inverse_operator(evoked.info, fwd_op, noise_cov,
rank=dict(eeg=20))
assert (compute_rank_inverse(inv) == 20)
def test_inverse_operator_noise_cov_rank(evoked, noise_cov):
"""Test MNE inverse operator with a specified noise cov rank."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
with pytest.deprecated_call(): # rank int
inv = make_inverse_operator(evoked.info, fwd_op, noise_cov, rank=64)
assert (compute_rank_inverse(inv) == 64)
inv = make_inverse_operator(evoked.info, fwd_op, noise_cov,
rank=dict(meg=64))
assert (compute_rank_inverse(inv) == 64)
fwd_op = read_forward_solution_eeg(fname_fwd, surf_ori=True)
inv = make_inverse_operator(evoked.info, fwd_op, noise_cov,
rank=dict(eeg=20))
assert (compute_rank_inverse(inv) == 20)
def test_apply_mne_inverse_fixed_raw():
"""Test MNE with fixed-orientation inverse operator on Raw
"""
raw = fiff.Raw(fname_raw)
start = 3
stop = 10
_, times = raw[0, start:stop]
label_lh = read_label(fname_label % 'Aud-lh')
# create a fixed-orientation inverse operator
fwd = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True)
noise_cov = read_cov(fname_cov)
inv_op = make_inverse_operator(raw.info, fwd, noise_cov,
loose=None, depth=0.8, fixed=True)
stc = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=None)
stc2 = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=3)
assert_true(stc.subject == 'sample')
assert_true(stc2.subject == 'sample')
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_apply_inverse_sphere():
"""Test applying an inverse with a sphere model (rank-deficient)."""
evoked = _get_evoked()
evoked.pick_channels(evoked.ch_names[:306:8])
evoked.info['projs'] = []
cov = make_ad_hoc_cov(evoked.info)
sphere = make_sphere_model('auto', 'auto', evoked.info)
fwd = read_forward_solution(fname_fwd)
vertices = [fwd['src'][0]['vertno'][::5],
fwd['src'][1]['vertno'][::5]]
stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)),
vertices, 0., 1.)
fwd = restrict_forward_to_stc(fwd, stc)
fwd = make_forward_solution(evoked.info, fwd['mri_head_t'], fwd['src'],
sphere, mindist=5.)
evoked = EvokedArray(fwd['sol']['data'].copy(), evoked.info)
assert fwd['sol']['nrow'] == 39
assert fwd['nsource'] == 101
assert fwd['sol']['ncol'] == 303
tempdir = _TempDir()
temp_fname = op.join(tempdir, 'temp-inv.fif')
inv = make_inverse_operator(evoked.info, fwd, cov, loose=1.)
# This forces everything to be float32
write_inverse_operator(temp_fname, inv)
inv = read_inverse_operator(temp_fname)
stc = apply_inverse(evoked, inv, method='eLORETA',
method_params=dict(eps=1e-2))
# assert zero localization bias
assert_array_equal(np.argmax(stc.data, axis=0),
np.repeat(np.arange(101), 3))
def test_make_inverse_operator_vector():
"""Test MNE inverse computation (vector result)."""
fwd_surf = read_forward_solution_meg(fname_fwd, surf_ori=True)
fwd_fixed = read_forward_solution_meg(fname_fwd, surf_ori=False)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# Make different version of the inverse operator
inv_1 = make_inverse_operator(evoked.info, fwd_fixed, noise_cov, loose=1)
inv_2 = make_inverse_operator(evoked.info, fwd_surf, noise_cov, depth=None,
use_cps=True)
inv_3 = make_inverse_operator(evoked.info, fwd_surf, noise_cov, fixed=True,
use_cps=True)
inv_4 = make_inverse_operator(evoked.info, fwd_fixed, noise_cov,
loose=.2, depth=None)
# Apply the inverse operators and check the result
for ii, inv in enumerate((inv_1, inv_2, inv_4)):
# Don't do eLORETA here as it will be quite slow
methods = ['MNE', 'dSPM', 'sLORETA'] if ii < 2 else ['MNE']
for method in methods:
stc = apply_inverse(evoked, inv, method=method)
stc_vec = apply_inverse(evoked, inv, pick_ori='vector',
method=method)
assert_allclose(stc.data, stc_vec.magnitude().data)
# Vector estimates don't work when using fixed orientations
pytest.raises(RuntimeError, apply_inverse, evoked, inv_3,
pick_ori='vector')
# When computing with vector fields, computing the difference between two
# evokeds and then performing the inverse should yield the same result as
# computing the difference between the inverses.
evoked0 = read_evokeds(fname_data, condition=0, baseline=(None, 0))
evoked0.crop(0, 0.2)
evoked1 = read_evokeds(fname_data, condition=1, baseline=(None, 0))
evoked1.crop(0, 0.2)
diff = combine_evoked((evoked0, evoked1), [1, -1])
stc_diff = apply_inverse(diff, inv_1, method='MNE')
stc_diff_vec = apply_inverse(diff, inv_1, method='MNE', pick_ori='vector')
stc_vec0 = apply_inverse(evoked0, inv_1, method='MNE', pick_ori='vector')
stc_vec1 = apply_inverse(evoked1, inv_1, method='MNE', pick_ori='vector')
assert_allclose(stc_diff_vec.data, (stc_vec0 - stc_vec1).data,
atol=1e-20)
assert_allclose(stc_diff.data, (stc_vec0 - stc_vec1).magnitude().data,
atol=1e-20)
def test_make_inverse_operator_fixed():
"""Test MNE inverse computation (fixed orientation)."""
fwd = read_forward_solution_meg(fname_fwd)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# can't make fixed inv with depth weighting without free ori fwd
fwd_fixed = convert_forward_solution(fwd, force_fixed=True,
use_cps=True)
pytest.raises(ValueError, make_inverse_operator, evoked.info, fwd_fixed,
noise_cov, depth=0.8, fixed=True)
# now compare to C solution
# note that the forward solution must not be surface-oriented
# to get equivalency (surf_ori=True changes the normals)
with catch_logging() as log:
inv_op = make_inverse_operator( # test depth=0. alias for depth=None
evoked.info, fwd, noise_cov, depth=0., fixed=True,
use_cps=False, verbose=True)
log = log.getvalue()
assert 'rank 302 (3 small eigenvalues omitted)' in log
assert 'EEG channels: 0' in repr(inv_op)
assert 'MEG channels: 305' in repr(inv_op)
del fwd_fixed
inverse_operator_nodepth = read_inverse_operator(fname_inv_fixed_nodepth)
# XXX We should have this but we don't (MNE-C doesn't restrict info):
# assert 'EEG channels: 0' in repr(inverse_operator_nodepth)
assert 'MEG channels: 305' in repr(inverse_operator_nodepth)
_compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked,
rtol=1e-5, atol=1e-4)
# Inverse has 306 channels - 6 proj = 302
assert (compute_rank_inverse(inverse_operator_nodepth) == 302)
# Now with depth
fwd_surf = convert_forward_solution(fwd, surf_ori=True) # not fixed
for kwargs, use_fwd in zip([dict(fixed=True), dict(loose=0.)],
[fwd, fwd_surf]): # Should be equiv.
inv_op_depth = make_inverse_operator(
evoked.info, use_fwd, noise_cov, depth=0.8, use_cps=True,
**kwargs)
inverse_operator_depth = read_inverse_operator(fname_inv_fixed_depth)
# Normals should be the adjusted ones
assert_allclose(inverse_operator_depth['source_nn'],
fwd_surf['source_nn'][2::3], atol=1e-5)
_compare_inverses_approx(inverse_operator_depth, inv_op_depth, evoked,
rtol=1e-3, atol=1e-4)
def test_inverse_ctf_comp():
"""Test interpolation with compensated CTF data."""
raw = mne.io.read_raw_ctf(fname_raw_ctf).crop(0, 0)
raw.apply_gradient_compensation(1)
sphere = make_sphere_model()
cov = make_ad_hoc_cov(raw.info)
src = mne.setup_volume_source_space(
pos=dict(rr=[[0., 0., 0.01]], nn=[[0., 1., 0.]]))
fwd = make_forward_solution(raw.info, None, src, sphere, eeg=False)
raw.apply_gradient_compensation(0)
with pytest.raises(RuntimeError, match='compensation grade mismatch'):
make_inverse_operator(raw.info, fwd, cov, loose=1.)
raw.apply_gradient_compensation(1)
inv = make_inverse_operator(raw.info, fwd, cov, loose=1.)
apply_inverse_raw(raw, inv, 1. / 9.) # smoke test
raw.apply_gradient_compensation(0)
with pytest.raises(RuntimeError, match='compensation grade mismatch'):
apply_inverse_raw(raw, inv, 1. / 9.)
def test_make_inverse_operator_free(evoked, noise_cov):
"""Test MNE inverse computation (free orientation)."""
fwd = read_forward_solution_meg(fname_fwd)
fwd_surf = convert_forward_solution(fwd, surf_ori=True)
fwd_fixed = convert_forward_solution(fwd, force_fixed=True,
use_cps=True)
# can't make free inv with fixed fwd
pytest.raises(ValueError, make_inverse_operator, evoked.info, fwd_fixed,
noise_cov, depth=None)
# for depth=None, surf_ori of the fwd should not matter
inv_3 = make_inverse_operator(evoked.info, fwd_surf, noise_cov, depth=None,
loose=1.)
inv_4 = make_inverse_operator(evoked.info, fwd, noise_cov,
depth=None, loose=1.)
_compare_inverses_approx(inv_3, inv_4, evoked, rtol=1e-5, atol=1e-8,
check_nn=False, check_K=False)
def test_apply_inverse_operator(self):
"""Test MNE inverse computation (precomputed and non-precomputed)
"""
# Test old version of inverse computation starting from forward
# operator
my_inv_op = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, self.inv_op, evoked, 2,
check_depth=False)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(self.inv_op) == 302)
# Test MNE inverse computation starting from forward operator
my_inv_op = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, self.inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(self.inv_op) == 302)
stc = apply_inverse(evoked, self.inv_op, lambda2, "MNE")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10e-10)
assert_true(stc.data.mean() > 1e-11)
stc = apply_inverse(evoked, self.inv_op, lambda2, "sLORETA")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 9.0)
assert_true(stc.data.mean() > 0.1)
stc = apply_inverse(evoked, self.inv_op, lambda2, "dSPM")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 35)
assert_true(stc.data.mean() > 0.1)
my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM")
assert_true('dev_head_t' in my_inv_op['info'])
assert_true('mri_head_t' in my_inv_op)
assert_equal(stc.times, my_stc.times)
assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_localization_bias_fixed(bias_params_fixed, method, lower, upper,
depth):
"""Test inverse localization bias for fixed minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_fixed
fwd_use = convert_forward_solution(fwd, force_fixed=False)
inv_fixed = make_inverse_operator(evoked.info, fwd_use, noise_cov,
loose=0., depth=depth)
loc = np.abs(apply_inverse(evoked, inv_fixed, lambda2, method).data)
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_localization_bias_free(bias_params_free, method, lower, upper,
kwargs, depth):
"""Test inverse localization bias for free minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_free
inv_free = make_inverse_operator(evoked.info, fwd, noise_cov, loose=1.,
depth=depth)
loc = apply_inverse(evoked, inv_free, lambda2, method,
pick_ori='vector', **kwargs).data
loc = np.linalg.norm(loc, axis=1)
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_make_inverse_operator_free(self):
"""Test MNE inverse computation w/ fixed orientation (& no depth
weighting)
"""
# can't make free inv with fixed fwd
assert_raises(ValueError, make_inverse_operator, evoked.info,
self.fwd_2, noise_cov, depth=None)
# for free ori inv, loose=None and loose=1 should be equivalent
inv_1 = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
loose=None)
inv_2 = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
loose=1)
_compare_inverses_approx(inv_1, inv_2, evoked, 2)
# for depth=None, surf_ori of the fwd should not matter
inv_3 = make_inverse_operator(evoked.info, self.fwd_op, noise_cov,
depth=None, loose=None)
inv_4 = make_inverse_operator(evoked.info, self.fwd_1, noise_cov,
depth=None, loose=None)
_compare_inverses_approx(inv_3, inv_4, evoked, 2)
def test_make_inverse_operator_diag(self):
"""Test MNE inverse computation with diagonal noise cov
"""
inv_op = make_inverse_operator(evoked.info, self.fwd_op,
noise_cov.as_diag(), loose=0.2,
depth=0.8)
_compare_io(inv_op)
inverse_operator_diag = read_inverse_operator(fname_inv_diag)
# This one's only good to zero decimal places, roundoff error (?)
_compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_diag) == 302)
def test_localization_bias_loose(bias_params_fixed, method, lower, upper,
depth):
"""Test inverse localization bias for loose minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_fixed
fwd = convert_forward_solution(fwd, surf_ori=False, force_fixed=False)
assert not is_fixed_orient(fwd)
inv_loose = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=depth)
loc = apply_inverse(evoked, inv_loose, lambda2, method).data
assert (loc >= 0).all()
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_inverse_ctf_comp():
"""Test interpolation with compensated CTF data."""
ctf_dir = op.join(testing.data_path(download=False), 'CTF')
raw_fname = op.join(ctf_dir, 'somMDYO-18av.ds')
raw = mne.io.read_raw_ctf(raw_fname)
raw.apply_gradient_compensation(1)
sphere = make_sphere_model()
cov = make_ad_hoc_cov(raw.info)
src = mne.setup_volume_source_space(
pos=dict(rr=[[0., 0., 0.01]], nn=[[0., 1., 0.]]))
fwd = make_forward_solution(raw.info, None, src, sphere, eeg=False)
inv = make_inverse_operator(raw.info, fwd, cov, loose=1.)
apply_inverse_raw(raw, inv, 1. / 9.)
def test_make_inverse_operator():
"""Test MNE inverse computation (precomputed and non-precomputed)
"""
# Test old version of inverse computation starting from forward operator
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
inverse_operator = read_inverse_operator(fname_inv)
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
_compare_io(my_inv_op)
assert_true(inverse_operator['units'] == 'Am')
_compare_inverses_approx(my_inv_op, inverse_operator, evoked, 1e-2, 1e-2,
check_depth=False)
# Test MNE inverse computation starting from forward operator
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked, 1e-2, 1e-2)
assert_true('dev_head_t' in my_inv_op['info'])
assert_true('mri_head_t' in my_inv_op)
def test_make_inverse_operator_free():
"""Test MNE inverse computation (free orientation)
"""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
fwd_1 = read_forward_solution_meg(fname_fwd,
surf_ori=False,
force_fixed=False)
fwd_2 = read_forward_solution_meg(fname_fwd,
surf_ori=False,
force_fixed=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# can't make free inv with fixed fwd
assert_raises(ValueError,
make_inverse_operator,
evoked.info,
fwd_2,
noise_cov,
depth=None)
# for free ori inv, loose=None and loose=1 should be equivalent
inv_1 = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=None)
inv_2 = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=1)
_compare_inverses_approx(inv_1, inv_2, evoked, 0, 1e-2)
# for depth=None, surf_ori of the fwd should not matter
inv_3 = make_inverse_operator(evoked.info,
fwd_op,
noise_cov,
depth=None,
loose=None)
inv_4 = make_inverse_operator(evoked.info,
fwd_1,
noise_cov,
depth=None,
loose=None)
_compare_inverses_approx(inv_3, inv_4, evoked, 0, 1e-2)
def test_make_inverse_operator_fixed():
"""Test MNE inverse computation (fixed orientation)
"""
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
fwd_1 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=False)
fwd_2 = read_forward_solution(fname_fwd, surf_ori=False, force_fixed=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# can't make depth-weighted fixed inv without surf ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_1,
noise_cov, depth=0.8, loose=None, fixed=True)
# can't make fixed inv with depth weighting without free ori fwd
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_2,
noise_cov, depth=0.8, loose=None, fixed=True)
# can't make non-depth-weighted fixed inv with surf_ori fwd
# (otherwise the average normal could be employed)
assert_raises(ValueError, make_inverse_operator, evoked.info, fwd_op,
noise_cov, depth=None, loose=None, fixed=True)
# compare to C solution w/fixed
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov, depth=0.8,
loose=None, fixed=True)
_compare_io(inv_op)
inverse_operator_fixed = read_inverse_operator(fname_inv_fixed)
_compare_inverses_approx(inverse_operator_fixed, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
# now compare to C solution
# note that the forward solution must not be surface-oriented
# to get equivalency (surf_ori=True changes the normals)
inv_op = make_inverse_operator(evoked.info, fwd_2, noise_cov, depth=None,
loose=None, fixed=True)
inverse_operator_nodepth = read_inverse_operator(fname_inv_nodepth)
_compare_inverses_approx(inverse_operator_nodepth, inv_op, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator_fixed) == 302)
def test_make_inverse_operator():
"""Test MNE inverse computation (precomputed and non-precomputed)."""
# Test old version of inverse computation starting from forward operator
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
inverse_operator = read_inverse_operator(fname_inv)
fwd_op = convert_forward_solution(read_forward_solution_meg(fname_fwd),
surf_ori=True, copy=False)
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8,
limit_depth_chs=False)
_compare_io(my_inv_op)
assert_equal(inverse_operator['units'], 'Am')
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-2, atol=1e-5, depth_atol=1e-3)
# Test MNE inverse computation starting from forward operator
my_inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked,
rtol=1e-3, atol=1e-5)
assert ('dev_head_t' in my_inv_op['info'])
assert ('mri_head_t' in my_inv_op)
def test_make_inverse_operator_diag(evoked, noise_cov):
"""Test MNE inverse computation with diagonal noise cov."""
noise_cov = noise_cov.as_diag()
fwd_op = convert_forward_solution(read_forward_solution(fname_fwd),
surf_ori=True)
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(inv_op)
inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag)
# This one is pretty bad
_compare_inverses_approx(inverse_operator_diag, inv_op, evoked,
rtol=1e-1, atol=1e-1, ctol=0.99, check_K=False)
# Inverse has 366 channels - 6 proj = 360
assert (compute_rank_inverse(inverse_operator_diag) == 360)
def test_make_inverse_operator_diag():
"""Test MNE inverse computation with diagonal noise cov
"""
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov.as_diag(),
loose=0.2, depth=0.8)
_compare_io(inv_op)
inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag)
# This one's only good to zero decimal places, roundoff error (?)
_compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0, 1e0)
# Inverse has 366 channels - 6 proj = 360
assert_true(compute_rank_inverse(inverse_operator_diag) == 360)
def test_localization_bias_loose(bias_params_free, method, lower, upper):
"""Test inverse localization bias for loose minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_free
inv_free = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=0.2,
depth=0.8)
loc = apply_inverse(evoked, inv_free, lambda2, method,
pick_ori='vector').data
loc = np.linalg.norm(loc, axis=1)
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_localization_bias_fixed(bias_params_fixed, method, lower, upper,
depth):
"""Test inverse localization bias for fixed minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_fixed
fwd_use = convert_forward_solution(fwd, force_fixed=False)
inv_fixed = make_inverse_operator(evoked.info,
fwd_use,
noise_cov,
loose=0.,
depth=depth)
loc = np.abs(apply_inverse(evoked, inv_fixed, lambda2, method).data)
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_make_inverse_operator_diag():
"""Test MNE inverse computation with diagonal noise cov
"""
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov.as_diag(),
loose=0.2, depth=0.8)
_compare_io(inv_op)
inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag)
# This one's only good to zero decimal places, roundoff error (?)
_compare_inverses_approx(inverse_operator_diag, inv_op, evoked, 0, 1e0)
# Inverse has 366 channels - 6 proj = 360
assert_true(compute_rank_inverse(inverse_operator_diag) == 360)
def test_make_inverse_operator_diag(evoked, noise_cov):
"""Test MNE inverse computation with diagonal noise cov."""
noise_cov = noise_cov.as_diag()
fwd_op = convert_forward_solution(read_forward_solution(fname_fwd),
surf_ori=True)
inv_op = make_inverse_operator(evoked.info, fwd_op, noise_cov,
loose=0.2, depth=0.8)
_compare_io(inv_op)
inverse_operator_diag = read_inverse_operator(fname_inv_meeg_diag)
# This one is pretty bad
_compare_inverses_approx(inverse_operator_diag, inv_op, evoked,
rtol=1e-1, atol=1e-1, ctol=0.99, check_K=False)
# Inverse has 366 channels - 6 proj = 360
assert (compute_rank_inverse(inverse_operator_diag) == 360)
def test_make_inverse_operator_bads(evoked, noise_cov):
"""Test MNE inverse computation given a mismatch of bad channels."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
assert evoked.info['bads'] == noise_cov['bads']
assert evoked.info['bads'] == fwd_op['info']['bads'] + ['EEG 053']
# one fewer bad in evoked than cov
bad = evoked.info['bads'].pop()
inv_ = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=1.)
union_good = set(noise_cov['names']) & set(evoked.ch_names)
union_bads = set(noise_cov['bads']) & set(evoked.info['bads'])
evoked.info['bads'].append(bad)
assert len(set(inv_['info']['ch_names']) - union_good) == 0
assert len(set(inv_['info']['bads']) - union_bads) == 0
def test_make_inverse_operator_bads():
"""Test MNE inverse computation given a mismatch of bad channels."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# test bads
bad = evoked.info['bads'].pop()
inv_ = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=1.)
union_good = set(noise_cov['names']) & set(evoked.ch_names)
union_bads = set(noise_cov['bads']) & set(evoked.info['bads'])
evoked.info['bads'].append(bad)
assert_true(len(set(inv_['info']['ch_names']) - union_good) == 0)
assert_true(len(set(inv_['info']['bads']) - union_bads) == 0)
def test_make_inverse_operator_bads():
"""Test MNE inverse computation given a mismatch of bad channels."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# test bads
bad = evoked.info['bads'].pop()
inv_ = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=None)
union_good = set(noise_cov['names']) & set(evoked.ch_names)
union_bads = set(noise_cov['bads']) & set(evoked.info['bads'])
evoked.info['bads'].append(bad)
assert_true(len(set(inv_['info']['ch_names']) - union_good) == 0)
assert_true(len(set(inv_['info']['bads']) - union_bads) == 0)
def test_make_inverse_operator_bads(evoked, noise_cov):
"""Test MNE inverse computation given a mismatch of bad channels."""
fwd_op = read_forward_solution_meg(fname_fwd, surf_ori=True)
assert evoked.info['bads'] == noise_cov['bads']
assert evoked.info['bads'] == fwd_op['info']['bads'] + ['EEG 053']
# one fewer bad in evoked than cov
bad = evoked.info['bads'].pop()
inv_ = make_inverse_operator(evoked.info, fwd_op, noise_cov, loose=1.)
union_good = set(noise_cov['names']) & set(evoked.ch_names)
union_bads = set(noise_cov['bads']) & set(evoked.info['bads'])
evoked.info['bads'].append(bad)
assert len(set(inv_['info']['ch_names']) - union_good) == 0
assert len(set(inv_['info']['bads']) - union_bads) == 0
def test_localization_bias_loose(bias_params_fixed, method, lower, upper,
depth):
"""Test inverse localization bias for loose minimum-norm solvers."""
evoked, fwd, noise_cov, _, want = bias_params_fixed
fwd = convert_forward_solution(fwd, surf_ori=False, force_fixed=False)
assert not is_fixed_orient(fwd)
inv_loose = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=0.2,
depth=depth)
loc = apply_inverse(evoked, inv_loose, lambda2, method).data
assert (loc >= 0).all()
# Compute the percentage of sources for which there is no loc bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
def test_apply_mne_inverse_fixed_raw():
"""Test MNE with fixed-orientation inverse operator on Raw
"""
raw = Raw(fname_raw)
start = 3
stop = 10
_, times = raw[0, start:stop]
label_lh = read_label(fname_label % 'Aud-lh')
# create a fixed-orientation inverse operator
fwd = read_forward_solution(fname_fwd, force_fixed=False, surf_ori=True)
noise_cov = read_cov(fname_cov)
inv_op = make_inverse_operator(raw.info,
fwd,
noise_cov,
loose=None,
depth=0.8,
fixed=True)
stc = apply_inverse_raw(raw,
inv_op,
lambda2,
"dSPM",
label=label_lh,
start=start,
stop=stop,
nave=1,
pick_ori=None,
buffer_size=None)
stc2 = apply_inverse_raw(raw,
inv_op,
lambda2,
"dSPM",
label=label_lh,
start=start,
stop=stop,
nave=1,
pick_ori=None,
buffer_size=3)
assert_true(stc.subject == 'sample')
assert_true(stc2.subject == 'sample')
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_apply_inverse_eLORETA_MNE_equiv(bias_params_free, loose, lambda2):
"""Test that eLORETA with no iterations is the same as MNE."""
method_params = dict(max_iter=0, force_equal=False)
pick_ori = None if loose == 0 else 'vector'
evoked, fwd, noise_cov, _, _ = bias_params_free
inv = make_inverse_operator(
evoked.info, fwd, noise_cov, loose=loose, depth=None,
verbose='debug')
stc_mne = apply_inverse(evoked, inv, lambda2, 'MNE', pick_ori=pick_ori,
verbose='debug')
with pytest.warns(RuntimeWarning, match='converge'):
stc_e = apply_inverse(evoked, inv, lambda2, 'eLORETA',
method_params=method_params, pick_ori=pick_ori,
verbose='debug')
atol = np.mean(np.abs(stc_mne.data)) * 1e-6
assert 3e-9 < atol < 3e-6 # nothing has blown up
assert_allclose(stc_mne.data, stc_e.data, atol=atol, rtol=1e-4)
def test_apply_inverse_operator():
"""Test MNE inverse computation
With and without precomputed inverse operator.
"""
evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0))
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10e-10)
assert_true(stc.data.mean() > 1e-11)
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 9.0)
assert_true(stc.data.mean() > 0.1)
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 35)
assert_true(stc.data.mean() > 0.1)
# Test MNE inverse computation starting from forward operator
evoked = fiff.Evoked(fname_data, setno=0, baseline=(None, 0))
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
my_inv_op = make_inverse_operator(evoked.info,
fwd_op,
noise_cov,
loose=0.2,
depth=0.8)
write_inverse_operator('test-inv.fif', my_inv_op)
read_my_inv_op = read_inverse_operator('test-inv.fif')
_compare(my_inv_op, read_my_inv_op)
my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM")
assert_true('dev_head_t' in my_inv_op['info'])
assert_true('mri_head_t' in my_inv_op)
assert_equal(stc.times, my_stc.times)
assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_orientation_prior(bias_params_free, method, looses, vmin, vmax,
nmin, nmax):
"""Test that orientation priors are handled properly."""
evoked, fwd, noise_cov, _, _ = bias_params_free
stcs = list()
vec_stc = None
for loose in looses:
inv = make_inverse_operator(evoked.info, fwd, noise_cov, loose=loose)
if looses[0] == 0.:
pick_ori = None if loose == 0 else 'normal'
else:
pick_ori = 'vector'
stcs.append(apply_inverse(
evoked, inv, method=method, pick_ori=pick_ori))
if loose in (1., 0.2):
assert vec_stc is None
vec_stc = apply_inverse(
evoked, inv, method=method, pick_ori='vector')
assert vec_stc is not None
rot = _normal_orth(np.concatenate(
[_get_src_nn(s) for s in inv['src']]))
vec_stc_surf = np.matmul(rot, vec_stc.data)
if 0. in looses:
vec_stc_normal = vec_stc.normal(inv['src'])
assert_allclose(stcs[1].data, vec_stc_normal.data)
del vec_stc
assert_allclose(vec_stc_normal.data, vec_stc_surf[:, 2])
assert_allclose(vec_stc_normal.data, stcs[1].data)
# Ensure that our relative strengths are reasonable
# (normal should be much larger than tangential)
normal = np.linalg.norm(vec_stc_surf[:, 2].ravel())
for ii in range(2):
tangential = np.linalg.norm(vec_stc_surf[:, ii].ravel())
ratio = normal / tangential
assert nmin < ratio < nmax
assert stcs[0].data.shape == stcs[1].data.shape
R2 = 1. - (
np.linalg.norm(stcs[0].data.ravel() - stcs[1].data.ravel()) /
np.linalg.norm(stcs[0].data.ravel()))
assert vmin < R2 < vmax
def test_apply_mne_inverse_fixed_raw():
"""Test MNE with fixed-orientation inverse operator on Raw"""
start = 3
stop = 10
_, times = raw[0, start:stop]
# create a fixed-orientation inverse operator
fwd = read_forward_solution(fname_fwd, force_fixed=True)
inv_op = make_inverse_operator(raw.info,
fwd,
noise_cov,
loose=None,
depth=0.8)
stc = apply_inverse_raw(raw,
inv_op,
lambda2,
"dSPM",
label=label_lh,
start=start,
stop=stop,
nave=1,
pick_normal=False,
buffer_size=None)
stc2 = apply_inverse_raw(raw,
inv_op,
lambda2,
"dSPM",
label=label_lh,
start=start,
stop=stop,
nave=1,
pick_normal=False,
buffer_size=3)
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_apply_mne_inverse_fixed_raw(self):
"""Test MNE with fixed-orientation inverse operator on Raw
"""
start = 3
stop = 10
_, times = raw[0, start:stop]
# create a fixed-orientation inverse operator
inv_op = make_inverse_operator(raw.info, self.fwd_op, noise_cov,
loose=None, depth=0.8, fixed=True)
stc = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_normal=False, buffer_size=None)
stc2 = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop,
nave=1, pick_normal=False, buffer_size=3)
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc.data, stc2.data)
def test_apply_mne_inverse_fixed_raw():
"""Test MNE with fixed-orientation inverse operator on Raw."""
raw = read_raw_fif(fname_raw)
start = 3
stop = 10
_, times = raw[0, start:stop]
label_lh = read_label(fname_label % 'Aud-lh')
# create a fixed-orientation inverse operator
fwd = read_forward_solution_meg(fname_fwd, force_fixed=False,
surf_ori=True)
noise_cov = read_cov(fname_cov)
pytest.raises(ValueError, make_inverse_operator,
raw.info, fwd, noise_cov, loose=1., fixed=True)
inv_op = make_inverse_operator(raw.info, fwd, noise_cov,
fixed=True, use_cps=True)
inv_op2 = prepare_inverse_operator(inv_op, nave=1,
lambda2=lambda2, method="dSPM")
stc = apply_inverse_raw(raw, inv_op2, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=None, prepared=True)
stc2 = apply_inverse_raw(raw, inv_op2, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=3, prepared=True)
stc3 = apply_inverse_raw(raw, inv_op, lambda2, "dSPM",
label=label_lh, start=start, stop=stop, nave=1,
pick_ori=None, buffer_size=None)
assert (stc.subject == 'sample')
assert (stc2.subject == 'sample')
assert_array_almost_equal(stc.times, times)
assert_array_almost_equal(stc2.times, times)
assert_array_almost_equal(stc3.times, times)
assert_array_almost_equal(stc.data, stc2.data)
assert_array_almost_equal(stc.data, stc3.data)
def test_apply_inverse_operator():
"""Test MNE inverse computation (precomputed and non-precomputed)
"""
inverse_operator = read_inverse_operator(fname_inv)
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
# Test old version of inverse computation starting from forward operator
fwd_op = read_forward_solution(fname_fwd, surf_ori=True)
my_inv_op = make_inverse_operator(evoked.info,
fwd_op,
noise_cov,
loose=0.2,
depth=0.8,
limit_depth_chs=False)
_compare_io(my_inv_op)
assert_true(inverse_operator['units'] == 'Am')
_compare_inverses_approx(my_inv_op,
inverse_operator,
evoked,
2,
check_depth=False)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
# Test MNE inverse computation starting from forward operator
my_inv_op = make_inverse_operator(evoked.info,
fwd_op,
noise_cov,
loose=0.2,
depth=0.8)
_compare_io(my_inv_op)
_compare_inverses_approx(my_inv_op, inverse_operator, evoked, 2)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10e-10)
assert_true(stc.data.mean() > 1e-11)
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10.0)
assert_true(stc.data.mean() > 0.1)
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 35)
assert_true(stc.data.mean() > 0.1)
my_stc = apply_inverse(evoked, my_inv_op, lambda2, "dSPM")
assert_true('dev_head_t' in my_inv_op['info'])
assert_true('mri_head_t' in my_inv_op)
assert_true(my_stc.subject == 'sample')
assert_equal(stc.times, my_stc.times)
assert_array_almost_equal(stc.data, my_stc.data, 2)
def test_inverse_operator_channel_ordering():
"""Test MNE inverse computation is immune to channel reorderings
"""
# These are with original ordering
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
fwd_orig = make_forward_solution(evoked.info,
fname_trans,
src_fname,
fname_bem,
eeg=True,
mindist=5.0)
fwd_orig = convert_forward_solution(fwd_orig, surf_ori=True)
inv_orig = make_inverse_operator(evoked.info,
fwd_orig,
noise_cov,
loose=0.2,
depth=0.8,
limit_depth_chs=False)
stc_1 = apply_inverse(evoked, inv_orig, lambda2, "dSPM")
# Assume that a raw reordering applies to both evoked and noise_cov,
# so we don't need to create those from scratch. Just reorder them,
# then try to apply the original inverse operator
new_order = np.arange(len(evoked.info['ch_names']))
randomiser = np.random.RandomState(42)
randomiser.shuffle(new_order)
evoked.data = evoked.data[new_order]
evoked.info['ch_names'] = [evoked.info['ch_names'][n] for n in new_order]
evoked.info['chs'] = [evoked.info['chs'][n] for n in new_order]
cov_ch_reorder = [
c for c in evoked.info['ch_names'] if (c in noise_cov.ch_names)
]
new_order_cov = [noise_cov.ch_names.index(name) for name in cov_ch_reorder]
noise_cov['data'] = noise_cov.data[np.ix_(new_order_cov, new_order_cov)]
noise_cov['names'] = [noise_cov['names'][idx] for idx in new_order_cov]
fwd_reorder = make_forward_solution(evoked.info,
fname_trans,
src_fname,
fname_bem,
eeg=True,
mindist=5.0)
fwd_reorder = convert_forward_solution(fwd_reorder, surf_ori=True)
inv_reorder = make_inverse_operator(evoked.info,
fwd_reorder,
noise_cov,
loose=0.2,
depth=0.8,
limit_depth_chs=False)
stc_2 = apply_inverse(evoked, inv_reorder, lambda2, "dSPM")
assert_equal(stc_1.subject, stc_2.subject)
assert_array_equal(stc_1.times, stc_2.times)
assert_allclose(stc_1.data, stc_2.data, rtol=1e-5, atol=1e-5)
assert_true(inv_orig['units'] == inv_reorder['units'])
# Reload with original ordering & apply reordered inverse
evoked = _get_evoked()
noise_cov = read_cov(fname_cov)
stc_3 = apply_inverse(evoked, inv_reorder, lambda2, "dSPM")
assert_allclose(stc_1.data, stc_3.data, rtol=1e-5, atol=1e-5)
def test_make_inverse_operator_fixed(evoked, noise_cov):
"""Test MNE inverse computation (fixed orientation)."""
fwd = read_forward_solution_meg(fname_fwd)
# can't make fixed inv with depth weighting without free ori fwd
fwd_fixed = convert_forward_solution(fwd, force_fixed=True, use_cps=True)
pytest.raises(ValueError,
make_inverse_operator,
evoked.info,
fwd_fixed,
noise_cov,
depth=0.8,
fixed=True)
# now compare to C solution
# note that the forward solution must not be surface-oriented
# to get equivalence (surf_ori=True changes the normals)
with catch_logging() as log:
inv_op = make_inverse_operator( # test depth=0. alias for depth=None
evoked.info,
fwd,
noise_cov,
depth=0.,
fixed=True,
use_cps=False,
verbose=True)
log = log.getvalue()
assert 'MEG: rank 302 computed from 305' in log
assert 'EEG channels: 0' in repr(inv_op)
assert 'MEG channels: 305' in repr(inv_op)
del fwd_fixed
inverse_operator_nodepth = read_inverse_operator(fname_inv_fixed_nodepth)
# XXX We should have this but we don't (MNE-C doesn't restrict info):
# assert 'EEG channels: 0' in repr(inverse_operator_nodepth)
assert 'MEG channels: 305' in repr(inverse_operator_nodepth)
_compare_inverses_approx(inverse_operator_nodepth,
inv_op,
evoked,
rtol=1e-5,
atol=1e-4)
# Inverse has 306 channels - 6 proj = 302
assert (compute_rank_inverse(inverse_operator_nodepth) == 302)
# Now with depth
fwd_surf = convert_forward_solution(fwd, surf_ori=True) # not fixed
for kwargs, use_fwd in zip(
[dict(fixed=True), dict(loose=0.)],
[fwd, fwd_surf]): # Should be equiv.
inv_op_depth = make_inverse_operator(evoked.info,
use_fwd,
noise_cov,
depth=0.8,
use_cps=True,
**kwargs)
inverse_operator_depth = read_inverse_operator(fname_inv_fixed_depth)
# Normals should be the adjusted ones
assert_allclose(inverse_operator_depth['source_nn'],
fwd_surf['source_nn'][2::3],
atol=1e-5)
_compare_inverses_approx(inverse_operator_depth,
inv_op_depth,
evoked,
rtol=1e-3,
atol=1e-4)
def test_apply_inverse_operator(evoked):
"""Test MNE inverse application."""
# use fname_inv as it will be faster than fname_full (fewer verts and chs)
inverse_operator = read_inverse_operator(fname_inv)
# Inverse has 306 channels - 4 proj = 302
assert (compute_rank_inverse(inverse_operator) == 302)
# Inverse has 306 channels - 4 proj = 302
assert (compute_rank_inverse(inverse_operator) == 302)
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert stc.subject == 'sample'
assert stc.data.min() > 0
assert stc.data.max() < 13e-9
assert stc.data.mean() > 1e-11
# test if using prepared and not prepared inverse operator give the same
# result
inv_op = prepare_inverse_operator(inverse_operator,
nave=evoked.nave,
lambda2=lambda2,
method="MNE")
stc2 = apply_inverse(evoked, inv_op, lambda2, "MNE")
assert_array_almost_equal(stc.data, stc2.data)
assert_array_almost_equal(stc.times, stc2.times)
# This is little more than a smoke test...
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert stc.subject == 'sample'
assert stc.data.min() > 0
assert stc.data.max() < 10.0
assert stc.data.mean() > 0.1
stc = apply_inverse(evoked, inverse_operator, lambda2, "eLORETA")
assert stc.subject == 'sample'
assert stc.data.min() > 0
assert stc.data.max() < 3.0
assert stc.data.mean() > 0.1
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert stc.subject == 'sample'
assert stc.data.min() > 0
assert stc.data.max() < 35
assert stc.data.mean() > 0.1
# test without using a label (so delayed computation is used)
label = read_label(fname_label % 'Aud-lh')
stc = apply_inverse(evoked, inv_op, lambda2, "MNE")
stc_label = apply_inverse(evoked, inv_op, lambda2, "MNE", label=label)
assert_equal(stc_label.subject, 'sample')
label_stc = stc.in_label(label)
assert label_stc.subject == 'sample'
assert_allclose(stc_label.data, label_stc.data)
# Test that no errors are raised with loose inverse ops and picking normals
noise_cov = read_cov(fname_cov)
fwd = read_forward_solution_meg(fname_fwd)
inv_op_meg = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=1,
fixed='auto',
depth=None)
apply_inverse(evoked, inv_op_meg, 1 / 9., method='MNE', pick_ori='normal')
# Test we get errors when using custom ref or no average proj is present
evoked.info['custom_ref_applied'] = True
pytest.raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
evoked.info['custom_ref_applied'] = False
evoked.info['projs'] = [] # remove EEG proj
pytest.raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
# But test that we do not get EEG-related errors on MEG-only inv (gh-4650)
apply_inverse(evoked, inv_op_meg, 1. / 9.)
def test_apply_inverse_operator():
"""Test MNE inverse application."""
inverse_operator = read_inverse_operator(fname_full)
evoked = _get_evoked()
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
# Inverse has 306 channels - 4 proj = 302
assert_true(compute_rank_inverse(inverse_operator) == 302)
stc = apply_inverse(evoked, inverse_operator, lambda2, "MNE")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10e-9)
assert_true(stc.data.mean() > 1e-11)
# test if using prepared and not prepared inverse operator give the same
# result
inv_op = prepare_inverse_operator(inverse_operator,
nave=evoked.nave,
lambda2=lambda2,
method="MNE")
stc2 = apply_inverse(evoked, inv_op, lambda2, "MNE")
assert_array_almost_equal(stc.data, stc2.data)
assert_array_almost_equal(stc.times, stc2.times)
stc = apply_inverse(evoked, inverse_operator, lambda2, "sLORETA")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 10.0)
assert_true(stc.data.mean() > 0.1)
stc = apply_inverse(evoked, inverse_operator, lambda2, "dSPM")
assert_true(stc.subject == 'sample')
assert_true(stc.data.min() > 0)
assert_true(stc.data.max() < 35)
assert_true(stc.data.mean() > 0.1)
# test without using a label (so delayed computation is used)
label = read_label(fname_label % 'Aud-lh')
stc = apply_inverse(evoked, inv_op, lambda2, "MNE")
stc_label = apply_inverse(evoked, inv_op, lambda2, "MNE", label=label)
assert_equal(stc_label.subject, 'sample')
label_stc = stc.in_label(label)
assert_true(label_stc.subject == 'sample')
assert_allclose(stc_label.data, label_stc.data)
# Test that no errors are raised with loose inverse ops and picking normals
noise_cov = read_cov(fname_cov)
fwd = read_forward_solution_meg(fname_fwd)
inv_op2 = make_inverse_operator(evoked.info,
fwd,
noise_cov,
loose=1,
fixed='auto',
depth=None)
apply_inverse(evoked, inv_op2, 1 / 9., method='MNE', pick_ori='normal')
# Test we get errors when using custom ref or no average proj is present
evoked.info['custom_ref_applied'] = True
assert_raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
evoked.info['custom_ref_applied'] = False
evoked.info['projs'] = [] # remove EEG proj
assert_raises(ValueError, apply_inverse, evoked, inv_op, lambda2, "MNE")
def test_localization_bias():
"""Test inverse localization bias for minimum-norm solvers."""
# Identity input
evoked = _get_evoked()
evoked.pick_types(meg=True, eeg=True, exclude=())
evoked = EvokedArray(np.eye(len(evoked.data)), evoked.info)
noise_cov = read_cov(fname_cov)
# restrict to limited set of verts (small src here) and one hemi for speed
fwd_orig = read_forward_solution(fname_fwd)
vertices = [fwd_orig['src'][0]['vertno'].copy(), []]
stc = SourceEstimate(np.zeros((sum(len(v) for v in vertices), 1)),
vertices, 0., 1.)
fwd_orig = restrict_forward_to_stc(fwd_orig, stc)
#
# Fixed orientation (not very different)
#
fwd = fwd_orig.copy()
inv_fixed = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.,
depth=0.8)
fwd = convert_forward_solution(fwd, force_fixed=True, surf_ori=True)
fwd = fwd['sol']['data']
want = np.arange(fwd.shape[1])
for method, lower, upper in (('MNE', 83, 87),
('dSPM', 96, 98),
('sLORETA', 100, 100),
('eLORETA', 100, 100)):
inv_op = apply_inverse(evoked, inv_fixed, lambda2, method).data
loc = np.abs(np.dot(inv_op, fwd))
# Compute the percentage of sources for which there is no localization
# bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
#
# Loose orientation
#
fwd = fwd_orig.copy()
inv_free = make_inverse_operator(evoked.info, fwd, noise_cov, loose=0.2,
depth=0.8)
fwd = fwd['sol']['data']
want = np.arange(fwd.shape[1]) // 3
for method, lower, upper in (('MNE', 25, 35),
('dSPM', 25, 35),
('sLORETA', 35, 40),
('eLORETA', 40, 45)):
inv_op = apply_inverse(evoked, inv_free, lambda2, method,
pick_ori='vector').data
loc = np.linalg.norm(np.einsum('vos,sx->vxo', inv_op, fwd), axis=-1)
# Compute the percentage of sources for which there is no localization
# bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
#
# Free orientation
#
fwd = fwd_orig.copy()
inv_free = make_inverse_operator(evoked.info, fwd, noise_cov, loose=1.,
depth=0.8)
fwd = fwd['sol']['data']
want = np.arange(fwd.shape[1]) // 3
force_kwargs = dict(method_params=dict(force_equal=True))
for method, lower, upper, kwargs in (('MNE', 45, 55, {}),
('dSPM', 40, 45, {}),
('sLORETA', 90, 95, {}),
('eLORETA', 90, 95, force_kwargs),
('eLORETA', 100, 100, {}),
):
inv_op = apply_inverse(evoked, inv_free, lambda2, method,
pick_ori='vector', **kwargs).data
loc = np.linalg.norm(np.einsum('vos,sx->vxo', inv_op, fwd), axis=-1)
# Compute the percentage of sources for which there is no localization
# bias:
perc = (want == np.argmax(loc, axis=0)).mean() * 100
assert lower <= perc <= upper, method
