def test_corr():
"Test testnd.corr()"
plot.configure_backend(False, False)
ds = datasets.get_rand(True)
# add correlation
Y = ds['Y']
utsnd = ds['utsnd']
utsnd.x.shape
utsnd.x[:, 3:5, 50:65] += Y.x[:, None, None]
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds)
repr(res)
p = plot.Array(res)
p.close()
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds, samples=10, pmin=0.05)
p = plot.Array(res)
p.close()
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
assert_dataobj_equal(res.p, res_.p)
# NaN
r = _testnd._corr(np.arange(10), np.zeros(10))
assert_equal(r, 0)
def test_morphing():
stc = datasets.get_mne_stc()
y = load.fiff.stc_ndvar(stc,
'sample',
'ico-5',
subjects_dir,
'dSPM',
name='src')
# sample to fsaverage
m = mne.compute_source_morph(stc, 'sample', 'fsaverage', subjects_dir)
stc_fsa = m.apply(stc)
y_fsa = morph_source_space(y, 'fsaverage')
assert_array_equal(y_fsa.x, stc_fsa.data)
stc_fsa_ndvar = load.fiff.stc_ndvar(stc_fsa,
'fsaverage',
'ico-5',
subjects_dir,
'dSPM',
False,
'src',
parc=None)
assert_dataobj_equal(stc_fsa_ndvar, y_fsa)
# scaled to fsaverage
y_scaled = datasets.get_mne_stc(True, subject='fsaverage_scaled')
y_scaled_m = morph_source_space(y_scaled, 'fsaverage')
assert y_scaled_m.source.subject == 'fsaverage'
assert_array_equal(y_scaled_m.x, y_scaled.x)
# scaled to fsaverage [masked]
y_sub = y_scaled.sub(source='superiortemporal-lh')
y_sub_m = morph_source_space(y_sub, 'fsaverage')
assert y_sub_m.source.subject == 'fsaverage'
assert_array_equal(y_sub_m.x, y_sub.x)
def test_vec_source():
"Test vector source space"
ds = datasets.get_mne_sample(0, 0.1, src='vol', sub="(modality=='A') & (side == 'L')", ori='vector', stc=True)
# conversion: vector
stc = ds[0, 'stc']
stc2 = load.fiff.stc_ndvar([stc, stc], ds.info['subject'], 'vol-10', ds.info['subjects_dir'])
assert_dataobj_equal(stc2[1], ds[0, 'src'], name=False)
# non-vector
if hasattr(stc, 'magnitude'): # added in mne 0.18
stc = stc.magnitude()
ndvar = load.fiff.stc_ndvar(stc, ds.info['subject'], 'vol-10', ds.info['subjects_dir'])
assert_dataobj_equal(ndvar, ds[0, 'src'].norm('space'), name=False)
# test
res = testnd.Vector('src', ds=ds, samples=2)
clusters = res.find_clusters()
assert_array_equal(clusters['n_sources'], [799, 1, 7, 1, 2, 1])
# NDVar
v = ds['src']
assert v.sub(source='lh', time=0).shape == (72, 712, 3)
# parc
v = ds[0, 'src']
v = set_parc(v, Factor('abcdefg', repeat=227))
v1 = v.sub(source='a')
assert len(v1.source) == 227
v2 = v.sub(source=('b', 'c'))
assert len(v2.source) == 454
assert 'b' in v2.source.parc
assert 'd' not in v2.source.parc
with pytest.raises(IndexError):
v.sub(source='ab')
with pytest.raises(IndexError):
v.sub(source=['a', 'bc'])
def test_morphing():
mne.set_log_level('warning')
data_dir = mne.datasets.sample.data_path()
subjects_dir = os.path.join(data_dir, 'subjects')
sss = datasets._mne_source_space('fsaverage', 'ico-4', subjects_dir)
vertices_to = [sss[0]['vertno'], sss[1]['vertno']]
ds = datasets.get_mne_sample(-0.1,
0.1,
src='ico',
sub='index==0',
stc=True)
stc = ds['stc', 0]
morph_mat = mne.compute_morph_matrix('sample', 'fsaverage', stc.vertices,
vertices_to, None, subjects_dir)
ndvar = ds['src']
morphed_ndvar = morph_source_space(ndvar, 'fsaverage')
morphed_stc = mne.morph_data_precomputed('sample', 'fsaverage', stc,
vertices_to, morph_mat)
assert_array_equal(morphed_ndvar.x[0], morphed_stc.data)
morphed_stc_ndvar = load.fiff.stc_ndvar([morphed_stc],
'fsaverage',
'ico-4',
subjects_dir,
'dSPM',
False,
'src',
parc=None)
assert_dataobj_equal(morphed_ndvar, morphed_stc_ndvar)
def test_t_contrast():
ds = datasets.get_uts()
# simple contrast
res = testnd.t_contrast_rel('uts', 'A', 'a1>a0', 'rm', ds=ds, samples=10,
pmin=0.05)
repr(res)
res_ = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_array_equal(res.t.x, res_.t.x)
assert_in('samples', repr(res))
# complex contrast
res = testnd.t_contrast_rel('uts', 'A%B', 'min(a0|b0>a1|b0, a0|b1>a1|b1)',
'rm', ds=ds, samples=10, pmin=0.05)
res_b0 = testnd.ttest_rel('uts', 'A%B', ('a0', 'b0'), ('a1', 'b0'), 'rm',
ds=ds)
res_b1 = testnd.ttest_rel('uts', 'A%B', ('a0', 'b1'), ('a1', 'b1'), 'rm',
ds=ds)
assert_array_equal(res.t.x, np.min([res_b0.t.x, res_b1.t.x], axis=0))
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p, res_.p)
# contrast with "*"
res = testnd.t_contrast_rel('uts', 'A%B', 'min(a1|b0>a0|*, a1|b1>a0|*)',
'rm', ds=ds, tail=1)
def test_ttest_ind():
"Test testnd.ttest_ind()"
ds = datasets.get_uts(True)
# basic
res = testnd.ttest_ind('uts', 'A', 'a1', 'a0', ds=ds)
repr(res)
assert_less(res.p_uncorrected.min(), 0.05)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
repr(res_)
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# cluster
res = testnd.ttest_ind('uts', 'A', 'a1', 'a0', ds=ds, tail=1, samples=1)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# nd
res = testnd.ttest_ind('utsnd', 'A', 'a1', 'a0', ds=ds, pmin=0.05, samples=2)
eq_(res._cdist.n_clusters, 10)
def test_ttest_ind():
"Test testnd.ttest_ind()"
ds = datasets.get_uts(True)
# basic
res = testnd.ttest_ind('uts', 'A', 'a1', 'a0', ds=ds)
repr(res)
assert_less(res.p_uncorrected.min(), 0.05)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
repr(res_)
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# cluster
res = testnd.ttest_ind('uts', 'A', 'a1', 'a0', ds=ds, tail=1, samples=1)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# nd
res = testnd.ttest_ind('utsnd',
'A',
'a1',
'a0',
ds=ds,
pmin=0.05,
samples=2)
eq_(res._cdist.n_clusters, 10)
def test_corr():
"Test testnd.corr()"
plot.configure_backend(False, False)
ds = datasets.get_uts(True)
# add correlation
Y = ds['Y']
utsnd = ds['utsnd']
utsnd.x.shape
utsnd.x[:, 3:5, 50:65] += Y.x[:, None, None]
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds)
repr(res)
p = plot.Array(res)
p.close()
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds, samples=10, pmin=0.05)
p = plot.Array(res)
p.close()
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
assert_dataobj_equal(res.p, res_.p)
# NaN
r = _testnd._corr(np.arange(10), np.zeros(10))
assert_equal(r, 0)
def test_ttest_rel():
"Test testnd.ttest_rel()"
ds = datasets.get_uts(True)
# basic
res = testnd.ttest_rel('uts', 'A%B', ('a1', 'b1'), ('a0', 'b0'), 'rm',
ds=ds, samples=100)
repr(res)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
repr(res_)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# collapsing cells
res2 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_less(res2.p_uncorrected.min(), 0.05)
assert_equal(res2.n, res.n)
# reproducibility
res3 = testnd.ttest_rel('uts', 'A%B', ('a1', 'b1'), ('a0', 'b0'), 'rm',
ds=ds, samples=100)
assert_dataset_equal(res3.find_clusters(maps=True), res.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 0
res4 = testnd.ttest_rel('uts', 'A%B', ('a1', 'b1'), ('a0', 'b0'), 'rm',
ds=ds, samples=100)
assert_dataset_equal(res4.find_clusters(maps=True), res.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 1
sds = ds.sub("B=='b0'")
# thresholded, UTS
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=sds, pmin=0.1,
samples=100)
tgt = res0.find_clusters()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=sds, pmin=0.1,
samples=100)
assert_dataset_equal(res1.find_clusters(), tgt)
# thresholded, UTSND
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('utsnd', 'A', 'a1', 'a0', 'rm', ds=sds, pmin=0.1,
samples=100)
tgt = res0.find_clusters()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('utsnd', 'A', 'a1', 'a0', 'rm', ds=sds, pmin=0.1,
samples=100)
assert_dataset_equal(res1.find_clusters(), tgt)
# TFCE, UTS
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=sds, tfce=True,
samples=10)
tgt = res0.compute_probability_map()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=sds, tfce=True,
samples=10)
assert_dataobj_equal(res1.compute_probability_map(), tgt)
def test_ttest_1samp():
"Test testnd.ttest_1samp()"
ds = datasets.get_uts(True)
# no clusters
res0 = testnd.ttest_1samp('uts', sub="A == 'a0'", ds=ds)
assert_less(res0.p_uncorrected.min(), 0.05)
repr0 = repr(res0)
assert_in("'uts'", repr0)
assert_not_in('clusters', repr0)
assert_not_in('mintime', repr0)
# clusters without resampling
res1 = testnd.ttest_1samp('uts', sub="A == 'a0'", ds=ds, samples=0,
pmin=0.05, tstart=0, tstop=0.6, mintime=0.05)
assert_equal(res1.clusters.n_cases, 1)
assert_not_in('p', res1.clusters)
repr1 = repr(res1)
assert_in('clusters', repr1)
assert_in('samples', repr1)
assert_in('mintime', repr1)
# persistence
string = pickle.dumps(res1, pickle.HIGHEST_PROTOCOL)
res1_ = pickle.loads(string)
assert_equal(repr(res1_), repr1)
assert_dataobj_equal(res1.p_uncorrected, res1_.p_uncorrected)
# clusters with resampling
res2 = testnd.ttest_1samp('uts', sub="A == 'a0'", ds=ds, samples=10,
pmin=0.05, tstart=0, tstop=0.6, mintime=0.05)
assert_equal(res2.clusters.n_cases, 1)
assert_equal(res2.samples, 10)
assert_in('p', res2.clusters)
repr2 = repr(res2)
assert_in('samples', repr2)
# clusters with permutations
dss = ds.sub("logical_and(A=='a0', B=='b0')")[:8]
res3 = testnd.ttest_1samp('uts', sub="A == 'a0'", ds=dss, samples=10000,
pmin=0.05, tstart=0, tstop=0.6, mintime=0.05)
assert_equal(res3.clusters.n_cases, 2)
assert_equal(res3.samples, -1)
assert_less(res3.clusters['p'].x.min(), 0.05)
repr3 = repr(res3)
assert_in('samples', repr3)
# TFCE properties
res = testnd.ttest_1samp('utsnd', sub="A == 'a0'", ds=ds, samples=1)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res = pickle.loads(string)
tfce_clusters = res.find_clusters(pmin=0.05)
peaks = res.find_peaks()
assert_equal(tfce_clusters.eval("p.min()"), peaks.eval("p.min()"))
masked = res.masked_parameter_map(pmin=0.05)
assert_array_equal(masked.abs().x <= res.t.abs().x, True)
def test_t_contrast():
ds = datasets.get_uts()
# test aux functions
y = np.arange(9.).reshape((3, 3))
indexes = {'a': 0, 'b': 1, 'c': 2}
contrast = "+sum(a>c, b>c)"
contrast_ = _testnd._parse_t_contrast(contrast)
assert_equal(contrast_, ('func', '+', np.sum, [('comp', None, 'a', 'c'),
('comp', None, 'b', 'c')]))
contrast = "+sum(a>*, b>*)"
contrast_ = _testnd._parse_t_contrast(contrast)
assert_equal(contrast_, ('func', '+', np.sum, [('comp', None, 'a', '*'),
('comp', None, 'b', '*')]))
_, cells = _testnd._t_contrast_rel_properties(contrast_)
pc, mc = _testnd._t_contrast_rel_expand_cells(cells, ('a', 'b', 'c'))
data = _testnd._t_contrast_rel_data(y, indexes, pc, mc)
assert_array_equal(data['a'], np.arange(3.))
assert_array_equal(data['*'], y.mean(0))
assert_raises(ValueError, _testnd._t_contrast_rel_expand_cells, cells,
('a|c', 'b|c', 'c|c'))
# simple contrast
res = testnd.t_contrast_rel('uts', 'A', 'a1>a0', 'rm', ds=ds, samples=10,
pmin=0.05)
repr(res)
res_ = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_array_equal(res.t.x, res_.t.x)
assert_in('samples', repr(res))
# complex contrast
res = testnd.t_contrast_rel('uts', 'A%B', 'min(a0|b0>a1|b0, a0|b1>a1|b1)',
'rm', ds=ds, samples=10, pmin=0.05)
res_b0 = testnd.ttest_rel('uts', 'A%B', ('a0', 'b0'), ('a1', 'b0'), 'rm',
ds=ds)
res_b1 = testnd.ttest_rel('uts', 'A%B', ('a0', 'b1'), ('a1', 'b1'), 'rm',
ds=ds)
assert_array_equal(res.t.x, np.min([res_b0.t.x, res_b1.t.x], axis=0))
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p, res_.p)
# contrast with "*"
contrast_star = '+min(a1|b0>a0|*, a1|b1>a0|*)'
res = testnd.t_contrast_rel('uts', 'A%B', contrast_star, 'rm', ds=ds)
def test_t_contrast():
ds = datasets.get_uts()
# simple contrast
res = testnd.t_contrast_rel('uts',
'A',
'a1>a0',
'rm',
ds=ds,
samples=10,
pmin=0.05)
repr(res)
res_ = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_array_equal(res.t.x, res_.t.x)
assert_in('samples', repr(res))
# complex contrast
res = testnd.t_contrast_rel('uts',
'A%B',
'min(a0|b0>a1|b0, a0|b1>a1|b1)',
'rm',
ds=ds,
samples=10,
pmin=0.05)
res_b0 = testnd.ttest_rel('uts',
'A%B', ('a0', 'b0'), ('a1', 'b0'),
'rm',
ds=ds)
res_b1 = testnd.ttest_rel('uts',
'A%B', ('a0', 'b1'), ('a1', 'b1'),
'rm',
ds=ds)
assert_array_equal(res.t.x, np.min([res_b0.t.x, res_b1.t.x], axis=0))
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p, res_.p)
# contrast with "*"
res = testnd.t_contrast_rel('uts',
'A%B',
'min(a1|b0>a0|*, a1|b1>a0|*)',
'rm',
ds=ds,
tail=1)
def test_morphing():
mne.set_log_level('warning')
sss = datasets._mne_source_space('fsaverage', 'ico-4', subjects_dir)
vertices_to = [sss[0]['vertno'], sss[1]['vertno']]
ds = datasets.get_mne_sample(-0.1, 0.1, src='ico', sub='index==0', stc=True)
stc = ds['stc', 0]
morph_mat = mne.compute_morph_matrix('sample', 'fsaverage', stc.vertices,
vertices_to, None, subjects_dir)
ndvar = ds['src']
morphed_ndvar = morph_source_space(ndvar, 'fsaverage')
morphed_stc = mne.morph_data_precomputed('sample', 'fsaverage', stc,
vertices_to, morph_mat)
assert_array_equal(morphed_ndvar.x[0], morphed_stc.data)
morphed_stc_ndvar = load.fiff.stc_ndvar([morphed_stc], 'fsaverage', 'ico-4',
subjects_dir, 'dSPM', False, 'src',
parc=None)
assert_dataobj_equal(morphed_ndvar, morphed_stc_ndvar)
def test_corr():
"Test testnd.corr()"
ds = datasets.get_uts(True)
# add correlation
Y = ds['Y']
utsnd = ds['utsnd']
utsnd.x[:, 3:5, 50:65] += Y.x[:, None, None]
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds)
repr(res)
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds, samples=10, pmin=0.05)
repr(res)
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
assert_dataobj_equal(res.p, res_.p)
def test_corr():
"Test testnd.corr()"
ds = datasets.get_uts(True)
# add correlation
Y = ds['Y']
utsnd = ds['utsnd']
utsnd.x[:, 3:5, 50:65] += Y.x[:, None, None]
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds)
repr(res)
res = testnd.corr('utsnd', 'Y', 'rm', ds=ds, samples=10, pmin=0.05)
repr(res)
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
assert_dataobj_equal(res.p, res_.p)
def test_ttest_rel():
"Test testnd.ttest_rel()"
ds = datasets.get_rand()
# basic
res = testnd.ttest_rel('uts',
'A%B', ('a1', 'b1'), ('a0', 'b0'),
'rm',
ds=ds)
repr(res)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
repr(res_)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# collapsing cells
res2 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_less(res2.p_uncorrected.min(), 0.05)
assert_equal(res2.n, res.n)
def test_vec_source():
"Test vector source space"
ds = datasets.get_mne_sample(0,
0.1, (0, 0),
src='vol',
sub="(modality=='A') & (side == 'L')",
ori='vector',
stc=True)
# conversion: vector
stc = ds[0, 'stc']
stc2 = load.fiff.stc_ndvar([stc, stc], ds.info['subject'], 'vol-10',
ds.info['subjects_dir'])
assert_dataobj_equal(stc2[1], ds[0, 'src'], name=False)
# non-vector
if hasattr(stc, 'magnitude'): # added in mne 0.18
stc = stc.magnitude()
ndvar = load.fiff.stc_ndvar(stc, ds.info['subject'], 'vol-10',
ds.info['subjects_dir'])
assert_dataobj_equal(ndvar, ds[0, 'src'].norm('space'), name=False)
# test
res = testnd.Vector('src', ds=ds, samples=2)
clusters = res.find_clusters()
assert_array_equal(clusters['n_sources'], [799, 1, 7, 1, 2, 1])
# NDVar
v = ds['src']
assert v.sub(source='lh', time=0).shape == (72, 712, 3)
# parc
v = ds[0, 'src']
v = set_parc(v, Factor('abcdefg', repeat=227))
v1 = v.sub(source='a')
assert len(v1.source) == 227
v2 = v.sub(source=('b', 'c'))
assert len(v2.source) == 454
assert 'b' in v2.source.parc
assert 'd' not in v2.source.parc
with pytest.raises(IndexError):
v.sub(source='ab')
with pytest.raises(IndexError):
v.sub(source=['a', 'bc'])
def test_morphing():
stc = datasets.get_mne_stc()
y = load.fiff.stc_ndvar(stc, 'sample', 'ico-5', subjects_dir, 'dSPM', name='src')
# sample to fsaverage
m = mne.compute_source_morph(stc, 'sample', 'fsaverage', subjects_dir)
stc_fsa = m.apply(stc)
y_fsa = morph_source_space(y, 'fsaverage')
assert_array_equal(y_fsa.x, stc_fsa.data)
stc_fsa_ndvar = load.fiff.stc_ndvar(stc_fsa, 'fsaverage', 'ico-5', subjects_dir, 'dSPM', False, 'src', parc=None)
assert_dataobj_equal(stc_fsa_ndvar, y_fsa)
# scaled to fsaverage
y_scaled = datasets.get_mne_stc(True, subject='fsaverage_scaled')
y_scaled_m = morph_source_space(y_scaled, 'fsaverage')
assert y_scaled_m.source.subject == 'fsaverage'
assert_array_equal(y_scaled_m.x, y_scaled.x)
# scaled to fsaverage [masked]
y_sub = y_scaled.sub(source='superiortemporal-lh')
y_sub_m = morph_source_space(y_sub, 'fsaverage')
assert y_sub_m.source.subject == 'fsaverage'
assert_array_equal(y_sub_m.x, y_sub.x)
def test_anova():
"Test testnd.anova()"
ds = datasets.get_uts(True)
testnd.anova('utsnd', 'A*B', ds=ds)
for samples in (0, 2):
logger.info("TEST: samples=%r" % samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, pmin=0.05)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, tfce=True)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=0, pmin=0.05)
repr(res)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=2, pmin=0.05)
repr(res)
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
# threshold-free
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=10)
repr(res)
assert_in('A clusters', res.clusters.info)
assert_in('B clusters', res.clusters.info)
assert_in('A x B clusters', res.clusters.info)
# no clusters
res = testnd.anova('uts', 'B', sub="A=='a1'", ds=ds, samples=5, pmin=0.05,
mintime=0.02)
repr(res)
assert_in('v', res.clusters)
assert_in('p', res.clusters)
# all effects with clusters
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5, pmin=0.05,
tstart=0.1, mintime=0.02)
assert_equal(set(res.clusters['effect'].cells), set(res.effects))
# some effects with clusters, some without
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5, pmin=0.05,
tstart=0.37, mintime=0.02)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_dataobj_equal(res.clusters, res_.clusters)
# test multi-effect results (with persistence)
# UTS
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5)
repr(res)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
resr = pickle.loads(string)
tf_clusters = resr.find_clusters(pmin=0.05)
peaks = resr.find_peaks()
assert_dataobj_equal(tf_clusters, res.find_clusters(pmin=0.05))
assert_dataobj_equal(peaks, res.find_peaks())
assert_equal(tf_clusters.eval("p.min()"), peaks.eval("p.min()"))
unmasked = resr.f[0]
masked = resr.masked_parameter_map(effect=0, pmin=0.05)
assert_array_equal(masked.x <= unmasked.x, True)
# reproducibility
res0 = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
assert_dataset_equal(res.clusters, res0.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 0
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
assert_dataset_equal(res.clusters, res0.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 1
# permutation
eelbrain._stats.permutation._YIELD_ORIGINAL = 1
samples = 4
# raw
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=samples)
for dist in res._cdist:
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, dist.parameter_map.abs().max())
# TFCE
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, tfce=True, samples=samples)
for dist in res._cdist:
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, dist.tfce_map.abs().max())
# thresholded
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=samples)
clusters = res.find_clusters()
for dist, effect in izip(res._cdist, res.effects):
effect_idx = clusters.eval("effect == %r" % effect)
vmax = clusters[effect_idx, 'v'].abs().max()
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, vmax)
eelbrain._stats.permutation._YIELD_ORIGINAL = 0
def test_clusterdist():
"Test _ClusterDist class"
shape = (10, 6, 6, 4)
locs = [[0, 0, 0],
[1, 0, 0],
[1, 1, 0],
[0, 1, 0]]
x = np.random.normal(0, 1, shape)
sensor = Sensor(locs, ['0', '1', '2', '3'])
sensor.set_connectivity(connect_dist=1.1)
dims = ('case', UTS(-0.1, 0.1, 6), Ordered('dim2', range(6), 'unit'),
sensor)
y = NDVar(x, dims)
# test connecting sensors
logger.info("TEST: connecting sensors")
bin_map = np.zeros(shape[1:], dtype=np.bool8)
bin_map[:3, :3, :2] = True
pmap = np.random.normal(0, 1, shape[1:])
np.clip(pmap, -1, 1, pmap)
pmap[bin_map] = 2
cdist = _ClusterDist(y, 0, 1.5)
print repr(cdist)
cdist.add_original(pmap)
print repr(cdist)
assert_equal(cdist.n_clusters, 1)
assert_array_equal(cdist._original_cluster_map == cdist._cids[0],
cdist._crop(bin_map).swapaxes(0, cdist._nad_ax))
assert_equal(cdist.parameter_map.dims, y.dims[1:])
# test connecting many sensors
logger.info("TEST: connecting sensors")
bin_map = np.zeros(shape[1:], dtype=np.bool8)
bin_map[:3, :3] = True
pmap = np.random.normal(0, 1, shape[1:])
np.clip(pmap, -1, 1, pmap)
pmap[bin_map] = 2
cdist = _ClusterDist(y, 0, 1.5)
cdist.add_original(pmap)
assert_equal(cdist.n_clusters, 1)
assert_array_equal(cdist._original_cluster_map == cdist._cids[0],
cdist._crop(bin_map).swapaxes(0, cdist._nad_ax))
# test keeping sensors separate
logger.info("TEST: keeping sensors separate")
bin_map = np.zeros(shape[1:], dtype=np.bool8)
bin_map[:3, :3, 0] = True
bin_map[:3, :3, 2] = True
pmap = np.random.normal(0, 1, shape[1:])
np.clip(pmap, -1, 1, pmap)
pmap[bin_map] = 2
cdist = _ClusterDist(y, 1, 1.5)
cdist.add_original(pmap)
assert_equal(cdist.n_clusters, 2)
# criteria
ds = datasets.get_uts(True)
res = testnd.ttest_rel('utsnd', 'A', match='rm', ds=ds, samples=0, pmin=0.05)
assert_less(res.clusters['duration'].min(), 0.01)
eq_(res.clusters['n_sensors'].min(), 1)
res = testnd.ttest_rel('utsnd', 'A', match='rm', ds=ds, samples=0, pmin=0.05,
mintime=0.02, minsensor=2)
assert_greater_equal(res.clusters['duration'].min(), 0.02)
eq_(res.clusters['n_sensors'].min(), 2)
# 1d
res1d = testnd.ttest_rel('utsnd.sub(time=0.1)', 'A', match='rm', ds=ds,
samples=0, pmin=0.05)
assert_dataobj_equal(res1d.p_uncorrected, res.p_uncorrected.sub(time=0.1))
# TFCE
logger.info("TEST: TFCE")
sensor = Sensor(locs, ['0', '1', '2', '3'])
sensor.set_connectivity(connect_dist=1.1)
dims = ('case', UTS(-0.1, 0.1, 4), sensor,
Ordered('dim2', range(10), 'unit'))
y = NDVar(np.random.normal(0, 1, (10, 4, 4, 10)), dims)
cdist = _ClusterDist(y, 3, None)
cdist.add_original(y.x[0])
cdist.finalize()
assert_equal(cdist.dist.shape, (3,))
# I/O
string = pickle.dumps(cdist, pickle.HIGHEST_PROTOCOL)
cdist_ = pickle.loads(string)
assert_equal(repr(cdist_), repr(cdist))
# find peaks
x = np.array([[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[7, 7, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 7, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[5, 7, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 6, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 7, 5, 5, 0, 0],
[0, 0, 0, 0, 5, 4, 4, 4, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]],
[[0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 4, 0, 0],
[0, 0, 0, 0, 7, 0, 0, 3, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]])
tgt = np.equal(x, 7)
peaks = cdist._find_peaks(x)
logging.debug(' detected: \n%s' % (peaks.astype(int)))
logging.debug(' target: \n%s' % (tgt.astype(int)))
assert_array_equal(peaks, tgt)
mps = False, True
thresholds = (None, 'tfce')
for mp, threshold in product(mps, thresholds):
logger.info("TEST: multiprocessing=%r, threshold=%r" % (mp, threshold))
_testnd.multiprocessing = mp
# test keeping dimension
cdist = _ClusterDist(y, 5, threshold, dist_dim='sensor')
print repr(cdist)
cdist.add_original(y.x[0])
print repr(cdist)
assert_equal(cdist.dist.shape, (5, 4))
# test keeping time bins
cdist = _ClusterDist(y, 5, threshold, dist_tstep=0.2)
cdist.add_original(y.x[0])
assert_equal(cdist.dist.shape, (5, 2))
assert_raises(ValueError, _ClusterDist, y, 5, threshold, dist_tstep=0.3)
# test keeping dimension and time bins
cdist = _ClusterDist(y, 5, threshold, dist_dim='sensor', dist_tstep=0.2)
cdist.add_original(y.x[0])
assert_equal(cdist.dist.shape, (5, 4, 2))
# test keeping 2 dimensions and time bins
cdist = _ClusterDist(y, 5, threshold, dist_dim=('sensor', 'dim2'),
dist_tstep=0.2)
cdist.add_original(y.x[0])
assert_equal(cdist.dist.shape, (5, 4, 2, 10))
def test_source_estimate():
"Test SourceSpace dimension"
mne.set_log_level('warning')
ds = datasets.get_mne_sample(src='ico')
dsa = ds.aggregate('side')
# test auto-conversion
asndvar('epochs', ds=ds)
asndvar('epochs', ds=dsa)
asndvar(dsa['epochs'][0])
# source space clustering
res = testnd.ttest_ind('src',
'side',
ds=ds,
samples=0,
pmin=0.05,
tstart=0.05,
mintime=0.02,
minsource=10)
assert res.clusters.n_cases == 52
# test disconnecting parc
src = ds['src']
source = src.source
parc = source.parc
orig_conn = set(map(tuple, source.connectivity()))
disc_conn = set(map(tuple, source.connectivity(True)))
assert len(disc_conn) < len(orig_conn)
for pair in orig_conn:
s, d = pair
if pair in disc_conn:
assert parc[s] == parc[d]
else:
assert parc[s] != parc[d]
# threshold-based test with parc
srcl = src.sub(source='lh')
res = testnd.ttest_ind(srcl,
'side',
ds=ds,
samples=10,
pmin=0.05,
tstart=0.05,
mintime=0.02,
minsource=10,
parc='source')
assert res._cdist.dist.shape[1] == len(srcl.source.parc.cells)
label = 'superiortemporal-lh'
c_all = res.find_clusters(maps=True)
c_label = res.find_clusters(maps=True, source=label)
assert_array_equal(c_label['location'], label)
for case in c_label.itercases():
id_ = case['id']
idx = c_all['id'].index(id_)[0]
assert case['v'] == c_all[idx, 'v']
assert case['tstart'] == c_all[idx, 'tstart']
assert case['tstop'] == c_all[idx, 'tstop']
assert case['p'] <= c_all[idx, 'p']
assert_dataobj_equal(case['cluster'],
c_all[idx, 'cluster'].sub(source=label))
# threshold-free test with parc
res = testnd.ttest_ind(srcl,
'side',
ds=ds,
samples=10,
tstart=0.05,
parc='source')
cl = res.find_clusters(0.05)
assert cl.eval("p.min()") == res.p.min()
mp = res.masked_parameter_map()
assert mp.min() == res.t.min()
assert mp.max() == res.t.max(res.p <= 0.05)
assert mp.max() == pytest.approx(-4.95817732)
# indexing source space
s_sub = src.sub(source='fusiform-lh')
idx = source.index_for_label('fusiform-lh')
s_idx = src[idx]
assert_dataobj_equal(s_sub, s_idx)
# concatenate
src_reconc = concatenate((src.sub(source='lh'), src.sub(source='rh')),
'source')
assert_dataobj_equal(src_reconc, src)
def test_ttest_1samp():
"Test testnd.ttest_1samp()"
ds = datasets.get_uts(True)
# no clusters
res0 = testnd.ttest_1samp('uts', sub="A == 'a0'", ds=ds)
assert_less(res0.p_uncorrected.min(), 0.05)
repr0 = repr(res0)
assert_in("'uts'", repr0)
assert_not_in('clusters', repr0)
assert_not_in('mintime', repr0)
# clusters without resampling
res1 = testnd.ttest_1samp('uts',
sub="A == 'a0'",
ds=ds,
samples=0,
pmin=0.05,
tstart=0,
tstop=0.6,
mintime=0.05)
assert_equal(res1.clusters.n_cases, 1)
assert_not_in('p', res1.clusters)
repr1 = repr(res1)
assert_in('clusters', repr1)
assert_in('samples', repr1)
assert_in('mintime', repr1)
# persistence
string = pickle.dumps(res1, pickle.HIGHEST_PROTOCOL)
res1_ = pickle.loads(string)
assert_equal(repr(res1_), repr1)
assert_dataobj_equal(res1.p_uncorrected, res1_.p_uncorrected)
# clusters with resampling
res2 = testnd.ttest_1samp('uts',
sub="A == 'a0'",
ds=ds,
samples=10,
pmin=0.05,
tstart=0,
tstop=0.6,
mintime=0.05)
assert_equal(res2.clusters.n_cases, 1)
assert_equal(res2.samples, 10)
assert_in('p', res2.clusters)
repr2 = repr(res2)
assert_in('samples', repr2)
# clusters with permutations
dss = ds.sub("logical_and(A=='a0', B=='b0')")[:8]
res3 = testnd.ttest_1samp('uts',
sub="A == 'a0'",
ds=dss,
samples=10000,
pmin=0.05,
tstart=0,
tstop=0.6,
mintime=0.05)
assert_equal(res3.clusters.n_cases, 2)
assert_equal(res3.samples, -1)
assert_less(res3.clusters['p'].x.min(), 0.05)
repr3 = repr(res3)
assert_in('samples', repr3)
# nd
dss = ds.sub("A == 'a0'")
res = testnd.ttest_1samp('utsnd', ds=dss, samples=1)
res = testnd.ttest_1samp('utsnd', ds=dss, pmin=0.05, samples=1)
res = testnd.ttest_1samp('utsnd', ds=dss, tfce=True, samples=1)
# TFCE properties
res = testnd.ttest_1samp('utsnd', sub="A == 'a0'", ds=ds, samples=1)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res = pickle.loads(string)
tfce_clusters = res.find_clusters(pmin=0.05)
peaks = res.find_peaks()
assert_equal(tfce_clusters.eval("p.min()"), peaks.eval("p.min()"))
masked = res.masked_parameter_map(pmin=0.05)
assert_array_equal(masked.abs().x <= res.t.abs().x, True)
def test_t_contrast():
ds = datasets.get_rand()
# test aux functions
y = np.arange(9.).reshape((3, 3))
indexes = {'a': 0, 'b': 1, 'c': 2}
contrast = "+sum(a>c, b>c)"
contrast_ = _testnd._parse_t_contrast(contrast)
assert_equal(contrast_, ('func', '+', np.sum, [('comp', None, 'a', 'c'),
('comp', None, 'b', 'c')]))
contrast = "+sum(a>*, b>*)"
contrast_ = _testnd._parse_t_contrast(contrast)
assert_equal(contrast_, ('func', '+', np.sum, [('comp', None, 'a', '*'),
('comp', None, 'b', '*')]))
_, cells = _testnd._t_contrast_rel_properties(contrast_)
pc, mc = _testnd._t_contrast_rel_expand_cells(cells, ('a', 'b', 'c'))
data = _testnd._t_contrast_rel_data(y, indexes, pc, mc)
assert_array_equal(data['a'], np.arange(3.))
assert_array_equal(data['*'], y.mean(0))
assert_raises(ValueError, _testnd._t_contrast_rel_expand_cells, cells,
('a|c', 'b|c', 'c|c'))
# simple contrast
res = testnd.t_contrast_rel('uts',
'A',
'a1>a0',
'rm',
ds=ds,
samples=10,
pmin=0.05)
repr(res)
res_ = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_array_equal(res.t.x, res_.t.x)
assert_in('samples', repr(res))
# complex contrast
res = testnd.t_contrast_rel('uts',
'A%B',
'min(a0|b0>a1|b0, a0|b1>a1|b1)',
'rm',
ds=ds,
samples=10,
pmin=0.05)
res_b0 = testnd.ttest_rel('uts',
'A%B', ('a0', 'b0'), ('a1', 'b0'),
'rm',
ds=ds)
res_b1 = testnd.ttest_rel('uts',
'A%B', ('a0', 'b1'), ('a1', 'b1'),
'rm',
ds=ds)
assert_array_equal(res.t.x, np.min([res_b0.t.x, res_b1.t.x], axis=0))
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p, res_.p)
# contrast with "*"
contrast_star = '+min(a1|b0>a0|*, a1|b1>a0|*)'
res = testnd.t_contrast_rel('uts', 'A%B', contrast_star, 'rm', ds=ds)
def test_ttest_rel():
"Test testnd.ttest_rel()"
ds = datasets.get_uts(True)
# basic
res = testnd.ttest_rel('uts',
'A%B', ('a1', 'b1'), ('a0', 'b0'),
'rm',
ds=ds,
samples=100)
repr(res)
# persistence
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
repr(res_)
assert_equal(repr(res_), repr(res))
assert_dataobj_equal(res.p_uncorrected, res_.p_uncorrected)
# collapsing cells
res2 = testnd.ttest_rel('uts', 'A', 'a1', 'a0', 'rm', ds=ds)
assert_less(res2.p_uncorrected.min(), 0.05)
assert_equal(res2.n, res.n)
# reproducibility
res3 = testnd.ttest_rel('uts',
'A%B', ('a1', 'b1'), ('a0', 'b0'),
'rm',
ds=ds,
samples=100)
assert_dataset_equal(res3.find_clusters(maps=True), res.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 0
res4 = testnd.ttest_rel('uts',
'A%B', ('a1', 'b1'), ('a0', 'b0'),
'rm',
ds=ds,
samples=100)
assert_dataset_equal(res4.find_clusters(maps=True), res.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 1
sds = ds.sub("B=='b0'")
# thresholded, UTS
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('uts',
'A',
'a1',
'a0',
'rm',
ds=sds,
pmin=0.1,
samples=100)
tgt = res0.find_clusters()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('uts',
'A',
'a1',
'a0',
'rm',
ds=sds,
pmin=0.1,
samples=100)
assert_dataset_equal(res1.find_clusters(), tgt)
# thresholded, UTSND
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('utsnd',
'A',
'a1',
'a0',
'rm',
ds=sds,
pmin=0.1,
samples=100)
tgt = res0.find_clusters()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('utsnd',
'A',
'a1',
'a0',
'rm',
ds=sds,
pmin=0.1,
samples=100)
assert_dataset_equal(res1.find_clusters(), tgt)
# TFCE, UTS
eelbrain._stats.testnd.MULTIPROCESSING = 0
res0 = testnd.ttest_rel('uts',
'A',
'a1',
'a0',
'rm',
ds=sds,
tfce=True,
samples=10)
tgt = res0.compute_probability_map()
eelbrain._stats.testnd.MULTIPROCESSING = 1
res1 = testnd.ttest_rel('uts',
'A',
'a1',
'a0',
'rm',
ds=sds,
tfce=True,
samples=10)
assert_dataobj_equal(res1.compute_probability_map(), tgt)
def test_anova():
"Test testnd.anova()"
ds = datasets.get_uts(True)
testnd.anova('utsnd', 'A*B', ds=ds)
for samples in (0, 2):
logger.info("TEST: samples=%r" % samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, pmin=0.05)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, tfce=True)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=0, pmin=0.05)
repr(res)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=2, pmin=0.05)
repr(res)
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
# threshold-free
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=10)
repr(res)
assert_in('A clusters', res.clusters.info)
assert_in('B clusters', res.clusters.info)
assert_in('A x B clusters', res.clusters.info)
# no clusters
res = testnd.anova('uts',
'B',
sub="A=='a1'",
ds=ds,
samples=5,
pmin=0.05,
mintime=0.02)
repr(res)
assert_in('v', res.clusters)
assert_in('p', res.clusters)
# all effects with clusters
res = testnd.anova('uts',
'A*B*rm',
ds=ds,
samples=5,
pmin=0.05,
tstart=0.1,
mintime=0.02)
assert_equal(set(res.clusters['effect'].cells), set(res.effects))
# some effects with clusters, some without
res = testnd.anova('uts',
'A*B*rm',
ds=ds,
samples=5,
pmin=0.05,
tstart=0.37,
mintime=0.02)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_dataobj_equal(res.clusters, res_.clusters)
# test multi-effect results (with persistence)
# UTS
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5)
repr(res)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
resr = pickle.loads(string)
tf_clusters = resr.find_clusters(pmin=0.05)
peaks = resr.find_peaks()
assert_dataobj_equal(tf_clusters, res.find_clusters(pmin=0.05))
assert_dataobj_equal(peaks, res.find_peaks())
assert_equal(tf_clusters.eval("p.min()"), peaks.eval("p.min()"))
unmasked = resr.f[0]
masked = resr.masked_parameter_map(effect=0, pmin=0.05)
assert_array_equal(masked.x <= unmasked.x, True)
# reproducibility
res0 = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
assert_dataset_equal(res.clusters, res0.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 0
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=5)
assert_dataset_equal(res.clusters, res0.clusters)
eelbrain._stats.testnd.MULTIPROCESSING = 1
# permutation
eelbrain._stats.permutation._YIELD_ORIGINAL = 1
samples = 4
# raw
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=samples)
for dist in res._cdist:
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, dist.parameter_map.abs().max())
# TFCE
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, tfce=True, samples=samples)
for dist in res._cdist:
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, dist.tfce_map.abs().max())
# thresholded
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, pmin=0.05, samples=samples)
clusters = res.find_clusters()
for dist, effect in izip(res._cdist, res.effects):
effect_idx = clusters.eval("effect == %r" % effect)
vmax = clusters[effect_idx, 'v'].abs().max()
eq_(len(dist.dist), samples)
assert_array_equal(dist.dist, vmax)
eelbrain._stats.permutation._YIELD_ORIGINAL = 0
def test_anova():
"Test testnd.anova()"
plot.configure_backend(False, False)
ds = datasets.get_uts(True)
testnd.anova('utsnd', 'A*B', ds=ds)
for samples in (0, 2):
logger.info("TEST: samples=%r" % samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, pmin=0.05)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, tfce=True)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=0, pmin=0.05)
repr(res)
p = plot.Array(res)
p.close()
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=2, pmin=0.05)
repr(res)
p = plot.Array(res)
p.close()
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
# threshold-free
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=10)
repr(res)
assert_in('A clusters', res.clusters.info)
assert_in('B clusters', res.clusters.info)
assert_in('A x B clusters', res.clusters.info)
# no clusters
res = testnd.anova('uts', 'B', sub="A=='a1'", ds=ds, samples=5, pmin=0.05,
mintime=0.02)
repr(res)
assert_in('v', res.clusters)
assert_in('p', res.clusters)
# all effects with clusters
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5, pmin=0.05,
tstart=0.1, mintime=0.02)
assert_equal(set(res.clusters['effect'].cells), set(res.effects))
# some effects with clusters, some without
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5, pmin=0.05,
tstart=0.37, mintime=0.02)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_dataobj_equal(res.clusters, res_.clusters)
# test multi-effect results (with persistence)
# UTS
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5)
repr(res)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res = pickle.loads(string)
tfce_clusters = res.find_clusters(pmin=0.05)
peaks = res.find_peaks()
assert_equal(tfce_clusters.eval("p.min()"), peaks.eval("p.min()"))
unmasked = res.f[0]
masked = res.masked_parameter_map(effect=0, pmin=0.05)
assert_array_equal(masked.x <= unmasked.x, True)
def test_anova():
"Test testnd.anova()"
plot.configure_backend(False, False)
ds = datasets.get_rand(True)
testnd.anova('utsnd', 'A*B', ds=ds)
for samples in (0, 2):
logger.info("TEST: samples=%r" % samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, pmin=0.05)
testnd.anova('utsnd', 'A*B', ds=ds, samples=samples, tfce=True)
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=0, pmin=0.05)
repr(res)
p = plot.Array(res)
p.close()
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=2, pmin=0.05)
repr(res)
p = plot.Array(res)
p.close()
# persistence
string = pickle.dumps(res, protocol=pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_equal(repr(res_), repr(res))
# threshold-free
res = testnd.anova('utsnd', 'A*B*rm', ds=ds, samples=10)
repr(res)
assert_in('A clusters', res.clusters.info)
assert_in('B clusters', res.clusters.info)
assert_in('A x B clusters', res.clusters.info)
# no clusters
res = testnd.anova('uts',
'B',
sub="A=='a1'",
ds=ds,
samples=5,
pmin=0.05,
mintime=0.02)
repr(res)
assert_in('v', res.clusters)
assert_in('p', res.clusters)
# all effects with clusters
res = testnd.anova('uts',
'A*B*rm',
ds=ds,
samples=5,
pmin=0.05,
tstart=0.1,
mintime=0.02)
assert_equal(set(res.clusters['effect'].cells), set(res.effects))
# some effects with clusters, some without
res = testnd.anova('uts',
'A*B*rm',
ds=ds,
samples=5,
pmin=0.05,
tstart=0.37,
mintime=0.02)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res_ = pickle.loads(string)
assert_dataobj_equal(res.clusters, res_.clusters)
# test multi-effect results (with persistence)
# UTS
res = testnd.anova('uts', 'A*B*rm', ds=ds, samples=5)
repr(res)
string = pickle.dumps(res, pickle.HIGHEST_PROTOCOL)
res = pickle.loads(string)
tfce_clusters = res._clusters(pmin=0.05)
peaks = res.find_peaks()
assert_equal(tfce_clusters.eval("p.min()"), peaks.eval("p.min()"))
unmasked = res.f[0]
masked = res.masked_parameter_map(effect=0, pmin=0.05)
assert_array_equal(masked.x <= unmasked.x, True)
def test_source_estimate():
"Test SourceSpace dimension"
mne.set_log_level('warning')
ds = datasets.get_mne_sample(src='ico')
dsa = ds.aggregate('side')
# test auto-conversion
asndvar('epochs', ds=ds)
asndvar('epochs', ds=dsa)
asndvar(dsa['epochs'][0])
# source space clustering
res = testnd.ttest_ind('src', 'side', ds=ds, samples=0, pmin=0.05,
tstart=0.05, mintime=0.02, minsource=10)
eq_(res.clusters.n_cases, 52)
# test disconnecting parc
src = ds['src']
source = src.source
parc = source.parc
orig_conn = set(map(tuple, source.connectivity()))
disc_conn = set(map(tuple, source.connectivity(True)))
ok_(len(disc_conn) < len(orig_conn))
for pair in orig_conn:
s, d = pair
if pair in disc_conn:
eq_(parc[s], parc[d])
else:
assert_not_equal(parc[s], parc[d])
# threshold-based test with parc
srcl = src.sub(source='lh')
res = testnd.ttest_ind(srcl, 'side', ds=ds, samples=10, pmin=0.05,
tstart=0.05, mintime=0.02, minsource=10,
parc='source')
eq_(res._cdist.dist.shape[1], len(srcl.source.parc.cells))
label = 'superiortemporal-lh'
c_all = res.find_clusters(maps=True)
c_label = res.find_clusters(maps=True, source=label)
assert_array_equal(c_label['location'], label)
for case in c_label.itercases():
id_ = case['id']
idx = c_all['id'].index(id_)[0]
eq_(case['v'], c_all[idx, 'v'])
eq_(case['tstart'], c_all[idx, 'tstart'])
eq_(case['tstop'], c_all[idx, 'tstop'])
assert_less_equal(case['p'], c_all[idx, 'p'])
assert_dataobj_equal(case['cluster'],
c_all[idx, 'cluster'].sub(source=label))
# threshold-free test with parc
res = testnd.ttest_ind(srcl, 'side', ds=ds, samples=10, tstart=0.05,
parc='source')
cl = res.find_clusters(0.05)
eq_(cl.eval("p.min()"), res.p.min())
mp = res.masked_parameter_map()
assert_in(mp.min(), (0, res.t.min()))
assert_in(mp.max(), (0, res.t.max()))
# indexing source space
s_sub = src.sub(source='fusiform-lh')
idx = source.index_for_label('fusiform-lh')
s_idx = src[idx]
assert_dataobj_equal(s_sub, s_idx)
