def test_load_fiff_mne(): data_path = mne.datasets.sample.data_path() fwd_path = os.path.join(data_path, 'MEG', 'sample', 'sample-ico-4-fwd.fif') evoked_path = os.path.join(data_path, 'MEG', 'sample', 'sample_audvis-no-filter-ave.fif') cov_path = os.path.join(data_path, 'MEG', 'sample', 'sample_audvis-cov.fif') mri_sdir = os.path.join(data_path, 'subjects') mne_evoked = mne.read_evokeds(evoked_path, 'Left Auditory') mne_fwd = mne.read_forward_solution(fwd_path) mne_fwd = mne.convert_forward_solution(mne_fwd, force_fixed=True, use_cps=True) cov = mne.read_cov(cov_path) picks = mne.pick_types(mne_evoked.info, 'mag') channels = [mne_evoked.ch_names[i] for i in picks] mne_evoked = mne_evoked.pick_channels(channels) mne_fwd = mne.pick_channels_forward(mne_fwd, channels) cov = mne.pick_channels_cov(cov, channels) mne_inv = mne.minimum_norm.make_inverse_operator(mne_evoked.info, mne_fwd, cov, 0, None, True) mne_stc = mne.minimum_norm.apply_inverse(mne_evoked, mne_inv, 1., 'MNE') meg = load.fiff.evoked_ndvar(mne_evoked) inv = load.fiff.inverse_operator(mne_inv, 'ico-4', mri_sdir) stc = inv.dot(meg) assert_array_almost_equal(stc.get_data(('source', 'time')), mne_stc.data) fwd = load.fiff.forward_operator(mne_fwd, 'ico-4', mri_sdir) reconstruct = fwd.dot(stc) mne_reconstruct = mne.apply_forward(mne_fwd, mne_stc, mne_evoked.info) assert_array_almost_equal(reconstruct.get_data(('sensor', 'time')), mne_reconstruct.data)
def test_io_cov(): """Test IO for noise covariance matrices """ tempdir = _TempDir() cov = read_cov(cov_fname) cov.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif')) assert_array_almost_equal(cov.data, cov2.data) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) cov['bads'] = ['EEG 039'] cov_sel = pick_channels_cov(cov, exclude=cov['bads']) assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads']))) assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim'])) cov_sel.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_cov(cov_badname, cov) read_cov(cov_badname) assert_true(len(w) == 2)
def test_lcmv_cov(weight_norm, pick_ori): """Test LCMV source power computation.""" raw, epochs, evoked, data_cov, noise_cov, label, forward,\ forward_surf_ori, forward_fixed, forward_vol = _get_data() convert_forward_solution(forward, surf_ori=True, copy=False) filters = make_lcmv(evoked.info, forward, data_cov, noise_cov=noise_cov, weight_norm=weight_norm, pick_ori=pick_ori) for cov in (data_cov, noise_cov): this_cov = pick_channels_cov(cov, evoked.ch_names) this_evoked = evoked.copy().pick_channels(this_cov['names']) this_cov['projs'] = this_evoked.info['projs'] assert this_evoked.ch_names == this_cov['names'] stc = apply_lcmv_cov(this_cov, filters) assert stc.data.min() > 0 assert stc.shape == (498, 1) ev = EvokedArray(this_cov.data, this_evoked.info) stc_1 = apply_lcmv(ev, filters) assert stc_1.data.min() < 0 ev = EvokedArray(stc_1.data.T, this_evoked.info) stc_2 = apply_lcmv(ev, filters) assert stc_2.data.shape == (498, 498) data = np.diag(stc_2.data)[:, np.newaxis] assert data.min() > 0 assert_allclose(data, stc.data, rtol=1e-12)
def test_whiten_evoked(): """Test whitening of evoked data.""" evoked = read_evokeds(ave_fname, condition=0, baseline=(None, 0), proj=True) cov = read_cov(cov_fname) ########################################################################### # Show result picks = pick_types(evoked.info, meg=True, eeg=True, ref_meg=False, exclude='bads') noise_cov = regularize(cov, evoked.info, grad=0.1, mag=0.1, eeg=0.1, exclude='bads') evoked_white = whiten_evoked(evoked, noise_cov, picks, diag=True) whiten_baseline_data = evoked_white.data[picks][:, evoked.times < 0] mean_baseline = np.mean(np.abs(whiten_baseline_data), axis=1) assert_true(np.all(mean_baseline < 1.)) assert_true(np.all(mean_baseline > 0.2)) # degenerate cov_bad = pick_channels_cov(cov, include=evoked.ch_names[:10]) assert_raises(RuntimeError, whiten_evoked, evoked, cov_bad, picks)
def test_io_cov(): """Test IO for noise covariance matrices """ cov = read_cov(cov_fname) cov.save(op.join(tempdir, "test-cov.fif")) cov2 = read_cov(op.join(tempdir, "test-cov.fif")) assert_array_almost_equal(cov.data, cov2.data) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, "test-cov.fif.gz")) cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz")) assert_array_almost_equal(cov.data, cov2.data) cov["bads"] = ["EEG 039"] cov_sel = pick_channels_cov(cov, exclude=cov["bads"]) assert_true(cov_sel["dim"] == (len(cov["data"]) - len(cov["bads"]))) assert_true(cov_sel["data"].shape == (cov_sel["dim"], cov_sel["dim"])) cov_sel.save(op.join(tempdir, "test-cov.fif")) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, "test-cov.fif.gz")) cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz")) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") cov_badname = op.join(tempdir, "test-bad-name.fif.gz") write_cov(cov_badname, cov) read_cov(cov_badname) assert_true(len(w) == 2)
def test_io_cov(): """Test IO for noise covariance matrices """ cov = read_cov(cov_fname) cov.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif')) assert_array_almost_equal(cov.data, cov2.data) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) cov['bads'] = ['EEG 039'] cov_sel = pick_channels_cov(cov, exclude=cov['bads']) assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads']))) assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim'])) cov_sel.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_cov(cov_badname, cov) read_cov(cov_badname) assert_true(len(w) == 2)
def test_manual_report_2d(tmpdir, invisible_fig): """Simulate user manually creating report by adding one file at a time.""" from sklearn.exceptions import ConvergenceWarning r = Report(title='My Report') raw = read_raw_fif(raw_fname) raw.pick_channels(raw.ch_names[:6]).crop(10, None) raw.info.normalize_proj() cov = read_cov(cov_fname) cov = pick_channels_cov(cov, raw.ch_names) events = read_events(events_fname) epochs = Epochs(raw=raw, events=events, baseline=None) evokeds = read_evokeds(evoked_fname) evoked = evokeds[0].pick('eeg') with pytest.warns(ConvergenceWarning, match='did not converge'): ica = (ICA(n_components=2, max_iter=1, random_state=42) .fit(inst=raw.copy().crop(tmax=1))) ica_ecg_scores = ica_eog_scores = np.array([3, 0]) ica_ecg_evoked = ica_eog_evoked = epochs.average() r.add_raw(raw=raw, title='my raw data', tags=('raw',), psd=True, projs=False) r.add_events(events=events_fname, title='my events', sfreq=raw.info['sfreq']) r.add_epochs(epochs=epochs, title='my epochs', tags=('epochs',), psd=False, projs=False) r.add_evokeds(evokeds=evoked, noise_cov=cov_fname, titles=['my evoked 1'], tags=('evoked',), projs=False, n_time_points=2) r.add_projs(info=raw_fname, projs=ecg_proj_fname, title='my proj', tags=('ssp', 'ecg')) r.add_ica(ica=ica, title='my ica', inst=None) with pytest.raises(RuntimeError, match='not preloaded'): r.add_ica(ica=ica, title='ica', inst=raw) r.add_ica( ica=ica, title='my ica with inst', inst=raw.copy().load_data(), picks=[0], ecg_evoked=ica_ecg_evoked, eog_evoked=ica_eog_evoked, ecg_scores=ica_ecg_scores, eog_scores=ica_eog_scores ) r.add_covariance(cov=cov, info=raw_fname, title='my cov') r.add_forward(forward=fwd_fname, title='my forward', subject='sample', subjects_dir=subjects_dir) r.add_html(html='<strong>Hello</strong>', title='Bold') r.add_code(code=__file__, title='my code') r.add_sys_info(title='my sysinfo') fname = op.join(tmpdir, 'report.html') r.save(fname=fname, open_browser=False)
def test_whiten_evoked(): """Test whitening of evoked data.""" evoked = read_evokeds(ave_fname, condition=0, baseline=(None, 0), proj=True) cov = read_cov(cov_fname) ########################################################################### # Show result picks = pick_types(evoked.info, meg=True, eeg=True, ref_meg=False, exclude="bads") noise_cov = regularize(cov, evoked.info, grad=0.1, mag=0.1, eeg=0.1, exclude="bads") evoked_white = whiten_evoked(evoked, noise_cov, picks, diag=True) whiten_baseline_data = evoked_white.data[picks][:, evoked.times < 0] mean_baseline = np.mean(np.abs(whiten_baseline_data), axis=1) assert_true(np.all(mean_baseline < 1.0)) assert_true(np.all(mean_baseline > 0.2)) # degenerate cov_bad = pick_channels_cov(cov, include=evoked.ch_names[:10]) assert_raises(RuntimeError, whiten_evoked, evoked, cov_bad, picks)
def test_io_cov(): """Test IO for noise covariance matrices """ tempdir = _TempDir() cov = read_cov(cov_fname) cov['method'] = 'empirical' cov['loglik'] = -np.inf cov.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif')) assert_array_almost_equal(cov.data, cov2.data) assert_equal(cov['method'], cov2['method']) assert_equal(cov['loglik'], cov2['loglik']) assert_true('Covariance' in repr(cov)) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) cov['bads'] = ['EEG 039'] cov_sel = pick_channels_cov(cov, exclude=cov['bads']) assert_true(cov_sel['dim'] == (len(cov['data']) - len(cov['bads']))) assert_true(cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim'])) cov_sel.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov_badname = op.join(tempdir, 'test-bad-name.fif.gz') write_cov(cov_badname, cov) read_cov(cov_badname) assert_naming(w, 'test_cov.py', 2)
def test_io_cov(): """Test IO for noise covariance matrices.""" tempdir = _TempDir() cov = read_cov(cov_fname) cov["method"] = "empirical" cov["loglik"] = -np.inf cov.save(op.join(tempdir, "test-cov.fif")) cov2 = read_cov(op.join(tempdir, "test-cov.fif")) assert_array_almost_equal(cov.data, cov2.data) assert_equal(cov["method"], cov2["method"]) assert_equal(cov["loglik"], cov2["loglik"]) assert_true("Covariance" in repr(cov)) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, "test-cov.fif.gz")) cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz")) assert_array_almost_equal(cov.data, cov2.data) cov["bads"] = ["EEG 039"] cov_sel = pick_channels_cov(cov, exclude=cov["bads"]) assert_true(cov_sel["dim"] == (len(cov["data"]) - len(cov["bads"]))) assert_true(cov_sel["data"].shape == (cov_sel["dim"], cov_sel["dim"])) cov_sel.save(op.join(tempdir, "test-cov.fif")) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, "test-cov.fif.gz")) cov2 = read_cov(op.join(tempdir, "test-cov.fif.gz")) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") cov_badname = op.join(tempdir, "test-bad-name.fif.gz") write_cov(cov_badname, cov) read_cov(cov_badname) assert_naming(w, "test_cov.py", 2)
def test_io_cov(): """Test IO for noise covariance matrices.""" tempdir = _TempDir() cov = read_cov(cov_fname) cov['method'] = 'empirical' cov['loglik'] = -np.inf cov.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif')) assert_array_almost_equal(cov.data, cov2.data) assert_equal(cov['method'], cov2['method']) assert_equal(cov['loglik'], cov2['loglik']) assert 'Covariance' in repr(cov) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) cov['bads'] = ['EEG 039'] cov_sel = pick_channels_cov(cov, exclude=cov['bads']) assert cov_sel['dim'] == (len(cov['data']) - len(cov['bads'])) assert cov_sel['data'].shape == (cov_sel['dim'], cov_sel['dim']) cov_sel.save(op.join(tempdir, 'test-cov.fif')) cov2 = read_cov(cov_gz_fname) assert_array_almost_equal(cov.data, cov2.data) cov2.save(op.join(tempdir, 'test-cov.fif.gz')) cov2 = read_cov(op.join(tempdir, 'test-cov.fif.gz')) assert_array_almost_equal(cov.data, cov2.data) # test warnings on bad filenames cov_badname = op.join(tempdir, 'test-bad-name.fif.gz') with pytest.warns(RuntimeWarning, match='-cov.fif'): write_cov(cov_badname, cov) with pytest.warns(RuntimeWarning, match='-cov.fif'): read_cov(cov_badname)
epochs, tmax=0., method=('empirical', 'shrunk'), return_estimators=True, rank=None) evoked.plot_white(noise_covs, time_unit='s') ############################################################################## # This will plot the whitened evoked for the optimal estimator and display the # GFPs for all estimators as separate lines in the related panel. ############################################################################## # Finally, let's have a look at the difference between empty room and # event related covariance. evoked_meg = evoked.copy().pick_types(meg=True, eeg=False) noise_cov_meg = mne.pick_channels_cov(noise_cov_baseline, evoked_meg.ch_names) noise_cov['method'] = 'empty_room' noise_cov_meg['method'] = 'baseline' evoked_meg.plot_white([noise_cov_meg, noise_cov], time_unit='s') ############################################################################## # Based on the negative log-likelihood, the baseline covariance # seems more appropriate. ############################################################################### # References # ---------- # # .. [1] Engemann D. and Gramfort A. (2015) Automated model selection in
def DeFleCT_make_estimator(forward, noise_cov, labels, lambda2_cov=3/10., lambda2_S=1/9., pick_meg=True, pick_eeg=False, mode='svd', n_svd_comp=1, verbose=None): """ Create the DeFleCT estimator for a set of labels Parameters: ----------- forward: forward solution (assumes surf_ori=True) noise_cov: noise covariance matrix lambda2_cov: regularisation paramter for noise covariance matrix (whitening) pick_meg: Which MEG channels to pick (True/False/'grad'/'mag') pick_eeg: Which EEG channels to pick (True/False) labels: list of labels, first one is the target for DeFleCT mode : 'mean' | 'sum' | 'svd' | PSFs can be computed for different summary measures with labels: 'sum' or 'mean': sum or means of sub-leadfields for labels This corresponds to situations where labels can be assumed to be homogeneously activated. 'svd': SVD components of sub-leadfields for labels This is better suited for situations where activation patterns are assumed to be more variable. "sub-leadfields" are the parts of the forward solutions that belong to vertices within invidual labels. n_svd_comp : integer Number of SVD components for which PSFs will be computed and output (irrelevant for 'sum' and 'mean'). Explained variances within sub-leadfields are shown in screen output. verbose : bool, str, int, or None If not None, override default verbose level (see mne.verbose). Returns: -------- w: np-array (1xn_chan), spatial filter for first column of P F: np-array, whitened leadfield matrix (n_chan x n_vert) P: np-array, whitened projection matrix (n_chan x n_comp) noise_cov_mat: noise covariance matrix as used in DeFleCT whitener: whitening matrix as used in DeFleCT """ # get wanted channels picks = pick_types(forward['info'], meg=pick_meg, eeg=pick_eeg, eog=False, stim=False, exclude='bads') fwd_ch_names_all = [c['ch_name'] for c in forward['info']['chs']] fwd_ch_names = [fwd_ch_names_all[pp] for pp in picks] ch_names = [c for c in fwd_ch_names if ((c not in noise_cov['bads']) and (c not in forward['info']['bads'])) and (c in noise_cov.ch_names)] if not len(forward['info']['bads']) == len(noise_cov['bads']) or \ not all([b in noise_cov['bads'] for b in forward['info']['bads']]): logger.info('\nforward["info"]["bads"] and noise_cov["bads"] do not ' 'match excluding bad channels from both') # reduce forward to desired channels forward = pick_channels_forward(forward, ch_names) noise_cov = pick_channels_cov(noise_cov, ch_names) logger.info("\nNoise covariance matrix has %d channels." % noise_cov.data.shape[0] ) info_fwd = deepcopy(forward['info']) info_fwd['sfreq'] = 1000. if pick_eeg: avgproj = make_eeg_average_ref_proj(info_fwd, activate=True) info_fwd['projs'] = [] info_fwd['projs'].append(avgproj) else: info_fwd['projs'] = noise_cov['projs'] if lambda2_cov: # regularize covariance matrix "old style" lbd = lambda2_cov noise_cov_reg = cov_regularize(noise_cov, info_fwd, mag=lbd['mag'], grad=lbd['gra'], eeg=lbd['eeg'], proj=True) else: # use cov_mat as is noise_cov_reg = noise_cov fwd_info, leadfield, noise_cov_fwd, whitener, n_nzero = _prepare_forward( forward, info_fwd, noise_cov_reg, pca=False, rank=None, verbose=None) leadfield = leadfield[:,2::3] # assumes surf_ori=True, (normal component) n_chan, n_vert = leadfield.shape logger.info("\nLeadfield has dimensions %d by %d\n" % (n_chan, n_vert)) # if EEG present: remove mean of columns for EEG (average-reference) if pick_eeg: print "\nReferening EEG \n" EEG_idx = [cc for cc in range(len(ch_names)) if ch_names[cc][:3]=='EEG'] nr_eeg = len(EEG_idx) lfdmean = leadfield[EEG_idx,:].mean(axis=0) leadfield[EEG_idx,:] = leadfield[EEG_idx,:] - lfdmean[np.newaxis,:] #### CREATE SUBLEADFIELDs FOR LABELS # extract SUBLEADFIELDS for labels label_lfd_summary = DeFleCT_make_subleadfields(labels, forward, leadfield, mode='svd', n_svd_comp=n_svd_comp, verbose=None) #### COMPUTE DEFLECT ESTIMATOR # rename variables to match paper F = np.dot( whitener, leadfield ) P = np.dot( whitener, label_lfd_summary ) nr_comp = P.shape[1] i = np.eye( nr_comp )[0,:].T # desired sensitivity to columns in P t = np.zeros(n_vert).T[np.newaxis,:] # desired CTF associated with w # Compute DeFleCT ESTIMATOR w = DeFleCT_matrix(F, P, i, t, lambda2_S) # add whitener on the right (i.e. input should be unwhitened) w = w.dot(whitener) return w, ch_names, leadfield, label_lfd_summary, noise_cov_fwd, whitener
def test_make_lcmv(tmpdir, reg, proj): """Test LCMV with evoked data and single trials.""" raw, epochs, evoked, data_cov, noise_cov, label, forward,\ forward_surf_ori, forward_fixed, forward_vol = _get_data(proj=proj) for fwd in [forward, forward_vol]: filters = make_lcmv(evoked.info, fwd, data_cov, reg=reg, noise_cov=noise_cov) stc = apply_lcmv(evoked, filters, max_ori_out='signed') stc.crop(0.02, None) stc_pow = np.sum(np.abs(stc.data), axis=1) idx = np.argmax(stc_pow) max_stc = stc.data[idx] tmax = stc.times[np.argmax(max_stc)] assert 0.08 < tmax < 0.15, tmax assert 0.9 < np.max(max_stc) < 3.5, np.max(max_stc) if fwd is forward: # Test picking normal orientation (surface source space only). filters = make_lcmv(evoked.info, forward_surf_ori, data_cov, reg=reg, noise_cov=noise_cov, pick_ori='normal', weight_norm=None) stc_normal = apply_lcmv(evoked, filters, max_ori_out='signed') stc_normal.crop(0.02, None) stc_pow = np.sum(np.abs(stc_normal.data), axis=1) idx = np.argmax(stc_pow) max_stc = stc_normal.data[idx] tmax = stc_normal.times[np.argmax(max_stc)] lower = 0.04 if proj else 0.025 assert lower < tmax < 0.14, tmax lower = 3e-7 if proj else 2e-7 assert lower < np.max(max_stc) < 3e-6, np.max(max_stc) # No weight normalization was applied, so the amplitude of normal # orientation results should always be smaller than free # orientation results. assert (np.abs(stc_normal.data) <= stc.data).all() # Test picking source orientation maximizing output source power filters = make_lcmv(evoked.info, fwd, data_cov, reg=reg, noise_cov=noise_cov, pick_ori='max-power') stc_max_power = apply_lcmv(evoked, filters, max_ori_out='signed') stc_max_power.crop(0.02, None) stc_pow = np.sum(np.abs(stc_max_power.data), axis=1) idx = np.argmax(stc_pow) max_stc = np.abs(stc_max_power.data[idx]) tmax = stc.times[np.argmax(max_stc)] lower = 0.08 if proj else 0.04 assert lower < tmax < 0.15, tmax assert 0.8 < np.max(max_stc) < 3., np.max(max_stc) stc_max_power.data[:, :] = np.abs(stc_max_power.data) if fwd is forward: # Maximum output source power orientation results should be # similar to free orientation results in areas with channel # coverage label = mne.read_label(fname_label) mean_stc = stc.extract_label_time_course(label, fwd['src'], mode='mean') mean_stc_max_pow = \ stc_max_power.extract_label_time_course(label, fwd['src'], mode='mean') assert_array_less(np.abs(mean_stc - mean_stc_max_pow), 1.0) # Test NAI weight normalization: filters = make_lcmv(evoked.info, fwd, data_cov, reg=reg, noise_cov=noise_cov, pick_ori='max-power', weight_norm='nai') stc_nai = apply_lcmv(evoked, filters, max_ori_out='signed') stc_nai.crop(0.02, None) # Test whether unit-noise-gain solution is a scaled version of NAI pearsoncorr = np.corrcoef(np.concatenate(np.abs(stc_nai.data)), np.concatenate(stc_max_power.data)) assert_almost_equal(pearsoncorr[0, 1], 1.) # Test if spatial filter contains src_type assert 'src_type' in filters # __repr__ assert len(evoked.ch_names) == 22 assert len(evoked.info['projs']) == (3 if proj else 0) assert len(evoked.info['bads']) == 2 rank = 17 if proj else 20 assert 'LCMV' in repr(filters) assert 'unknown subject' not in repr(filters) assert '4157 vert' in repr(filters) assert '20 ch' in repr(filters) assert 'rank %s' % rank in repr(filters) # I/O fname = op.join(str(tmpdir), 'filters.h5') with pytest.warns(RuntimeWarning, match='-lcmv.h5'): filters.save(fname) filters_read = read_beamformer(fname) assert isinstance(filters, Beamformer) assert isinstance(filters_read, Beamformer) # deal with object_diff strictness filters_read['rank'] = int(filters_read['rank']) filters['rank'] = int(filters['rank']) assert object_diff(filters, filters_read) == '' # Test if fixed forward operator is detected when picking normal or # max-power orientation pytest.raises(ValueError, make_lcmv, evoked.info, forward_fixed, data_cov, reg=0.01, noise_cov=noise_cov, pick_ori='normal') pytest.raises(ValueError, make_lcmv, evoked.info, forward_fixed, data_cov, reg=0.01, noise_cov=noise_cov, pick_ori='max-power') # Test if non-surface oriented forward operator is detected when picking # normal orientation pytest.raises(ValueError, make_lcmv, evoked.info, forward, data_cov, reg=0.01, noise_cov=noise_cov, pick_ori='normal') # Test if volume forward operator is detected when picking normal # orientation pytest.raises(ValueError, make_lcmv, evoked.info, forward_vol, data_cov, reg=0.01, noise_cov=noise_cov, pick_ori='normal') # Test if missing of noise covariance matrix is detected when more than # one channel type is present in the data pytest.raises(ValueError, make_lcmv, evoked.info, forward_vol, data_cov=data_cov, reg=0.01, noise_cov=None, pick_ori='max-power') # Test if wrong channel selection is detected in application of filter evoked_ch = deepcopy(evoked) evoked_ch.pick_channels(evoked_ch.ch_names[1:]) filters = make_lcmv(evoked.info, forward_vol, data_cov, reg=0.01, noise_cov=noise_cov) pytest.raises(ValueError, apply_lcmv, evoked_ch, filters, max_ori_out='signed') # Test if discrepancies in channel selection of data and fwd model are # handled correctly in apply_lcmv # make filter with data where first channel was removed filters = make_lcmv(evoked_ch.info, forward_vol, data_cov, reg=0.01, noise_cov=noise_cov) # applying that filter to the full data set should automatically exclude # this channel from the data # also test here that no warnings are thrown - implemented to check whether # src should not be None warning occurs with pytest.warns(None) as w: stc = apply_lcmv(evoked, filters, max_ori_out='signed') assert len(w) == 0 # the result should be equal to applying this filter to a dataset without # this channel: stc_ch = apply_lcmv(evoked_ch, filters, max_ori_out='signed') assert_array_almost_equal(stc.data, stc_ch.data) # Test if non-matching SSP projection is detected in application of filter if proj: raw_proj = deepcopy(raw) raw_proj.del_proj() with pytest.raises(ValueError, match='do not match the projections'): apply_lcmv_raw(raw_proj, filters, max_ori_out='signed') # Test if spatial filter contains src_type assert 'src_type' in filters # check whether a filters object without src_type throws expected warning del filters['src_type'] # emulate 0.16 behaviour to cause warning with pytest.warns(RuntimeWarning, match='spatial filter does not contain ' 'src_type'): apply_lcmv(evoked, filters, max_ori_out='signed') # Now test single trial using fixed orientation forward solution # so we can compare it to the evoked solution filters = make_lcmv(epochs.info, forward_fixed, data_cov, reg=0.01, noise_cov=noise_cov) stcs = apply_lcmv_epochs(epochs, filters, max_ori_out='signed') stcs_ = apply_lcmv_epochs(epochs, filters, return_generator=True, max_ori_out='signed') assert_array_equal(stcs[0].data, next(stcs_).data) epochs.drop_bad() assert (len(epochs.events) == len(stcs)) # average the single trial estimates stc_avg = np.zeros_like(stcs[0].data) for this_stc in stcs: stc_avg += this_stc.data stc_avg /= len(stcs) # compare it to the solution using evoked with fixed orientation filters = make_lcmv(evoked.info, forward_fixed, data_cov, reg=0.01, noise_cov=noise_cov) stc_fixed = apply_lcmv(evoked, filters, max_ori_out='signed') assert_array_almost_equal(stc_avg, stc_fixed.data) # use a label so we have few source vertices and delayed computation is # not used filters = make_lcmv(epochs.info, forward_fixed, data_cov, reg=0.01, noise_cov=noise_cov, label=label) stcs_label = apply_lcmv_epochs(epochs, filters, max_ori_out='signed') assert_array_almost_equal(stcs_label[0].data, stcs[0].in_label(label).data) # Test condition where the filters weights are zero. There should not be # any divide-by-zero errors zero_cov = data_cov.copy() zero_cov['data'][:] = 0 filters = make_lcmv(epochs.info, forward_fixed, zero_cov, reg=0.01, noise_cov=noise_cov) assert_array_equal(filters['weights'], 0) # Test condition where one channel type is picked # (avoid "grad data rank (13) did not match the noise rank (None)") data_cov_grad = pick_channels_cov( data_cov, [ch_name for ch_name in epochs.info['ch_names'] if ch_name.endswith(('2', '3'))]) assert len(data_cov_grad['names']) > 4 make_lcmv(epochs.info, forward_fixed, data_cov_grad, reg=0.01, noise_cov=noise_cov)
noise_covs = mne.compute_covariance( epochs, tmax=0., method=('empirical', 'shrunk'), return_estimators=True) evoked.plot_white(noise_covs) ############################################################################## # This will plot the whitened evoked for the optimal estimator and display the # GFPs for all estimators as separate lines in the related panel. ############################################################################## # Finally, let's have a look at the difference between empty room and # event related covariance. evoked_meg = evoked.copy().pick_types(meg=True, eeg=False) noise_cov_meg = mne.pick_channels_cov(noise_cov_baseline, evoked_meg.ch_names) noise_cov['method'] = 'empty_room' noise_cov_meg['method'] = 'baseline' evoked_meg.plot_white([noise_cov_meg, noise_cov]) ############################################################################## # Based on the negative log-likelihood, the baseline covariance # seems more appropriate. ############################################################################### # References # ---------- # # .. [1] Engemann D. and Gramfort A. (2015) Automated model selection in
def test_manual_report_2d(tmp_path, invisible_fig): """Simulate user manually creating report by adding one file at a time.""" from sklearn.exceptions import ConvergenceWarning r = Report(title='My Report') raw = read_raw_fif(raw_fname) raw.pick_channels(raw.ch_names[:6]).crop(10, None) raw.info.normalize_proj() cov = read_cov(cov_fname) cov = pick_channels_cov(cov, raw.ch_names) events = read_events(events_fname) event_id = { 'auditory/left': 1, 'auditory/right': 2, 'visual/left': 3, 'visual/right': 4, 'face': 5, 'buttonpress': 32 } metadata, metadata_events, metadata_event_id = make_metadata( events=events, event_id=event_id, tmin=-0.2, tmax=0.5, sfreq=raw.info['sfreq']) epochs_without_metadata = Epochs(raw=raw, events=events, event_id=event_id, baseline=None) epochs_with_metadata = Epochs(raw=raw, events=metadata_events, event_id=metadata_event_id, baseline=None, metadata=metadata) evokeds = read_evokeds(evoked_fname) evoked = evokeds[0].pick('eeg') with pytest.warns(ConvergenceWarning, match='did not converge'): ica = (ICA(n_components=2, max_iter=1, random_state=42).fit(inst=raw.copy().crop(tmax=1))) ica_ecg_scores = ica_eog_scores = np.array([3, 0]) ica_ecg_evoked = ica_eog_evoked = epochs_without_metadata.average() r.add_raw(raw=raw, title='my raw data', tags=('raw', ), psd=True, projs=False) r.add_raw(raw=raw, title='my raw data 2', psd=False, projs=False, butterfly=1) r.add_events(events=events_fname, title='my events', sfreq=raw.info['sfreq']) r.add_epochs(epochs=epochs_without_metadata, title='my epochs', tags=('epochs', ), psd=False, projs=False) r.add_epochs(epochs=epochs_without_metadata, title='my epochs 2', psd=1, projs=False) r.add_epochs(epochs=epochs_without_metadata, title='my epochs 2', psd=True, projs=False) assert 'Metadata' not in r.html[-1] # Try with metadata r.add_epochs(epochs=epochs_with_metadata, title='my epochs with metadata', psd=False, projs=False) assert 'Metadata' in r.html[-1] with pytest.raises(ValueError, match='requested to calculate PSD on a duration'): r.add_epochs(epochs=epochs_with_metadata, title='my epochs 2', psd=100000000, projs=False) r.add_evokeds(evokeds=evoked, noise_cov=cov_fname, titles=['my evoked 1'], tags=('evoked', ), projs=False, n_time_points=2) r.add_projs(info=raw_fname, projs=ecg_proj_fname, title='my proj', tags=('ssp', 'ecg')) r.add_ica(ica=ica, title='my ica', inst=None) with pytest.raises(RuntimeError, match='not preloaded'): r.add_ica(ica=ica, title='ica', inst=raw) r.add_ica(ica=ica, title='my ica with inst', inst=raw.copy().load_data(), picks=[0], ecg_evoked=ica_ecg_evoked, eog_evoked=ica_eog_evoked, ecg_scores=ica_ecg_scores, eog_scores=ica_eog_scores) r.add_covariance(cov=cov, info=raw_fname, title='my cov') r.add_forward(forward=fwd_fname, title='my forward', subject='sample', subjects_dir=subjects_dir) r.add_html(html='<strong>Hello</strong>', title='Bold') r.add_code(code=__file__, title='my code') r.add_sys_info(title='my sysinfo') # drop locations (only EEG channels in `evoked`) evoked_no_ch_locs = evoked.copy() for ch in evoked_no_ch_locs.info['chs']: ch['loc'][:3] = np.nan with pytest.warns(RuntimeWarning, match='No EEG channel locations'): r.add_evokeds(evokeds=evoked_no_ch_locs, titles=['evoked no chan locs'], tags=('evoked', ), projs=True, n_time_points=1) assert 'Time course' not in r._content[-1].html assert 'Topographies' not in r._content[-1].html assert evoked.info['projs'] # only then the following test makes sense assert 'SSP' not in r._content[-1].html assert 'Global field power' in r._content[-1].html # Drop locations from Info used for projs info_no_ch_locs = raw.info.copy() for ch in info_no_ch_locs['chs']: ch['loc'][:3] = np.nan with pytest.warns(RuntimeWarning, match='No channel locations found'): r.add_projs(info=info_no_ch_locs, title='Projs no chan locs') # Drop locations from ICA ica_no_ch_locs = ica.copy() for ch in ica_no_ch_locs.info['chs']: ch['loc'][:3] = np.nan with pytest.warns(RuntimeWarning, match='No Magnetometers channel locations'): r.add_ica(ica=ica_no_ch_locs, picks=[0], inst=raw.copy().load_data(), title='ICA') assert 'ICA component properties' not in r._content[-1].html assert 'ICA component topographies' not in r._content[-1].html assert 'Original and cleaned signal' in r._content[-1].html fname = op.join(tmp_path, 'report.html') r.save(fname=fname, open_browser=False)
rand = np.random.RandomState(42) ############################################################################### # Load the info, the forward solution and the noise covariance # The forward solution also defines the employed brain discretization. info = mne.io.read_info(raw_fname) fwd = mne.read_forward_solution(fwd_fname) noise_cov = mne.read_cov(erm_cov_fname) ############################################################################### # In this example, to save computation time, we shall only simulate gradiometer # data. You can try simulating other types of sensors as well. picks = mne.pick_types(info, meg='grad', stim=True, exclude='bads') mne.pick_info(info, picks, copy=False) fwd = mne.pick_channels_forward(fwd, include=info['ch_names']) noise_cov = mne.pick_channels_cov(noise_cov, include=info['ch_names']) ############################################################################### # Data simulation # --------------- # # The following function generates a timeseries that contains an oscillator, # modulated by a Gaussian. The frequency of the oscillator fluctuates a little # over time, but stays close to 10 Hz. def gen_signal(times, base_freq, rand=None, t_rand=1e-3, std_rand=0.1,