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)
dims = ('case', UTS(-0.1, 0.1, 6), Ordered('dim2', range(6), 'unit'),
Sensor(locs, ['0', '1', '2', '3'], connect_dist=1.1))
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)
# TFCE
logger.info("TEST: TFCE")
dims = ('case', UTS(-0.1, 0.1, 4),
Sensor(locs, ['0', '1', '2', '3'], connect_dist=1.1),
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])
for i in xrange(1, 4):
cdist.add_perm(Y.x[i])
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)
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
assert_equal(cdist.dist.shape, (5, 4, 2, 10))
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_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()"
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)
# 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_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_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)
dims = ('case', UTS(-0.1, 0.1, 6), Ordered('dim2', range(6), 'unit'),
Sensor(locs, ['0', '1', '2', '3'], connect_dist=1.1))
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)
# TFCE
logger.info("TEST: TFCE")
dims = ('case', UTS(-0.1, 0.1,
4), Sensor(locs, ['0', '1', '2', '3'],
connect_dist=1.1),
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])
for i in xrange(1, 4):
cdist.add_perm(Y.x[i])
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)
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
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])
for i in xrange(1, 6):
cdist.add_perm(Y.x[i])
assert_equal(cdist.dist.shape, (5, 4, 2, 10))
