def test_cov_estimation_on_raw_reg(): """Test estimation from raw with regularization.""" raw = read_raw_fif(raw_fname, preload=True) raw.info['sfreq'] /= 10. raw = RawArray(raw._data[:, ::10].copy(), raw.info) # decimate for speed cov_mne = read_cov(erm_cov_fname) with pytest.warns(RuntimeWarning, match='Too few samples'): # XXX don't use "shrunk" here, for some reason it makes Travis 2.7 # hang... "diagonal_fixed" is much faster. Use long epochs for speed. cov = compute_raw_covariance(raw, tstep=5., method='diagonal_fixed') assert_snr(cov.data, cov_mne.data, 5)
def test_cov_estimation_on_raw_reg(): """Test estimation from raw with regularization.""" raw = read_raw_fif(raw_fname, preload=True, add_eeg_ref=False) raw.info["sfreq"] /= 10.0 raw = RawArray(raw._data[:, ::10].copy(), raw.info) # decimate for speed cov_mne = read_cov(erm_cov_fname) with warnings.catch_warnings(record=True): # too few samples warnings.simplefilter("always") # XXX don't use "shrunk" here, for some reason it makes Travis 2.7 # hang... "diagonal_fixed" is much faster. Use long epochs for speed. cov = compute_raw_covariance(raw, tstep=5.0, method="diagonal_fixed") assert_snr(cov.data, cov_mne.data, 5)
def test_cov_estimation_on_raw(): """Test estimation from raw (typically empty room)""" tempdir = _TempDir() raw = Raw(raw_fname, preload=False) cov_mne = read_cov(erm_cov_fname) cov = compute_raw_covariance(raw, tstep=None) assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) cov = compute_raw_covariance(raw) # tstep=0.2 (default) assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert_true(cov_read.ch_names == cov.ch_names) assert_true(cov_read.nfree == cov.nfree) assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels picks = pick_channels(raw.ch_names, include=raw.ch_names[:5]) cov = compute_raw_covariance(raw, picks=picks, tstep=None) assert_true(cov_mne.ch_names[:5] == cov.ch_names) assert_snr(cov.data, cov_mne.data[picks][:, picks], 1e4) cov = compute_raw_covariance(raw, picks=picks) assert_snr(cov.data, cov_mne.data[picks][:, picks], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = raw.crop(0, 1) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov = compute_raw_covariance(raw_2) assert_true(any('Too few samples' in str(ww.message) for ww in w))
def test_cov_estimation_on_raw(): """Test estimation from raw (typically empty room).""" tempdir = _TempDir() raw = read_raw_fif(raw_fname, preload=True, add_eeg_ref=False) cov_mne = read_cov(erm_cov_fname) # The pure-string uses the more efficient numpy-based method, the # the list gets triaged to compute_covariance (should be equivalent # but use more memory) for method in (None, ['empirical']): # None is cast to 'empirical' cov = compute_raw_covariance(raw, tstep=None, method=method) assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) cov = compute_raw_covariance(raw, method=method) # tstep=0.2 (default) assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert_true(cov_read.ch_names == cov.ch_names) assert_true(cov_read.nfree == cov.nfree) assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels picks = pick_channels(raw.ch_names, include=raw.ch_names[:5]) raw_pick = raw.copy().pick_channels( [raw.ch_names[pick] for pick in picks]) raw_pick.info.normalize_proj() cov = compute_raw_covariance(raw_pick, picks=picks, tstep=None, method=method) assert_true(cov_mne.ch_names[:5] == cov.ch_names) assert_snr(cov.data, cov_mne.data[picks][:, picks], 1e4) cov = compute_raw_covariance(raw_pick, picks=picks, method=method) assert_snr(cov.data, cov_mne.data[picks][:, picks], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = read_raw_fif(raw_fname, add_eeg_ref=False).crop(0, 1, copy=False) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov = compute_raw_covariance(raw_2, method=method) assert_true(any('Too few samples' in str(ww.message) for ww in w)) # no epochs found due to rejection assert_raises(ValueError, compute_raw_covariance, raw, tstep=None, method='empirical', reject=dict(eog=200e-6)) # but this should work cov = compute_raw_covariance(raw.copy().crop(0, 10., copy=False), tstep=None, method=method, reject=dict(eog=1000e-6))
def test_cov_estimation_on_raw(method): """Test estimation from raw (typically empty room).""" tempdir = _TempDir() raw = read_raw_fif(raw_fname, preload=True) cov_mne = read_cov(erm_cov_fname) # The pure-string uses the more efficient numpy-based method, the # the list gets triaged to compute_covariance (should be equivalent # but use more memory) cov = compute_raw_covariance(raw, tstep=None, method=method, rank='full') assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) # tstep=0.2 (default) cov = compute_raw_covariance(raw, method=method, rank='full') assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert cov_read.ch_names == cov.ch_names assert cov_read.nfree == cov.nfree assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels raw_pick = raw.copy().pick_channels(raw.ch_names[:5]) raw_pick.info.normalize_proj() cov = compute_raw_covariance(raw_pick, tstep=None, method=method, rank='full') assert cov_mne.ch_names[:5] == cov.ch_names assert_snr(cov.data, cov_mne.data[:5, :5], 1e4) cov = compute_raw_covariance(raw_pick, method=method, rank='full') assert_snr(cov.data, cov_mne.data[:5, :5], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = read_raw_fif(raw_fname).crop(0, 1) with pytest.warns(RuntimeWarning, match='Too few samples'): cov = compute_raw_covariance(raw_2, method=method) # no epochs found due to rejection pytest.raises(ValueError, compute_raw_covariance, raw, tstep=None, method='empirical', reject=dict(eog=200e-6)) # but this should work cov = compute_raw_covariance(raw.copy().crop(0, 10.), tstep=None, method=method, reject=dict(eog=1000e-6), verbose='error')
def test_cov_estimation_on_raw(): """Test estimation from raw (typically empty room)""" tempdir = _TempDir() raw = read_raw_fif(raw_fname, preload=True) cov_mne = read_cov(erm_cov_fname) # The pure-string uses the more efficient numpy-based method, the # the list gets triaged to compute_covariance (should be equivalent # but use more memory) for method in (None, ['empirical']): # None is cast to 'empirical' cov = compute_raw_covariance(raw, tstep=None, method=method) assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) cov = compute_raw_covariance(raw, method=method) # tstep=0.2 (default) assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert_true(cov_read.ch_names == cov.ch_names) assert_true(cov_read.nfree == cov.nfree) assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels picks = pick_channels(raw.ch_names, include=raw.ch_names[:5]) raw_pick = raw.copy().pick_channels( [raw.ch_names[pick] for pick in picks]) raw_pick.info.normalize_proj() cov = compute_raw_covariance(raw_pick, picks=picks, tstep=None, method=method) assert_true(cov_mne.ch_names[:5] == cov.ch_names) assert_snr(cov.data, cov_mne.data[picks][:, picks], 1e4) cov = compute_raw_covariance(raw_pick, picks=picks, method=method) assert_snr(cov.data, cov_mne.data[picks][:, picks], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = read_raw_fif(raw_fname).crop(0, 1, copy=False) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov = compute_raw_covariance(raw_2, method=method) assert_true(any('Too few samples' in str(ww.message) for ww in w)) # no epochs found due to rejection assert_raises(ValueError, compute_raw_covariance, raw, tstep=None, method='empirical', reject=dict(eog=200e-6)) # but this should work cov = compute_raw_covariance(raw.copy().crop(0, 10., copy=False), tstep=None, method=method, reject=dict(eog=1000e-6))
def test_cov_estimation_on_raw(method): """Test estimation from raw (typically empty room).""" tempdir = _TempDir() raw = read_raw_fif(raw_fname, preload=True) cov_mne = read_cov(erm_cov_fname) # The pure-string uses the more efficient numpy-based method, the # the list gets triaged to compute_covariance (should be equivalent # but use more memory) with pytest.warns(None): # can warn about EEG ref cov = compute_raw_covariance(raw, tstep=None, method=method, rank='full') assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) # tstep=0.2 (default) with pytest.warns(None): # can warn about EEG ref cov = compute_raw_covariance(raw, method=method, rank='full') assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert cov_read.ch_names == cov.ch_names assert cov_read.nfree == cov.nfree assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels raw_pick = raw.copy().pick_channels(raw.ch_names[:5]) raw_pick.info.normalize_proj() cov = compute_raw_covariance(raw_pick, tstep=None, method=method, rank='full') assert cov_mne.ch_names[:5] == cov.ch_names assert_snr(cov.data, cov_mne.data[:5, :5], 1e4) cov = compute_raw_covariance(raw_pick, method=method, rank='full') assert_snr(cov.data, cov_mne.data[:5, :5], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = read_raw_fif(raw_fname).crop(0, 1) with pytest.warns(RuntimeWarning, match='Too few samples'): cov = compute_raw_covariance(raw_2, method=method) # no epochs found due to rejection pytest.raises(ValueError, compute_raw_covariance, raw, tstep=None, method='empirical', reject=dict(eog=200e-6)) # but this should work cov = compute_raw_covariance(raw.copy().crop(0, 10.), tstep=None, method=method, reject=dict(eog=1000e-6), verbose='error')
def test_cov_estimation_on_raw(): """Test estimation from raw (typically empty room)""" tempdir = _TempDir() raw = Raw(raw_fname, preload=True) cov_mne = read_cov(erm_cov_fname) cov = compute_raw_covariance(raw, tstep=None) assert_equal(cov.ch_names, cov_mne.ch_names) assert_equal(cov.nfree, cov_mne.nfree) assert_snr(cov.data, cov_mne.data, 1e4) cov = compute_raw_covariance(raw) # tstep=0.2 (default) assert_equal(cov.nfree, cov_mne.nfree - 119) # cutoff some samples assert_snr(cov.data, cov_mne.data, 1e2) # test IO when computation done in Python cov.save(op.join(tempdir, 'test-cov.fif')) # test saving cov_read = read_cov(op.join(tempdir, 'test-cov.fif')) assert_true(cov_read.ch_names == cov.ch_names) assert_true(cov_read.nfree == cov.nfree) assert_array_almost_equal(cov.data, cov_read.data) # test with a subset of channels picks = pick_channels(raw.ch_names, include=raw.ch_names[:5]) raw.pick_channels([raw.ch_names[pick] for pick in picks]) raw.info.normalize_proj() cov = compute_raw_covariance(raw, picks=picks, tstep=None) assert_true(cov_mne.ch_names[:5] == cov.ch_names) assert_snr(cov.data, cov_mne.data[picks][:, picks], 1e4) cov = compute_raw_covariance(raw, picks=picks) assert_snr(cov.data, cov_mne.data[picks][:, picks], 90) # cutoff samps # make sure we get a warning with too short a segment raw_2 = Raw(raw_fname).crop(0, 1) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') cov = compute_raw_covariance(raw_2) assert_true(any('Too few samples' in str(ww.message) for ww in w))