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