def lasso(xs): '''Use GraphicalLassoCV. Parameters ---------- xs : array_like N samples of X. Returns ------- C : array_like Covariance matrix estimate. Notes ----- This implementation uses cross-validation to find the correct weight for Lasso. Graphical Lasso is a method for finding a sparse inverse covariance matrix, so this is additional information that might not follow from having a Toeplitz covariance matrix... ''' model = GraphicalLassoCV(cv=3) model.fit(xs) C = model.covariance_ return C
def create_prior_from_samples(self, samples): from sklearn.covariance import GraphicalLassoCV from numpy import asarray, linalg model = GraphicalLassoCV() model.fit(asarray(samples)) return th_Mahalanobis( asarray(samples).mean(axis=0), linalg.cholesky(model.precision_), self.prefix)
def est_connectivity(X, gm="Glasso", assume_centered=False): if gm == "QuicGlasso-CV": quic = QuicGraphicalLassoCV(cv=5) quic.fit(X) return quic.covariance_, quic.precision_, quic.lam_ elif gm == "QuicGlasso-BIC": quic_bic = QuicGraphicalLassoEBIC(gamma=0) quic_bic.fit(X) return quic_bic.covariance_, quic_bic.precision_, quic_bic.lam_ else: # Default: Glasso glasso = GraphicalLassoCV(assume_centered=assume_centered, cv=5).fit(X) return glasso.covariance_, glasso.get_precision(), glasso.alpha_
def _infer_network(self, data): """ Infer the network. Args: data (pd.DataFrame): data to be used for the inference. """ entities = data.columns model = GraphicalLassoCV(**self.parameters) model.fit(data.values) self.graph = Graph(adjacency=pd.DataFrame( from_precision_matrix_partial_correlations(model.precision_), index=entities, columns=entities)) logger.debug('inferred with {}'.format(self.method))
def test_graphical_lasso_cv_grid_scores_and_cv_alphas_deprecated(): splits = 4 n_alphas = 5 n_refinements = 3 true_cov = np.array([ [0.8, 0.0, 0.2, 0.0], [0.0, 0.4, 0.0, 0.0], [0.2, 0.0, 0.3, 0.1], [0.0, 0.0, 0.1, 0.7], ]) rng = np.random.RandomState(0) X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200) cov = GraphicalLassoCV(cv=splits, alphas=n_alphas, n_refinements=n_refinements).fit(X) total_alphas = n_refinements * n_alphas + 1 msg = (r"The `grid_scores_` attribute is deprecated in version 0\.24 in " r"favor of `cv_results_` and will be removed in version 1\.1 " r"\(renaming of 0\.26\).") with pytest.warns(FutureWarning, match=msg): assert cov.grid_scores_.shape == (total_alphas, splits) msg = (r"The `cv_alphas_` attribute is deprecated in version 0\.24 in " r"favor of `cv_results_\['alpha'\]` and will be removed in version " r"1\.1 \(renaming of 0\.26\)") with pytest.warns(FutureWarning, match=msg): assert len(cov.cv_alphas_) == total_alphas
def test_graphical_lasso_cv_scores_deprecated(): """Check that the following keys in cv_results_ are deprecated: `mean_score`, `std_score`, and `split(k)_score`.""" splits = 4 n_alphas = 5 n_refinements = 3 true_cov = np.array([ [0.8, 0.0, 0.2, 0.0], [0.0, 0.4, 0.0, 0.0], [0.2, 0.0, 0.3, 0.1], [0.0, 0.0, 0.1, 0.7], ]) rng = np.random.RandomState(0) X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200) cov = GraphicalLassoCV(cv=splits, alphas=n_alphas, n_refinements=n_refinements).fit(X) cv_results = cov.cv_results_ deprecated_keys = ["mean_score", "std_score" ] + [f"split{k}_score" for k in range(splits)] for deprecated_key in deprecated_keys: new_key = deprecated_key.replace("_score", "_test_score") msg = ( f"Key: '{deprecated_key}', is deprecated in 1.0 and will be removed in 1.2." f" Use '{new_key}' instead") with pytest.warns(FutureWarning, match=msg): cv_results[deprecated_key]
def test_graphical_lasso_cv_scores(): splits = 4 n_alphas = 5 n_refinements = 3 true_cov = np.array([[0.8, 0.0, 0.2, 0.0], [0.0, 0.4, 0.0, 0.0], [0.2, 0.0, 0.3, 0.1], [0.0, 0.0, 0.1, 0.7]]) rng = np.random.RandomState(0) X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200) cov = GraphicalLassoCV(cv=splits, alphas=n_alphas, n_refinements=n_refinements).fit(X) cv_results = cov.cv_results_ # alpha and one for each split total_alphas = n_refinements * n_alphas + 1 keys = ['alphas'] split_keys = ['split{}_score'.format(i) for i in range(splits)] for key in keys + split_keys: assert key in cv_results assert len(cv_results[key]) == total_alphas cv_scores = np.asarray([cov.cv_results_[key] for key in split_keys]) expected_mean = cv_scores.mean(axis=0) expected_std = cv_scores.std(axis=0) assert_allclose(cov.cv_results_["mean_score"], expected_mean) assert_allclose(cov.cv_results_["std_score"], expected_std)
def getConnectome(imgPath=None, atlasPath=None, viewInBrowser=False, displayCovMatrix=False): """ Gets the connectome of a functional MRI scan imgPath -> absolute or relative path to the .nii file atlasPath -> download path for the reference MSDL atlas viewInBrowser (optional, default=False) -> if True, opens up an interactive viewer in the browser displayCovMatrix (optional, default=False) -> display the inverse covariance matrix Returns a tuple of shape (estimator, atlas) """ # Download the reference atlas atlas = datasets.fetch_atlas_msdl(data_dir=atlasPath) # Loading atlas image stored in 'maps' atlasFilename = atlas['maps'] # Get the time series for the fMRI scan masker = NiftiMapsMasker(maps_img=atlasFilename, standardize=True, memory='nilearn_cache', verbose=5) timeSeries = masker.fit_transform(imgPath) # Compute the connectome using sparse inverse covariance estimator = GraphicalLassoCV() estimator.fit(timeSeries) if (displayCovMatrix): labels = atlas['labels'] plotting.plot_matrix(estimator.covariance_, labels=labels, figure=(9, 7), vmax=1, vmin=-1, title='Covariance') plotting.plot_matrix(estimator.precision_, labels=labels, figure=(9, 7), vmax=1, vmin=-1, title='Inverse covariance (Precision)') #covPlot.get_figure().savefig('Covariance.png') # precPlot.get_figure().savefig('Inverse Covariance.png') if (viewInBrowser): coords = atlas.region_coords view = plotting.view_connectome(-estimator.precision_, coords, '60.0%') #view.save_as_html(file_name='Connectome Test.html') view.open_in_browser() return (estimator, atlas)
def main(): mean = torch.tensor(np.ones(16), dtype=torch.float32) diag = torch.tensor(np.ones(16), dtype=torch.float32) population = Gaussian_Distribution(mean=mean, diag=diag, sub=0.3, type='chain', slash=1) truth = population.invcov.numpy() n = 1000 d = population.dim print(truth) dist, sample, _, S = population.generate(n, numpy_like=True) #print(S) #print(np.array(sample)) print(sample_mean(np.array(sample))) print(sample_cov(np.array(sample))) R = np.linalg.inv(S) #print(R) #print(sample) np.random.seed(0) model = GraphicalLassoCV() model.fit(np.array(sample)) cov_ = model.covariance_ prec_ = model.precision_ heatmap(prec_) plt.figure(figsize=(4, 3)) plt.axes([.2, .15, .75, .7]) plt.plot(model.cv_alphas_, np.mean(model.grid_scores_, axis=1), 'o-') plt.axvline(model.alpha_, color='.5') plt.title('Model selection') plt.ylabel('Cross-validation score') plt.xlabel('alpha') plt.show() print(model.cv_alphas_, model.grid_scores_) model = GraphicalLasso() model.fit(sample) heatmap(model.precision_, 0.055) score = dict() score['log_lik'] = [] score['AIC'] = [] alpha_list = np.hstack((np.arange(0, 0.1, 0.001), np.arange(0.11, 0.3, 0.01))) data = np.array(sample) for alpha in alpha_list: out_dict = cross_val_score_GLasso(data, alpha=alpha) score['log_lik'].append(out_dict['log_lik']) score['AIC'].append(out_dict['AIC']) plt.plot(alpha_list, score['log_lik'], 'o-') plt.show() plt.plot(alpha_list, score['AIC']) plt.show()
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 test_graphical_lasso_cv(random_state=1): # Sample area_data from a sparse multivariate normal dim = 5 n_samples = 6 random_state = check_random_state(random_state) prec = make_sparse_spd_matrix(dim, alpha=.96, random_state=random_state) cov = linalg.inv(prec) X = random_state.multivariate_normal(np.zeros(dim), cov, size=n_samples) # Capture stdout, to smoke test the verbose mode orig_stdout = sys.stdout try: sys.stdout = StringIO() # We need verbose very high so that Parallel prints on stdout GraphicalLassoCV(verbose=100, alphas=5, tol=1e-1).fit(X) finally: sys.stdout = orig_stdout # Smoke test with specified alphas GraphicalLassoCV(alphas=[0.8, 0.5], tol=1e-1, n_jobs=1).fit(X)
def glasso(data, alphas=5, n_jobs=None, mode='cd'): """ Estimates the graph with graphical lasso finding the best alpha based on cross validation Parameters ---------- data: numpy ndarray The input data for to reconstruct/estimate a graph on. Features as columns and observations as rows. alphas: int or array-like of shape (n_alphas,), dtype=float, default=5 Non-negative. If an integer is given, it fixes the number of points on the grids of alpha to be used. If a list is given, it gives the grid to be used. Returns ------- adjacency matrix : the estimated adjacency matrix. """ scaler = StandardScaler() data = scaler.fit_transform(data) cov = GraphicalLassoCV(alphas=alphas, n_jobs=n_jobs).fit(data) precision_matrix = cov.get_precision() adjacency_matrix = precision_matrix.astype(bool).astype(int) adjacency_matrix[np.diag_indices_from(adjacency_matrix)] = 0 return adjacency_matrix
def helper_graphical_lasso(X, theta_true, tf_names=[]): # Estimate the covariance if args.mode == 'cv': model = GraphicalLassoCV() else: model = GraphicalLasso(alpha=args.alpha_l1, mode=args.mode, tol=1e-7, enet_tol=1e-6, max_iter=100, verbose=False, assume_centered=False) model.fit(X) # cov_ = model.covariance_ prec_ = model.precision_ if args.USE_TF_NAMES == 'yes' and len(tf_names) != 0: prec_ = postprocess_tf(prec_, tf_names) recovery_metrics = report_metrics(np.array(theta_true), prec_) print( 'GLASSO: FDR, TPR, FPR, SHD, nnz_true, nnz_pred, precision, recall, Fb, aupr, auc' ) print('GLASSO: TEST: Recovery of true theta: ', *np.around(recovery_metrics, 3)) return list(recovery_metrics)
def test_deprecated_grid_scores(random_state=1): dim = 5 n_samples = 6 random_state = check_random_state(random_state) prec = make_sparse_spd_matrix(dim, alpha=.96, random_state=random_state) cov = linalg.inv(prec) X = random_state.multivariate_normal(np.zeros(dim), cov, size=n_samples) graphical_lasso = GraphicalLassoCV(alphas=[0.8, 0.5], tol=1e-1, n_jobs=1) graphical_lasso.fit(X) depr_message = ("Attribute grid_scores was deprecated in version " "0.19 and will be removed in 0.21. Use " "``grid_scores_`` instead") with pytest.warns(DeprecationWarning, match=depr_message): assert_equal(graphical_lasso.grid_scores, graphical_lasso.grid_scores_)
def test_graphical_lasso_cv_alphas_iterable(alphas_container_type): """Check that we can pass an array-like to `alphas`. Non-regression test for: https://github.com/scikit-learn/scikit-learn/issues/22489 """ true_cov = np.array([ [0.8, 0.0, 0.2, 0.0], [0.0, 0.4, 0.0, 0.0], [0.2, 0.0, 0.3, 0.1], [0.0, 0.0, 0.1, 0.7], ]) rng = np.random.RandomState(0) X = rng.multivariate_normal(mean=[0, 0, 0, 0], cov=true_cov, size=200) alphas = _convert_container([0.02, 0.03], alphas_container_type) GraphicalLassoCV(alphas=alphas, tol=1e-1, n_jobs=1).fit(X)
def estimate_covariance(x, method): """ Covariance estimator wrapper :param x: :param method: :return: """ cov = None if method == 'shrunk': cov = ShrunkCovariance().fit(x) elif method == 'glasso': cov = GraphicalLassoCV(cv=5, alphas=10, n_refinements=10).fit(x) else: ValueError('Covariance method not in [shrunk,glasso]') return cov.covariance_, cov.precision_
def main(): mean = torch.tensor(np.ones(16), dtype=torch.float32) diag = torch.tensor(np.ones(16), dtype=torch.float32) population = Gaussian_Distribution(mean=mean, diag=diag, sub=0.25, type='chain', slash=1) truth = population.invcov.numpy() n = 1000 d = population.dim print(truth) dist, sample, _, S = population.generate(n, numpy_like=True) # ############################################################################# # Generate the data n_samples = 60 n_features = 20 prng = np.random.RandomState(1) prec = make_sparse_spd_matrix(n_features, alpha=.98, smallest_coef=.4, largest_coef=.7, random_state=prng) cov = linalg.inv(prec) d = np.sqrt(np.diag(cov)) cov /= d cov /= d[:, np.newaxis] prec *= d prec *= d[:, np.newaxis] X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples) X -= X.mean(axis=0) X /= X.std(axis=0) #prec = population.invcov # ############################################################################# # Estimate the covariance emp_cov = np.dot(X.T, X) / n_samples model = GraphicalLassoCV() model.fit(sample) cov_ = model.covariance_ prec_ = model.precision_ lw_cov_, _ = ledoit_wolf(X) lw_prec_ = linalg.inv(lw_cov_) # ############################################################################# # Plot the results plt.figure(figsize=(10, 6)) plt.subplots_adjust(left=0.02, right=0.98) # plot the covariances covs = [('Empirical', emp_cov), ('Ledoit-Wolf', lw_cov_), ('GraphicalLassoCV', cov_), ('True', cov)] vmax = cov_.max() for i, (name, this_cov) in enumerate(covs): plt.subplot(2, 4, i + 1) plt.imshow(this_cov, interpolation='nearest', vmin=-vmax, vmax=vmax, cmap=plt.cm.RdBu_r) plt.xticks(()) plt.yticks(()) plt.title('%s covariance' % name) # plot the precisions precs = [('Empirical', linalg.inv(emp_cov)), ('Ledoit-Wolf', lw_prec_), ('GraphicalLasso', prec_), ('True', prec)] vmax = .9 * prec_.max() for i, (name, this_prec) in enumerate(precs): ax = plt.subplot(2, 4, i + 5) plt.imshow(np.ma.masked_equal(this_prec, 0), interpolation='nearest', vmin=-vmax, vmax=vmax, cmap=plt.cm.RdBu_r) plt.xticks(()) plt.yticks(()) plt.title('%s precision' % name) if hasattr(ax, 'set_facecolor'): ax.set_facecolor('.7') else: ax.set_axis_bgcolor('.7') # plot the model selection metric plt.figure(figsize=(4, 3)) plt.axes([.2, .15, .75, .7]) plt.plot(model.cv_alphas_, np.mean(model.grid_scores_, axis=1), 'o-') plt.axvline(model.alpha_, color='.5') plt.title('Model selection') plt.ylabel('Cross-validation score') plt.xlabel('alpha') plt.show()
ns = nitk.NeighbourhoodSelectionColumnwiseCV() ns.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, ns.precision_) ns_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) te = nitk.ThresholdEstimatorCV() te.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, te.covariance_) ts_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) sc = nitk.SCIOColumnwiseCV() sc.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, sc.precision_) sc_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) gl = GraphicalLassoCV() gl.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, gl.precision_) gl_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) sli = nitk.ScaledLassoInference() sli.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, sli.precision_) sli_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) cli = nitk.CLIMECV() cli.fit(X) tpr, fpr, prec = nitk.methods.calculate_matrix_accuracy(K, cli.precision_) cli_f1[i] = nitk.methods.calculate_f1_score(tpr, prec) print("Graphical Lasso & %s & %s & %6.3f $\pm$ %6.3f" % (p, n, np.mean(gl_f1), np.std(gl_f1)))
def main(): # 'Date', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume' df = pd.read_csv(pt.join(DATA_ROOT, '1999_2018_complete.csv')) # drop malaysia and venezuela df.drop(['malaysia', 'venezuela'], axis=1, inplace=True) # print(df.columns[2:]) data = df.values[:, 2:] data = preprocessing.scale(data, axis=1) print(data.shape) # plt.plot(data[:, 6], c='b', label='Japan') # plt.plot(data[:, 13], c='g', label='Sri Lanka') # plt.legend() # plt.show() # Estimate the covariance emp_cov = np.dot(data.T, data) / data.shape[0] for count in range(20): temp_data = data[count * 242:(count + 1) * 242] # GraphicalLasso model = GraphicalLassoCV() model.fit(temp_data) cov_ = model.covariance_ prec_ = model.precision_ # print(model.alpha_) # print(model.cv_alphas_) # print(model.grid_scores_) # print(model.n_iter_) # Ledoit-Wolf lw_cov_, _ = ledoit_wolf(data) lw_prec_ = linalg.inv(lw_cov_) # ############################################################################# # Plot the results # plt.figure(figsize=(8, 6)) # plt.subplots_adjust(left=0.02, right=0.98) # # # plot the covariances # covs = [('Empirical', emp_cov), ('Ledoit-Wolf', # lw_cov_), ('GraphicalLassoCV', cov_)] # vmax = cov_.max() # for i, (name, this_cov) in enumerate(covs): # plt.subplot(2, 3, i + 1) # plt.imshow(this_cov, interpolation='nearest', vmin=-vmax, vmax=vmax, # cmap=plt.cm.RdBu_r) # plt.xticks(()) # plt.yticks(()) # plt.title('%s covariance' % name) # # # plot the precisions # precs = [('Empirical', linalg.inv(emp_cov)), ('Ledoit-Wolf', lw_prec_), # ('GraphicalLasso', prec_)] # vmax = .9 * prec_.max() # for i, (name, this_prec) in enumerate(precs): # ax = plt.subplot(2, 3, i + 4) # plt.imshow(np.ma.masked_equal(this_prec, 0), # interpolation='nearest', vmin=-vmax, vmax=vmax, # cmap=plt.cm.RdBu_r) # plt.xticks(()) # plt.yticks(()) # plt.title('%s precision' % name) # if hasattr(ax, 'set_facecolor'): # ax.set_facecolor('.7') # else: # ax.set_axis_bgcolor('.7') # plt.show() # print(prec_) name = 'GraphicalLasso' this_prec = prec_ vmax = .9 * prec_.max() plt.figure() ax = plt.subplot(1, 1, 1) plt.imshow(np.ma.masked_equal(this_prec, 0), interpolation='nearest', vmin=-vmax, vmax=vmax, cmap=plt.cm.RdBu_r) plt.xticks(()) plt.yticks(()) plt.title('year: %d' % (1999 + count)) if hasattr(ax, 'set_facecolor'): ax.set_facecolor('.7') else: ax.set_axis_bgcolor('.7') plt.show()
def main(): mean = torch.tensor(np.zeros(32), dtype=torch.float32) diag = torch.tensor(np.ones(32), dtype=torch.float32) X = torch.eye(32, dtype=torch.float32) X[5, 10] = X[10, 5] = X[19, 20] = X[20, 19] = X[1, 31] = X[31, 1] = -0.5 population = Gaussian_Distribution(mean=mean, diag=diag, sub=-0.2, type='DIY', slash=1, prec=X) truth = population.invcov.numpy() n = 400 p = population.dim print(truth) heatmap(truth) data = pd.read_csv("chain.csv") sample = data.values[1:, 1:] sample = z_score(sample) emp_cov = sample_cov(sample) score = dict() score['log_lik'] = [] score['AIC'] = [] score['non_zero'] = [] alpha_list = np.hstack((np.arange(1e-5, 0.1, 0.002), np.arange(0.1, 0.3, 0.01))) data = np.array(sample) for alpha in alpha_list: out_dict = cross_val_score_ProxGrad(data, alpha=alpha, type='FISTA') score['log_lik'].append(out_dict['log_lik']) score['AIC'].append(out_dict['AIC']) score['non_zero'].append(out_dict['non_zero']) plt.plot(alpha_list, score['log_lik']) plt.show() plt.plot(alpha_list, score['AIC']) plt.show() plt.plot(alpha_list, score['non_zero']) plt.show() model = ProxGrad() l = len(alpha_list) alpha = 0 log_lik = -1e12 for i in range(0, l): if score['log_lik'][i] > log_lik: alpha = alpha_list[i] log_lik = score['log_lik'][i] print(alpha) prec = model.fit_FISTA(emp_cov, alpha) heatmap(prec) print('nonzero:', L0_penal(prec)) alpha = 0 aic = 1e12 for i in range(0, l): if score['AIC'][i] < aic: alpha = alpha_list[i] aic = score['AIC'][i] print(alpha) prec = model.fit_FISTA(emp_cov, alpha) heatmap(prec) print('nonzero:', L0_penal(prec)) model = GraphicalLassoCV(tol=1e-8) model.fit(sample) heatmap(model.precision_) print('nonzero:', L0_penal(model.precision_))
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)
random_state=prng) cov = linalg.inv(prec) d = np.sqrt(np.diag(cov)) cov /= d cov /= d[:, np.newaxis] prec *= d prec *= d[:, np.newaxis] X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples) X -= X.mean(axis=0) X /= X.std(axis=0) # ############################################################################# # Estimate the covariance emp_cov = np.dot(X.T, X) / n_samples model = GraphicalLassoCV() model.fit(X) cov_ = model.covariance_ prec_ = model.precision_ lw_cov_, _ = ledoit_wolf(X) lw_prec_ = linalg.inv(lw_cov_) # ############################################################################# # Plot the results plt.figure(figsize=(10, 6)) plt.subplots_adjust(left=0.02, right=0.98) # plot the covariances covs = [ ("Empirical", emp_cov),
standardize=True, memory='nilearn_cache', verbose=5) time_series = masker.fit_transform(data.func[0], confounds=data.confounds) ############################################################################## # Compute the sparse inverse covariance # -------------------------------------- try: from sklearn.covariance import GraphicalLassoCV except ImportError: # for Scitkit-Learn < v0.20.0 from sklearn.covariance import GraphLassoCV as GraphicalLassoCV estimator = GraphicalLassoCV() estimator.fit(time_series) ############################################################################## # Display the connectome matrix # ------------------------------ from nilearn import plotting # Display the covariance # The covariance can be found at estimator.covariance_ plotting.plot_matrix(estimator.covariance_, labels=labels, figure=(9, 7), vmax=1, vmin=-1, title='Covariance')
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
plotting.plot_matrix(gsc.precisions_[..., n], axes=ax, vmin=-max_precision, vmax=max_precision, colorbar=False) if n == 0: plt.title("group-sparse\n$\\alpha=%.2f$" % gsc.alpha_) # Fit one graph lasso per subject try: from sklearn.covariance import GraphicalLassoCV except ImportError: # for Scitkit-Learn < v0.20.0 from sklearn.covariance import GraphLassoCV as GraphicalLassoCV gl = GraphicalLassoCV(verbose=1) for n, subject in enumerate(subjects[:n_displayed]): gl.fit(subject) ax = plt.subplot(n_displayed, 4, 4 * n + 3) max_precision = gl.precision_.max() plotting.plot_matrix(gl.precision_, axes=ax, vmin=-max_precision, vmax=max_precision, colorbar=False) if n == 0: plt.title("graph lasso") plt.ylabel("$\\alpha=%.2f$" % gl.alpha_)
def extract_vector(self): if self.level == 2: self.df_cifti_load = pd.DataFrame( self.fmri_data_np_arr.mean(axis=2)) if type(self.seed_ROI_name) == list and len(self.seed_ROI_name) > 1: if self.seed_analysis_output == 'parcellated': self.df_cifti_load = pd.DataFrame( self.parcellated_cifti_load.get_fdata()) self.df_cifti_load.columns = self.parcel_labels self.df_cifti_load['avg'] = self.df_cifti_load[ self.seed_ROI_name].mean(axis=1) self.parcel_labels = self.df_cifti_load.columns.to_list() else: self.df_cifti_load = pd.DataFrame(self.cifti_load.get_fdata()) df_parcellated_cifti_load = pd.DataFrame( self.parcellated_cifti_load.get_fdata()) df_parcellated_cifti_load.columns = self.parcel_labels self.df_cifti_load['avg'] = df_parcellated_cifti_load[ self.seed_ROI_name].mean(axis=1) self.seed_ROI_name = 'avg' else: if self.seed_analysis_output == 'dense': self.df_cifti_load = pd.DataFrame(self.cifti_load.get_fdata()) df_parcellated_cifti_load = pd.DataFrame( self.parcellated_cifti_load.get_fdata()) df_parcellated_cifti_load.columns = self.parcel_labels self.df_cifti_load[ self.seed_ROI_name] = df_parcellated_cifti_load[ self.seed_ROI_name] else: self.df_cifti_load = pd.DataFrame( self.parcellated_cifti_load.get_fdata()) cifti_np_array = self.df_cifti_load.to_numpy() if self.method == 'correlation': #Pearson correlation coefficients with LedoitWolf covariance estimator #measure = ConnectivityMeasure(kind='correlation',cov_estimator='LedoitWolf') #Pearson correlation coefficients based oemperical covariance (i.e. standard) measure = ConnectivityMeasure(kind='correlation', cov_estimator=EmpiricalCovariance()) elif self.method == 'covariance': #LedoitWolf estimator measure = ConnectivityMeasure(kind='covariance') elif self.method == 'partial_correlation': # Partial correlation with LedoitWolf covariance estimator measure = ConnectivityMeasure(kind='partial correlation') elif self.method == 'precision': measure = ConnectivityMeasure(kind='precision') elif 'sparse' in self.method: measure = GraphicalLassoCV() if 'sparse' in self.method: measure.fit(cifti_np_array) if 'covariance' in self.method: network_matrix = measure.covariance_ elif 'precision' in self.method: network_matrix = measure.precision_ else: network_matrix = measure.fit_transform([cifti_np_array])[0] df_network_matrix = pd.DataFrame(network_matrix) df_network_matrix.columns = self.parcel_labels if self.seed_ROI_name == 'avg': # take everything except last element, i.e. avg. Need to do this because downstream this object must match grayordinate_file self.r_functional_vector = df_network_matrix[ self.seed_ROI_name][:-1].to_numpy() else: self.r_functional_vector = np.squeeze( df_network_matrix[self.seed_ROI_name].to_numpy()) self.z_functional_vector = 0.5 * ( np.log(1 + self.r_functional_vector) - np.log(1 - self.r_functional_vector))
subject_time_series.append(region_ts) ############################################################################## # Computing group-sparse precision matrices # ------------------------------------------ from nilearn.connectome import GroupSparseCovarianceCV gsc = GroupSparseCovarianceCV(verbose=2) gsc.fit(subject_time_series) try: from sklearn.covariance import GraphicalLassoCV except ImportError: # for Scitkit-Learn < v0.20.0 from sklearn.covariance import GraphLassoCV as GraphicalLassoCV gl = GraphicalLassoCV(verbose=2) gl.fit(np.concatenate(subject_time_series)) ############################################################################## # Displaying results # ------------------- atlas_img = msdl_atlas_dataset.maps atlas_region_coords = plotting.find_probabilistic_atlas_cut_coords(atlas_img) labels = msdl_atlas_dataset.labels plotting.plot_connectome(gl.covariance_, atlas_region_coords, edge_threshold='90%', title="Covariance", display_mode="lzr") plotting.plot_connectome(-gl.precision_,
random_state=prng) cov = linalg.inv(prec) d = np.sqrt(np.diag(cov)) cov /= d cov /= d[:, np.newaxis] prec *= d prec *= d[:, np.newaxis] X = prng.multivariate_normal(np.zeros(n_features), cov, size=n_samples) X -= X.mean(axis=0) X /= X.std(axis=0) # ############################################################################# # Estimate the covariance emp_cov = np.dot(X.T, X) / n_samples model = GraphicalLassoCV(cv=5) model.fit(X) cov_ = model.covariance_ prec_ = model.precision_ lw_cov_, _ = ledoit_wolf(X) lw_prec_ = linalg.inv(lw_cov_) # ############################################################################# # Plot the results plt.figure(figsize=(10, 6)) plt.subplots_adjust(left=0.02, right=0.98) # plot the covariances covs = [('Empirical', emp_cov), ('Ledoit-Wolf', lw_cov_), ('GraphicalLassoCV', cov_), ('True', cov)]
# --------------------- # # We start by estimating the signal **covariance** matrix. Here the # number of ROIs exceeds the number of samples, print('time series has {0} samples'.format(timeseries.shape[0])) ############################################################################### # in which situation the graphical lasso **sparse inverse covariance** # estimator captures well the covariance **structure**. try: from sklearn.covariance import GraphicalLassoCV except ImportError: # for Scitkit-Learn < v0.20.0 from sklearn.covariance import GraphLassoCV as GraphicalLassoCV covariance_estimator = GraphicalLassoCV(cv=3, verbose=1) ############################################################################### # We just fit our regions signals into the `GraphicalLassoCV` object covariance_estimator.fit(timeseries) ############################################################################### # and get the ROI-to-ROI covariance matrix. matrix = covariance_estimator.covariance_ print('Covariance matrix has shape {0}.'.format(matrix.shape)) ############################################################################### # Plot matrix, graph, and strength # -------------------------------- # # We use `:func: nilearn.plotting.plot_matrix` to visualize our correlation matrix
def get_covariance(data, method, lambda_val='CV', do_scale=False, n_cv_folds=None): # default cov if it is not calculated properly cov = -1 # scale timecourse if do_scale: data = scale(data, axis=1) # select method if method == 'QUIC': if lambda_val == 'CV': # set up model model = QuicGraphicalLassoCV(cv=n_cv_folds) # fit data to model and return resulting covariance model.fit(np.transpose(data)) return model.covariance_ elif lambda_val == 'EBIC': # set up model model = QuicGraphicalLassoEBIC() # fit data to model and return resulting covariance model.fit(np.transpose(data)) return model.covariance_ elif isinstance(lambda_val, float) and lambda_val > 0 and lambda_val < 1: # set up model model = QuicGraphicalLasso(lam=lambda_val) # fit data to model and return resulting covariance model.fit(data) return model.covariance_ else: print('Error in QUIC covariance:') print( 'lambda_val must be a float between 0 and 1, "CV" to find the best value by cross-validation, or "EBIC" to use extended Bayesian information criterion for model selection.' ) elif method == 'graphLasso': # transpose data as graphLasso likes it this way round data = np.transpose(data) # select whether to use supplied regularisation parameter or find the # best regularisation parameter by cross validation and maximum likelihood # use scikit-learn implementation of graph lasso and CV graph lasso if lambda_val == 'CV': try: model = GraphicalLassoCV(max_iter=1500, cv=n_cv_folds, assume_centered=True) model.fit(data) cov = model.covariance_ except: print( 'An error in cross validated graphLasso calculation occured.' ) elif isinstance(lambda_val, float) and lambda_val > 0 and lambda_val < 1: try: model = GraphicalLasso(alpha=lambda_val, mode='cd', tol=0.0001, max_iter=1500, verbose=False) model.fit(data) cov = model.covariance_ except (FloatingPointError, e): print( 'A floating point error in cross validated graphLasso calculation occured.' ) print(e) else: print('Error in graphLasso covariance:') print( 'lambda_val must be a float between 0 and 1, or "CV" to find the best value by cross-validation' ) # select method else: print('Method must be one of "graphLasso" or "QUIC".') return cov