def test_scaling_SGL():
Sigma, Theta = group_power_network(p, K = 1, M = 2)
S, samples = sample_covariance_matrix(Sigma, N); S = S[0,:,:]
S2 = 10*S
reg_params = {'lambda1': 0.01}
reg_params2 = {'lambda1': 0.1}
P = glasso_problem(S = S2, N = N, reg = None, latent = False, do_scaling = True)
P.set_reg_params(reg_params)
P.solve(tol = 1e-10, rtol = 1e-15)
solver_params = {'rho': 10}
P2 = glasso_problem(S = S2, N = N, reg = None, latent = False, do_scaling = False)
P2.set_reg_params(reg_params2)
P2.solve(tol = 1e-10, rtol = 1e-15, solver_params = solver_params)
Theta = P.solution.precision_
Theta2 = P2.solution.precision_
assert np.linalg.norm(Theta - Theta2)/np.linalg.norm(Theta) <= 0.02
return
def test_GGL_ext_latent():
Sigma, Theta = group_power_network(p, K, M)
S, samples = sample_covariance_matrix(Sigma, N)
Sdict = dict()
for k in np.arange(K):
Sdict[k] = S[k,:,:].copy()
G = construct_trivial_G(p, K)
template_problem_MGL(S, N, reg = 'GGL', latent = True, G = G)
return
def template_admm_vs_ppdna(p=50, K=3, N=1000, reg="GGL"):
M = 5 # M should be divisor of p
if reg == 'GGL':
Sigma, Theta = group_power_network(p, K, M)
elif reg == 'FGL':
Sigma, Theta = time_varying_power_network(p, K, M)
S, samples = sample_covariance_matrix(Sigma, N)
lambda1 = 0.05
lambda2 = 0.01
Omega_0 = get_K_identity(K, p)
sol, info = ADMM_MGL(S,
lambda1,
lambda2,
reg,
Omega_0,
stopping_criterion='kkt',
tol=1e-6,
rtol=1e-5,
verbose=True,
latent=False)
sol2, info2 = warmPPDNA(S,
lambda1,
lambda2,
reg,
Omega_0,
eps=1e-6,
verbose=False,
measure=True)
sol3, info3 = PPDNA(S,
lambda1,
lambda2,
reg,
Omega_0,
eps_ppdna=1e-6,
verbose=True,
measure=True)
assert_array_almost_equal(sol['Theta'], sol2['Theta'], 2)
assert_array_almost_equal(sol2['Theta'], sol3['Theta'], 2)
return
def template_ADMM_MGL(p=100, K=5, N=1000, reg='GGL', latent=False):
"""
template for test for ADMM MGL solver with conforming variables
"""
M = 10 # M should be divisor of p
if reg == 'GGL':
Sigma, Theta = group_power_network(p, K, M)
elif reg == 'FGL':
Sigma, Theta = time_varying_power_network(p, K, M)
S, samples = sample_covariance_matrix(Sigma, N)
lambda1 = 0.05
lambda2 = 0.01
Omega_0 = get_K_identity(K, p)
sol, info = ADMM_MGL(S,
lambda1,
lambda2,
reg,
Omega_0,
tol=1e-5,
rtol=1e-5,
verbose=True,
measure=True,
latent=latent,
mu1=0.01)
assert info['status'] == 'optimal'
_, info2 = ADMM_MGL(S,
lambda1,
lambda2,
reg,
Omega_0,
tol=1e-20,
rtol=1e-20,
max_iter=2,
latent=latent,
mu1=0.01)
assert info2['status'] == 'max iterations reached'
return
def test_GGL_latent():
Sigma, Theta = group_power_network(p, K, M)
S, samples = sample_covariance_matrix(Sigma, N)
template_problem_MGL(S, N, reg = 'GGL', latent = True)
return
def test_SGL_latent():
Sigma, Theta = group_power_network(p, K = 1, M = 2)
S, samples = sample_covariance_matrix(Sigma, N); S = S[0,:,:]
template_problem_SGL(S, N, latent = True)
return
from gglasso.solver.ppdna_solver import PPDNA, warmPPDNA from gglasso.helper.data_generation import group_power_network, sample_covariance_matrix from gglasso.helper.experiment_helper import get_K_identity, lambda_parametrizer, lambda_grid, discovery_rate, error, hamming_distance, mean_sparsity from gglasso.helper.experiment_helper import draw_group_heatmap, plot_fpr_tpr, plot_diff_fpr_tpr, plot_error_accuracy, surface_plot, plot_gamma_influence from gglasso.helper.model_selection import aic, ebic p = 100 K = 5 N = 5000 N_train = 5000 M = 10 reg = 'GGL' save = False Sigma, Theta = group_power_network(p, K, M) draw_group_heatmap(Theta, save=save) S, sample = sample_covariance_matrix(Sigma, N) S_train, sample_train = sample_covariance_matrix(Sigma, N_train) Sinv = np.linalg.pinv(S, hermitian=True) #%% # grid search for best lambda values with warm starts L1, L2, W2 = lambda_grid(num1=3, num2=9, reg=reg) grid1 = L1.shape[0] grid2 = L2.shape[1] ERR = np.zeros((grid1, grid2)) FPR = np.zeros((grid1, grid2))
def template_extADMM_consistent(latent=False):
"""
tests whether the extended ADMM solver results in the same as MGL-solver for the redundant case of conforming variables
"""
p = 50
N = 1000
K = 5
M = 10
lambda1 = 0.05
lambda2 = 0.01
Sigma, Theta = group_power_network(p, K, M)
S, samples = sample_covariance_matrix(Sigma, N)
Sdict = dict()
Omega_0 = dict()
for k in np.arange(K):
Sdict[k] = S[k, :, :].copy()
Omega_0[k] = np.eye(p)
# constructs the "trivial" groups, i.e. all variables present in all instances
G = construct_trivial_G(p, K)
solext, _ = ext_ADMM_MGL(Sdict,
lambda1,
lambda2 / np.sqrt(K),
'GGL',
Omega_0,
G,
tol=1e-9,
rtol=1e-9,
verbose=True,
latent=latent,
mu1=0.01)
solext2, _ = ext_ADMM_MGL(Sdict,
lambda1,
lambda2 / np.sqrt(K),
'GGL',
Omega_0,
G,
stopping_criterion='kkt',
tol=1e-8,
verbose=True,
latent=latent,
mu1=0.01)
Omega_0_arr = get_K_identity(K, p)
solADMM, info = ADMM_MGL(S,
lambda1,
lambda2,
'GGL',
Omega_0_arr,
tol=1e-9,
rtol=1e-9,
verbose=False,
latent=latent,
mu1=0.01)
for k in np.arange(K):
assert_array_almost_equal(solext['Theta'][k],
solADMM['Theta'][k, :, :], 2)
assert_array_almost_equal(solext2['Theta'][k],
solADMM['Theta'][k, :, :], 2)
if latent:
for k in np.arange(K):
assert_array_almost_equal(solext['L'][k], solADMM['L'][k, :, :], 2)
assert_array_almost_equal(solext2['L'][k], solADMM['L'][k, :, :],
2)
return
from gglasso.solver.admm_solver import ADMM_MGL from gglasso.helper.data_generation import group_power_network, sample_covariance_matrix from gglasso.helper.experiment_helper import lambda_grid, discovery_rate, error from gglasso.helper.utils import get_K_identity from gglasso.helper.experiment_helper import draw_group_heatmap, plot_fpr_tpr, plot_diff_fpr_tpr, surface_plot from gglasso.helper.model_selection import aic, ebic p = 100 K = 5 N = 80 M = 10 reg = 'GGL' Sigma, Theta = group_power_network(p, K, M, scale = False, nxseed = 2340) S, sample = sample_covariance_matrix(Sigma, N) # %% # Parameter selection (GGL) # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # We do a grid search over :math:`\lambda_1` and :math:`\lambda_2` values. # On each grid point we evaluate True/False Discovery Rate (TPR/FPR), True/False Discovery of Differential edges and AIC and eBIC. # # Note: the package contains functions for doing this grid search, but here we also want to evaluate True and False positive rates on each grid points. # # L1, L2, W2 = lambda_grid(num1 = 3, num2 = 10, reg = reg) grid1 = L1.shape[0]; grid2 = L2.shape[1]
from gglasso.helper.experiment_helper import lambda_parametrizer, lambda_grid, discovery_rate, error from gglasso.helper.utils import get_K_identity, hamming_distance from gglasso.helper.experiment_helper import draw_group_heatmap, plot_fpr_tpr, plot_diff_fpr_tpr, plot_error_accuracy, surface_plot, plot_gamma_influence from gglasso.helper.model_selection import aic, ebic p = 100 K = 5 N = 5000 N_train = 5000 M = 10 reg = 'GGL' # whether to save the plots as pdf-files save = False Sigma, Theta = group_power_network(p, K, M, nxseed=2340) draw_group_heatmap(Theta, save=save) S, sample = sample_covariance_matrix(Sigma, N) S_train, sample_train = sample_covariance_matrix(Sigma, N_train) Sinv = np.linalg.pinv(S, hermitian=True) #%% grid search for best lambda values with warm starts L1, L2, W2 = lambda_grid(num1=3, num2=9, reg=reg) grid1 = L1.shape[0] grid2 = L2.shape[1] ERR = np.zeros((grid1, grid2)) FPR = np.zeros((grid1, grid2))
lambda2 = 0.05
allK = [2, 5, 10, 15, 25]
allS = list()
J = len(allK)
rt_ggl = np.zeros(J)
rt_fgl = np.zeros(J)
rt_sgl = np.zeros(J)
for j in range(J):
Sigma, Theta = group_power_network(p,
K=allK[j],
M=5,
scale=False,
nxseed=1235)
S, sample = sample_covariance_matrix(Sigma, N)
print("Shape of empirical covariance matrix: ", S.shape)
print("Shape of the sample array: ", sample.shape)
allS.append(S)
#%% initialize solvers (for numba jitting)
_, _ = ADMM_MGL(allS[0],
lambda1,
lambda2,
"GGL",
allS[0],
"""
# sphinx_gallery_thumbnail_number = 2
from gglasso.helper.data_generation import generate_precision_matrix, group_power_network, sample_covariance_matrix
from gglasso.problem import glasso_problem
from gglasso.helper.basic_linalg import adjacency_matrix
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
p = 20
N = 5000
Sigma, Theta = group_power_network(p, K = 1, M = 1, nxseed = 1235)
Sigma, Theta = generate_precision_matrix(p=p, M=1, style = 'powerlaw', gamma = 2.8, nxseed = 12345)
S, sample = sample_covariance_matrix(Sigma, N)
print("Shape of empirical covariance matrix: ", S.shape)
print("Shape of the sample array: ", sample.shape)
#%%
# Draw the graph of the true precision matrix.
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
A = adjacency_matrix(Theta)
np.fill_diagonal(A,1)
