def test_fast_on_real_data(): from pandas import read_table from os import path as op k = 200 subdir = "/home2/data/Projects/CWAS/share/nki/subinfo/40_Set1_N104" ffile = op.join(subdir, "short_compcor_rois_random_k%04i.txt" % k) fpaths = read_table(ffile, header=None) fpath = fpaths.ix[0, 0] import nibabel as nib img = nib.load(fpath) dat = img.get_data() import numpy as np from CPAC.cwas.subdist import norm_cols, ncor norm_dat = norm_cols(dat) corr_dat = norm_dat.T.dot(norm_dat) ref = eigenvector_centrality(corr_dat) comp = fast_eigenvector_centrality(norm_dat) diff = np.abs(ref - comp).mean() # mean diff print(diff) ok_(diff < np.spacing(1e10)) # allow some differences
def test_degree_on_real_data(): # TODO: Replace the mask and func with a standard testing one mpath = "/home2/data/Projects/CPAC_Regression_Test/centrality_template/mask-thr50-3mm.nii.gz" mask_inds = nib.load(mpath).get_data().nonzero() fpath = "/home/data/Projects/CPAC_Regression_Test/2014-02-24_v-0-3-4/run/w/resting_preproc_0010042_session_1/_scan_rest_1_rest/_scan_rest_1_rest/_csf_threshold_0.98/_gm_threshold_0.7/_wm_threshold_0.98/_compcor_ncomponents_5_selector_pc10.linear1.wm0.global0.motion1.quadratic0.gm0.compcor1.csf0/_bandpass_freqs_0.009.0.1/_mask_mask-thr50-3mm/resample_functional_to_template_0/bandpassed_demeaned_filtered_wtsimt_flirt.nii.gz" import nibabel as nib img = nib.load(fpath) dat = img.get_data() dat = dat[mask_inds] import numpy as np from CPAC.cwas.subdist import norm_cols, ncor norm_dat = norm_cols(dat.T) corr_dat = norm_dat.T.dot(norm_dat) r_value = 0.2 ref = np.sum(corr_dat[:5, :5] > r_value, axis=1) comp = degree_centrality(corr_dat[:5, :5], r_value, "binarize") assert_equal(ref, comp) ref = np.sum(corr_dat * (corr_dat > r_value), axis=1) comp = degree_centrality(corr_dat, r_value, "weighted") assert_equal(ref, comp)
def test_degree_on_real_data(): # TODO: Replace the mask and func with a standard testing one mpath = "/home2/data/Projects/CPAC_Regression_Test/centrality_template/mask-thr50-3mm.nii.gz" mask_inds = nib.load(mpath).get_data().nonzero() fpath = "/home/data/Projects/CPAC_Regression_Test/2014-02-24_v-0-3-4/run/w/resting_preproc_0010042_session_1/_scan_rest_1_rest/_scan_rest_1_rest/_csf_threshold_0.98/_gm_threshold_0.7/_wm_threshold_0.98/_compcor_ncomponents_5_selector_pc10.linear1.wm0.global0.motion1.quadratic0.gm0.compcor1.csf0/_bandpass_freqs_0.009.0.1/_mask_mask-thr50-3mm/resample_functional_to_template_0/bandpassed_demeaned_filtered_wtsimt_flirt.nii.gz" import nibabel as nib img = nib.load(fpath) dat = img.get_data() dat = dat[mask_inds] import numpy as np from CPAC.cwas.subdist import norm_cols, ncor norm_dat = norm_cols(dat.T) corr_dat = norm_dat.T.dot(norm_dat) r_value = 0.2 ref = np.sum(corr_dat[:5,:5]>r_value, axis=1) comp = degree_centrality(corr_dat[:5,:5], r_value, "binarize") assert_equal(ref, comp) ref = np.sum(corr_dat*(corr_dat>r_value), axis=1) comp = degree_centrality(corr_dat, r_value, "weighted") assert_equal(ref, comp)
def test_fast_on_real_data(): from pandas import read_table from os import path as op k = 200 subdir = "/home2/data/Projects/CWAS/share/nki/subinfo/40_Set1_N104" ffile = op.join(subdir, "short_compcor_rois_random_k%04i.txt" % k) fpaths = read_table(ffile, header=None) fpath = fpaths.ix[0,0] import nibabel as nib img = nib.load(fpath) dat = img.get_data() import numpy as np from CPAC.cwas.subdist import norm_cols, ncor norm_dat = norm_cols(dat) corr_dat = norm_dat.T.dot(norm_dat) ref = eigenvector_centrality(corr_dat) comp = fast_eigenvector_centrality(norm_dat) diff = np.abs(ref-comp).mean() # mean diff print(diff) ok_(diff < np.spacing(1e10)) # allow some differences
def test_fast_eigenvector_centrality(ntpts=100, nvoxs=1000): print "testing fast_eigenvector_centrality" # Simulate Data import numpy as np from CPAC.cwas.subdist import norm_cols # Normalize Random Time-Series Data m = np.random.random((ntpts,nvoxs)) m = norm_cols(m) # Correlation Data with Range 0-1 mm = m.T.dot(m) # note that need to generate connectivity matrix here # Execute #from CPAC.network_centrality.core import fast_eigenvector_centrality,slow_eigenvector_centrality ref = eigenvector_centrality(mm, verbose=False) # we need to transform mm to be a distance comp = fast_eigenvector_centrality(m, verbose=False) diff = np.abs(ref-comp).mean() # mean diff print(diff) ok_(diff < np.spacing(1e2)) # allow minimal difference
def test_fast_eigenvector_centrality(ntpts=100, nvoxs=1000): print "testing fast_eigenvector_centrality" # Simulate Data import numpy as np from CPAC.cwas.subdist import norm_cols # Normalize Random Time-Series Data m = np.random.random((ntpts, nvoxs)) m = norm_cols(m) # Correlation Data with Range 0-1 mm = m.T.dot(m) # note that need to generate connectivity matrix here # Execute #from CPAC.network_centrality.core import fast_eigenvector_centrality,slow_eigenvector_centrality ref = eigenvector_centrality( mm, verbose=False) # we need to transform mm to be a distance comp = fast_eigenvector_centrality(m, verbose=False) diff = np.abs(ref - comp).mean() # mean diff print(diff) ok_(diff < np.spacing(1e2)) # allow minimal difference
def calc_centrality(datafile, template, method_option, threshold_option, threshold, weight_options, allocated_memory): ''' Method to calculate centrality and map them to a nifti file Parameters ---------- datafile : string (nifti file) path to subject data file template : string (nifti file) path to mask/parcellation unit method_option : integer 0 - degree centrality calculation, 1 - eigenvector centrality calculation, 2 - lFCD calculation threshold_option : an integer 0 for probability p_value, 1 for sparsity threshold, 2 for actual threshold value, and 3 for no threshold and fast approach threshold : a float pvalue/sparsity_threshold/threshold value weight_options : list (boolean) list of booleans, where, weight_options[0] corresponds to binary counting and weight_options[1] corresponds to weighted counting (e.g. [True,False]) allocated_memory : string amount of memory allocated to degree centrality Returns ------- out_list : list list containing out mapped centrality images ''' # Import packages from CPAC.network_centrality import load,\ get_centrality_by_rvalue,\ get_centrality_by_sparsity,\ get_centrality_fast,\ map_centrality_matrix,\ calc_blocksize,\ convert_pvalue_to_r from CPAC.cwas.subdist import norm_cols # Check for input errors if weight_options.count(True) == 0: raise Exception("Invalid values in weight options" \ "At least one True value is required") # If it's sparsity thresholding, check for (0,1] if threshold_option == 1: if threshold <= 0 or threshold > 1: raise Exception('Threshold value must be a positive number'\ 'greater than 0 and less than or equal to 1.'\ '\nCurrently it is set at %d' % threshold) if method_option == 2 and threshold_option != 2: raise Exception('lFCD must use correlation-type thresholding.'\ 'Check the pipline configuration has this setting') import time start = time.clock() # Init variables out_list = [] ts, aff, mask, t_type, scans = load(datafile, template) # If we're doing eigenvectory centrality, need entire correlation matrix if method_option == 0 and threshold_option == 1: block_size = calc_blocksize(ts, memory_allocated=allocated_memory, sparsity_thresh=threshold) elif method_option == 1: block_size = calc_blocksize(ts, memory_allocated=allocated_memory, include_full_matrix=True) # Otherwise, compute blocksize with regards to available memory else: block_size = calc_blocksize(ts, memory_allocated=allocated_memory, include_full_matrix=False) # Normalize the timeseries for easy dot-product correlation calc. ts_normd = norm_cols(ts.T) # P-value threshold centrality if threshold_option == 0: r_value = convert_pvalue_to_r(scans, threshold) centrality_matrix = get_centrality_by_rvalue(ts_normd, mask, method_option, weight_options, r_value, block_size) # Sparsity threshold elif threshold_option == 1: centrality_matrix = get_centrality_by_sparsity(ts_normd, method_option, weight_options, threshold, block_size) # R-value threshold centrality elif threshold_option == 2: centrality_matrix = get_centrality_by_rvalue(ts_normd, mask, method_option, weight_options, threshold, block_size) # For fast approach (no thresholding) elif threshold_option == 3: centrality_matrix = get_centrality_fast(ts, method_option) # Otherwise, incorrect input for threshold_option else: raise Exception('Option must be between 0-3 and not %s, check your '\ 'pipeline config file' % str(threshold_option)) # Print timing info print 'Timing:', time.clock() - start # Map the arrays back to images for mat in centrality_matrix: centrality_image = map_centrality_matrix(mat, aff, mask, t_type) out_list.append(centrality_image) # Finally return return out_list
def get_centrality_fast(timeseries, method_options): ''' Method to calculate degree and eigen vector centrality. Relative to `get_centrality_opt`, it runs fast by not directly computing the correlation matrix. As a consequence, there are several differences/ limitations from the standard approach: 1. Cannot specify a correlation threshold 2. As a consequence, the weighted dense matrix centrality is computed 3. No memory limit is specified since it is assumed to be ok Note that the approach doesn't directly calculate the complete correlation matrix. Parameters ---------- timeseries_data : numpy array timeseries of the input subject method_options : string (list of boolean) list of two booleans for binarize and weighted options respectively Returns ------- out_list : string (list of tuples) list of tuple containing output name to be used to store nifti image for centrality and centrality matrix. this will only be weighted since the fast approaches are limited to this type of output. Raises ------ Exception ''' # Import packages from CPAC.network_centrality import fast_degree_centrality,\ fast_eigenvector_centrality from CPAC.cwas.subdist import norm_cols try: out_list = [] nvoxs = timeseries.shape[0] ntpts = timeseries.shape[1] # It's assumed that there is enough memory # So a block size isn't set here calc_degree = method_options[0] calc_eigen = method_options[1] print "Normalize Time-series" timeseries = norm_cols(timeseries.T) print "Computing centrality across %i voxels" % nvoxs if calc_degree: print "...calculating degree" degree_weighted = fast_degree_centrality(timeseries) out_list.append(('degree_centrality_weighted', degree_weighted)) if calc_eigen: print "...calculating eigen" eigen_weighted = fast_eigenvector_centrality(timeseries) out_list.append(('eigenvector_centrality_weighted', eigen_weighted)) return out_list except Exception: print "Error in calcuating centrality" raise
ref_file = "/data/Projects/ABIDE_Initiative/CPAC/test_qp/Centrality_Working/resting_preproc_0051466_session_1/_mask_mask_abide_90percent_gm_4mm/_scan_rest_1_rest/resample_functional_to_template_0/tmp_binarize.nii.gz" comp_file = "/data/Projects/ABIDE_Initiative/CPAC/test_qp/Centrality_Working/resting_preproc_0051466_session_1/network_centrality_0/_mask_mask_abide_90percent_gm_4mm/_scan_rest_1_rest/calculate_centrality/degree_centrality_binarize.nii.gz" ref_img = nib.load(ref_file) comp_img = nib.load(comp_file) ref_data = ref_img.get_data() comp_data = comp_img.get_data() mask = nib.load(templ["mask"]).get_data().nonzero() nvoxs = float(len(mask[0])) diff_data = np.abs(ref_data[mask] - comp_data[mask]) w = diff_data.nonzero() # We allow for some differences but the majority of voxels are assumed to be the same ok_(w[0].shape[0] < 25) ok_(diff_data[w].mean() <= 1) from CPAC.cwas.subdist import norm_cols, ncor ts_img = nib.load(templ['input']) ts_data = ts_img.get_data() ts = ts_data[mask] norm_ts = norm_cols(ts.T) corr_matrix = np.nan_to_num(ts.T.dot(ts)) binarize = np.sum(corr_matrix > templ['thresh'], axis=1) binarize[binarize != 0] = binarize[binarize != 0] - 1
ref_img = nib.load(ref_file) comp_img = nib.load(comp_file) ref_data = ref_img.get_data() comp_data = comp_img.get_data() mask = nib.load(templ["mask"]).get_data().nonzero() nvoxs = float(len(mask[0])) diff_data = np.abs(ref_data[mask] - comp_data[mask]) w = diff_data.nonzero() # We allow for some differences but the majority of voxels are assumed to be the same ok_(w[0].shape[0] < 25) ok_(diff_data[w].mean() <= 1) from CPAC.cwas.subdist import norm_cols, ncor ts_img = nib.load(templ['input']) ts_data = ts_img.get_data() ts = ts_data[mask] norm_ts = norm_cols(ts.T) corr_matrix = np.nan_to_num(ts.T.dot(ts)) binarize = np.sum(corr_matrix > templ['thresh'], axis=1) binarize[binarize!=0] = binarize[binarize!=0] - 1
def calc_centrality(in_file, template, method_option, threshold_option, threshold, allocated_memory): ''' Function to calculate centrality and map them to a nifti file Parameters ---------- in_file : string (nifti file) path to subject data file template : string (nifti file) path to mask/parcellation unit method_option : string accepted values are 'degree centrality', 'eigenvector centrality', and 'lfcd' threshold_option : string accepted values are: 'significance', 'sparsity', and 'correlation' threshold : float pvalue/sparsity_threshold/threshold value allocated_memory : string amount of memory allocated to degree centrality Returns ------- out_list : list list containing out mapped centrality images ''' # Import packages from CPAC.network_centrality import load,\ get_centrality_by_rvalue,\ get_centrality_by_sparsity,\ get_centrality_fast,\ map_centrality_matrix,\ calc_blocksize,\ convert_pvalue_to_r from CPAC.network_centrality.utils import check_centrality_params from CPAC.cwas.subdist import norm_cols # First check input parameters and get proper formatted method/thr options method_option, threshold_option = \ check_centrality_params(method_option, threshold_option, threshold) # Init variables out_list = [] ts, aff, mask, t_type, scans = load(in_file, template) # If we're doing degree sparsity if method_option == 'degree' and threshold_option == 'sparsity': block_size = calc_blocksize(ts, memory_allocated=allocated_memory, sparsity_thresh=threshold) # Otherwise elif method_option == 'eigenvector': block_size = calc_blocksize(ts, memory_allocated=allocated_memory, include_full_matrix=True) # Otherwise, compute blocksize with regards to available memory else: block_size = calc_blocksize(ts, memory_allocated=allocated_memory, include_full_matrix=False) # Normalize the timeseries for easy dot-product correlation calc. ts_normd = norm_cols(ts.T) # P-value threshold centrality if threshold_option == 'significance': r_value = convert_pvalue_to_r(in_file, threshold, two_tailed=False) centrality_matrix = get_centrality_by_rvalue(ts_normd, mask, method_option, r_value, block_size) # Sparsity threshold elif threshold_option == 'sparsity': centrality_matrix = get_centrality_by_sparsity(ts_normd, method_option, threshold, block_size) # R-value threshold centrality elif threshold_option == 'correlation': centrality_matrix = get_centrality_by_rvalue(ts_normd, mask, method_option, threshold, block_size) # For fast approach (no thresholding) elif threshold_option == 3: centrality_matrix = get_centrality_fast(ts, method_option) # Otherwise, incorrect input for threshold_option else: err_msg = 'Threshold option: %s not supported for network centrality '\ 'measure: %s; fix this in the pipeline config'\ % (str(threshold_option), str(method_option)) raise Exception(err_msg) # Map the arrays back to images for mat in centrality_matrix: centrality_image = map_centrality_matrix(mat, aff, mask, t_type) out_list.append(centrality_image) # Finally return return out_list
def get_centrality_by_thresh(timeseries, template, method_option, weight_options, threshold, r_value, memory_allocated): """ Method to calculate degree and eigen vector centrality. This method takes into consideration the amount of memory allocated by the user to calculate degree centrality. Parameters ---------- timeseries_data : numpy array timeseries of the input subject template : numpy array Mask/ROI template for timeseries of subject method_option : integer 0 - degree centrality calculation, 1 - eigenvector centrality calculation, 2 - lFCD calculation weight_options : string (list of boolean) list of two booleans for binarize and weighted options respectively threshold : float p-value threshold for the correlation values (ignored if the r_value option is specified) r_value : float threshold value in terms of the correlation (this will override the threshold option) memory_allocated : a string amount of memory allocated to degree centrality Returns ------- out_list : string (list of tuples) list of tuple containing output name to be used to store nifti image for centrality and centrality matrix Raises ------ Exception """ import numpy as np import os from CPAC.network_centrality import calc_blocksize,\ cluster_data,\ convert_pvalue_to_r,\ degree_centrality,\ eigenvector_centrality from CPAC.cwas.subdist import norm_cols try: # Init variables for use out_list = [] nvoxs = timeseries.shape[0] ntpts = timeseries.shape[1] r_matrix = None # init correlation matrix calc_degree = False # init degree measure flag to false calc_eigen = False # init eigen measure flag to false calc_lfcd= False # init lFCD measure flag to false # Select which method we're going to perform if method_option == 0: calc_degree = True elif method_option == 1: calc_eigen = True elif method_option == 2: calc_lfcd = True # Set weighting parameters out_binarize = weight_options[0] out_weighted = weight_options[1] # Calculate the block size (i.e., number of voxels) to compute part of the # connectivity matrix at once. if calc_eigen: # We still use a block size to calculate the whole correlation matrix # because of issues in numpy that lead to extra memory usage when # computing the dot product. # See https://cmi.hackpad.com/Numpy-Memory-Issues-BlV9Pg5nRDM. block_size = calc_blocksize(timeseries, memory_allocated, include_full_matrix=True) else: block_size = calc_blocksize(timeseries, memory_allocated) if r_value == None: print "Calculating threshold" r_value = convert_pvalue_to_r(ntpts, threshold) print "...%s -> %s" % (threshold, r_value) print "Setup Intermediates/Outputs" # Degree matrix init if calc_degree: print "...degree" if out_binarize: degree_binarize = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('degree_centrality_binarize', degree_binarize)) if out_weighted: degree_weighted = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('degree_centrality_weighted', degree_weighted)) # Eigen matrix init if calc_eigen: print "...eigen" r_matrix = np.zeros((nvoxs, nvoxs), dtype=timeseries.dtype) if out_binarize: eigen_binarize = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('eigenvector_centrality_binarize', eigen_binarize)) if out_weighted: eigen_weighted = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('eigenvector_centrality_weighted', eigen_weighted)) # lFCD matrix init if calc_lfcd: print "...degree" if out_binarize: lfcd_binarize = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('lFCD_binarize', lfcd_binarize)) if out_weighted: lfcd_weighted = np.zeros(nvoxs, dtype=timeseries.dtype) out_list.append(('lFCD_weighted', lfcd_weighted)) # Normalize the timeseries columns for simple correlation calc via dot product later.. print "Normalize TimeSeries" timeseries = norm_cols(timeseries.T) # Init blocking indices for correlation matrix calculation print "Computing centrality across %i voxels" % nvoxs i = block_size j = 0 # Calculate correlation matrix in blocks while loop while i <= nvoxs: print "running block ->", i, j try: print "...correlating" corr_matrix = np.dot(timeseries[:,j:i].T, timeseries) except: raise Exception("Error in calcuating block wise correlation for the block %i,%i"%(j,i)) if calc_eigen: print "...storing correlation matrix" r_matrix[j:i] = corr_matrix if calc_degree: if out_binarize: print "...calculating binarize degree" degree_centrality(corr_matrix, r_value, method="binarize", out=degree_binarize[j:i]) if out_weighted: print "...calculating weighted degree" degree_centrality(corr_matrix, r_value, method="weighted", out=degree_weighted[j:i]) if calc_lfcd: xyz_a = np.argwhere(template) krange = corr_matrix.shape[0] print "...iterating through seeds in block - lfcd" for k in range (0,krange): corr_seed = corr_matrix[k,:] labels = cluster_data(corr_seed,r_value,xyz_a) seed_label = labels[j+k] if out_binarize: if seed_label > 0: lfcd = np.sum(labels==seed_label) else: lfcd = 1 lfcd_binarize[j+k] = lfcd if out_weighted: if seed_label > 0: lfcd = np.sum(corr_seed*(labels==seed_label)) else: lfcd = 1 lfcd_weighted[j+k] = lfcd print "...removing temporary correlation matrix" del corr_matrix j = i if i == nvoxs: break elif (i+block_size) > nvoxs: i = nvoxs else: i += block_size # In case there are any zeros in lfcd matrix, set them to 1 if calc_lfcd: if out_binarize: lfcd_binarize[np.argwhere(lfcd_binarize == 0)] = 1 if out_weighted: lfcd_weighted[np.argwhere(lfcd_weighted == 0)] = 1 # Perform eigenvector measures if necessary try: if calc_eigen: if out_binarize: print "...calculating binarize eigenvector" eigen_binarize[:] = eigenvector_centrality(r_matrix, r_value, method="binarize").squeeze() if out_weighted: print "...calculating weighted eigenvector" eigen_weighted[:] = eigenvector_centrality(r_matrix, r_value, method="weighted").squeeze() except Exception: print "Error in calcuating eigen vector centrality" raise if calc_degree: print "...removing effect of auto-correlation on degree" degree_binarize[degree_binarize!=0] = degree_binarize[degree_binarize!=0] - 1 degree_weighted[degree_weighted!=0] = degree_weighted[degree_weighted!=0] - 1 return out_list except Exception: print "Error in calcuating Centrality" raise
def get_centrality_by_sparsity(timeseries, method_option, weight_options, threshold, memory_allocated): """ Method to calculate degree and eigen vector centrality Parameters ---------- timeseries : numpy array timeseries of the input subject method_options : string (list of boolean) list of two booleans for degree and eigen options respectively weight_options : string (list of boolean) list of two booleans for binarize and weighted options respectively threshold : float sparsity threshold for the correlation values memory_allocated : a string amount of memory allocated to degree centrality Returns ------- out_list : string (list of tuples) list of tuple containing output name to be used to store nifti image for centrality and centrality matrix Raises ------ Exception """ import os import numpy as np from CPAC.network_centrality import calc_blocksize,\ convert_sparsity_to_r,\ degree_centrality,\ eigenvector_centrality from CPAC.cwas.subdist import norm_cols out_list=[] try: # Calculate the block size (i.e., number of voxels) to compute part of the # connectivity matrix at once. # # We still use a block size to calculate the whole correlation matrix # because of issues in numpy that lead to extra memory usage when # computing the dot product. # See https://cmi.hackpad.com/Numpy-Memory-Issues-BlV9Pg5nRDM. block_size = calc_blocksize(timeseries, memory_allocated, include_full_matrix=True) nvoxs = timeseries.shape[0] ntpts = timeseries.shape[1] calc_degree = False # init degree measure flag to false calc_eigen = False # init eigen measure flag to false calc_lfcd= False # init lFCD measure flag to false # Select which method we're going to perform if method_option == 0: calc_degree = True elif method_option == 1: calc_eigen = True elif method_option == 2: calc_lfcd = True # Set weighting parameters out_binarize = weight_options[0] out_weighted = weight_options[1] corr_matrix = np.zeros((nvoxs, nvoxs), dtype = timeseries.dtype) print "Normalize TimeSeries" timeseries = norm_cols(timeseries.T) print "Computing centrality across %i voxels" % nvoxs j = 0 i = block_size while i <= timeseries.shape[1]: print "running block ->", i,j print "...correlating" np.dot(timeseries[:,j:i].T, timeseries, out=corr_matrix[j:i]) j = i if i == nvoxs: break elif (i+block_size) > nvoxs: i = nvoxs else: i += block_size print "Calculating threshold" r_value = convert_sparsity_to_r(corr_matrix, threshold, full_matrix = True) print "r_value ->", r_value if calc_degree: if out_binarize: print "...calculating binarize degree" degree_binarize = degree_centrality(corr_matrix, r_value, method="binarize") out_list.append(('degree_centrality_binarize', degree_binarize)) if out_weighted: print "...calculating weighted degree" degree_weighted = degree_centrality(corr_matrix, r_value, method="weighted") out_list.append(('degree_centrality_weighted', degree_weighted)) if calc_eigen: if out_binarize: print "...calculating binarize eigenvector" eigen_binarize = eigenvector_centrality(corr_matrix, r_value, method="binarize") out_list.append(('eigenvector_centrality_binarize', eigen_binarize)) if out_weighted: print "...calculating weighted eigenvector" eigen_weighted = eigenvector_centrality(corr_matrix, r_value, method="weighted") out_list.append(('eigenvector_centrality_weighted', eigen_weighted)) except Exception: print "Error while calculating centrality" raise return out_list