def quic_graph_lasso_ebic(X, gamma=0):
'''Run QuicGraphLassoEBIC with gamma.
QuicGraphLassoEBIC is a convenience class. Results should be identical to
those obtained via quic_graph_lasso_ebic_manual.
'''
print 'QuicGraphLassoEBIC with:'
print ' mode: path'
print ' gamma: {}'.format(gamma)
model = QuicGraphLassoEBIC(lam=1.0, init_method='cov', gamma=gamma)
model.fit(X)
print ' len(path lams): {}'.format(len(model.path_))
print ' lam_scale_: {}'.format(model.lam_scale_)
print ' lam_: {}'.format(model.lam_)
return model.covariance_, model.precision_, model.lam_
def adaptive_graph_lasso(X, model_selector, method):
'''Run QuicGraphLassoCV or QuicGraphLassoEBIC as a two step adaptive fit
with method of choice (currently: 'binary', 'inverse', 'inverse_squared').
Compare the support and values to the model-selection estimator.
'''
metric = 'log_likelihood'
print 'Adaptive {} with:'.format(model_selector)
print ' adaptive-method: {}'.format(method)
if model_selector == 'QuicGraphLassoCV':
print ' metric: {}'.format(metric)
model = AdaptiveGraphLasso(
estimator=QuicGraphLassoCV(
cv=2, # cant deal w more folds at small size
n_refinements=6,
init_method='cov',
score_metric=metric),
method=method,
)
elif model_selector == 'QuicGraphLassoEBIC':
model = AdaptiveGraphLasso(
estimator=QuicGraphLassoEBIC(),
method=method,
)
model.fit(X)
lam_norm_ = np.linalg.norm(model.estimator_.lam_)
print ' ||lam_||_2: {}'.format(lam_norm_)
return model.estimator_.covariance_, model.estimator_.precision_, lam_norm_
class TestStatisticalPower(object):
@pytest.mark.parametrize("params_in", [
({
'model_selection_estimator': QuicGraphLassoCV(),
'n_trials': 20,
'n_features': 25,
}),
({
'model_selection_estimator': QuicGraphLassoEBIC(),
'n_trials': 20,
'n_features': 10,
'n_jobs': 2,
}),
({
'model_selection_estimator': GraphLassoCV(),
'n_trials': 20,
'n_features': 20,
'penalty_': 'alpha_',
}),
])
def test_integration_statistical_power(self, params_in):
'''
Just tests inputs/outputs (not validity of result).
'''
X = datasets.load_diabetes().data
sp = StatisticalPower(**params_in)
sp.fit(X)
num_k = 5
assert np.sum(sp.results_.flat) > 0
assert sp.results_.shape == (num_k, sp.n_grid_points)
assert len(sp.ks_) == num_k
assert len(sp.grid_) == sp.n_grid_points
def test_integration_quic_graph_lasso_ebic(self, params_in, expected):
'''
Just tests inputs/outputs (not validity of result).
'''
X = datasets.load_diabetes().data
ic = QuicGraphLassoEBIC(**params_in)
ic.fit(X)
result_vec = [
np.linalg.norm(ic.covariance_),
np.linalg.norm(ic.precision_),
]
if isinstance(ic.lam_, float):
result_vec.append(ic.lam_)
elif isinstance(ic.lam_, np.ndarray):
assert ic.lam_.shape == params_in['lam'].shape
print result_vec
assert_allclose(expected, result_vec, rtol=1e-1)
class TestAverageError(object):
@pytest.mark.parametrize("params_in", [
({
'model_selection_estimator': QuicGraphLassoCV(),
'n_trials': 20,
'n_features': 25,
}),
({
'model_selection_estimator': QuicGraphLassoEBIC(),
'n_trials': 20,
'n_features': 10,
'n_jobs': 2,
}),
({
'model_selection_estimator': GraphLassoCV(),
'n_trials': 20,
'n_features': 20,
'penalty_': 'alpha_',
}),
])
def test_integration_statistical_power(self, params_in):
'''
Just tests inputs/outputs (not validity of result).
'''
X = datasets.load_diabetes().data
ae = AverageError(**params_in)
ae.fit(X)
num_k = 3
assert np.sum(ae.error_fro_.flat) > 0
assert ae.error_fro_.shape == (num_k, ae.n_grid_points)
assert np.sum(ae.error_supp_.flat) > 0
assert ae.error_supp_.shape == (num_k, ae.n_grid_points)
assert np.sum(ae.error_fp_.flat) > 0
assert ae.error_fp_.shape == (num_k, ae.n_grid_points)
assert np.sum(ae.error_fn_.flat) > 0
assert ae.error_fn_.shape == (num_k, ae.n_grid_points)
assert len(ae.ks_) == num_k
assert len(ae.grid_) == ae.n_grid_points
def get_conn_matrix(time_series, conn_model):
import warnings
warnings.simplefilter("ignore")
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import GraphLassoCV
try:
from brainiak.fcma.util import compute_correlation
except ImportError:
pass
if conn_model == 'corr':
# credit: nilearn
print('\nComputing correlation matrix...\n')
conn_measure = ConnectivityMeasure(kind='correlation')
conn_matrix = conn_measure.fit_transform([time_series])[0]
elif conn_model == 'corr_fast':
# credit: brainiak
try:
print('\nComputing accelerated fcma correlation matrix...\n')
conn_matrix = compute_correlation(time_series, time_series)
except RuntimeError:
print(
'Cannot run accelerated correlation computation due to a missing dependency. You need brainiak installed!'
)
elif conn_model == 'partcorr':
# credit: nilearn
print('\nComputing partial correlation matrix...\n')
conn_measure = ConnectivityMeasure(kind='partial correlation')
conn_matrix = conn_measure.fit_transform([time_series])[0]
elif conn_model == 'tangent':
# credit: nilearn
print('\nComputing tangent matrix...\n')
conn_measure = ConnectivityMeasure(kind='tangent')
conn_matrix = conn_measure.fit_transform([time_series])[0]
elif conn_model == 'cov' or conn_model == 'sps':
##Fit estimator to matrix to get sparse matrix
estimator = GraphLassoCV()
try:
print('\nComputing covariance...\n')
estimator.fit(time_series)
except:
try:
print(
'Unstable Lasso estimation--Attempting to re-run by first applying shrinkage...'
)
from sklearn.covariance import GraphLasso, empirical_covariance, shrunk_covariance
emp_cov = empirical_covariance(time_series)
for i in np.arange(0.8, 0.99, 0.01):
shrunk_cov = shrunk_covariance(emp_cov, shrinkage=i)
alphaRange = 10.0**np.arange(-8, 0)
for alpha in alphaRange:
try:
estimator_shrunk = GraphLasso(alpha)
estimator_shrunk.fit(shrunk_cov)
print(
"Calculated graph-lasso covariance matrix for alpha=%s"
% alpha)
break
except FloatingPointError:
print("Failed at alpha=%s" % alpha)
if estimator_shrunk == None:
pass
else:
break
except:
raise ValueError(
'Unstable Lasso estimation! Shrinkage failed.')
if conn_model == 'sps':
try:
print(
'\nFetching precision matrix from covariance estimator...\n'
)
conn_matrix = -estimator.precision_
except:
print(
'\nFetching shrunk precision matrix from covariance estimator...\n'
)
conn_matrix = -estimator_shrunk.precision_
elif conn_model == 'cov':
try:
print(
'\nFetching covariance matrix from covariance estimator...\n'
)
conn_matrix = estimator.covariance_
except:
conn_matrix = estimator_shrunk.covariance_
elif conn_model == 'QuicGraphLasso':
from inverse_covariance import QuicGraphLasso
# Compute the sparse inverse covariance via QuicGraphLasso
# credit: skggm
model = QuicGraphLasso(init_method='cov',
lam=0.5,
mode='default',
verbose=1)
print('\nCalculating QuicGraphLasso precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphLassoCV':
from inverse_covariance import QuicGraphLassoCV
# Compute the sparse inverse covariance via QuicGraphLassoCV
# credit: skggm
model = QuicGraphLassoCV(init_method='cov', verbose=1)
print(
'\nCalculating QuicGraphLassoCV precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphLassoEBIC':
from inverse_covariance import QuicGraphLassoEBIC
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
# credit: skggm
model = QuicGraphLassoEBIC(init_method='cov', verbose=1)
print(
'\nCalculating QuicGraphLassoEBIC precision matrix using skggm...\n'
)
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'AdaptiveQuicGraphLasso':
from inverse_covariance import AdaptiveGraphLasso, QuicGraphLassoEBIC
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
# credit: skggm
model = AdaptiveGraphLasso(
estimator=QuicGraphLassoEBIC(init_method='cov', ),
method='binary',
)
print(
'\nCalculating AdaptiveQuicGraphLasso precision matrix using skggm...\n'
)
model.fit(time_series)
conn_matrix = -model.estimator_.precision_
return (conn_matrix)
class TestAdaptiveGraphLasso(object):
@pytest.mark.parametrize("params_in", [
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'binary',
}),
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'inverse',
}),
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'inverse_squared',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'binary',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'inverse',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'inverse_squared',
}),
])
def test_integration_adaptive_graph_lasso(self, params_in):
'''
Just tests inputs/outputs (not validity of result).
'''
X = datasets.load_diabetes().data
n_examples, n_features = X.shape
model = AdaptiveGraphLasso(**params_in)
model.fit(X)
assert model.estimator_ is not None
assert model.lam_ is not None
assert np.sum(model.lam_[np.diag_indices(n_features)]) == 0
if params_in['method'] == 'binary':
uvals = set(model.lam_.flat)
assert len(uvals) == 2
assert 0 in uvals
assert 1 in uvals
elif params_in['method'] == 'inverse' or\
params_in['method'] == 'inverse_squared':
uvals = set(model.lam_.flat[model.lam_.flat != 0])
assert len(uvals) > 0
def get_conn_matrix(time_series, conn_model):
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import GraphLassoCV
conn_matrix = None
if conn_model == 'corr':
# credit: nilearn
print('\nComputing correlation matrix...\n')
conn_measure = ConnectivityMeasure(kind='correlation')
conn_matrix = conn_measure.fit_transform([time_series])[0]
elif conn_model == 'partcorr':
# credit: nilearn
print('\nComputing partial correlation matrix...\n')
conn_measure = ConnectivityMeasure(kind='partial correlation')
conn_matrix = conn_measure.fit_transform([time_series])[0]
elif conn_model == 'cov' or conn_model == 'sps':
# Fit estimator to matrix to get sparse matrix
estimator_shrunk = None
estimator = GraphLassoCV()
try:
print('\nComputing covariance...\n')
estimator.fit(time_series)
except RuntimeWarning:
print('Unstable Lasso estimation--Attempting to re-run by first applying shrinkage...')
try:
from sklearn.covariance import GraphLasso, empirical_covariance, shrunk_covariance
emp_cov = empirical_covariance(time_series)
for i in np.arange(0.8, 0.99, 0.01):
shrunk_cov = shrunk_covariance(emp_cov, shrinkage=i)
alphaRange = 10.0 ** np.arange(-8, 0)
for alpha in alphaRange:
try:
estimator_shrunk = GraphLasso(alpha)
estimator_shrunk.fit(shrunk_cov)
print("Retrying covariance matrix estimate with alpha=%s" % alpha)
if estimator_shrunk is None:
pass
else:
break
except RuntimeWarning:
print("Covariance estimation failed with shrinkage at alpha=%s" % alpha)
continue
except ValueError:
print('Unstable Lasso estimation! Shrinkage failed. A different connectivity model may be needed.')
if estimator is None and estimator_shrunk is None:
raise RuntimeError('ERROR: Covariance estimation failed.')
if conn_model == 'sps':
if estimator_shrunk is None:
print('\nFetching precision matrix from covariance estimator...\n')
conn_matrix = -estimator.precision_
else:
print('\nFetching shrunk precision matrix from covariance estimator...\n')
conn_matrix = -estimator_shrunk.precision_
elif conn_model == 'cov':
if estimator_shrunk is None:
print('\nFetching covariance matrix from covariance estimator...\n')
conn_matrix = estimator.covariance_
else:
conn_matrix = estimator_shrunk.covariance_
elif conn_model == 'QuicGraphLasso':
from inverse_covariance import QuicGraphLasso
# Compute the sparse inverse covariance via QuicGraphLasso
# credit: skggm
model = QuicGraphLasso(
init_method='cov',
lam=0.5,
mode='default',
verbose=1)
print('\nCalculating QuicGraphLasso precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphLassoCV':
from inverse_covariance import QuicGraphLassoCV
# Compute the sparse inverse covariance via QuicGraphLassoCV
# credit: skggm
model = QuicGraphLassoCV(
init_method='cov',
verbose=1)
print('\nCalculating QuicGraphLassoCV precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphLassoEBIC':
from inverse_covariance import QuicGraphLassoEBIC
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
# credit: skggm
model = QuicGraphLassoEBIC(
init_method='cov',
verbose=1)
print('\nCalculating QuicGraphLassoEBIC precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'AdaptiveQuicGraphLasso':
from inverse_covariance import AdaptiveGraphLasso, QuicGraphLassoEBIC
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
# credit: skggm
model = AdaptiveGraphLasso(
estimator=QuicGraphLassoEBIC(
init_method='cov',
),
method='binary',
)
print('\nCalculating AdaptiveQuicGraphLasso precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.estimator_.precision_
return conn_matrix
class TestAdaptiveGraphLasso(object):
@pytest.mark.parametrize("params_in", [
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'binary',
}),
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'inverse',
}),
({
'estimator':
QuicGraphLassoCV(
cv=2,
n_refinements=6,
init_method='cov',
score_metric='log_likelihood',
),
'method':
'inverse_squared',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'binary',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'inverse',
}),
({
'estimator': QuicGraphLassoEBIC(),
'method': 'inverse_squared',
}),
])
def test_integration_adaptive_graph_lasso(self, params_in):
'''
Just tests inputs/outputs (not validity of result).
'''
n_features = 20
n_samples = 25
cov, prec, adj = ClusterGraph(
n_blocks=1,
chain_blocks=False,
seed=1,
).create(n_features, 0.8)
prng = np.random.RandomState(2)
X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples)
model = AdaptiveGraphLasso(**params_in)
model.fit(X)
assert model.estimator_ is not None
assert model.lam_ is not None
assert np.sum(model.lam_[np.diag_indices(n_features)]) == 0
if params_in['method'] == 'binary':
uvals = set(model.lam_.flat)
assert len(uvals) == 2
assert 0 in uvals
assert 1 in uvals
elif params_in['method'] == 'inverse' or\
params_in['method'] == 'inverse_squared':
uvals = set(model.lam_.flat[model.lam_.flat != 0])
assert len(uvals) > 0
plot(g) #, layout = "fr3d")
#%% save array to txt
np.savetxt("firstLASSO.csv", np.array(np.average(lassoTime1, axis=0)), delimiter = ",")
np.savetxt("correlationMatrixFirstRun.csv", np.array(np.average(ket1_corr, axis=0)), delimiter = ",")
#%%
# run analysis on all subjects
# build timeseries for first scan (before)
totalSub_series_1 = timeSeries(func_files=fileList(totalSub,'1'), confound_files=confList(totalSub, '1'))
totalSub_series_2 = timeSeries(func_files=fileList(totalSub,'2'), confound_files=confList(totalSub, '2'))
# In[skggm]:
# run EBIC LASSO on each subject
from inverse_covariance import QuicGraphLassoEBIC
# call estimator EBIC
estimator = QuicGraphLassoEBIC(init_method="cov", verbose=1)
# create emtpy array
ebicMat = []
ebicMat2 = []
# run loop over timeseries and create precision matrix for each subject, append to a list of matrices
for i in totalSub_series_1:
estimator.fit(i)
ebicMat.append(-estimator.precision_)
for i in totalSub_series_2:
estimator.fit(i)
ebicMat2.append(-estimator.precision_)
ket1_forLASSO.shape
#%%
if estimator_type == 'QuicGraphLasso':
# Compute the sparse inverse covariance via QuicGraphLasso
estimator = QuicGraphLasso(init_method='cov',
lam=0.5,
mode='default',
verbose=1)
elif estimator_type == 'QuicGraphLassoCV':
# Compute the sparse inverse covariance via QuicGraphLassoCV
estimator = QuicGraphLassoCV(init_method='cov', verbose=1)
estimator.fit(timeseries)
elif estimator_type == 'QuicGraphLassoEBIC':
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
estimator = QuicGraphLassoEBIC(init_method='cov', verbose=1)
estimator.fit(timeseries)
elif estimator_type == 'AdaptiveQuicGraphLasso':
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
model = AdaptiveGraphLasso(
estimator=QuicGraphLassoEBIC(init_method='cov', ),
method='binary',
)
model.fit(timeseries)
estimator = model.estimator_
# Display the sparse inverse covariance
plt.figure(figsize=(7.5, 7.5))
plt.imshow(np.triu(-estimator.precision_, 1),
import sys
sys.path.append('..')
from inverse_covariance import (QuicGraphLassoCV, QuicGraphLassoEBIC,
ModelAverage)
from inverse_covariance.profiling import AverageError
from matplotlib import pyplot as plt
n_features = 50
n_trials = 100
verbose = True
# average plots for QuicGraphLassoEBIC
ae = AverageError(
model_selection_estimator=QuicGraphLassoEBIC(gamma=0.0),
n_features=n_features,
n_trials=n_trials,
verbose=verbose,
)
ae.fit()
ae.show()
plt.suptitle('QuicGraphLassoEBIC (BIC)')
# average plots for QuicGraphLassoCV
ae = AverageError(
model_selection_estimator=QuicGraphLassoCV(),
n_features=n_features,
n_trials=n_trials,
verbose=verbose,
)
ae.fit()