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_merged_temporal_cluster_dist():
"Test use of _MergedTemporalClusterDist with testnd test results"
ds1 = datasets.get_uts()
ds2 = datasets.get_uts(seed=42)
anova_kw = dict(Y='uts', X='A*B*rm', pmin=0.05, samples=10)
ttest_kw = dict(Y='uts', X='A', c1='a1', c0='a0', pmin=0.05, samples=10)
contrast_kw = dict(Y='uts', X='A', contrast='a1>a0', pmin=0.05, samples=10)
def test_merged(res1, res2):
merged_dist = _MergedTemporalClusterDist([res1._cdist, res2._cdist])
if isinstance(res1, testnd.anova):
assert_equal(len(merged_dist.dist), len(res1.effects))
for effect, dist in merged_dist.dist.iteritems():
assert_in(effect, res1.effects)
assert_equal(len(dist), res1.samples)
else:
assert_equal(len(merged_dist.dist), res1.samples)
res1_clusters = merged_dist.correct_cluster_p(res1)
res2_clusters = merged_dist.correct_cluster_p(res2)
for clusters in [res1_clusters, res2_clusters]:
assert_in('p_parc', clusters)
for cl in clusters.itercases():
assert_greater_equal(cl['p_parc'], cl['p'])
# multi-effect
res1 = testnd.anova(ds=ds1, **anova_kw)
res2 = testnd.anova(ds=ds2, **anova_kw)
test_merged(res1, res2)
# ttest_rel
res1 = testnd.ttest_rel(ds=ds1, match='rm', **ttest_kw)
res2 = testnd.ttest_rel(ds=ds2, match='rm', **ttest_kw)
test_merged(res1, res2)
# ttest_ind
res1 = testnd.ttest_ind(ds=ds1, **ttest_kw)
res2 = testnd.ttest_ind(ds=ds2, **ttest_kw)
test_merged(res1, res2)
# ttest_1samp
res1 = testnd.ttest_1samp('uts', ds=ds1, pmin=0.05, samples=10)
res2 = testnd.ttest_1samp('uts', ds=ds2, pmin=0.05, samples=10)
test_merged(res1, res2)
# t_contrast_rel
res1 = testnd.t_contrast_rel(ds=ds1, match='rm', **contrast_kw)
res2 = testnd.t_contrast_rel(ds=ds2, match='rm', **contrast_kw)
test_merged(res1, res2)
def test_merged_temporal_cluster_dist():
"Test use of _MergedTemporalClusterDist with testnd test results"
ds1 = datasets.get_uts()
ds2 = datasets.get_uts(seed=42)
anova_kw = dict(Y='uts', X='A*B*rm', pmin=0.05, samples=10)
ttest_kw = dict(Y='uts', X='A', c1='a1', c0='a0', pmin=0.05, samples=10)
contrast_kw = dict(Y='uts', X='A', contrast='a1>a0', pmin=0.05, samples=10)
def test_merged(res1, res2):
merged_dist = _MergedTemporalClusterDist([res1._cdist, res2._cdist])
if isinstance(res1, testnd.anova):
assert_equal(len(merged_dist.dist), len(res1.effects))
for effect, dist in merged_dist.dist.iteritems():
assert_in(effect, res1.effects)
assert_equal(len(dist), res1.samples)
else:
assert_equal(len(merged_dist.dist), res1.samples)
res1_clusters = merged_dist.correct_cluster_p(res1)
res2_clusters = merged_dist.correct_cluster_p(res2)
for clusters in [res1_clusters, res2_clusters]:
assert_in('p_parc', clusters)
for cl in clusters.itercases():
assert_greater_equal(cl['p_parc'], cl['p'])
# multi-effect
res1 = testnd.anova(ds=ds1, **anova_kw)
res2 = testnd.anova(ds=ds2, **anova_kw)
test_merged(res1, res2)
# ttest_rel
res1 = testnd.ttest_rel(ds=ds1, match='rm', **ttest_kw)
res2 = testnd.ttest_rel(ds=ds2, match='rm', **ttest_kw)
test_merged(res1, res2)
# ttest_ind
res1 = testnd.ttest_ind(ds=ds1, **ttest_kw)
res2 = testnd.ttest_ind(ds=ds2, **ttest_kw)
test_merged(res1, res2)
# ttest_1samp
res1 = testnd.ttest_1samp('uts', ds=ds1, pmin=0.05, samples=10)
res2 = testnd.ttest_1samp('uts', ds=ds2, pmin=0.05, samples=10)
test_merged(res1, res2)
# t_contrast_rel
res1 = testnd.t_contrast_rel(ds=ds1, match='rm', **contrast_kw)
res2 = testnd.t_contrast_rel(ds=ds2, match='rm', **contrast_kw)
test_merged(res1, res2)
def reg_clusters_t_src(mod, IV, factor=None, c1=None, c0=None):
""" Cluster permutation (src x time) t-tests on regression coefficients.
Example: mod='main-VerbGivenWord', IV='LogFre'
"""
dr = '/Volumes/Backup/sufAmb/regression/'
f = dr+'ols_'+mod+'.pickled'
data = load.unpickle(f)
cond = "predictor=='%s'" % IV
data = data.sub(cond) # smaller ds with only the predictor of interest
# cluster permutation parameters
Y='beta'
match='subject'
samples=100
pmin=0.05
tstart=0.13
tstop=0.45
mintime=0.03
minsource=10
if factor is None:
test = testnd.ttest_1samp(Y=Y, ds=data, match=match, samples=samples, pmin=pmin,
tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
elif factor == 'main':
test = testnd.ttest_1samp(Y=Y, ds=data.sub("condition=='main'"), match=match, samples=samples, pmin=pmin,
tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
else:
test = testnd.ttest_rel(Y=Y, ds=data, X=factor, c1=c1, c0=c0, match=match, samples=samples, pmin=pmin,
tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
print "Finished cluster test: mod=%s, IV=%s, factor=%s, c1=%s, c0=%s" % (mod, IV, factor, c1, c0)
path = "/Volumes/BackUp/sufAmb/reg-cluster_time_src/ols_mod-%s_IV-%s_factor-%s_c1-%s_c0-%s.pickled" \
% (mod, IV, factor, c1, c0)
save.pickle(test, path)
return test
def test_result_report():
"Test result_report function for different Results"
ds = datasets.get_uts(True)
sds = ds.sub("B == 'b0'")
for y in (
'uts', # time
"utsnd.summary(time=(0.25, 0.35))", # sensor
'utsnd', # sensor x time
):
dims = tuple(dim.name for dim in ds.eval(y).dims[1:])
logging.info("y=%s %s", y, dims)
kwargs = dict(pmin=0.1, samples=100)
if 'time' in dims:
kwargs['tstart'] = 0.2
kwargs['tstop'] = 0.4
for match in (None, 'rm'):
logging.info(" match=%s", match)
res = testnd.ttest_1samp(y, match=match, ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_ind(y, 'A', ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_rel(y, 'A', ds=sds, match='rm', **kwargs)
rep = result_report(res, sds)
html(rep)
res = testnd.anova(y, 'A * B', ds=ds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.anova(y, 'A * rm', ds=sds, match='rm', **kwargs)
rep = result_report(res, ds)
html(rep)
def test_result_report():
"Test result_report function for different Results"
ds = datasets.get_uts(True)
sds = ds.sub("B == 'b0'")
ys = [
'uts', # time
"utsnd.summary(time=(0.25, 0.35))", # sensor
'utsnd', # sensor x time
]
for y in ys:
y_obj = sds.eval(y)
kwargs = dict(pmin=0.1, samples=100)
if y_obj.has_dim('time'):
kwargs['tstart'] = 0.2
kwargs['tstop'] = 0.4
for match in (None, 'rm'):
logging.info(" match=%s", match)
res = testnd.ttest_1samp(y, match=match, ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_ind(y, 'A', ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_rel(y, 'A', ds=sds, match='rm', **kwargs)
rep = result_report(res, sds)
html(rep)
res = testnd.anova(y, 'A * B', ds=ds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.anova(y, 'A * rm', ds=sds, match='rm', **kwargs)
rep = result_report(res, ds)
html(rep)
def test_result_report():
"Test result_report function for different Results"
ds = datasets.get_uts(True)
sds = ds.sub("B == 'b0'")
for y in ('uts', # time
"utsnd.summary(time=(0.25, 0.35))", # sensor
'utsnd', # sensor x time
):
dims = tuple(dim.name for dim in ds.eval(y).dims[1:])
logging.info("y=%s %s", y, dims)
kwargs = dict(pmin=0.1, samples=100)
if 'time' in dims:
kwargs['tstart'] = 0.2
kwargs['tstop'] = 0.4
for match in (None, 'rm'):
logging.info(" match=%s", match)
res = testnd.ttest_1samp(y, match=match, ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_ind(y, 'A', ds=sds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.ttest_rel(y, 'A', ds=sds, match='rm', **kwargs)
rep = result_report(res, sds)
html(rep)
res = testnd.anova(y, 'A * B', ds=ds, **kwargs)
rep = result_report(res, ds)
html(rep)
res = testnd.anova(y, 'A * rm', ds=sds, match='rm', **kwargs)
rep = result_report(res, ds)
html(rep)
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)
# sub as array
res1 = testnd.ttest_1samp('uts', sub=ds.eval("A == 'a0'"), ds=ds)
repr1 = repr(res1)
assert_not_equal(repr1, 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)
# zero variance
ds['utsnd'].x[:, 1, 10] = 0.
ds['utsnd'].x[:, 2, 10] = 0.1
res = testnd.ttest_1samp('utsnd', ds=ds)
eq_(res.t.x[1, 10], 0.)
assert_greater(res.t.x[2, 10], 1e10)
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), Scalar('dim2', range(6),
'unit'), sensor)
y = NDVar(x, dims)
# test connecting sensors
logging.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
logging.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
logging.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
logging.info("TEST: TFCE")
sensor = Sensor(locs, ['0', '1', '2', '3'])
sensor.set_connectivity(connect_dist=1.1)
time = UTS(-0.1, 0.1, 4)
scalar = Scalar('scalar', range(10), 'unit')
dims = ('case', time, sensor, scalar)
np.random.seed(0)
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 = find_peaks(x, cdist._connectivity)
logging.debug(' detected: \n%s' % (peaks.astype(int)))
logging.debug(' target: \n%s' % (tgt.astype(int)))
assert_array_equal(peaks, tgt)
# testnd permutation result
res = testnd.ttest_1samp(y, tfce=True, samples=3)
assert_allclose(np.sort(res._cdist.dist),
[77.5852307, 119.1976153, 217.6270428])
# parc with TFCE on unconnected dimension
configure(False)
x = np.random.normal(0, 1, (10, 5, 2, 4))
time = UTS(-0.1, 0.1, 5)
categorial = Categorial('categorial', ('a', 'b'))
y = NDVar(x, ('case', time, categorial, sensor))
y0 = NDVar(x[:, :, 0], ('case', time, sensor))
y1 = NDVar(x[:, :, 1], ('case', time, sensor))
res = testnd.ttest_1samp(y, tfce=True, samples=3)
res_parc = testnd.ttest_1samp(y, tfce=True, samples=3, parc='categorial')
res0 = testnd.ttest_1samp(y0, tfce=True, samples=3)
res1 = testnd.ttest_1samp(y1, tfce=True, samples=3)
# cdist
eq_(res._cdist.shape, (4, 2, 5))
# T-maps don't depend on connectivity
assert_array_equal(res.t.x[:, 0], res0.t.x)
assert_array_equal(res.t.x[:, 1], res1.t.x)
assert_array_equal(res_parc.t.x[:, 0], res0.t.x)
assert_array_equal(res_parc.t.x[:, 1], res1.t.x)
# TFCE-maps should always be the same because they're unconnected
assert_array_equal(res.tfce_map.x[:, 0], res0.tfce_map.x)
assert_array_equal(res.tfce_map.x[:, 1], res1.tfce_map.x)
assert_array_equal(res_parc.tfce_map.x[:, 0], res0.tfce_map.x)
assert_array_equal(res_parc.tfce_map.x[:, 1], res1.tfce_map.x)
# Probability-maps should depend on what is taken into account
p_a = res0.compute_probability_map().x
p_b = res1.compute_probability_map().x
assert_array_equal(res_parc.compute_probability_map(categorial='a').x, p_a)
assert_array_equal(res_parc.compute_probability_map(categorial='b').x, p_b)
p_parc = res_parc.compute_probability_map()
assert_array_equal(p_parc.x, res.compute_probability_map().x)
ok_(np.all(p_parc.sub(categorial='a').x >= p_a))
ok_(np.all(p_parc.sub(categorial='b').x >= p_b))
configure(True)
def test_vector():
"""Test vector tests"""
# single vector
ds = datasets.get_uv(vector=True)
res = testnd.Vector('v[:40]', ds=ds, samples=10)
assert res.p == 0.0
res = testnd.Vector('v[40:]', ds=ds, samples=10)
assert res.p == 1.0
# single vector with norm stat
res_t = testnd.Vector('v[:40]', ds=ds, samples=10, norm=True)
assert res_t.p == 0.0
res_t = testnd.Vector('v[40:]', ds=ds, samples=10, norm=True)
assert res_t.p == 1.0
# non-space tests should raise error
with pytest.raises(WrongDimension):
testnd.ttest_1samp('v', ds=ds)
with pytest.raises(WrongDimension):
testnd.ttest_rel('v', 'A', match='rm', ds=ds)
with pytest.raises(WrongDimension):
testnd.ttest_ind('v', 'A', ds=ds)
with pytest.raises(WrongDimension):
testnd.t_contrast_rel('v', 'A', 'a0 > a1', 'rm', ds=ds)
with pytest.raises(WrongDimension):
testnd.corr('v', 'fltvar', ds=ds)
with pytest.raises(WrongDimension):
testnd.anova('v', 'A * B', ds=ds)
# vector in time
ds = datasets.get_uts(vector3d=True)
v1 = ds[30:, 'v3d']
v2 = ds[:30, 'v3d']
vd = v1 - v2
res = testnd.Vector(vd, samples=10)
assert res.p.min() == 0.2
difference = res.masked_difference(0.5)
assert difference.x.mask.sum() == 288
# diff related
resd = testnd.VectorDifferenceRelated(v1, v2, samples=10)
assert_dataobj_equal(resd.p, res.p, name=False)
assert_dataobj_equal(resd.t2, res.t2, name=False)
# diff independent
res = VectorDifferenceIndependent(v1, v2, samples=10, norm=True)
assert_dataobj_equal(res.difference, v1.mean('case') - v2.mean('case'), name=False)
assert res.p.max() == 1
assert res.p.min() == 0
# with mp
res = testnd.Vector(v1, samples=10)
assert res.p.min() == 0.4
# without mp
configure(n_workers=0)
res0 = testnd.Vector(v1, samples=10)
assert_array_equal(np.sort(res0._cdist.dist), np.sort(res._cdist.dist))
configure(n_workers=True)
# time window
res = testnd.Vector(v2, samples=10, tstart=0.1, tstop=0.4)
assert res.p.min() == 0.3
difference = res.masked_difference(0.5)
assert difference.x.mask.sum() == 294
# vector in time with norm stat
res = testnd.Vector(vd, samples=10, norm=True)
assert res.p.min() == 0
difference = res.masked_difference()
assert difference.x.mask.sum() == 297
resd = testnd.VectorDifferenceRelated(v1, v2, samples=10, norm=True)
assert_dataobj_equal(resd.p, res.p, name=False)
assert_dataobj_equal(resd.difference, res.difference, name=False)
v_small = v2 / 100
res = testnd.Vector(v_small, tfce=True, samples=10, norm=True)
assert 'WARNING' in repr(res)
res = testnd.Vector(v_small, tfce=0.1, samples=10)
assert res.p.min() == 0.0
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 res0.p_uncorrected.min() < 0.05
assert repr(res0) == "<ttest_1samp 'uts', sub=\"A == 'a0'\">"
# sub as array
res1 = testnd.ttest_1samp('uts', sub=ds.eval("A == 'a0'"), ds=ds)
assert repr(res1) == "<ttest_1samp 'uts', sub=<array>>"
# 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 res1.clusters.n_cases == 1
assert 'p' not in res1.clusters
assert repr(res1) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=0, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 1 clusters>"
# persistence
string = pickle.dumps(res1, pickle.HIGHEST_PROTOCOL)
res1_ = pickle.loads(string)
assert repr(res1_) == repr(res1)
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 res2.clusters.n_cases == 1
assert res2.samples == 10
assert 'p' in res2.clusters
assert repr(res2) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=10, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 1 clusters, p < .001>"
# 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 repr(res3) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=255, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 2 clusters, p = .020>"
assert res3.clusters.n_cases == 2
assert res3.samples == -1
assert str(res3.clusters) == (
'id tstart tstop duration v p sig\n'
'--------------------------------------------------------\n'
'3 0.08 0.34 0.26 95.692 0.015686 * \n'
'4 0.35 0.56 0.21 81.819 0.019608 * ')
# 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 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)
# zero variance
ds['utsnd'].x[:, 1, 10] = 0.
ds['utsnd'].x[:, 2, 10] = 0.1
res = testnd.ttest_1samp('utsnd', ds=ds)
assert res.t.x[1, 10] == 0.
assert res.t.x[2, 10] > 1e10
# argument length
with pytest.raises(ValueError):
testnd.ttest_1samp('utsnd', sub="A[:-1] == 'a0'", ds=ds)
def test_clusterdist():
"Test NDPermutationDistribution 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), Scalar('dim2', range(6), 'unit'),
sensor)
y = NDVar(x, dims)
# test connecting sensors
logging.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 = NDPermutationDistribution(y, 0, 1.5)
print(repr(cdist))
cdist.add_original(pmap)
print(repr(cdist))
assert cdist.n_clusters == 1
assert_array_equal(cdist._original_cluster_map == cdist._cids[0],
cdist._crop(bin_map).swapaxes(0, cdist._nad_ax))
assert cdist.parameter_map.dims == y.dims[1:]
# test connecting many sensors
logging.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 = NDPermutationDistribution(y, 0, 1.5)
cdist.add_original(pmap)
assert 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
logging.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 = NDPermutationDistribution(y, 1, 1.5)
cdist.add_original(pmap)
assert 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 res.clusters['duration'].min() < 0.01
assert 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 res.clusters['duration'].min() >= 0.02
assert 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
logging.info("TEST: TFCE")
sensor = Sensor(locs, ['0', '1', '2', '3'])
sensor.set_connectivity(connect_dist=1.1)
time = UTS(-0.1, 0.1, 4)
scalar = Scalar('scalar', range(10), 'unit')
dims = ('case', time, sensor, scalar)
np.random.seed(0)
y = NDVar(np.random.normal(0, 1, (10, 4, 4, 10)), dims)
cdist = NDPermutationDistribution(y, 3, None)
cdist.add_original(y.x[0])
cdist.finalize()
assert cdist.dist.shape == (3,)
# I/O
string = pickle.dumps(cdist, pickle.HIGHEST_PROTOCOL)
cdist_ = pickle.loads(string)
assert 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 = find_peaks(x, cdist._connectivity)
logging.debug(' detected: \n%s' % (peaks.astype(int)))
logging.debug(' target: \n%s' % (tgt.astype(int)))
assert_array_equal(peaks, tgt)
# testnd permutation result
res = testnd.ttest_1samp(y, tfce=True, samples=3)
if sys.version_info[0] == 3:
target = [96.84232967, 205.83207424, 425.65942084]
else:
target = [77.5852307, 119.1976153, 217.6270428]
assert_allclose(np.sort(res._cdist.dist), target)
# parc with TFCE on unconnected dimension
configure(False)
x = np.random.normal(0, 1, (10, 5, 2, 4))
time = UTS(-0.1, 0.1, 5)
categorial = Categorial('categorial', ('a', 'b'))
y = NDVar(x, ('case', time, categorial, sensor))
y0 = NDVar(x[:, :, 0], ('case', time, sensor))
y1 = NDVar(x[:, :, 1], ('case', time, sensor))
res = testnd.ttest_1samp(y, tfce=True, samples=3)
res_parc = testnd.ttest_1samp(y, tfce=True, samples=3, parc='categorial')
res0 = testnd.ttest_1samp(y0, tfce=True, samples=3)
res1 = testnd.ttest_1samp(y1, tfce=True, samples=3)
# cdist
assert res._cdist.shape == (4, 2, 5)
# T-maps don't depend on connectivity
assert_array_equal(res.t.x[:, 0], res0.t.x)
assert_array_equal(res.t.x[:, 1], res1.t.x)
assert_array_equal(res_parc.t.x[:, 0], res0.t.x)
assert_array_equal(res_parc.t.x[:, 1], res1.t.x)
# TFCE-maps should always be the same because they're unconnected
assert_array_equal(res.tfce_map.x[:, 0], res0.tfce_map.x)
assert_array_equal(res.tfce_map.x[:, 1], res1.tfce_map.x)
assert_array_equal(res_parc.tfce_map.x[:, 0], res0.tfce_map.x)
assert_array_equal(res_parc.tfce_map.x[:, 1], res1.tfce_map.x)
# Probability-maps should depend on what is taken into account
p_a = res0.compute_probability_map().x
p_b = res1.compute_probability_map().x
assert_array_equal(res_parc.compute_probability_map(categorial='a').x, p_a)
assert_array_equal(res_parc.compute_probability_map(categorial='b').x, p_b)
p_parc = res_parc.compute_probability_map()
assert_array_equal(p_parc.x, res.compute_probability_map().x)
assert np.all(p_parc.sub(categorial='a').x >= p_a)
assert np.all(p_parc.sub(categorial='b').x >= p_b)
configure(True)
def test_vector():
"""Test vector tests"""
# single vector
ds = datasets.get_uv(vector=True)
res = testnd.Vector('v[:40]', ds=ds, samples=10)
assert res.p == 0.0
res = testnd.Vector('v[40:]', ds=ds, samples=10)
assert res.p == 1.0
# single vector with norm stat
res_t = testnd.Vector('v[:40]', ds=ds, samples=10, norm=True)
assert res_t.p == 0.0
res_t = testnd.Vector('v[40:]', ds=ds, samples=10, norm=True)
assert res_t.p == 1.0
# non-space tests should raise error
with pytest.raises(WrongDimension):
testnd.ttest_1samp('v', ds=ds)
with pytest.raises(WrongDimension):
testnd.ttest_rel('v', 'A', match='rm', ds=ds)
with pytest.raises(WrongDimension):
testnd.ttest_ind('v', 'A', ds=ds)
with pytest.raises(WrongDimension):
testnd.t_contrast_rel('v', 'A', 'a0 > a1', 'rm', ds=ds)
with pytest.raises(WrongDimension):
testnd.corr('v', 'fltvar', ds=ds)
with pytest.raises(WrongDimension):
testnd.anova('v', 'A * B', ds=ds)
# vector in time
ds = datasets.get_uts(vector3d=True)
v1 = ds[30:, 'v3d']
v2 = ds[:30, 'v3d']
vd = v1 - v2
res = testnd.Vector(vd, samples=10)
assert res.p.min() == 0.2
difference = res.masked_difference(0.5)
assert difference.x.mask.sum() == 288
# diff related
resd = testnd.VectorDifferenceRelated(v1, v2, samples=10)
assert_dataobj_equal(resd.p, res.p, name=False)
assert_dataobj_equal(resd.t2, res.t2, name=False)
# diff independent
res = VectorDifferenceIndependent(v1, v2, samples=10, norm=True)
assert_dataobj_equal(res.difference,
v1.mean('case') - v2.mean('case'),
name=False)
assert res.p.max() == 1
assert res.p.min() == 0
# with mp
res = testnd.Vector(v1, samples=10)
assert res.p.min() == 0.4
# without mp
configure(n_workers=0)
res0 = testnd.Vector(v1, samples=10)
assert_array_equal(np.sort(res0._cdist.dist), np.sort(res._cdist.dist))
configure(n_workers=True)
# time window
res = testnd.Vector(v2, samples=10, tstart=0.1, tstop=0.4)
assert res.p.min() == 0.3
difference = res.masked_difference(0.5)
assert difference.x.mask.sum() == 294
# vector in time with norm stat
res = testnd.Vector(vd, samples=10, norm=True)
assert res.p.min() == 0
difference = res.masked_difference()
assert difference.x.mask.sum() == 297
resd = testnd.VectorDifferenceRelated(v1, v2, samples=10, norm=True)
assert_dataobj_equal(resd.p, res.p, name=False)
assert_dataobj_equal(resd.difference, res.difference, name=False)
v_small = v2 / 100
res = testnd.Vector(v_small, tfce=True, samples=10, norm=True)
assert 'WARNING' in repr(res)
res = testnd.Vector(v_small, tfce=0.1, samples=10)
assert res.p.min() == 0.0
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, samples=0)
assert res0.p_uncorrected.min() < 0.05
assert repr(res0) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=0>"
# sub as array
res1 = testnd.ttest_1samp('uts',
sub=ds.eval("A == 'a0'"),
ds=ds,
samples=0)
assert repr(res1) == "<ttest_1samp 'uts', sub=<array>, samples=0>"
# 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 res1.clusters.n_cases == 1
assert 'p' not in res1.clusters
assert repr(
res1
) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=0, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 1 clusters>"
# persistence
string = pickle.dumps(res1, pickle.HIGHEST_PROTOCOL)
res1_ = pickle.loads(string)
assert repr(res1_) == repr(res1)
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 res2.clusters.n_cases == 1
assert res2.samples == 10
assert 'p' in res2.clusters
assert repr(
res2
) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=10, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 1 clusters, p < .001>"
# 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 repr(
res3
) == "<ttest_1samp 'uts', sub=\"A == 'a0'\", samples=255, pmin=0.05, tstart=0, tstop=0.6, mintime=0.05, 2 clusters, p = .020>"
assert res3.clusters.n_cases == 2
assert res3.samples == -1
assert str(res3.clusters) == (
'id tstart tstop duration v p sig\n'
'--------------------------------------------------------\n'
'3 0.08 0.34 0.26 95.692 0.015686 * \n'
'4 0.35 0.56 0.21 81.819 0.019608 * ')
# 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 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)
# zero variance
ds['utsnd'].x[:, 1, 10] = 0.
ds['utsnd'].x[:, 2, 10] = 0.1
res = testnd.ttest_1samp('utsnd', ds=ds, samples=0)
assert res.t.x[1, 10] == 0.
assert res.t.x[2, 10] > 1e10
# argument length
with pytest.raises(ValueError):
testnd.ttest_1samp('utsnd', sub="A[:-1] == 'a0'", ds=ds, samples=0)
pmin=0.15
tstart=0.13
tstop=0.45
mintime=0.03
minsource=10
X = 'Type'
tests = {}
for v in IVs:
print v
testsv = {}
fil = dr+'corr_'+v+'.pickled'
data = load.unpickle(fil)
print 'main'
testsv['main'] = testnd.ttest_1samp(Y=Y, ds=data.sub("Type=='all'"), match=match, samples=samples, pmin=pmin, tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
print 'test 1'
testsv['stemVstemS'] = testnd.ttest_rel(Y=Y, ds=data, X=X, c1='stem', c0='stemS', match=match, samples=samples, pmin=pmin, tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
print 'test 2'
testsv['stemVstemEd'] = testnd.ttest_rel(Y=Y, ds=data, X=X, c1='stem', c0='stemEd', match=match, samples=samples, pmin=pmin, tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
print 'test 3'
testsv['stemSVstemEd'] = testnd.ttest_rel(Y=Y, ds=data, X=X, c1='stemS', c0='stemEd', match=match, samples=samples, pmin=pmin, tstart=tstart, tstop=tstop, mintime=mintime, minsource=minsource)
for t in testsv:
name = v+'_'+t
path = '/Volumes/BackUp/sufAmb/corr_cluster_timespace/corr_%s.pickled' % name
save.pickle(testsv[t], path)
tests[v] = testsv
