def ica_apply(raw, n_component=15, l_freq=0.5):
filt_raw = raw.copy()
filt_raw.load_data().filter(l_freq=l_freq, h_freq=None)
ica = ICA(n_components=n_component, random_state=97)
ica.fit(filt_raw)
return ica
tmin, tmax = -0.5, 0.5
epochs = mne.Epochs(raw,
events,
event_id,
tmin,
tmax,
proj=False,
picks=picks,
baseline=(None, 0),
preload=True,
reject=reject)
###############################################################################
# 1) Fit ICA model using the FastICA algorithm
ica = ICA(n_components=0.95, method='fastica').fit(epochs)
###############################################################################
# 2) Find ECG Artifacts
# generate ECG epochs to improve detection by correlation
ecg_epochs = create_ecg_epochs(raw, tmin=-.5, tmax=.5, picks=picks)
ecg_inds, scores = ica.find_bads_ecg(ecg_epochs)
ica.plot_scores(scores, exclude=ecg_inds)
title = 'Sources related to %s artifacts (red)'
show_picks = np.abs(scores).argsort()[::-1][:5]
ica.plot_sources(epochs, show_picks, exclude=ecg_inds, title=title % 'ecg')
ica.plot_components(ecg_inds, title=title % 'ecg', colorbar=True)
# ------- # # ICA parameters: n_components = 25 # if float, select n_components by explained variance of PCA method = 'fastica' # for comparison with EEGLAB try "extended-infomax" here decim = 3 # we need sufficient statistics, not all time points -> saves time # we will also set state of the random number generator - ICA is a # non-deterministic algorithm, but we want to have the same decomposition # and the same order of components each time this tutorial is run random_state = 23 ############################################################################### # Define the ICA object instance ica = ICA(n_components=n_components, method=method, random_state=random_state) print(ica) ############################################################################### # we avoid fitting ICA on crazy environmental artifacts that would # dominate the variance and decomposition reject = dict(mag=5e-12, grad=4000e-13) ica.fit(raw, picks=picks_meg, decim=decim, reject=reject) print(ica) ############################################################################### # Plot ICA components ica.plot_components() # can you spot some potential bad guys? ############################################################################### # Component properties
def test_ica_eeg():
"""Test ICA on EEG."""
method = 'fastica'
raw_fif = read_raw_fif(fif_fname, preload=True)
with pytest.warns(RuntimeWarning, match='events'):
raw_eeglab = read_raw_eeglab(input_fname=eeglab_fname,
montage=eeglab_montage,
preload=True)
for raw in [raw_fif, raw_eeglab]:
events = make_fixed_length_events(raw,
99999,
start=0,
stop=0.3,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = []
picks_all.extend(picks_meg)
picks_all.extend(picks_eeg)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2,
random_state=0,
max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst, picks=picks)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
with pytest.warns(RuntimeWarning, match='MISC channel'):
raw = read_raw_ctf(ctf_fname2, preload=True)
events = make_fixed_length_events(raw,
99999,
start=0,
stop=0.2,
duration=0.1)
picks_meg = pick_types(raw.info, meg=True, eeg=False)[:2]
picks_eeg = pick_types(raw.info, meg=False, eeg=True)[:2]
picks_all = picks_meg + picks_eeg
for comp in [0, 1]:
raw.apply_gradient_compensation(comp)
epochs = Epochs(raw, events, None, -0.1, 0.1, preload=True)
evoked = epochs.average()
for picks in [picks_meg, picks_eeg, picks_all]:
if len(picks) == 0:
continue
# test fit
for inst in [raw, epochs]:
ica = ICA(n_components=2,
random_state=0,
max_iter=2,
method=method)
with pytest.warns(None):
ica.fit(inst)
# test apply and get_sources
for inst in [raw, epochs, evoked]:
ica.apply(inst)
ica.get_sources(inst)
def test_ica_additional(method):
"""Test additional ICA functionality."""
_skip_check_picard(method)
import matplotlib.pyplot as plt
tempdir = _TempDir()
stop2 = 500
raw = read_raw_fif(raw_fname).crop(1.5, stop).load_data()
raw.del_proj() # avoid warnings
raw.set_annotations(Annotations([0.5], [0.5], ['BAD']))
# XXX This breaks the tests :(
# raw.info['bads'] = [raw.ch_names[1]]
test_cov = read_cov(test_cov_name)
events = read_events(event_name)
picks = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')[1::2]
epochs = Epochs(raw,
events,
None,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True,
proj=False)
epochs.decimate(3, verbose='error')
assert len(epochs) == 4
# test if n_components=None works
ica = ICA(n_components=None,
max_pca_components=None,
n_pca_components=None,
random_state=0,
method=method,
max_iter=1)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(epochs)
# for testing eog functionality
picks2 = np.concatenate([picks, pick_types(raw.info, False, eog=True)])
epochs_eog = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks2,
baseline=(None, 0),
preload=True)
del picks2
test_cov2 = test_cov.copy()
ica = ICA(noise_cov=test_cov2,
n_components=3,
max_pca_components=4,
n_pca_components=4,
method=method)
assert (ica.info is None)
with pytest.warns(RuntimeWarning, match='normalize_proj'):
ica.fit(raw, picks[:5])
assert (isinstance(ica.info, Info))
assert (ica.n_components_ < 5)
ica = ICA(n_components=3,
max_pca_components=4,
method=method,
n_pca_components=4,
random_state=0)
pytest.raises(RuntimeError, ica.save, '')
ica.fit(raw, picks=[1, 2, 3, 4, 5], start=start, stop=stop2)
# check passing a ch_name to find_bads_ecg
with pytest.warns(RuntimeWarning, match='longer'):
_, scores_1 = ica.find_bads_ecg(raw)
_, scores_2 = ica.find_bads_ecg(raw, raw.ch_names[1])
assert scores_1[0] != scores_2[0]
# test corrmap
ica2 = ica.copy()
ica3 = ica.copy()
corrmap([ica, ica2], (0, 0),
threshold='auto',
label='blinks',
plot=True,
ch_type="mag")
corrmap([ica, ica2], (0, 0), threshold=2, plot=False, show=False)
assert (ica.labels_["blinks"] == ica2.labels_["blinks"])
assert (0 in ica.labels_["blinks"])
# test retrieval of component maps as arrays
components = ica.get_components()
template = components[:, 0]
EvokedArray(components, ica.info, tmin=0.).plot_topomap([0], time_unit='s')
corrmap([ica, ica3],
template,
threshold='auto',
label='blinks',
plot=True,
ch_type="mag")
assert (ica2.labels_["blinks"] == ica3.labels_["blinks"])
plt.close('all')
# test warnings on bad filenames
ica_badname = op.join(op.dirname(tempdir), 'test-bad-name.fif.gz')
with pytest.warns(RuntimeWarning, match='-ica.fif'):
ica.save(ica_badname)
with pytest.warns(RuntimeWarning, match='-ica.fif'):
read_ica(ica_badname)
# test decim
ica = ICA(n_components=3,
max_pca_components=4,
n_pca_components=4,
method=method,
max_iter=1)
raw_ = raw.copy()
for _ in range(3):
raw_.append(raw_)
n_samples = raw_._data.shape[1]
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw, picks=picks[:5], decim=3)
assert raw_._data.shape[1] == n_samples
# test expl var
ica = ICA(n_components=1.0,
max_pca_components=4,
n_pca_components=4,
method=method,
max_iter=1)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw, picks=None, decim=3)
assert (ica.n_components_ == 4)
ica_var = _ica_explained_variance(ica, raw, normalize=True)
assert (np.all(ica_var[:-1] >= ica_var[1:]))
# test ica sorting
ica.exclude = [0]
ica.labels_ = dict(blink=[0], think=[1])
ica_sorted = _sort_components(ica, [3, 2, 1, 0], copy=True)
assert_equal(ica_sorted.exclude, [3])
assert_equal(ica_sorted.labels_, dict(blink=[3], think=[2]))
# epochs extraction from raw fit
pytest.raises(RuntimeError, ica.get_sources, epochs)
# test reading and writing
test_ica_fname = op.join(op.dirname(tempdir), 'test-ica.fif')
for cov in (None, test_cov):
ica = ICA(noise_cov=cov,
n_components=2,
max_pca_components=4,
n_pca_components=4,
method=method,
max_iter=1)
with pytest.warns(None): # ICA does not converge
ica.fit(raw, picks=picks[:10], start=start, stop=stop2)
sources = ica.get_sources(epochs).get_data()
assert (ica.mixing_matrix_.shape == (2, 2))
assert (ica.unmixing_matrix_.shape == (2, 2))
assert (ica.pca_components_.shape == (4, 10))
assert (sources.shape[1] == ica.n_components_)
for exclude in [[], [0], np.array([1, 2, 3])]:
ica.exclude = exclude
ica.labels_ = {'foo': [0]}
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
assert (list(ica.exclude) == ica_read.exclude)
assert_equal(ica.labels_, ica_read.labels_)
ica.apply(raw)
ica.exclude = []
ica.apply(raw, exclude=[1])
assert (ica.exclude == [])
ica.exclude = [0, 1]
ica.apply(raw, exclude=[1])
assert (ica.exclude == [0, 1])
ica_raw = ica.get_sources(raw)
assert (ica.exclude == [
ica_raw.ch_names.index(e) for e in ica_raw.info['bads']
])
# test filtering
d1 = ica_raw._data[0].copy()
ica_raw.filter(4, 20, fir_design='firwin2')
assert_equal(ica_raw.info['lowpass'], 20.)
assert_equal(ica_raw.info['highpass'], 4.)
assert ((d1 != ica_raw._data[0]).any())
d1 = ica_raw._data[0].copy()
ica_raw.notch_filter([10], trans_bandwidth=10, fir_design='firwin')
assert ((d1 != ica_raw._data[0]).any())
ica.n_pca_components = 2
ica.method = 'fake'
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
assert (ica.n_pca_components == ica_read.n_pca_components)
assert_equal(ica.method, ica_read.method)
assert_equal(ica.labels_, ica_read.labels_)
# check type consistency
attrs = ('mixing_matrix_ unmixing_matrix_ pca_components_ '
'pca_explained_variance_ pre_whitener_')
def f(x, y):
return getattr(x, y).dtype
for attr in attrs.split():
assert_equal(f(ica_read, attr), f(ica, attr))
ica.n_pca_components = 4
ica_read.n_pca_components = 4
ica.exclude = []
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
for attr in [
'mixing_matrix_', 'unmixing_matrix_', 'pca_components_',
'pca_mean_', 'pca_explained_variance_', 'pre_whitener_'
]:
assert_array_almost_equal(getattr(ica, attr),
getattr(ica_read, attr))
assert (ica.ch_names == ica_read.ch_names)
assert (isinstance(ica_read.info, Info))
sources = ica.get_sources(raw)[:, :][0]
sources2 = ica_read.get_sources(raw)[:, :][0]
assert_array_almost_equal(sources, sources2)
_raw1 = ica.apply(raw, exclude=[1])
_raw2 = ica_read.apply(raw, exclude=[1])
assert_array_almost_equal(_raw1[:, :][0], _raw2[:, :][0])
os.remove(test_ica_fname)
# check score funcs
for name, func in get_score_funcs().items():
if name in score_funcs_unsuited:
continue
scores = ica.score_sources(raw,
target='EOG 061',
score_func=func,
start=0,
stop=10)
assert (ica.n_components_ == len(scores))
# check univariate stats
scores = ica.score_sources(raw, score_func=stats.skew)
# check exception handling
pytest.raises(ValueError, ica.score_sources, raw, target=np.arange(1))
params = []
params += [(None, -1, slice(2), [0, 1])] # variance, kurtosis params
params += [(None, 'MEG 1531')] # ECG / EOG channel params
for idx, ch_name in product(*params):
ica.detect_artifacts(raw,
start_find=0,
stop_find=50,
ecg_ch=ch_name,
eog_ch=ch_name,
skew_criterion=idx,
var_criterion=idx,
kurt_criterion=idx)
evoked = epochs.average()
evoked_data = evoked.data.copy()
raw_data = raw[:][0].copy()
epochs_data = epochs.get_data().copy()
with pytest.warns(RuntimeWarning, match='longer'):
idx, scores = ica.find_bads_ecg(raw, method='ctps')
assert_equal(len(scores), ica.n_components_)
with pytest.warns(RuntimeWarning, match='longer'):
idx, scores = ica.find_bads_ecg(raw, method='correlation')
assert_equal(len(scores), ica.n_components_)
with pytest.warns(RuntimeWarning, match='longer'):
idx, scores = ica.find_bads_eog(raw)
assert_equal(len(scores), ica.n_components_)
idx, scores = ica.find_bads_ecg(epochs, method='ctps')
assert_equal(len(scores), ica.n_components_)
pytest.raises(ValueError,
ica.find_bads_ecg,
epochs.average(),
method='ctps')
pytest.raises(ValueError, ica.find_bads_ecg, raw, method='crazy-coupling')
with pytest.warns(RuntimeWarning, match='longer'):
idx, scores = ica.find_bads_eog(raw)
assert_equal(len(scores), ica.n_components_)
raw.info['chs'][raw.ch_names.index('EOG 061') - 1]['kind'] = 202
with pytest.warns(RuntimeWarning, match='longer'):
idx, scores = ica.find_bads_eog(raw)
assert (isinstance(scores, list))
assert_equal(len(scores[0]), ica.n_components_)
idx, scores = ica.find_bads_eog(evoked, ch_name='MEG 1441')
assert_equal(len(scores), ica.n_components_)
idx, scores = ica.find_bads_ecg(evoked, method='correlation')
assert_equal(len(scores), ica.n_components_)
assert_array_equal(raw_data, raw[:][0])
assert_array_equal(epochs_data, epochs.get_data())
assert_array_equal(evoked_data, evoked.data)
# check score funcs
for name, func in get_score_funcs().items():
if name in score_funcs_unsuited:
continue
scores = ica.score_sources(epochs_eog,
target='EOG 061',
score_func=func)
assert (ica.n_components_ == len(scores))
# check univariate stats
scores = ica.score_sources(epochs, score_func=stats.skew)
# check exception handling
pytest.raises(ValueError, ica.score_sources, epochs, target=np.arange(1))
# ecg functionality
ecg_scores = ica.score_sources(raw,
target='MEG 1531',
score_func='pearsonr')
with pytest.warns(RuntimeWarning, match='longer'):
ecg_events = ica_find_ecg_events(raw,
sources[np.abs(ecg_scores).argmax()])
assert (ecg_events.ndim == 2)
# eog functionality
eog_scores = ica.score_sources(raw,
target='EOG 061',
score_func='pearsonr')
with pytest.warns(RuntimeWarning, match='longer'):
eog_events = ica_find_eog_events(raw,
sources[np.abs(eog_scores).argmax()])
assert (eog_events.ndim == 2)
# Test ica fiff export
ica_raw = ica.get_sources(raw, start=0, stop=100)
assert (ica_raw.last_samp - ica_raw.first_samp == 100)
assert_equal(len(ica_raw._filenames), 1) # API consistency
ica_chans = [ch for ch in ica_raw.ch_names if 'ICA' in ch]
assert (ica.n_components_ == len(ica_chans))
test_ica_fname = op.join(op.abspath(op.curdir), 'test-ica_raw.fif')
ica.n_components = np.int32(ica.n_components)
ica_raw.save(test_ica_fname, overwrite=True)
ica_raw2 = read_raw_fif(test_ica_fname, preload=True)
assert_allclose(ica_raw._data, ica_raw2._data, rtol=1e-5, atol=1e-4)
ica_raw2.close()
os.remove(test_ica_fname)
# Test ica epochs export
ica_epochs = ica.get_sources(epochs)
assert (ica_epochs.events.shape == epochs.events.shape)
ica_chans = [ch for ch in ica_epochs.ch_names if 'ICA' in ch]
assert (ica.n_components_ == len(ica_chans))
assert (ica.n_components_ == ica_epochs.get_data().shape[1])
assert (ica_epochs._raw is None)
assert (ica_epochs.preload is True)
# test float n pca components
ica.pca_explained_variance_ = np.array([0.2] * 5)
ica.n_components_ = 0
for ncomps, expected in [[0.3, 1], [0.9, 4], [1, 1]]:
ncomps_ = ica._check_n_pca_components(ncomps)
assert (ncomps_ == expected)
ica = ICA(method=method)
with pytest.warns(None): # sometimes does not converge
ica.fit(raw, picks=picks[:5])
with pytest.warns(RuntimeWarning, match='longer'):
ica.find_bads_ecg(raw)
ica.find_bads_eog(epochs, ch_name='MEG 0121')
assert_array_equal(raw_data, raw[:][0])
raw.drop_channels(['MEG 0122'])
pytest.raises(RuntimeError, ica.find_bads_eog, raw)
with pytest.warns(RuntimeWarning, match='longer'):
pytest.raises(RuntimeError, ica.find_bads_ecg, raw)
def test_plot_ica_properties():
"""Test plotting of ICA properties."""
raw = _get_raw(preload=True).crop(0, 5)
raw.add_proj([], remove_existing=True)
events = make_fixed_length_events(raw)
picks = _get_picks(raw)[:6]
pick_names = [raw.ch_names[k] for k in picks]
raw.pick_channels(pick_names)
reject = dict(grad=4000e-13, mag=4e-12)
epochs = Epochs(raw,
events[:3],
event_id,
tmin,
tmax,
baseline=(None, 0),
preload=True)
ica = ICA(noise_cov=read_cov(cov_fname),
n_components=2,
max_iter=1,
random_state=0)
with pytest.warns(RuntimeWarning, match='projection'):
ica.fit(raw)
# test _create_properties_layout
fig, ax = _create_properties_layout()
assert_equal(len(ax), 5)
with pytest.raises(ValueError, match='specify both fig and figsize'):
_create_properties_layout(figsize=(2, 2), fig=fig)
topoargs = dict(topomap_args={'res': 4, 'contours': 0, "sensors": False})
with catch_logging() as log:
ica.plot_properties(raw, picks=0, verbose='debug', **topoargs)
log = log.getvalue()
assert raw.ch_names[0] == 'MEG 0113'
assert 'Interpolation mode local to mean' in log, log
ica.plot_properties(epochs, picks=1, dB=False, plot_std=1.5, **topoargs)
ica.plot_properties(epochs,
picks=1,
image_args={'sigma': 1.5},
topomap_args={
'res': 4,
'colorbar': True
},
psd_args={'fmax': 65.},
plot_std=False,
figsize=[4.5, 4.5],
reject=reject)
plt.close('all')
with pytest.raises(TypeError, match='must be an instance'):
ica.plot_properties(epochs, dB=list('abc'))
with pytest.raises(TypeError, match='must be an instance'):
ica.plot_properties(ica)
with pytest.raises(TypeError, match='must be an instance'):
ica.plot_properties([0.2])
with pytest.raises(TypeError, match='must be an instance'):
plot_ica_properties(epochs, epochs)
with pytest.raises(TypeError, match='must be an instance'):
ica.plot_properties(epochs, psd_args='not dict')
with pytest.raises(TypeError, match='must be an instance'):
ica.plot_properties(epochs, plot_std=[])
fig, ax = plt.subplots(2, 3)
ax = ax.ravel()[:-1]
ica.plot_properties(epochs, picks=1, axes=ax, **topoargs)
pytest.raises(TypeError,
plot_ica_properties,
epochs,
ica,
picks=[0, 1],
axes=ax)
pytest.raises(ValueError, ica.plot_properties, epochs, axes='not axes')
plt.close('all')
# Test merging grads.
pick_names = raw.ch_names[:15:2] + raw.ch_names[1:15:2]
raw = _get_raw(preload=True).pick_channels(pick_names).crop(0, 5)
raw.info.normalize_proj()
ica = ICA(random_state=0, max_iter=1)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw)
ica.plot_properties(raw)
plt.close('all')
# Test handling of zeros
ica = ICA(random_state=0, max_iter=1)
epochs.pick_channels(pick_names)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(epochs)
epochs._data[0] = 0
with pytest.warns(None): # Usually UserWarning: Infinite value .* for epo
ica.plot_properties(epochs, **topoargs)
plt.close('all')
# Test Raw with annotations
annot = Annotations(onset=[1], duration=[1], description=['BAD'])
raw_annot = _get_raw(preload=True).set_annotations(annot).crop(0, 8)
raw_annot.pick(np.arange(10))
raw_annot.del_proj()
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw_annot)
# drop bad data segments
fig = ica.plot_properties(raw_annot, picks=[0, 1], **topoargs)
assert_equal(len(fig), 2)
# don't drop
ica.plot_properties(raw_annot, reject_by_annotation=False, **topoargs)
def test_plot_ica_components():
"""Test plotting of ICA solutions."""
res = 8
fast_test = {"res": res, "contours": 0, "sensors": False}
raw = _get_raw()
ica = ICA(noise_cov=read_cov(cov_fname), n_components=2)
ica_picks = _get_picks(raw)
with pytest.warns(RuntimeWarning, match='projection'):
ica.fit(raw, picks=ica_picks)
for components in [0, [0], [0, 1], [0, 1] * 2, None]:
ica.plot_components(components,
image_interp='bilinear',
colorbar=True,
**fast_test)
plt.close('all')
# test interactive mode (passing 'inst' arg)
with catch_logging() as log:
ica.plot_components([0, 1],
image_interp='bilinear',
inst=raw,
res=16,
verbose='debug',
ch_type='grad')
log = log.getvalue()
assert 'grad data' in log
assert 'Interpolation mode local to mean' in log
fig = plt.gcf()
# test title click
# ----------------
lbl = fig.axes[1].get_label()
ica_idx = int(lbl[-3:])
titles = [ax.title for ax in fig.axes]
title_pos_midpoint = (titles[1].get_window_extent().extents.reshape(
(2, 2)).mean(axis=0))
# first click adds to exclude
_fake_click(fig, fig.axes[1], title_pos_midpoint, xform='pix')
assert ica_idx in ica.exclude
# clicking again removes from exclude
_fake_click(fig, fig.axes[1], title_pos_midpoint, xform='pix')
assert ica_idx not in ica.exclude
# test topo click
# ---------------
_fake_click(fig, fig.axes[1], (0., 0.), xform='data')
c_fig = plt.gcf()
labels = [ax.get_label() for ax in c_fig.axes]
for label in ['topomap', 'image', 'erp', 'spectrum', 'variance']:
assert label in labels
topomap_ax = c_fig.axes[labels.index('topomap')]
title = topomap_ax.get_title()
assert (lbl == title)
ica.info = None
with pytest.raises(RuntimeError, match='fit the ICA'):
ica.plot_components(1, ch_type='mag')
raw = Raw(maxfiltered_folder + "%s_%s_mc_tsss-raw.fif" % (subject,
condition),
preload=True)
raw.drop_channels(raw.info["bads"])
raw.notch_filter(n_freq, n_jobs=n_jobs)
raw.filter(l_freq, h_freq, n_jobs=n_jobs)
raw.save(save_folder + "%s_%s_filtered_mc_tsss-raw.fif" % (subject,
condition),
overwrite=True)
# ICA Part
ica = ICA(n_components=0.99, method='fastica', max_iter=256)
picks = mne.pick_types(raw.info, meg=True, eeg=False, eog=False, emg=False,
bio=False, stim=False, exclude='bads')
ica.fit(raw, picks=picks, decim=decim, reject=reject_params)
# maximum number of components to reject
n_max_eog = 1
##########################################################################
# 2) identify bad components by analyzing latent sources.
# DETECT EOG BY CORRELATION
# HORIZONTAL EOG
title = "ICA: %s for %s"
def remove_linenoise(raw,
noise_freq,
width=2,
shuffle_time=True,
decim=100,
n_component=1,
plot=False,
copy=True,
picks=None,
harmonics=True):
import matplotlib.pyplot as plt
from mne import pick_types
from mne.preprocessing import ICA
from mne.time_frequency.psd import psd_welch
# Setup line frequency
if isinstance(noise_freq, str):
# automatic harmonics
if noise_freq == 'us':
noise_freq = 60
else:
noise_freq = 50
elif not isinstance(noise_freq, (float, int)):
raise NotImplementedError('Multiple bands')
def plot_psd(psd, freqs, ax, title):
for psd_ in psd:
ax.plot(freqs, np.log10(psd_))
ax.set_xlabel('Frequencies')
ax.set_title(title)
if copy:
raw = raw.copy()
if picks is None:
picks = pick_types(raw.info, eeg=True, meg=True, seeg=True)
if plot:
fig, axes = plt.subplots(1, 3, sharex=True)
psd, freqs = psd_welch(raw, picks=picks)
plot_psd(psd, freqs, axes[0], 'Raw Sensors')
# Fit ICA on filtered data
raw_ = raw.copy()
if harmonics:
# set up harmonics
n_harm = raw_.info['sfreq'] // (2. * noise_freq) + 1
harmonics = noise_freq * np.arange(1, n_harm)
# Band pass filtering outside lowest harmonics and nquist
raw_.filter(noise_freq - width, harmonics[-1] + width)
# Band stop filter in between harmonics
raw_.notch_filter(freqs=harmonics[:-1] + noise_freq // 2,
notch_widths=noise_freq - 2 * width)
else:
raw_.filter(noise_freq - width, noise_freq + width)
# Shuffle time axis to avoid decimation aliasing
if shuffle_time:
time = np.arange(raw_.n_times)
np.random.shuffle(time)
raw_._data[:, time] = raw_._data
ica = ICA(verbose=False)
ica.fit(raw_, decim=decim, picks=picks)
# Compute PSD of components
raw_._data[picks, :] = np.dot(ica.mixing_matrix_, raw._data[picks, :])
psd, freqs = psd_welch(raw_, picks=picks)
if plot:
plot_psd(psd, freqs, axes[1], 'Components')
# Find noise component and remove
freq = np.where(freqs >= noise_freq)[0][0]
sel = np.argsort(psd[:, freq])[-n_component:].tolist()
raw_ = ica.apply(raw, exclude=sel, copy=True)
if plot:
psd, freqs = psd_welch(raw_, picks=picks)
plot_psd(psd, freqs, axes[2], 'Clean sensors')
return raw_
preload=True) #get rid of empty channels
'Initial frequency filtering'
raw.filter(0.1, 70) #bandpass filter between 0.1 and 70 Hz
'Initialize variables, obtain frequency and # of timepoints, channels'
(data1, times) = raw[::, ::]
data1 = data1.T
(timepoints, channels) = data1.shape
frequency = raw.info['sfreq']
errorval = [0] * 500 #used for error calculation
errorval2 = [0] * 500 #used for error calculation
totaltrials = np.arange(500) + 5
'ICA'
ica = ICA(n_components=32) #set up ica
ica.fit(raw) #run the ica
ica.plot_components() #plot the topographs of each component
Montage.plot(show_names=True) #plot the electrode locations
ica.plot_properties(raw, picks=0) #plot the properties of a single component
ica.plot_sources(raw) #plot the timecourse of each component
ica.plot_overlay(raw, exclude=[0, 2, 11, 19, 21, 24, 30,
33]) #plot the proposed transformation
ica.apply(raw, exclude=[0, 2, 11, 19, 21, 24, 30,
33]) #apply the transformation
'Change-able variables'
channeltopick = 49
thetathreshold = 0.5
'Pick 1 channel'
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')
# 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(tmpdir, 'report.html')
r.save(fname=fname, open_browser=False)
def apply_ica_data(fname,
raw=None,
do_run=False,
verbose=False,
save=True,
fif_extention=".fif",
fif_postfix="-ica",
**kwargs):
"""
apply mne ica
return
fnica_out : fif filename of mne ica-obj
raw : fif-raw obj
ICAobj : mne-ica-object
Attributes
----------
current_fit : str
Flag informing about which data type (raw or epochs) was used for
the fit.
ch_names : list-like
Channel names resulting from initial picking.
The number of components used for ICA decomposition.
n_components_` : int
If fit, the actual number of components used for ICA decomposition.
n_pca_components : int
See above.
max_pca_components : int
The number of components used for PCA dimensionality reduction.
verbose : bool, str, int, or None
See above.
pca_components_` : ndarray
If fit, the PCA components
pca_mean_` : ndarray
If fit, the mean vector used to center the data before doing the PCA.
pca_explained_variance_` : ndarray
If fit, the variance explained by each PCA component
mixing_matrix_` : ndarray
If fit, the mixing matrix to restore observed data, else None.
unmixing_matrix_` : ndarray
If fit, the matrix to unmix observed data, else None.
exclude : list
List of sources indices to exclude, i.e. artifact components identified
throughout the ICA solution. Indices added to this list, will be
dispatched to the .pick_sources methods. Source indices passed to
the .pick_sources method via the 'exclude' argument are added to the
.exclude attribute. When saving the ICA also the indices are restored.
Hence, artifact components once identified don't have to be added
again. To dump this 'artifact memory' say: ica.exclude = []
info : None | instance of mne.io.meas_info.Info
The measurement info copied from the object fitted.
n_samples_` : int
the number of samples used on fit.
"""
ICAobj = None
if do_run:
raw, fname = jumeg_base.get_raw_obj(fname, raw=raw)
from mne.preprocessing import ICA
picks = jumeg_base.pick_meg_nobads(raw)
#--- init MNE ICA obj
kwargs['global_parameter']['verbose'] = verbose
ICAobj = ICA(**kwargs['global_parameter'])
#--- run mne ica
kwargs['fit_parameter']['verbose'] = verbose
ICAobj.fit(raw, picks=picks, **kwargs['fit_parameter'])
fnica_out = fname[:fname.rfind('-raw.fif'
)] + fif_postfix + fif_extention
# fnica_out = fname[0:len(fname)-4]+'-ica.fif'
#--- save ICA object
if save:
ICAobj.save(fnica_out)
print "===> Done JuMEG MNE ICA : " + fnica_out
print "\n"
return (fnica_out, raw, ICAobj)
preload=False)
for run in range(2, 7):
raw.append(mne.io.read_raw_fif(
fname.filt(subject=subject, run=run, fmin=1, fmax=bandpass_fmax),
preload=False))
# SSS reduces the data rank and the noise levels, so let's include
# components based on a higher proportion of variance explained (0.999)
# than we would otherwise do for non-Maxwell-filtered raw data (0.98)
n_components = 0.999
# Define the parameters for the ICA. There is a random component to this.
# We set a specific seed for the random state, so this script produces exactly
# the same results every time.
print('Fitting ICA')
ica = ICA(method='fastica', random_state=42, n_components=n_components)
# To compute the ICA, we don't need all data. We just need enough data to
# perform the statistics to a reasonable degree. Here, we use every 11th
# sample. We also apply some rejection limits to discard epochs with overly
# large signals that are likely due to the subject moving about.
ica.fit(raw, reject=dict(grad=4000e-13, mag=4e-12), decim=11)
print('Fit %d components (explaining at least %0.1f%% of the variance)'
% (ica.n_components_, 100 * n_components))
# Find onsets of heart beats and blinks. Create epochs around them
ecg_epochs = create_ecg_epochs(raw, tmin=-.3, tmax=.3, preload=False)
eog_epochs = create_eog_epochs(raw, tmin=-.5, tmax=.5, preload=False)
# Find ICA components that correlate with heart beats.
ecg_epochs.decimate(5)
baseline=(0, 0),
reject=None,
verbose=False,
detrend=0,
preload=True)
# plot epochs
epochs.plot()
#%% Fit ICA on epochs under rejection threshhold trials
# find peak to peak rejection threshhold
reject = get_rejection_threshold(epochs)
# run ICA on all epochs lower than the threshhold
ica = ICA(n_components=15, random_state=42)
ica.fit(epochs, reject=reject, tstep=tstep)
# plot the components
raw.load_data()
ica.plot_sources(raw)
ica.plot_components()
# notify when done
os.system('say "... I am ready for you Neil."')
#%% Select components to exclude and zero them out
rm_select = [0, 3, 8]
'proportion_rejected_epochs': len(bad_epochs)/len(epochs),
'metadata': 'n/a',
'artifact_detection': {
'extreme_value': [int(i) for i in ext_val_bad.nonzero()[0]],
'global_p2p': [int(i) for i in p2p_bad.nonzero()[0]],
'blink_at_onset': [int(i) for i in blink_inds]
}
}
json_file = deriv_path / f'{sub}_task-{task}_ref-FCz_desc-ica_epo.json'
with open(json_file, 'w') as outfile:
json.dump(json_info, outfile, indent=4)
del json_info, json_file
# Estimate ICA
ica = ICA(method='picard', max_iter=1000, random_state=97,
fit_params=dict(ortho=True, extended=True),
verbose=True)
ica.fit(epochs)
# Save ICA
ica_file = deriv_path / f'{sub}_task-{task}_ref-FCz_desc-ica_ica.fif.gz'
ica.save(ica_file)
# Find EOG artifacts
eog_inds, eog_scores = ica.find_bads_eog(raw)
ica.exclude = eog_inds
eog_ica_plot = ica.plot_scores(eog_scores, labels=['VEOG', 'HEOG'])
eog_ica_file = fig_path / f'{sub}_task-{task}_ic_eog_scores.png'
eog_ica_plot.savefig(eog_ica_file, dpi=600)
plt.close(eog_ica_plot)
def __run_ica_rejection(self,
epochs,
n_components=None,
random_state=42,
method='fastica',
fit_params=None,
max_iter=200,
make_plots=False):
"""
Simple function for running ICA artifact rejection, based on hardcoded options.
Parameters
----------
epochs : Epoch object (MNE)
MNE ready epochs to process. See 'build_epochs' for more details.
n_components : int, optional
Number of principal components passed to the ICA during fitting.
See the mne.preprocessing.ICA docstring for more details.
The default is None.
random_state : int, optional
The value to be used as the 'seed' for `numpy.random.RandomState`.
See the mne.preprocessing.ICA docstring for more details.
The default is 42.
method : TYPE, optional
ICA method to be used. Can be 'fastica', 'infomax', or 'picard'.
See the mne.preprocessing.ICA docstring for more details.
The default is 'fastica'.
fit_params : dict, optional
Additional parameters pased to the ICA estimator as specified by 'method'.
See the mne.preprocessing.ICA docstring for more details.
The default is None.
max_iter : int, optional
Maximum number of iterations during ICA fit.
The default is 200.
make_plots : bool, optional
Plot the individual principal components found for the ICA.
The default is False.
Returns
-------
cleaned_epochs : Epoch object
Returns an artifact cleaned MNE ready epoch object.
See Also
--------
mne.preprocessing.ICA
"""
if method.casefold() == 'infomax':
fit_params = dict(extended=True) # For extended infomax
# We will use artificat rejection for each epoch through ICA.
ica = ICA(n_components=n_components,
random_state=random_state,
method=method,
fit_params=fit_params,
max_iter=max_iter)
# Fit the ICA
ica.fit(epochs)
# Detect artifacts automatically
ica.detect_artifacts(epochs)
# Exclude based on detected artifacts
ica.exclude
print("The rejected ICA components were: " + str(ica.exclude))
# This is just making basic plots right now. Will update later to be more thorough.
if make_plots is True and n_components is None:
nchans = ica.info['nchan']
ica.plot_components()
[ica.plot_properties(epochs, picks=[x]) for x in range(0, nchans)]
elif make_plots is True:
ncomps = n_components
ica.plot_components()
[ica.plot_properties(epochs, picks=[x]) for x in range(0, ncomps)]
# Save to new data - not needed here, but kept just in case
cleaned_epochs = epochs.copy()
# Apply ICA rejections
ica.apply(cleaned_epochs)
return cleaned_epochs
# Create events
events = np.load(os.path.join(sub_path, 'events.npy'))
events = np.insert(events, 1, 0, axis=1).astype(np.uint)
events[:, 0] = events[:, 0] * 128 / 1000
event_id = {"correct": 0, "wrong": 2}
# Read and filter
edf = os.path.join(sub_path, sub + '.edf')
edf_data = mne.io.read_raw_edf(edf, preload=True)
# mne.filter.notch_filter(edf_data, edf_data.info['sfreq'], freqs=50)
edf_data.drop_channels(drops)
edf_data.plot(events=events, title=sub)
edf_data.filter(l_freq=0.2, h_freq=40)
# ICA stuff
ica = ICA(n_components=7, random_state=97)
ica.fit(edf_data)
ica.plot_sources(edf_data)
ica.plot_components(layout=layout)
epochs = mne.Epochs(edf_data,
events,
event_id=event_id,
tmin=-0.5,
tmax=1.5,
preload=True)
correct = epochs['correct']
wrong = epochs['wrong']
# correct.plot_image()
# plt.show()
def test_plot_ica_sources(raw_orig, browser_backend, monkeypatch):
"""Test plotting of ICA panel."""
raw = raw_orig.copy().crop(0, 1)
picks = _get_picks(raw)
epochs = _get_epochs()
raw.pick_channels([raw.ch_names[k] for k in picks])
ica_picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=False,
ecg=False,
eog=False,
exclude='bads')
ica = ICA(n_components=2)
ica.fit(raw, picks=ica_picks)
ica.exclude = [1]
if sys.platform == 'darwin': # unknown transformation bug
monkeypatch.setenv('MNE_BROWSE_RAW_SIZE', '20,20')
fig = ica.plot_sources(raw)
assert browser_backend._get_n_figs() == 1
# change which component is in ICA.exclude (click data trace to remove
# current one; click name to add other one)
fig._redraw()
assert_array_equal(ica.exclude, [1])
assert fig.mne.info['bads'] == [ica._ica_names[1]]
x = fig.mne.traces[1].get_xdata()[5]
y = fig.mne.traces[1].get_ydata()[5]
fig._fake_click((x, y), xform='data') # exclude = []
assert fig.mne.info['bads'] == []
assert_array_equal(ica.exclude, [1]) # unchanged
fig._click_ch_name(ch_index=0, button=1) # exclude = [0]
assert fig.mne.info['bads'] == [ica._ica_names[0]]
assert_array_equal(ica.exclude, [1])
fig._fake_keypress(fig.mne.close_key)
fig._close_event()
assert browser_backend._get_n_figs() == 0
assert_array_equal(ica.exclude, [0])
# test when picks does not include ica.exclude.
ica.plot_sources(raw, picks=[1])
assert browser_backend._get_n_figs() == 1
browser_backend._close_all()
# dtype can change int->np.int64 after load, test it explicitly
ica.n_components_ = np.int64(ica.n_components_)
# test clicks on y-label (need >2 secs for plot_properties() to work)
long_raw = raw_orig.crop(0, 5)
fig = ica.plot_sources(long_raw)
assert browser_backend._get_n_figs() == 1
fig._redraw()
fig._click_ch_name(ch_index=0, button=3)
assert len(fig.mne.child_figs) == 1
assert browser_backend._get_n_figs() == 2
# close child fig directly (workaround for mpl issue #18609)
fig._fake_keypress('escape', fig=fig.mne.child_figs[0])
assert browser_backend._get_n_figs() == 1
fig._fake_keypress(fig.mne.close_key)
assert browser_backend._get_n_figs() == 0
del long_raw
# test with annotations
orig_annot = raw.annotations
raw.set_annotations(Annotations([0.2], [0.1], 'Test'))
fig = ica.plot_sources(raw)
if browser_backend.name == 'matplotlib':
assert len(fig.mne.ax_main.collections) == 1
assert len(fig.mne.ax_hscroll.collections) == 1
else:
assert len(fig.mne.regions) == 1
raw.set_annotations(orig_annot)
# test error handling
raw_ = raw.copy().load_data()
raw_.drop_channels('MEG 0113')
with pytest.raises(RuntimeError, match="Raw doesn't match fitted data"), \
pytest.warns(RuntimeWarning, match='could not be picked'):
ica.plot_sources(inst=raw_)
epochs_ = epochs.copy().load_data()
epochs_.drop_channels('MEG 0113')
with pytest.raises(RuntimeError, match="Epochs don't match fitted data"), \
pytest.warns(RuntimeWarning, match='could not be picked'):
ica.plot_sources(inst=epochs_)
del raw_
del epochs_
# test w/ epochs and evokeds
ica.plot_sources(epochs)
ica.plot_sources(epochs.average())
evoked = epochs.average()
fig = ica.plot_sources(evoked)
# Test a click
ax = fig.get_axes()[0]
line = ax.lines[0]
_fake_click(fig, ax, [line.get_xdata()[0], line.get_ydata()[0]], 'data')
_fake_click(fig, ax, [ax.get_xlim()[0], ax.get_ylim()[1]], 'data')
# plot with bad channels excluded
ica.exclude = [0]
ica.plot_sources(evoked)
# pretend find_bads_eog() yielded some results
ica.labels_ = {'eog': [0], 'eog/0/crazy-channel': [0]}
ica.plot_sources(evoked) # now with labels
# pass an invalid inst
with pytest.raises(ValueError, match='must be of Raw or Epochs type'):
ica.plot_sources('meeow')
def test_plot_ica_sources():
"""Test plotting of ICA panel."""
raw = read_raw_fif(raw_fname).crop(0, 1).load_data()
picks = _get_picks(raw)
epochs = _get_epochs()
raw.pick_channels([raw.ch_names[k] for k in picks])
ica_picks = pick_types(raw.info,
meg=True,
eeg=False,
stim=False,
ecg=False,
eog=False,
exclude='bads')
ica = ICA(n_components=2)
ica.fit(raw, picks=ica_picks)
ica.exclude = [1]
fig = ica.plot_sources(raw)
assert len(plt.get_fignums()) == 1
# change which component is in ICA.exclude (click data trace to remove
# current one; click name to add other one)
fig.canvas.draw()
x = fig.mne.traces[1].get_xdata()[5]
y = fig.mne.traces[1].get_ydata()[5]
_fake_click(fig, fig.mne.ax_main, (x, y), xform='data') # exclude = []
_click_ch_name(fig, ch_index=0, button=1) # exclude = [0]
fig.canvas.key_press_event(fig.mne.close_key)
_close_event(fig)
assert len(plt.get_fignums()) == 0
assert_array_equal(ica.exclude, [0])
plt.close('all')
# dtype can change int->np.int64 after load, test it explicitly
ica.n_components_ = np.int64(ica.n_components_)
# test clicks on y-label (need >2 secs for plot_properties() to work)
long_raw = read_raw_fif(raw_fname).crop(0, 5).load_data()
fig = ica.plot_sources(long_raw)
assert len(plt.get_fignums()) == 1
fig.canvas.draw()
_fake_click(fig, fig.mne.ax_main, (-0.1, 0), xform='data', button=3)
assert len(fig.mne.child_figs) == 1
assert len(plt.get_fignums()) == 2
# close child fig directly (workaround for mpl issue #18609)
fig.mne.child_figs[0].canvas.key_press_event('escape')
assert len(plt.get_fignums()) == 1
fig.canvas.key_press_event(fig.mne.close_key)
assert len(plt.get_fignums()) == 0
del long_raw
# test with annotations
orig_annot = raw.annotations
raw.set_annotations(Annotations([0.2], [0.1], 'Test'))
fig = ica.plot_sources(raw)
assert len(fig.mne.ax_main.collections) == 1
assert len(fig.mne.ax_hscroll.collections) == 1
raw.set_annotations(orig_annot)
# test error handling
raw.info['bads'] = ['MEG 0113']
with pytest.raises(RuntimeError, match="Raw doesn't match fitted data"):
ica.plot_sources(inst=raw)
epochs.info['bads'] = ['MEG 0113']
with pytest.raises(RuntimeError, match="Epochs don't match fitted data"):
ica.plot_sources(inst=epochs)
epochs.info['bads'] = []
# test w/ epochs and evokeds
ica.plot_sources(epochs)
ica.plot_sources(epochs.average())
evoked = epochs.average()
fig = ica.plot_sources(evoked)
# Test a click
ax = fig.get_axes()[0]
line = ax.lines[0]
_fake_click(fig, ax, [line.get_xdata()[0], line.get_ydata()[0]], 'data')
_fake_click(fig, ax, [ax.get_xlim()[0], ax.get_ylim()[1]], 'data')
# plot with bad channels excluded
ica.exclude = [0]
ica.plot_sources(evoked)
ica.labels_ = dict(eog=[0])
ica.labels_['eog/0/crazy-channel'] = [0]
ica.plot_sources(evoked) # now with labels
with pytest.raises(ValueError, match='must be of Raw or Epochs type'):
ica.plot_sources('meeow')
##normalizing ICA data
#for epochs_idx in range(len(ica_data)):
# for channels_idx in range(14):
# ica_data[epochs_idx,channels_idx] /= ica_data[epochs_idx].sum()
ica_data_reshape = ica_data.reshape(
(ica_data.shape[0], ica_data.shape[1] * ica_data.shape[2]))
#------------------------------------------------------------------------------
#Checking ICA through plot
method = 'fastica'
random_state = 42
ica = ICA(n_components=13, method=method, random_state=random_state)
ica.fit(epochs)
ica.plot_components()
ica.plot_properties(epochs, picks=0)
ica.plot_overlay(evoked, title='Plot Overlay', show=True)
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
#------------------------------------------------------------------------------
from PIL import Image
import os.path, sys
#zero-produceERP-Image
steps = np.arange(9.5, 20.5, 0.001)
for step in steps:
def test_plot_ica_properties():
"""Test plotting of ICA properties."""
res = 8
raw = _get_raw(preload=True)
raw.add_proj([], remove_existing=True)
events = _get_events()
picks = _get_picks(raw)[:6]
pick_names = [raw.ch_names[k] for k in picks]
raw.pick_channels(pick_names)
reject = dict(grad=4000e-13, mag=4e-12)
epochs = Epochs(raw,
events[:10],
event_id,
tmin,
tmax,
baseline=(None, 0),
preload=True)
ica = ICA(noise_cov=read_cov(cov_fname),
n_components=2,
max_iter=1,
max_pca_components=2,
n_pca_components=2,
random_state=0)
with pytest.warns(RuntimeWarning, match='projection'):
ica.fit(raw)
# test _create_properties_layout
fig, ax = _create_properties_layout()
assert_equal(len(ax), 5)
topoargs = dict(topomap_args={'res': res, 'contours': 0, "sensors": False})
ica.plot_properties(raw, picks=0, **topoargs)
ica.plot_properties(epochs, picks=1, dB=False, plot_std=1.5, **topoargs)
ica.plot_properties(epochs,
picks=1,
image_args={'sigma': 1.5},
topomap_args={
'res': 10,
'colorbar': True
},
psd_args={'fmax': 65.},
plot_std=False,
figsize=[4.5, 4.5],
reject=reject)
plt.close('all')
pytest.raises(TypeError, ica.plot_properties, epochs, dB=list('abc'))
pytest.raises(TypeError, ica.plot_properties, ica)
pytest.raises(TypeError, ica.plot_properties, [0.2])
pytest.raises(TypeError, plot_ica_properties, epochs, epochs)
pytest.raises(TypeError, ica.plot_properties, epochs, psd_args='not dict')
pytest.raises(ValueError, ica.plot_properties, epochs, plot_std=[])
fig, ax = plt.subplots(2, 3)
ax = ax.ravel()[:-1]
ica.plot_properties(epochs, picks=1, axes=ax, **topoargs)
fig = ica.plot_properties(raw, picks=[0, 1], **topoargs)
assert_equal(len(fig), 2)
pytest.raises(TypeError,
plot_ica_properties,
epochs,
ica,
picks=[0, 1],
axes=ax)
pytest.raises(ValueError, ica.plot_properties, epochs, axes='not axes')
plt.close('all')
# Test merging grads.
pick_names = raw.ch_names[:15:2] + raw.ch_names[1:15:2]
raw = _get_raw(preload=True).pick_channels(pick_names)
raw.info.normalize_proj()
ica = ICA(random_state=0, max_iter=1)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw)
ica.plot_properties(raw)
plt.close('all')
# Test handling of zeros
raw._data[:] = 0
with pytest.warns(UserWarning, match='Infinite value .* for epochs '):
ica.plot_properties(raw)
ica = ICA(random_state=0, max_iter=1)
epochs.pick_channels(pick_names)
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(epochs)
epochs._data[0] = 0
with pytest.warns(UserWarning, match='Infinite value .* for epoch 0'):
ica.plot_properties(epochs)
plt.close('all')
def run_ica(subject, tsss=config.mf_st_duration):
print("Processing subject: %s" % subject)
meg_subject_dir = op.join(config.meg_dir, subject)
raw_list = list()
events_list = list()
print(" Loading raw data")
for run in config.runs:
extension = run + '_filt_raw'
raw_fname_in = op.join(meg_subject_dir,
config.base_fname.format(**locals()))
eve_fname = op.splitext(raw_fname_in)[0] + '-eve.fif'
print("Input: ", raw_fname_in, eve_fname)
raw = mne.io.read_raw_fif(raw_fname_in, preload=True)
events = mne.read_events(eve_fname)
events_list.append(events)
raw_list.append(raw)
print(' Concatenating runs')
raw, events = mne.concatenate_raws(raw_list, events_list=events_list)
if "eeg" in config.ch_types:
raw.set_eeg_reference(projection=True)
del raw_list
# don't reject based on EOG to keep blink artifacts
# in the ICA computation.
reject_ica = config.reject
if reject_ica and 'eog' in reject_ica:
reject_ica = dict(reject_ica)
del reject_ica['eog']
# produce high-pass filtered version of the data for ICA
raw_ica = raw.copy().filter(l_freq=1., h_freq=None)
print(" Running ICA...")
epochs_for_ica = mne.Epochs(raw_ica,
events,
config.event_id,
config.tmin,
config.tmax,
proj=True,
baseline=config.baseline,
preload=True,
decim=config.decim,
reject=reject_ica)
# run ICA on MEG and EEG
picks_meg = mne.pick_types(epochs_for_ica.info,
meg=True,
eeg=False,
eog=False,
stim=False,
exclude='bads')
picks_eeg = mne.pick_types(epochs_for_ica.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
all_picks = {'meg': picks_meg, 'eeg': picks_eeg}
# get number of components for ICA
# compute_rank requires 0.18
# n_components_meg = (mne.compute_rank(epochs_for_ica.copy()
# .pick_types(meg=True)))['meg']
n_components_meg = 0.999
n_components = {'meg': n_components_meg, 'eeg': 0.999}
ch_types = []
if 'eeg' in config.ch_types:
ch_types.append('eeg')
if set(config.ch_types).intersection(('meg', 'grad', 'mag')):
ch_types.append('meg')
for ch_type in ch_types:
print('Running ICA for ' + ch_type)
ica = ICA(method='fastica',
random_state=config.random_state,
n_components=n_components[ch_type])
picks = all_picks[ch_type]
ica.fit(epochs_for_ica, picks=picks, decim=config.ica_decim)
print(' Fit %d components (explaining at least %0.1f%% of the'
' variance)' % (ica.n_components_, 100 * n_components[ch_type]))
ica_fname = \
'{0}_{1}_{2}-ica.fif'.format(subject, config.study_name, ch_type)
ica_fname = op.join(meg_subject_dir, ica_fname)
ica.save(ica_fname)
if config.plot:
# plot ICA components to html report
report_fname = \
'{0}_{1}_{2}-ica.html'.format(subject, config.study_name,
ch_type)
report_fname = op.join(meg_subject_dir, report_fname)
report = Report(report_fname, verbose=False)
for idx in range(0, ica.n_components_):
figure = ica.plot_properties(epochs_for_ica,
picks=idx,
psd_args={'fmax': 60},
show=False)
report.add_figs_to_section(figure,
section=subject,
captions=(ch_type.upper() +
' - ICA Components'))
report.save(report_fname, overwrite=True, open_browser=False)
def test_ica_core(method):
"""Test ICA on raw and epochs."""
_skip_check_picard(method)
raw = read_raw_fif(raw_fname).crop(1.5, stop).load_data()
# XXX. The None cases helped revealing bugs but are time consuming.
test_cov = read_cov(test_cov_name)
events = read_events(event_name)
picks = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
epochs = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
noise_cov = [None, test_cov]
# removed None cases to speed up...
n_components = [2, 1.0] # for future dbg add cases
max_pca_components = [3]
picks_ = [picks]
methods = [method]
iter_ica_params = product(noise_cov, n_components, max_pca_components,
picks_, methods)
# # test init catchers
pytest.raises(ValueError, ICA, n_components=3, max_pca_components=2)
pytest.raises(ValueError, ICA, n_components=2.3, max_pca_components=2)
# test essential core functionality
for n_cov, n_comp, max_n, pcks, method in iter_ica_params:
# Test ICA raw
ica = ICA(noise_cov=n_cov,
n_components=n_comp,
max_pca_components=max_n,
n_pca_components=max_n,
random_state=0,
method=method,
max_iter=1)
pytest.raises(ValueError, ica.__contains__, 'mag')
print(ica) # to test repr
# test fit checker
pytest.raises(RuntimeError, ica.get_sources, raw)
pytest.raises(RuntimeError, ica.get_sources, epochs)
# test decomposition
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw, picks=pcks, start=start, stop=stop)
repr(ica) # to test repr
assert ('mag' in ica) # should now work without error
# test re-fit
unmixing1 = ica.unmixing_matrix_
with pytest.warns(UserWarning, match='did not converge'):
ica.fit(raw, picks=pcks, start=start, stop=stop)
assert_array_almost_equal(unmixing1, ica.unmixing_matrix_)
raw_sources = ica.get_sources(raw)
# test for #3804
assert_equal(raw_sources._filenames, [None])
print(raw_sources)
sources = raw_sources[:, :][0]
assert (sources.shape[0] == ica.n_components_)
# test preload filter
raw3 = raw.copy()
raw3.preload = False
pytest.raises(RuntimeError, ica.apply, raw3, include=[1, 2])
#######################################################################
# test epochs decomposition
ica = ICA(noise_cov=n_cov,
n_components=n_comp,
max_pca_components=max_n,
n_pca_components=max_n,
random_state=0,
method=method)
with pytest.warns(None): # sometimes warns
ica.fit(epochs, picks=picks)
data = epochs.get_data()[:, 0, :]
n_samples = np.prod(data.shape)
assert_equal(ica.n_samples_, n_samples)
print(ica) # to test repr
sources = ica.get_sources(epochs).get_data()
assert (sources.shape[1] == ica.n_components_)
pytest.raises(ValueError,
ica.score_sources,
epochs,
target=np.arange(1))
# test preload filter
epochs3 = epochs.copy()
epochs3.preload = False
pytest.raises(RuntimeError, ica.apply, epochs3, include=[1, 2])
# test for bug with whitener updating
_pre_whitener = ica.pre_whitener_.copy()
epochs._data[:, 0, 10:15] *= 1e12
ica.apply(epochs.copy())
assert_array_equal(_pre_whitener, ica.pre_whitener_)
# test expl. var threshold leading to empty sel
ica.n_components = 0.1
pytest.raises(RuntimeError, ica.fit, epochs)
offender = 1, 2, 3,
pytest.raises(ValueError, ica.get_sources, offender)
pytest.raises(ValueError, ica.fit, offender)
pytest.raises(ValueError, ica.apply, offender)
def test_ica_additional():
"""Test additional ICA functionality"""
tempdir = _TempDir()
stop2 = 500
raw = Raw(raw_fname).crop(1.5, stop, copy=False)
raw.load_data()
# XXX This breaks the tests :(
# raw.info['bads'] = [raw.ch_names[1]]
test_cov = read_cov(test_cov_name)
events = read_events(event_name)
picks = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')
epochs = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
# test if n_components=None works
with warnings.catch_warnings(record=True):
ica = ICA(n_components=None,
max_pca_components=None,
n_pca_components=None,
random_state=0)
ica.fit(epochs, picks=picks, decim=3)
# for testing eog functionality
picks2 = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=True,
exclude='bads')
epochs_eog = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks2,
baseline=(None, 0),
preload=True)
test_cov2 = test_cov.copy()
ica = ICA(noise_cov=test_cov2,
n_components=3,
max_pca_components=4,
n_pca_components=4)
assert_true(ica.info is None)
with warnings.catch_warnings(record=True):
ica.fit(raw, picks[:5])
assert_true(isinstance(ica.info, Info))
assert_true(ica.n_components_ < 5)
ica = ICA(n_components=3, max_pca_components=4, n_pca_components=4)
assert_raises(RuntimeError, ica.save, '')
with warnings.catch_warnings(record=True):
ica.fit(raw, picks=[1, 2, 3, 4, 5], start=start, stop=stop2)
# test corrmap
ica2 = ica.copy()
ica3 = ica.copy()
corrmap([ica, ica2], (0, 0),
threshold='auto',
label='blinks',
plot=True,
ch_type="mag")
corrmap([ica, ica2], (0, 0), threshold=2, plot=False, show=False)
assert_true(ica.labels_["blinks"] == ica2.labels_["blinks"])
assert_true(0 in ica.labels_["blinks"])
template = _get_ica_map(ica)[0]
corrmap([ica, ica3],
template,
threshold='auto',
label='blinks',
plot=True,
ch_type="mag")
assert_true(ica2.labels_["blinks"] == ica3.labels_["blinks"])
plt.close('all')
# test warnings on bad filenames
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
ica_badname = op.join(op.dirname(tempdir), 'test-bad-name.fif.gz')
ica.save(ica_badname)
read_ica(ica_badname)
assert_naming(w, 'test_ica.py', 2)
# test decim
ica = ICA(n_components=3, max_pca_components=4, n_pca_components=4)
raw_ = raw.copy()
for _ in range(3):
raw_.append(raw_)
n_samples = raw_._data.shape[1]
with warnings.catch_warnings(record=True):
ica.fit(raw, picks=None, decim=3)
assert_true(raw_._data.shape[1], n_samples)
# test expl var
ica = ICA(n_components=1.0, max_pca_components=4, n_pca_components=4)
with warnings.catch_warnings(record=True):
ica.fit(raw, picks=None, decim=3)
assert_true(ica.n_components_ == 4)
# epochs extraction from raw fit
assert_raises(RuntimeError, ica.get_sources, epochs)
# test reading and writing
test_ica_fname = op.join(op.dirname(tempdir), 'test-ica.fif')
for cov in (None, test_cov):
ica = ICA(noise_cov=cov,
n_components=2,
max_pca_components=4,
n_pca_components=4)
with warnings.catch_warnings(record=True): # ICA does not converge
ica.fit(raw, picks=picks, start=start, stop=stop2)
sources = ica.get_sources(epochs).get_data()
assert_true(ica.mixing_matrix_.shape == (2, 2))
assert_true(ica.unmixing_matrix_.shape == (2, 2))
assert_true(ica.pca_components_.shape == (4, len(picks)))
assert_true(sources.shape[1] == ica.n_components_)
for exclude in [[], [0]]:
ica.exclude = exclude
ica.labels_ = {'foo': [0]}
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
assert_true(ica.exclude == ica_read.exclude)
assert_equal(ica.labels_, ica_read.labels_)
ica.exclude = []
ica.apply(raw, exclude=[1])
assert_true(ica.exclude == [])
ica.exclude = [0, 1]
ica.apply(raw, exclude=[1])
assert_true(ica.exclude == [0, 1])
ica_raw = ica.get_sources(raw)
assert_true(
ica.exclude ==
[ica_raw.ch_names.index(e) for e in ica_raw.info['bads']])
# test filtering
d1 = ica_raw._data[0].copy()
ica_raw.filter(4,
20,
l_trans_bandwidth='auto',
h_trans_bandwidth='auto',
filter_length='auto',
phase='zero')
assert_equal(ica_raw.info['lowpass'], 20.)
assert_equal(ica_raw.info['highpass'], 4.)
assert_true((d1 != ica_raw._data[0]).any())
d1 = ica_raw._data[0].copy()
ica_raw.notch_filter([10],
filter_length='auto',
trans_bandwidth=10,
phase='zero')
assert_true((d1 != ica_raw._data[0]).any())
ica.n_pca_components = 2
ica.method = 'fake'
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
assert_true(ica.n_pca_components == ica_read.n_pca_components)
assert_equal(ica.method, ica_read.method)
assert_equal(ica.labels_, ica_read.labels_)
# check type consistency
attrs = ('mixing_matrix_ unmixing_matrix_ pca_components_ '
'pca_explained_variance_ _pre_whitener')
def f(x, y):
return getattr(x, y).dtype
for attr in attrs.split():
assert_equal(f(ica_read, attr), f(ica, attr))
ica.n_pca_components = 4
ica_read.n_pca_components = 4
ica.exclude = []
ica.save(test_ica_fname)
ica_read = read_ica(test_ica_fname)
for attr in [
'mixing_matrix_', 'unmixing_matrix_', 'pca_components_',
'pca_mean_', 'pca_explained_variance_', '_pre_whitener'
]:
assert_array_almost_equal(getattr(ica, attr),
getattr(ica_read, attr))
assert_true(ica.ch_names == ica_read.ch_names)
assert_true(isinstance(ica_read.info, Info))
sources = ica.get_sources(raw)[:, :][0]
sources2 = ica_read.get_sources(raw)[:, :][0]
assert_array_almost_equal(sources, sources2)
_raw1 = ica.apply(raw, exclude=[1])
_raw2 = ica_read.apply(raw, exclude=[1])
assert_array_almost_equal(_raw1[:, :][0], _raw2[:, :][0])
os.remove(test_ica_fname)
# check scrore funcs
for name, func in get_score_funcs().items():
if name in score_funcs_unsuited:
continue
scores = ica.score_sources(raw,
target='EOG 061',
score_func=func,
start=0,
stop=10)
assert_true(ica.n_components_ == len(scores))
# check univariate stats
scores = ica.score_sources(raw, score_func=stats.skew)
# check exception handling
assert_raises(ValueError, ica.score_sources, raw, target=np.arange(1))
params = []
params += [(None, -1, slice(2), [0, 1])] # varicance, kurtosis idx params
params += [(None, 'MEG 1531')] # ECG / EOG channel params
for idx, ch_name in product(*params):
ica.detect_artifacts(raw,
start_find=0,
stop_find=50,
ecg_ch=ch_name,
eog_ch=ch_name,
skew_criterion=idx,
var_criterion=idx,
kurt_criterion=idx)
with warnings.catch_warnings(record=True):
idx, scores = ica.find_bads_ecg(raw, method='ctps')
assert_equal(len(scores), ica.n_components_)
idx, scores = ica.find_bads_ecg(raw, method='correlation')
assert_equal(len(scores), ica.n_components_)
idx, scores = ica.find_bads_eog(raw)
assert_equal(len(scores), ica.n_components_)
ica.labels_ = None
idx, scores = ica.find_bads_ecg(epochs, method='ctps')
assert_equal(len(scores), ica.n_components_)
assert_raises(ValueError,
ica.find_bads_ecg,
epochs.average(),
method='ctps')
assert_raises(ValueError,
ica.find_bads_ecg,
raw,
method='crazy-coupling')
raw.info['chs'][raw.ch_names.index('EOG 061') - 1]['kind'] = 202
idx, scores = ica.find_bads_eog(raw)
assert_true(isinstance(scores, list))
assert_equal(len(scores[0]), ica.n_components_)
# check score funcs
for name, func in get_score_funcs().items():
if name in score_funcs_unsuited:
continue
scores = ica.score_sources(epochs_eog,
target='EOG 061',
score_func=func)
assert_true(ica.n_components_ == len(scores))
# check univariate stats
scores = ica.score_sources(epochs, score_func=stats.skew)
# check exception handling
assert_raises(ValueError, ica.score_sources, epochs, target=np.arange(1))
# ecg functionality
ecg_scores = ica.score_sources(raw,
target='MEG 1531',
score_func='pearsonr')
with warnings.catch_warnings(record=True): # filter attenuation warning
ecg_events = ica_find_ecg_events(raw,
sources[np.abs(ecg_scores).argmax()])
assert_true(ecg_events.ndim == 2)
# eog functionality
eog_scores = ica.score_sources(raw,
target='EOG 061',
score_func='pearsonr')
with warnings.catch_warnings(record=True): # filter attenuation warning
eog_events = ica_find_eog_events(raw,
sources[np.abs(eog_scores).argmax()])
assert_true(eog_events.ndim == 2)
# Test ica fiff export
ica_raw = ica.get_sources(raw, start=0, stop=100)
assert_true(ica_raw.last_samp - ica_raw.first_samp == 100)
assert_true(len(ica_raw._filenames) == 0) # API consistency
ica_chans = [ch for ch in ica_raw.ch_names if 'ICA' in ch]
assert_true(ica.n_components_ == len(ica_chans))
test_ica_fname = op.join(op.abspath(op.curdir), 'test-ica_raw.fif')
ica.n_components = np.int32(ica.n_components)
ica_raw.save(test_ica_fname, overwrite=True)
ica_raw2 = Raw(test_ica_fname, preload=True)
assert_allclose(ica_raw._data, ica_raw2._data, rtol=1e-5, atol=1e-4)
ica_raw2.close()
os.remove(test_ica_fname)
# Test ica epochs export
ica_epochs = ica.get_sources(epochs)
assert_true(ica_epochs.events.shape == epochs.events.shape)
ica_chans = [ch for ch in ica_epochs.ch_names if 'ICA' in ch]
assert_true(ica.n_components_ == len(ica_chans))
assert_true(ica.n_components_ == ica_epochs.get_data().shape[1])
assert_true(ica_epochs._raw is None)
assert_true(ica_epochs.preload is True)
# test float n pca components
ica.pca_explained_variance_ = np.array([0.2] * 5)
ica.n_components_ = 0
for ncomps, expected in [[0.3, 1], [0.9, 4], [1, 1]]:
ncomps_ = ica._check_n_pca_components(ncomps)
assert_true(ncomps_ == expected)
def test_ica_full_data_recovery(method):
"""Test recovery of full data when no source is rejected."""
# Most basic recovery
_skip_check_picard(method)
raw = read_raw_fif(raw_fname).crop(0.5, stop).load_data()
events = read_events(event_name)
picks = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')[:10]
with pytest.warns(RuntimeWarning, match='projection'):
epochs = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
evoked = epochs.average()
n_channels = 5
data = raw._data[:n_channels].copy()
data_epochs = epochs.get_data()
data_evoked = evoked.data
raw.set_annotations(Annotations([0.5], [0.5], ['BAD']))
methods = [method]
for method in methods:
stuff = [(2, n_channels, True), (2, n_channels // 2, False)]
for n_components, n_pca_components, ok in stuff:
ica = ICA(n_components=n_components,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components,
method=method,
max_iter=1)
with pytest.warns(UserWarning, match=None): # sometimes warns
ica.fit(raw, picks=list(range(n_channels)))
raw2 = ica.apply(raw.copy(), exclude=[])
if ok:
assert_allclose(data[:n_channels],
raw2._data[:n_channels],
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data[:n_channels] - raw2._data[:n_channels])
assert (np.max(diff) > 1e-14)
ica = ICA(n_components=n_components,
method=method,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components)
with pytest.warns(None): # sometimes warns
ica.fit(epochs, picks=list(range(n_channels)))
epochs2 = ica.apply(epochs.copy(), exclude=[])
data2 = epochs2.get_data()[:, :n_channels]
if ok:
assert_allclose(data_epochs[:, :n_channels],
data2,
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data_epochs[:, :n_channels] - data2)
assert (np.max(diff) > 1e-14)
evoked2 = ica.apply(evoked.copy(), exclude=[])
data2 = evoked2.data[:n_channels]
if ok:
assert_allclose(data_evoked[:n_channels],
data2,
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(evoked.data[:n_channels] - data2)
assert (np.max(diff) > 1e-14)
pytest.raises(ValueError, ICA, method='pizza-decomposision')
def test_ica_full_data_recovery():
"""Test recovery of full data when no source is rejected"""
# Most basic recovery
raw = Raw(raw_fname).crop(0.5, stop, copy=False)
raw.load_data()
events = read_events(event_name)
picks = pick_types(raw.info,
meg=True,
stim=False,
ecg=False,
eog=False,
exclude='bads')[:10]
with warnings.catch_warnings(record=True): # bad proj
epochs = Epochs(raw,
events[:4],
event_id,
tmin,
tmax,
picks=picks,
baseline=(None, 0),
preload=True)
evoked = epochs.average()
n_channels = 5
data = raw._data[:n_channels].copy()
data_epochs = epochs.get_data()
data_evoked = evoked.data
for method in ['fastica']:
stuff = [(2, n_channels, True), (2, n_channels // 2, False)]
for n_components, n_pca_components, ok in stuff:
ica = ICA(n_components=n_components,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components,
method=method,
max_iter=1)
with warnings.catch_warnings(record=True):
ica.fit(raw, picks=list(range(n_channels)))
raw2 = ica.apply(raw.copy(), exclude=[])
if ok:
assert_allclose(data[:n_channels],
raw2._data[:n_channels],
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data[:n_channels] - raw2._data[:n_channels])
assert_true(np.max(diff) > 1e-14)
ica = ICA(n_components=n_components,
max_pca_components=n_pca_components,
n_pca_components=n_pca_components)
with warnings.catch_warnings(record=True):
ica.fit(epochs, picks=list(range(n_channels)))
epochs2 = ica.apply(epochs.copy(), exclude=[])
data2 = epochs2.get_data()[:, :n_channels]
if ok:
assert_allclose(data_epochs[:, :n_channels],
data2,
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(data_epochs[:, :n_channels] - data2)
assert_true(np.max(diff) > 1e-14)
evoked2 = ica.apply(evoked.copy(), exclude=[])
data2 = evoked2.data[:n_channels]
if ok:
assert_allclose(data_evoked[:n_channels],
data2,
rtol=1e-10,
atol=1e-15)
else:
diff = np.abs(evoked.data[:n_channels] - data2)
assert_true(np.max(diff) > 1e-14)
assert_raises(ValueError, ICA, method='pizza-decomposision')
proc_dir = root_dir+"proc/"
proclist = listdir(proc_dir)
l_freq = 0.3
h_freq = 200
n_jobs = "cuda"
max_thresh = 2e-3
for filename in proclist:
this_match = re.match("c_EPI_(.*)-raw.fif", filename)
if not this_match:
continue
file_id = this_match.groups(1)[0]
raw = mne.io.Raw(proc_dir+filename, preload=True)
raw_sel = raw.copy().pick_channels(["Cz", "Fz", "F3", "F4", "C3", "C4",
"Pz", "Fp1", "Fp2", "O1", "O2",
"VEOG", "HEOG", "ECG1+"])
raw_sel.filter(l_freq=0.3, h_freq=30, n_jobs=4)
raw_sel.resample(100, n_jobs="cuda")
ica = ICA(method="picard")
ica.fit(raw_sel)
ica.save("{}sel_c_EPI_{}-ica.fif".format(proc_dir, file_id))
bads_eog, scores = ica.find_bads_eog(raw_sel, ch_name="VEOG", threshold=2.3)
bads_ecg ,scores = ica.find_bads_ecg(raw_sel, ch_name="ECG1+")
bad_comps = bads_eog + bads_ecg
raw_sel = ica.apply(raw_sel, exclude=bad_comps)
raw_sel.save("{}csel_{}".format(proc_dir, filename), overwrite=True)
def test_fit_params():
"""Test fit_params for ICA"""
assert_raises(ValueError, ICA, fit_params=dict(extended=True))
fit_params = {}
ICA(fit_params=fit_params) # test no side effects
assert_equal(fit_params, {})
def ICA(ep, MRCP):
#%% Artifact Correction with ICA
"""
ICA finds directions in the feature space corresponding to projections with high non-Gaussianity.
We obtain a decomposition into independent components, and the artifact's contribution
is localized in only a small number of components.
These components have to be correctly identified and removed.
If EOG or ECG recordings are available, they can be used in ICA to
automatically select the corresponding artifact components from the
decomposition. To do so, you have to first build an Epoch object around
blink or heartbeat event.
"""
from mne.preprocessing import ICA
# ICA parameters:
n_components = 10 # if float, select n_components by explained variance of PCA
method = 'fastica'
decim = 3 # need sufficient statistics, not all time points -> saves time
# Set state of the random number generator - ICA is a
# non-deterministic algorithm, but we want to have the same decomposition
# and the same order of components each time
random_state = 23
picks_eeg = mne.pick_types(ep.info,
meg=False,
eeg=True,
eog=False,
stim=False,
exclude='bads')
# Define the ICA object instance
ica = ICA(n_components=n_components,
method=method,
random_state=random_state)
print(ica)
# avoid fitting ICA on crazy environmental artifacts that would
# dominate the variance and decomposition
reject = dict(eeg=40e-6)
ica.fit(ep, picks=picks_eeg, reject=reject, decim=decim)
print(ica)
#ica.plot_components() # can you spot some potential bad guys?
#% Advanced artifact detection
# We simplify things by setting the maximum number of components to reject
eog_inds, scores = ica.find_bads_eog(ep, ch_name='Fp1',
threshold=1) # find via correlation
#ica.plot_scores(scores, exclude=eog_inds) # look at r scores of components
ica.exclude.extend(eog_inds)
# apply ICA
ep = ica.apply(ep, exclude=eog_inds)
if MRCP:
# Extract MRCP and return a *band-pass* filtered signal in the range .1 Hz - 4 Hz
ep.filter(None,
4.,
l_trans_bandwidth='auto',
h_trans_bandwidth='auto',
filter_length='auto',
phase='zero')
return ep
})
raw.plot(**plot_kwargs)
###############################################################################
# The PSD of these data show the noise as clear peaks.
raw.plot_psd(fmax=30)
###############################################################################
# Run the "together" algorithm.
raw_tog = raw.copy()
ica_kwargs = dict(
method='picard',
fit_params=dict(tol=1e-4), # use a high tol here for speed
)
all_picks = mne.pick_types(raw_tog.info, meg=True, ref_meg=True)
ica_tog = ICA(n_components=60, allow_ref_meg=True, **ica_kwargs)
ica_tog.fit(raw_tog, picks=all_picks)
# low threshold (2.0) here because of cropped data, entire recording can use
# a higher threshold (2.5)
bad_comps, scores = ica_tog.find_bads_ref(raw_tog, threshold=2.0)
# Plot scores with bad components marked.
ica_tog.plot_scores(scores, bad_comps)
# Examine the properties of removed components. It's clear from the time
# courses and topographies that these components represent external,
# intermittent noise.
ica_tog.plot_properties(raw_tog, picks=bad_comps)
# Remove the components.
raw_tog = ica_tog.apply(raw_tog, exclude=bad_comps)
