def _draw_subject_specific_and_estimate(cov_u, dim, vnum,
                                        outliers_num, b, show_corrs=False,
                                        repeat_one=0, label=None):
        covars = []
        noise_covars = []
        for i in range(0, vnum-outliers_num):
            # ---construct covariance of subject#
            LambdaMatrix = _draw_eigenvalues(dim=args.dim, b=args.b, distribution="unif", overlap=args.overlap_eigenvalues)
            rotMatrix = _draw_rotation_matrix(args.dim)
            noise_cov = rotMatrix.dot(LambdaMatrix.dot(rotMatrix.transpose()))
            cov = np.add(cov_u, noise_cov)
            noise_covars.append(noise_cov)
            covars.append(cov)

        for i in range(repeat_one):
                covars.append(cov)
        # --------------------------------------#
        print("snr is :" + str(snr(np.asarray(noise_covars), cov_u)))
        if(show_corrs):
                factor =0.03 + (not args.overlap_eigenvalues)*dim*0.03
                f, axarr = plt.subplots(3, 3, figsize=(11, 5))
                idxs = np.random.choice(range(len(covars)), size=(3, 3))
                for i in range(idxs.shape[0]):
                        for j in range(idxs.shape[1]):
                                im = axarr[i, j].pcolormesh(np.flipud((connectivity_matrices.cov_to_corr(covars[idxs[i, j]])).T),
                                                            cmap=plt.cm.gist_earth_r,
                                                            edgecolors='k', vmin=-factor*b, vmax=factor*b, **{'linewidth': 0.1})
                                axarr[i, j].set_axis_off()
                                axarr[i, j].set_aspect('equal', 'box')
                                if(j == 2):
                                        divider = make_axes_locatable(axarr[i, j])
                                        cax = divider.append_axes("right", size="5%", pad=0.05)
                                        cb = f.colorbar(im, cax=cax)
                                        tick_locations = (-factor*b, 0, factor*b)
                                        tick_labels = ('{:{width}.{prec}f}'.format(-factor*b, width=1, prec=1),
                                                       '{:{width}.{prec}f}'.format(0, width=1, prec=1),
                                                       '{:{width}.{prec}f}'.format(factor*b, width=1, prec=1))
                                        cb.locator = ticker.FixedLocator(tick_locations)
                                        cb.formatter = ticker.FixedFormatter(tick_labels)
                                        cb.update_ticks()
                if label is None:
                        plt.savefig('./subjects_covars.eps', format='eps', dpi=1000)
                else:
                        plt.savefig('./subjects_covars_' + str(label) + '.eps', format='eps', dpi=1000)
        # construct outliers
        w, v = LA.eig(cov_u)
        for i in range(0, outliers_num):
                LambdaMatrix = _draw_eigenvalues(dim=args.dim, b=args.b, distribution="unif", overlap=args.overlap_eigenvalues)
                rotMatrix = _draw_rotation_matrix(dim=3)
                cov = rotMatrix.dot(LambdaMatrix.dot(rotMatrix.transpose()))
                covars.append(cov)
        our_est = est_common_cov(covars, outliers=args.outliers)
        eucl_mean = mean_euclid(np.array(covars))
        riemann_mean = mean_covariance(np.array(covars), metric='riemann', sample_weight=None)
        return our_est, eucl_mean, riemann_mean
Exemplo n.º 2
0
def test_distance_wrapper_random(met, gfunc, get_covmats):
    n_trials, n_channels = 2, 5
    covmats = get_covmats(n_trials, n_channels)
    A, B = covmats[0], covmats[1]
    if gfunc is geodesic_euclid:
        Ctrue = mean_euclid(covmats)
    elif gfunc is geodesic_logeuclid:
        Ctrue = mean_logeuclid(covmats)
    elif gfunc is geodesic_riemann:
        Ctrue = mean_riemann(covmats)
    assert geodesic(A, B, 0.5, metric=met) == approx(Ctrue)
Exemplo n.º 3
0
 def test_random_mat(self, geodesic_func, get_covmats):
     n_trials, n_channels = 2, 5
     covmats = get_covmats(n_trials, n_channels)
     A, B = covmats[0], covmats[1]
     if geodesic_func is geodesic_euclid:
         Ctrue = mean_euclid(covmats)
     elif geodesic_func is geodesic_logeuclid:
         Ctrue = mean_logeuclid(covmats)
     elif geodesic_func is geodesic_riemann:
         Ctrue = mean_riemann(covmats)
     self.geodesic_0(geodesic_func, A, B)
     self.geodesic_1(geodesic_func, A, B)
     self.geodesic_middle(geodesic_func, A, B, Ctrue)
Exemplo n.º 4
0
def test_power_mean(get_covmats):
    """Test the power mean"""
    n_matrices, n_channels = 3, 3
    covmats = get_covmats(n_matrices, n_channels)
    C_power_1 = mean_power(covmats, 1)
    C_power_0 = mean_power(covmats, 0)
    C_power_m1 = mean_power(covmats, -1)
    C_arithm = mean_euclid(covmats)
    C_geom = mean_riemann(covmats)
    C_harm = mean_harmonic(covmats)
    assert C_power_1 == approx(C_arithm)
    assert C_power_0 == approx(C_geom)
    assert C_power_m1 == approx(C_harm)
def test_euclid_mean():
    """Test the euclidean mean"""
    covmats, diags, A = generate_cov(100, 3)
    C = mean_euclid(covmats)
    assert_array_almost_equal(C, covmats.mean(axis=0))
def test_mean_covariance_euclid():
    """Test mean_covariance for euclidean metric"""
    covmats, diags, A = generate_cov(100, 3)
    C = mean_covariance(covmats, metric='euclid')
    Ctrue = mean_euclid(covmats)
    assert_array_equal(C, Ctrue)
def test_mean_covariance_euclid():
    """Test mean_covariance for euclidean metric"""
    covmats = generate_cov(100, 3)
    C = mean_covariance(covmats, metric='euclid')
    Ctrue = mean_euclid(covmats)
    assert_array_equal(C, Ctrue)
def test_euclid_mean():
    """Test the euclidean mean"""
    covmats = generate_cov(100, 3)
    C = mean_euclid(covmats)
    assert_array_almost_equal(C, covmats.mean(axis=0))
Exemplo n.º 9
0
def test_euclid_mean(get_covmats):
    """Test the euclidean mean"""
    n_matrices, n_channels = 100, 3
    covmats = get_covmats(n_matrices, n_channels)
    C = mean_euclid(covmats)
    assert C == approx(covmats.mean(axis=0))
Exemplo n.º 10
0
C = np.dot(Q, np.dot(D, Q.T))

theta = np.pi / 2.0
R = np.array([[cos(theta), -sin(theta)], [sin(theta), cos(theta)]])
Coutlier = np.dot(R, np.dot(C, R.T))

covs = [C, Coutlier]
for _ in range(5):
    theta = 1 * np.pi / 20 * np.random.randn()
    R = np.array([[cos(theta), -sin(theta)], [sin(theta), cos(theta)]])
    Cr = np.dot(R, np.dot(C, R.T))
    covs.append(Cr)

for cov in covs:
    e = gen_ellipse(cov)
    ax.add_artist(e)

covs = np.stack(covs)
Crmn = mean_riemann(covs)
Ceuc = mean_euclid(covs)

e = gen_ellipse(Crmn, ec='blue', lw=2.0)
ax.add_artist(e)
e = gen_ellipse(Ceuc, ec='red', lw=2.0)
ax.add_artist(e)

ax.set_xlim(-1.2, +1.2)
ax.set_ylim(-1.2, +1.2)

plt.show()