def test_shrunk_covariance():
# Tests ShrunkCovariance module on a simple dataset.
# compare shrunk covariance obtained from data and from MLE estimate
cov = ShrunkCovariance(shrinkage=0.5)
cov.fit(X)
assert_array_almost_equal(
shrunk_covariance(empirical_covariance(X), shrinkage=0.5),
cov.covariance_, 4)
# same test with shrinkage not provided
cov = ShrunkCovariance()
cov.fit(X)
assert_array_almost_equal(shrunk_covariance(empirical_covariance(X)),
cov.covariance_, 4)
# same test with shrinkage = 0 (<==> empirical_covariance)
cov = ShrunkCovariance(shrinkage=0.)
cov.fit(X)
assert_array_almost_equal(empirical_covariance(X), cov.covariance_, 4)
# test with n_features = 1
X_1d = X[:, 0].reshape((-1, 1))
cov = ShrunkCovariance(shrinkage=0.3)
cov.fit(X_1d)
assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4)
# test shrinkage coeff on a simple data set (without saving precision)
cov = ShrunkCovariance(shrinkage=0.5, store_precision=False)
cov.fit(X)
assert (cov.precision_ is None)
def test_shrunk_covariance():
"""Tests ShrunkCovariance module on a simple dataset.
"""
# compare shrunk covariance obtained from data and from MLE estimate
cov = ShrunkCovariance(shrinkage=0.5)
cov.fit(X)
assert_array_almost_equal(
shrunk_covariance(empirical_covariance(X), shrinkage=0.5),
cov.covariance_, 4)
# same test with shrinkage not provided
cov = ShrunkCovariance()
cov.fit(X)
assert_array_almost_equal(
shrunk_covariance(empirical_covariance(X)), cov.covariance_, 4)
# same test with shrinkage = 0 (<==> empirical_covariance)
cov = ShrunkCovariance(shrinkage=0.)
cov.fit(X)
assert_array_almost_equal(empirical_covariance(X), cov.covariance_, 4)
# test with n_features = 1
X_1d = X[:, 0].reshape((-1, 1))
cov = ShrunkCovariance(shrinkage=0.3)
cov.fit(X_1d)
assert_array_almost_equal(empirical_covariance(X_1d), cov.covariance_, 4)
# test shrinkage coeff on a simple data set (without saving precision)
cov = ShrunkCovariance(shrinkage=0.5, store_precision=False)
cov.fit(X)
assert(cov.precision_ is None)
def _get_omega(self, returns):
"""
Get robust covariance matrix for use in Newton solver.
Parameters
----------
returns: numpy array of return data
Returns
----------
omega: array of shape nxn where n is equal to the number of
securities invovled
"""
corr_returns = returns[-self.corr_window:, :]
cov_returns = returns[-self.cov_window:, :]
if self.cov_est == 'oas':
omega = OAS().fit(corr_returns).covariance_ * 10**4
elif self.cov_est == 'empirical':
omega = EmpiricalCovariance().fit(corr_returns).covariance_ * 10**4
else:
corr = np.corrcoef(corr_returns, rowvar=False)
cov_diag = np.diag(np.sqrt(np.var(cov_returns, axis=0)))
omega = cov_diag @ corr @ cov_diag
if self.lw_shrink is None:
lw = ledoit_wolf(corr_returns)[1]
omega = shrunk_covariance(omega, shrinkage=lw) * 10**4
else:
omega = shrunk_covariance(omega,
shrinkage=self.lw_shrink) * 10**4
return omega
def _cov(X, shrinkage=None):
"""Estimate covariance matrix (using optional shrinkage).
Parameters
----------
X : array-like, shape (n_samples, n_features)
Input data.
shrinkage : string or float, optional
Shrinkage parameter, possible values:
- None or 'empirical': no shrinkage (default).
- 'auto': automatic shrinkage using the Ledoit-Wolf lemma.
- float between 0 and 1: fixed shrinkage parameter.
Returns
-------
s : array, shape (n_features, n_features)
Estimated covariance matrix.
"""
shrinkage = "empirical" if shrinkage is None else shrinkage
if isinstance(shrinkage, str):
if shrinkage == 'auto':
sc = StandardScaler() # standardize features
X = sc.fit_transform(X)
s = ledoit_wolf(X)[0]
# rescale
s = sc.scale_[:, np.newaxis] * s * sc.scale_[np.newaxis, :]
elif shrinkage == 'empirical':
s = empirical_covariance(X)
else:
raise ValueError('unknown shrinkage parameter')
elif isinstance(shrinkage, float) or isinstance(shrinkage, int):
if shrinkage < 0 or shrinkage > 1:
raise ValueError('shrinkage parameter must be between 0 and 1')
s = shrunk_covariance(empirical_covariance(X), shrinkage)
else:
raise TypeError('shrinkage must be of string or int type')
return s
def get_optimal_cov_estimator(time_series):
from sklearn.covariance import GraphicalLassoCV
estimator = GraphicalLassoCV(cv=5, assume_centered=True)
print("\nSearching for best Lasso estimator...\n")
try:
estimator.fit(time_series)
return estimator
except BaseException:
ix = 0
print("\nModel did not converge on first attempt. "
"Varying tolerance...\n")
while not hasattr(estimator, 'covariance_') and \
not hasattr(estimator, 'precision_') and ix < 3:
for tol in [0.1, 0.01, 0.001, 0.0001]:
print(f"Tolerance={tol}")
estimator = GraphicalLassoCV(cv=5,
max_iter=200,
tol=tol,
assume_centered=True)
try:
estimator.fit(time_series)
return estimator
except BaseException:
ix += 1
continue
if not hasattr(estimator, 'covariance_') and not hasattr(
estimator, 'precision_'):
print("Unstable Lasso estimation. Applying shrinkage to empirical "
"covariance...")
from sklearn.covariance import (
GraphicalLasso,
empirical_covariance,
shrunk_covariance,
)
try:
emp_cov = empirical_covariance(time_series, assume_centered=True)
for i in np.arange(0.8, 0.99, 0.01):
print(f"Shrinkage={i}:")
shrunk_cov = shrunk_covariance(emp_cov, shrinkage=i)
alphaRange = 10.0**np.arange(-8, 0)
for alpha in alphaRange:
print(f"Auto-tuning alpha={alpha}...")
estimator_shrunk = GraphicalLasso(alpha,
assume_centered=True)
try:
estimator_shrunk.fit(shrunk_cov)
return estimator_shrunk
except BaseException:
continue
except BaseException:
return None
else:
return estimator
def get_covariance(var_iter, shrinkage=0.1):
cov = []
for (samples, genos, quals, variant) in var_iter:
if genos is None: continue
if any(np.isnan(genos)): continue
if len(np.unique(genos)) == 1: continue
cov.append(genos)
cov = np.cov(np.array(cov, dtype='f').T)
cov[np.diag_indices_from(cov)] = 1
# shrunk
cov = covariance.shrunk_covariance(cov, shrinkage=shrinkage)
#cov, _ = covariance.ledoit_wolf(cov)
#cov, _ = covariance.oas(cov)
# robust:
try:
cov = covariance.MinCovDet().fit(cov).covariance_
except ValueError:
pass
return cov
def get_covariance(var_iter, shrinkage=0.1):
cov = []
for (samples, genos, quals, variant) in var_iter:
if genos is None: continue
if any(np.isnan(genos)): continue
if len(np.unique(genos)) == 1: continue
cov.append(genos)
cov = np.cov(np.array(cov, dtype='f').T)
cov[np.diag_indices_from(cov)] = 1
# shrunk
cov = covariance.shrunk_covariance(cov, shrinkage=shrinkage)
#cov, _ = covariance.ledoit_wolf(cov)
#cov, _ = covariance.oas(cov)
# robust:
try:
cov = covariance.MinCovDet().fit(cov).covariance_
except ValueError:
pass
return cov
def _cov(X, shrinkage=None):
shrinkage = "empirical" if shrinkage is None else shrinkage
if isinstance(shrinkage, string_types):
if shrinkage == 'auto':
sc = StandardScaler() # standardize features
X = sc.fit_transform(X)
s = ledoit_wolf(X)[0]
# rescale
s = sc.scale_[:, np.newaxis] * s * sc.scale_[np.newaxis, :]
elif shrinkage == 'empirical':
s = empirical_covariance(X)
else:
raise ValueError('unknown shrinkage parameter')
elif isinstance(shrinkage, float) or isinstance(shrinkage, int):
if shrinkage < 0 or shrinkage > 1:
raise ValueError('shrinkage parameter must be between 0 and 1')
s = shrunk_covariance(empirical_covariance(X), shrinkage)
else:
raise TypeError('shrinkage must be of string or int type')
return s
def transform(self, X):
"""Shrink and return the covariance matrices.
Parameters
----------
X : ndarray, shape (n_trials, n_channels, n_channels)
ndarray of covariances matrices
Returns
-------
covmats : ndarray, shape (n_trials, n_channels, n_channels)
ndarray of covariance matrices for each trials.
"""
covmats = numpy.zeros_like(X)
for ii, x in enumerate(X):
covmats[ii] = shrunk_covariance(x, self.shrinkage)
return covmats
def transform(self, X):
"""Shrink and return the SPD matrices.
Parameters
----------
X : ndarray, shape (n_matrices, n_channels, n_channels)
Set of SPD matrices.
Returns
-------
covmats : ndarray, shape (n_matrices, n_channels, n_channels)
Set of shrunk SPD matrices.
"""
covmats = np.zeros_like(X)
for ii, x in enumerate(X):
covmats[ii] = shrunk_covariance(x, self.shrinkage)
return covmats
def transform(self, X):
"""Shrink and return the covariance matrices.
Parameters
----------
X : ndarray, shape (n_trials, n_channels, n_channels)
ndarray of covariances matrices
Returns
-------
covmats : ndarray, shape (n_trials, n_channels, n_channels)
ndarray of covariance matrices for each trials.
"""
covmats = numpy.zeros_like(X)
for ii, x in enumerate(X):
covmats[ii] = shrunk_covariance(x, self.shrinkage)
return covmats
def cal_covariance(X, tORs, reg_param):
# calculate the spatial or temporal covariances for the trials in X
# X has the following format [num_trials, num_channels, time_samps]
if tORs == 'time':
n_Samps = np.size(X, axis=2)
elif tORs == 'space':
n_Samps = np.size(X, axis=1)
num_trials = np.size(X, axis=0)
W = np.zeros([num_trials, n_Samps, n_Samps])
for ik in range(num_trials):
if tORs == 'time':
temp = np.cov(X[ik].transpose()) / np.trace(
np.cov(X[ik].transpose()))
elif tORs == 'space':
temp = np.cov(X[ik]) / np.trace(np.cov(X[ik]))
W[ik, :, :] = shrunk_covariance(temp, reg_param)
return W
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
def get_conn_matrix(time_series, conn_model, dir_path, node_size, smooth,
dens_thresh, network, ID, mask, min_span_tree, disp_filt,
parc, prune, atlas_select, uatlas_select, label_names,
coords, vox_array):
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:
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:
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 == 'QuicGraphicalLasso':
try:
from inverse_covariance import QuicGraphicalLasso
except ImportError:
print('Cannot run QuicGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLasso
# credit: skggm
model = QuicGraphicalLasso(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':
try:
from inverse_covariance import QuicGraphicalLassoCV
except ImportError:
print('Cannot run QuicGraphLassoCV. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoCV
# credit: skggm
model = QuicGraphicalLassoCV(init_method='cov', verbose=1)
print(
'\nCalculating QuicGraphLassoCV precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphicalLassoEBIC':
try:
from inverse_covariance import QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run QuicGraphLassoEBIC. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
# credit: skggm
model = QuicGraphicalLassoEBIC(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':
try:
from inverse_covariance import AdaptiveQuicGraphicalLasso, QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run AdaptiveGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
# credit: skggm
model = AdaptiveQuicGraphicalLasso(
estimator=QuicGraphicalLassoEBIC(init_method='cov', ),
method='binary',
)
print(
'\nCalculating AdaptiveQuicGraphLasso precision matrix using skggm...\n'
)
model.fit(time_series)
conn_matrix = -model.estimator_.precision_
# Weight reuslting matrix by voxels in each label if using parcels as nodes
# if parc is True:
# norm_parcels = (vox_array - min(vox_array)) / (max(vox_array) - min(vox_array))
# conn_matrix_norm = normalize(conn_matrix)
# conn_matrix = norm_parcels * conn_matrix_norm
coords = np.array(coords)
label_names = np.array(label_names)
return conn_matrix, conn_model, dir_path, node_size, smooth, dens_thresh, network, ID, mask, min_span_tree, disp_filt, parc, prune, atlas_select, uatlas_select, label_names, coords
def get_conn_matrix(time_series, conn_model, dir_path, node_size, smooth,
dens_thresh, network, ID, roi, min_span_tree, disp_filt,
parc, prune, atlas_select, uatlas_select, label_names,
coords, c_boot, norm, binary):
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import GraphicalLassoCV
conn_matrix = None
if conn_model == 'corr' or conn_model == 'cor' or conn_model == 'correlation':
# 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' or conn_model == 'parcorr' or conn_model == 'partialcorrelation':
# 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 == 'covariance' or conn_model == 'covar' or conn_model == 'sps' or conn_model == 'sparse' or conn_model == 'precision':
# Fit estimator to matrix to get sparse matrix
estimator_shrunk = None
estimator = GraphicalLassoCV(cv=5)
try:
print('\nComputing covariance...\n')
estimator.fit(time_series)
except:
print(
'Unstable Lasso estimation--Attempting to re-run by first applying shrinkage...'
)
try:
from sklearn.covariance import GraphicalLasso, 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 = GraphicalLasso(alpha)
estimator_shrunk.fit(shrunk_cov)
print(
"Retrying covariance matrix estimate with alpha=%s"
% alpha)
if estimator_shrunk is None:
pass
else:
break
except:
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('\nERROR: Covariance estimation failed.')
if conn_model == 'sps' or conn_model == 'sparse' or conn_model == 'precision':
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' or conn_model == 'covariance' or conn_model == 'covar':
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 == 'QuicGraphicalLasso':
try:
from inverse_covariance import QuicGraphicalLasso
except ImportError:
print('Cannot run QuicGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLasso
# credit: skggm
model = QuicGraphicalLasso(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':
try:
from inverse_covariance import QuicGraphicalLassoCV
except ImportError:
print('Cannot run QuicGraphLassoCV. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoCV
# credit: skggm
model = QuicGraphicalLassoCV(init_method='cov', verbose=1)
print(
'\nCalculating QuicGraphLassoCV precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphicalLassoEBIC':
try:
from inverse_covariance import QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run QuicGraphLassoEBIC. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
# credit: skggm
model = QuicGraphicalLassoEBIC(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':
try:
from inverse_covariance import AdaptiveQuicGraphicalLasso, QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run AdaptiveGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
# credit: skggm
model = AdaptiveQuicGraphicalLasso(
estimator=QuicGraphicalLassoEBIC(init_method='cov', ),
method='binary',
)
print(
'\nCalculating AdaptiveQuicGraphLasso precision matrix using skggm...\n'
)
model.fit(time_series)
conn_matrix = -model.estimator_.precision_
else:
raise ValueError(
'\nERROR! No connectivity model specified at runtime. Select a valid estimator using the '
'-mod flag.')
if conn_matrix.shape < (2, 2):
raise RuntimeError(
'\nERROR! Matrix estimation selection yielded an empty or 1-dimensional graph. '
'Check time-series for errors or try using a different atlas')
coords = np.array(coords)
label_names = np.array(label_names)
return conn_matrix, conn_model, dir_path, node_size, smooth, dens_thresh, network, ID, roi, min_span_tree, disp_filt, parc, prune, atlas_select, uatlas_select, label_names, coords, c_boot, norm, binary
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)
def get_conn_matrix(time_series, conn_model, dir_path, node_size, smooth, dens_thresh, network, ID, roi, min_span_tree,
disp_filt, parc, prune, atlas, uatlas, labels, coords, norm, binary,
hpass, extract_strategy):
"""
Computes a functional connectivity matrix based on a node-extracted time-series array.
Includes a library of routines across Nilearn, scikit-learn, and skggm packages, among others.
Parameters
----------
time_series : array
2D m x n array consisting of the time-series signal for each ROI node where m = number of scans and
n = number of ROI's.
conn_model : str
Connectivity estimation model (e.g. corr for correlation, cov for covariance, sps for precision covariance,
partcorr for partial correlation). sps type is used by default.
dir_path : str
Path to directory containing subject derivative data for given run.
node_size : int
Spherical centroid node size in the case that coordinate-based centroids
are used as ROI's.
smooth : int
Smoothing width (mm fwhm) to apply to time-series when extracting signal from ROI's.
dens_thresh : bool
Indicates whether a target graph density is to be used as the basis for
thresholding.
network : str
Resting-state network based on Yeo-7 and Yeo-17 naming (e.g. 'Default') used to filter nodes in the study of
brain subgraphs.
ID : str
A subject id or other unique identifier.
roi : str
File path to binarized/boolean region-of-interest Nifti1Image file.
min_span_tree : bool
Indicates whether local thresholding from the Minimum Spanning Tree
should be used.
disp_filt : bool
Indicates whether local thresholding using a disparity filter and
'backbone network' should be used.
parc : bool
Indicates whether to use parcels instead of coordinates as ROI nodes.
prune : bool
Indicates whether to prune final graph of disconnected nodes/isolates.
atlas : str
Name of atlas parcellation used.
uatlas : str
File path to atlas parcellation Nifti1Image in MNI template space.
labels : list
List of string labels corresponding to ROI nodes.
coords : list
List of (x, y, z) tuples corresponding to a coordinate atlas used or
which represent the center-of-mass of each parcellation node.
norm : int
Indicates method of normalizing resulting graph.
binary : bool
Indicates whether to binarize resulting graph edges to form an
unweighted graph.
hpass : bool
High-pass filter values (Hz) to apply to node-extracted time-series.
extract_strategy : str
The name of a valid function used to reduce the time-series region extraction.
Returns
-------
conn_matrix : array
Adjacency matrix stored as an m x n array of nodes and edges.
conn_model : str
Connectivity estimation model (e.g. corr for correlation, cov for covariance, sps for precision covariance,
partcorr for partial correlation). sps type is used by default.
dir_path : str
Path to directory containing subject derivative data for given run.
node_size : int
Spherical centroid node size in the case that coordinate-based centroids
are used as ROI's for tracking.
smooth : int
Smoothing width (mm fwhm) to apply to time-series when extracting signal from ROI's.
dens_thresh : bool
Indicates whether a target graph density is to be used as the basis for
thresholding.
network : str
Resting-state network based on Yeo-7 and Yeo-17 naming (e.g. 'Default') used to filter nodes in the study of
brain subgraphs.
ID : str
A subject id or other unique identifier.
roi : str
File path to binarized/boolean region-of-interest Nifti1Image file.
min_span_tree : bool
Indicates whether local thresholding from the Minimum Spanning Tree
should be used.
disp_filt : bool
Indicates whether local thresholding using a disparity filter and
'backbone network' should be used.
parc : bool
Indicates whether to use parcels instead of coordinates as ROI nodes.
prune : bool
Indicates whether to prune final graph of disconnected nodes/isolates.
atlas : str
Name of atlas parcellation used.
uatlas : str
File path to atlas parcellation Nifti1Image in MNI template space.
labels : list
List of string labels corresponding to graph nodes.
coords : list
List of (x, y, z) tuples corresponding to a coordinate atlas used or
which represent the center-of-mass of each parcellation node.
norm : int
Indicates method of normalizing resulting graph.
binary : bool
Indicates whether to binarize resulting graph edges to form an
unweighted graph.
hpass : bool
High-pass filter values (Hz) to apply to node-extracted time-series.
extract_strategy : str
The name of a valid function used to reduce the time-series region extraction.
References
----------
.. [1] Varoquaux, G., & Craddock, R. C. (2013). Learning and comparing functional connectomes
across subjects. NeuroImage. https://doi.org/10.1016/j.neuroimage.2013.04.007
.. [2] Jason Laska, Manjari Narayan, 2017. skggm 0.2.7: A scikit-learn compatible package
for Gaussian and related Graphical Models. doi:10.5281/zenodo.830033
"""
from nilearn.connectome import ConnectivityMeasure
from sklearn.covariance import GraphicalLassoCV
conn_matrix = None
if conn_model == 'corr' or conn_model == 'cor' or conn_model == 'correlation':
# 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' or conn_model == 'parcorr' or conn_model == 'partialcorrelation':
# 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 == 'covariance' or conn_model == 'covar' or conn_model == 'sps' or \
conn_model == 'sparse' or conn_model == 'precision':
# Fit estimator to matrix to get sparse matrix
estimator_shrunk = None
estimator = GraphicalLassoCV(cv=5)
try:
print('\nComputing covariance...\n')
estimator.fit(time_series)
except:
print('Unstable Lasso estimation--Attempting to re-run by first applying shrinkage...')
try:
from sklearn.covariance import GraphicalLasso, 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 = GraphicalLasso(alpha)
estimator_shrunk.fit(shrunk_cov)
print(f"Retrying covariance matrix estimate with alpha={alpha}")
if estimator_shrunk is None:
pass
else:
break
except:
print(f"Covariance estimation failed with shrinkage at alpha={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('\nERROR: Covariance estimation failed.')
if conn_model == 'sps' or conn_model == 'sparse' or conn_model == 'precision':
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' or conn_model == 'covariance' or conn_model == 'covar':
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 == 'QuicGraphicalLasso':
try:
from inverse_covariance import QuicGraphicalLasso
except ImportError:
print('Cannot run QuicGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLasso
# credit: skggm
model = QuicGraphicalLasso(
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 == 'QuicGraphicalLassoCV':
try:
from inverse_covariance import QuicGraphicalLassoCV
except ImportError:
print('Cannot run QuicGraphLassoCV. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoCV
# credit: skggm
model = QuicGraphicalLassoCV(
init_method='cov',
verbose=1)
print('\nCalculating QuicGraphLassoCV precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'QuicGraphicalLassoEBIC':
try:
from inverse_covariance import QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run QuicGraphLassoEBIC. Skggm not installed!')
# Compute the sparse inverse covariance via QuicGraphLassoEBIC
# credit: skggm
model = QuicGraphicalLassoEBIC(
init_method='cov',
verbose=1)
print('\nCalculating QuicGraphLassoEBIC precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.precision_
elif conn_model == 'AdaptiveQuicGraphicalLasso':
try:
from inverse_covariance import AdaptiveQuicGraphicalLasso, QuicGraphicalLassoEBIC
except ImportError:
print('Cannot run AdaptiveGraphLasso. Skggm not installed!')
# Compute the sparse inverse covariance via
# AdaptiveGraphLasso + QuicGraphLassoEBIC + method='binary'
# credit: skggm
model = AdaptiveQuicGraphicalLasso(
estimator=QuicGraphicalLassoEBIC(
init_method='cov',
),
method='binary',
)
print('\nCalculating AdaptiveQuicGraphLasso precision matrix using skggm...\n')
model.fit(time_series)
conn_matrix = -model.estimator_.precision_
else:
raise ValueError('\nERROR! No connectivity model specified at runtime. Select a valid estimator using the '
'-mod flag.')
# Enforce symmetry
conn_matrix = np.maximum(conn_matrix, conn_matrix.T)
if conn_matrix.shape < (2, 2):
raise RuntimeError('\nERROR! Matrix estimation selection yielded an empty or 1-dimensional graph. '
'Check time-series for errors or try using a different atlas')
coords = np.array(coords)
labels = np.array(labels)
del time_series
return (conn_matrix, conn_model, dir_path, node_size, smooth, dens_thresh, network, ID, roi, min_span_tree,
disp_filt, parc, prune, atlas, uatlas, labels, coords, norm, binary, hpass, extract_strategy)
def fit(self, X):
'''
Copulafit using Gaussian copula with marginals evaluated by Gaussian KDE
Precision matrix is evaluated using specified method, default to graphical LASSO
:param X: input dataset
:return: estimated precision matrix rho
'''
N, d = X.shape
if self.scaler is not None:
X_scale = self.scaler.fit_transform(X)
else:
X_scale = X
if len(self.vertexes) == 0:
self.vertexes = [str(id) for id in range(d)]
self.theta = 1.0 / N
cum_marginals = np.zeros_like(X)
inv_norm_cdf = np.zeros_like(X)
# inv_norm_cdf_scaled = np.zeros_like(X)
self.kernels = list([])
# TODO: complexity O(Nd) is high
if self.verbose:
colored('>> Computing marginals', color='blue')
for j in range(cum_marginals.shape[1]):
self.kernels.append(gaussian_kde(X_scale[:, j]))
cum_pdf_overall = self.kernels[-1].integrate_box_1d(
X_scale[:, j].min(), X_scale[:, j].max())
for i in range(cum_marginals.shape[0]):
cum_marginals[i, j] = self.kernels[-1].integrate_box_1d(
X_scale[:, j].min(), X_scale[i, j]) / cum_pdf_overall
# truncate cumulative marginals
if cum_marginals[i, j] < self.theta:
cum_marginals[i, j] = self.theta
elif cum_marginals[i, j] > 1 - self.theta:
cum_marginals[i, j] = 1 - self.theta
# inverse of normal CDF: \Phi(F_j(x))^{-1}
inv_norm_cdf[i, j] = norm.ppf(cum_marginals[i, j])
# scaled to preserve mean and variance: u_j + \sigma_j*\Phi(F_j(x))^{-1}
# inv_norm_cdf_scaled[i, j] = X_scale[:, j].mean() + X_scale[:, j].std() * inv_norm_cdf[i, j]
if self.method == 'mle':
# maximum-likelihood estiamtor
empirical_cov = EmpiricalCovariance()
empirical_cov.fit(inv_norm_cdf)
if self.verbose:
print colored('>> Running MLE to estiamte precision matrix',
color='blue')
self.est_cov = empirical_cov.covariance_
self.corr = scale_matrix(self.est_cov)
self.precision_ = inv(empirical_cov.covariance_)
if self.method == 'glasso':
if self.verbose:
print colored('>> Running glasso to estiamte precision matrix',
color='blue')
empirical_cov = EmpiricalCovariance()
empirical_cov.fit(inv_norm_cdf)
# shrunk convariance to avoid numerical instability
shrunk_cov = shrunk_covariance(empirical_cov.covariance_,
shrinkage=0.8)
self.est_cov, self.precision_ = graph_lasso(emp_cov=shrunk_cov,
alpha=self.penalty,
verbose=self.verbose,
max_iter=self.max_iter)
self.corr = scale_matrix(self.est_cov)
if self.method == 'ledoit_wolf':
if self.verbose:
print colored(
'>> Running ledoit_wolf to estiamte precision matrix',
color='blue')
self.est_cov, _ = ledoit_wolf(inv_norm_cdf)
self.corr = scale_matrix(self.est_cov)
self.precision_ = linalg.inv(self.est_cov)
if self.method == 'spectral':
'''L2 mehtod, use paper Inverse covariance estimation for high dimension data in linear time and space
:formular: in paper eq(8)
'''
if self.verbose:
print colored(
'>> Running Riccati to estiamte precision matrix',
color='blue')
# TODO: note estimated cov is sample cov
self.est_cov, self.precision_ = spectral(inv_norm_cdf,
rho=2 * self.penalty,
assume_centered=False)
self.corr = scale_matrix(self.est_cov)
if self.method == 'pc':
clf = pgmlearner.PGMLearner()
data_list = list([])
for row_id in range(X_scale.shape[0]):
instance = dict()
for i, n in enumerate(self.vertexes):
instance[n] = X_scale[row_id, i]
data_list.append(instance)
graph = clf.lg_constraint_estimatestruct(data=data_list,
pvalparam=self.pval,
bins=self.bins)
dag = np.zeros(shape=(len(graph.V), len(graph.V)))
for e in graph.E:
dag[self.vertexes.index(e[0]), self.vertexes.index(e[1])] = 1
self.conditional_independences_ = dag
if self.method == 'ic':
df = dict()
variable_types = dict()
for j in range(X_scale.shape[1]):
df[self.vertexes[j]] = X_scale[:, j]
variable_types[self.vertexes[j]] = 'c'
data = pd.DataFrame(df)
# run the search
ic_algorithm = IC(RobustRegressionTest,
data,
variable_types,
alpha=self.pval)
graph = ic_algorithm.search()
dag = np.zeros(shape=(X_scale.shape[1], X_scale.shape[1]))
for e in graph.edges(data=True):
i = self.vertexes.index(e[0])
j = self.vertexes.index(e[1])
dag[i, j] = 1
dag[j, i] = 1
arrows = set(e[2]['arrows'])
head_len = len(arrows)
if head_len > 0:
head = arrows.pop()
if head_len == 1 and head == e[0]:
dag[i, j] = 0
if head_len == 1 and head == e[1]:
dag[j, i] = 0
self.conditional_independences_ = dag
# finally we fit the structure
self.fit_structure(self.precision_)
