def test_sym_to_vec():
"""Testing sym_to_vec function"""
sym = np.ones((3, 3))
vec = my_con.sym_to_vec(sym)
vec_expected = np.array([1., np.sqrt(2), 1., np.sqrt(2), np.sqrt(2), 1.])
vec_bool = my_con.sym_to_vec(sym > 0, isometry=False)
bool_expected = np.ones(6, dtype=bool)
assert_array_almost_equal(vec, vec_expected)
assert_array_equal(vec_bool, bool_expected)
shape = random.randint(1, 40)
m = np.random.rand(shape, shape)
sym = m + m.T
syms = np.asarray([sym, 2. * sym, 0.5 * sym])
vec = my_con.sym_to_vec(sym)
vecs = my_con.sym_to_vec(syms)
assert_array_almost_equal(my_con.vec_to_sym(vec), sym)
for k, vec in enumerate(vecs):
assert_array_almost_equal(my_con.vec_to_sym(vec), syms[k])
vec = my_con.sym_to_vec(sym, isometry=False)
vecs = my_con.sym_to_vec(syms, isometry=False)
assert_array_almost_equal(my_con.vec_to_sym(vec, isometry=False), sym)
assert_array_almost_equal(vec[..., -shape:], sym[..., -1, :])
for k, vec in enumerate(vecs):
assert_array_almost_equal(
my_con.vec_to_sym(vec, isometry=False), syms[k])
assert_array_almost_equal(vecs[..., -shape:], syms[..., -1, :])
def statistical_test(df, conditions, estimators={'kind': 'tangent',
'cov_estimator': None},
p_correction="fdr",
n_jobs=1):
grouped = df.groupby(["condition", "subj_id"])
dict_list = list()
entries = ("baseline", "mean signif baseline",
"follow up", "mean signif follow up",
"comparison", "tstat", "pval", "mean signif comparison")
for (ix1_, condition1) in enumerate(conditions):
for (ix2_, condition2) in enumerate(conditions):
if ix1_ <= ix2_:
continue
cond = list()
grouped = df.groupby("subj_id")
for _, group in grouped:
cond.append(group[group["condition"] == condition1]
["region_signals"].iloc[0])
cond.append(group[group["condition"] == condition2]
["region_signals"].iloc[0])
X = CovEmbedding(**estimators).fit_transform(cond)
X = [vec_to_sym(x) for x in X]
X = np.asarray(X)
X = sym_to_vec(X, isometry=False)
Y = var_stabilize(X, estimators['kind'])
t_stat_baseline, p_baseline = scipy.stats.ttest_1samp(Y[::2, ...],
0.0,
axis=0)
q_baseline = pval_correction.correct(p_baseline, correction=p_correction)
q_baseline[np.isnan(q_baseline)] = 0.
baseline_signif = np.tanh(Y[::2, ...]).mean(axis=0) * (q_baseline < 0.05)
t_stat_followup, p_followup = scipy.stats.ttest_1samp(Y[1::2, ...],
0.0,
axis=0)
q_followup = pval_correction.correct(p_followup, correction=p_correction)
q_followup[np.isnan(q_followup)] = 0.
followup_signif = np.tanh(Y[1::2, ...]).mean(axis=0) * (q_followup < 0.05)
t_stat, p = scipy.stats.ttest_rel(Y[::2, ...],
Y[1::2, ...],
axis=0)
q = pval_correction.correct(p, correction=p_correction)
q[np.isnan(q)] = 0.
comp_signif = (np.tanh(Y[1::2, ...])- np.tanh(Y[::2, ...])).mean(axis=0) * \
(q < 0.05) * (np.minimum(q_baseline, q_followup) < 0.05 )
print "{} vs. {}: t_stat = {}, q-val = {}".format(
condition1, condition2, t_stat, q)
dict_list.append(
dict(zip(*[entries,
("{}".format(condition1),
baseline_signif,
"{}".format(condition2),
followup_signif,
"{} vs. {}".format(condition1, condition2),
t_stat, q, comp_signif)])))
return DataFrame(dict_list, columns=entries)
def test_vec_to_sym():
"""Testing vec_to_sym function"""
# Check error if unsuitable size
vec = np.random.rand(31)
with assert_raises(ValueError) as ve:
my_con.vec_to_sym(vec)
assert_equal(len(ve), 1)
# Test for random suitable size
n = random.randint(1, 50)
p = n * (n + 1) / 2
vec = np.random.rand(p)
sym = my_con.vec_to_sym(vec)
assert_array_almost_equal(my_con.sym_to_vec(sym), vec)
vec = np.ones(6, )
sym = my_con.vec_to_sym(vec)
sym_expected = np.array([[np.sqrt(2), 1., 1.], [1., np.sqrt(2), 1.],
[1., 1., np.sqrt(2)]]) / np.sqrt(2)
sym_bool = my_con.vec_to_sym(vec > 0, isometry=False)
bool_expected = np.ones((3, 3), dtype=bool)
assert_array_almost_equal(sym, sym_expected)
assert_array_equal(sym_bool, bool_expected)
def test_transform(): # TODO : class test for class CovEmbedding
"""Testing fit_transform method for class CovEmbedding"""
n_subjects = random.randint(3, 50)
shape = random.randint(1, 10)
n_samples = 300
covs = []
signals = []
for k in xrange(n_subjects):
signal = np.random.randn(n_samples, shape)
signals.append(signal)
signal -= signal.mean(axis=0)
covs.append((signal.T).dot(signal) / n_samples)
for kind in ["correlation", "precision", "partial correlation", "tangent"]:
estimators = {'kind': kind, 'cov_estimator': None}
cov_embedding = my_con.CovEmbedding(**estimators)
covs_transformed = cov_embedding.fit_transform(signals)
# Generic
assert_is_instance(covs_transformed, np.ndarray)
assert_equal(len(covs_transformed), len(covs))
for k, vec in enumerate(covs_transformed):
assert_equal(vec.size, shape * (shape + 1) / 2)
cov_new = my_con.vec_to_sym(vec)
assert_true(my_mfd.is_spd(covs[k]))
if estimators["kind"] == "tangent":
assert_array_almost_equal(cov_new, cov_new.T)
fre_sqrt = my_mfd.sqrtm(cov_embedding.mean_cov_)
assert_true(my_mfd.is_spd(fre_sqrt))
assert_true(my_mfd.is_spd(cov_embedding.whitening_))
assert_array_almost_equal(
cov_embedding.whitening_.dot(fre_sqrt), np.eye(shape))
assert_array_almost_equal(
fre_sqrt.dot(my_mfd.expm(cov_new)).dot(fre_sqrt), covs[k])
if estimators["kind"] == "precision":
assert_true(my_mfd.is_spd(cov_new))
assert_array_almost_equal(cov_new.dot(covs[k]), np.eye(shape))
if estimators["kind"] == "correlation":
assert_true(my_mfd.is_spd(cov_new))
d = np.sqrt(np.diag(np.diag(covs[k])))
assert_array_almost_equal(d.dot(cov_new).dot(d), covs[k])
if estimators["kind"] == "partial correlation":
assert_true(my_mfd.is_spd(cov_new))
prec = linalg.inv(covs[k])
d = np.sqrt(np.diag(np.diag(prec)))
assert_array_almost_equal(
d.dot(cov_new).dot(d), -prec + 2 * np.diag(np.diag(prec)))
