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_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_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_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_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_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)