def extract_features(g, method='None'): """ Extract features from each node of graph g. :param g: adjacency matrix of g :param method: specifies what features to extract :return: feature for each node """ feat = list(clustering_coef_wu(g)) feat = feat + list(eigenvector_centrality_und(g)) feat = feat + list(g.sum(axis=0)) feat.append(assortativity_wei(g)) return feat
def do_opt(adj,mods,option): if option=='global efficiency': return bct.efficiency_wei(adj) elif option=='local efficiency': return bct.efficiency_wei(adj,local=True) elif option=='average strength': return bct.strengths_und(adj) elif option=='clustering coefficient': return bct.clustering_coef_wu(adj) elif option=='eigenvector centrality': return bct.eigenvector_centrality_und(adj) elif option=='binary kcore': return bct.kcoreness_centrality_bu(adj)[0] elif option=='modularity': return bct.modularity_und(adj,mods)[1] elif option=='participation coefficient': return bct.participation_coef(adj,mods) elif option=='within-module degree': return bct.module_degree_zscore(adj,mods)
def do_opt(adj, mods, option): if option == 'global efficiency': return bct.efficiency_wei(adj) elif option == 'local efficiency': return bct.efficiency_wei(adj, local=True) elif option == 'average strength': return bct.strengths_und(adj) elif option == 'clustering coefficient': return bct.clustering_coef_wu(adj) elif option == 'eigenvector centrality': return bct.eigenvector_centrality_und(adj) elif option == 'binary kcore': return bct.kcoreness_centrality_bu(adj)[0] elif option == 'modularity': return bct.modularity_und(adj, mods)[1] elif option == 'participation coefficient': return bct.participation_coef(adj, mods) elif option == 'within-module degree': return bct.module_degree_zscore(adj, mods)
def get_true_network_metrics(A): #control centrality c_c = control_centrality(A) cc_fake = np.zeros((100, 1)) for i in range(0, 100): cc_fake[i] = np.mean(control_centrality(generate_fake_graph(A))) m_cc_fake = np.mean(cc_fake) cc_norm = c_c / m_cc_fake # Get identity of node with lowest control centrality min_cc_true = np.where(c_c == np.amin(c_c))[0] # get synchronizability sync = synchronizability(A) # normalized sync sync_fake = np.zeros((100, 1)) for i in range(0, 100): sync_fake[i] = synchronizability(generate_fake_graph(A)) m_sync_fake = np.mean(sync_fake) sync_norm = sync / m_sync_fake # get betweeness centrality bc = betweenness_centrality(A) bc_fake = np.zeros((100, 1)) for i in range(0, 100): bc_fake[i] = np.mean(betweenness_centrality(generate_fake_graph(A))) m_bc_fake = np.mean(bc_fake) bc_norm = bc / m_bc_fake # Get identity of node with max bc max_bc_true = np.where(bc == np.amax(bc))[0] # get eigenvector centrality ec = bct.eigenvector_centrality_und(A) ec_fake = np.zeros((100, 1)) for i in range(0, 100): ec_fake[i] = np.mean( bct.eigenvector_centrality_und(generate_fake_graph(A))) m_ec_fake = np.mean(ec_fake) ec_norm = ec / m_ec_fake # Get identity of node with max ec max_ec_true = np.where(ec == np.amax(ec))[0] # get edge betweeness centrality edge_bc, ignore = bct.edge_betweenness_wei(A) edge_bc_fake = np.zeros((100, 1)) for i in range(0, 100): edge_bc_fake[i] = np.mean( bct.edge_betweenness_wei(generate_fake_graph(A))[0]) m_edge_bc_fake = np.mean(edge_bc_fake) edge_bc_norm = edge_bc / m_edge_bc_fake # get clustering coeff clust = bct.clustering_coef_wu(A) clust_fake = np.zeros((100, 1)) for i in range(0, 100): clust_fake[i] = np.mean(bct.clustering_coef_wu(generate_fake_graph(A))) m_clust_fake = np.mean(clust_fake) clust_norm = clust / m_clust_fake # Get identity of node with max clust max_clust_true = np.where(clust == np.amax(clust))[0] # get node strength ns = node_strength(A) ns_fake = np.zeros((100, 1)) for i in range(0, 100): ns_fake[i] = np.mean(node_strength(generate_fake_graph(A))) m_ns_fake = np.mean(ns_fake) ns_norm = ns / m_ns_fake # Get identity of node with max clust max_ns_true = np.where(ns == np.amax(ns))[0] #Get true efficiency Ci, ignore = bct.modularity_und(A) par = bct.participation_coef(A, Ci) eff = bct.efficiency_wei(A, 0) eff_fake = np.zeros((100, 1)) for i in range(0, 100): eff_fake[i] = (bct.efficiency_wei(generate_fake_graph(A))) m_eff_fake = np.mean(eff_fake) eff_norm = eff / m_eff_fake # Get true transistivity trans = bct.transitivity_wu(A) trans_fake = np.zeros((100, 1)) for i in range(0, 100): trans_fake[i] = (bct.transitivity_wu(generate_fake_graph(A))) m_trans_fake = np.mean(trans_fake) trans_norm = trans / m_trans_fake # store output results in a dictionary #nodal results = {} results['control_centrality'] = c_c results['control_centrality_norm'] = cc_norm results['min_cc_node'] = min_cc_true # global measure results['sync'] = sync results['sync_norm'] = sync_norm # nodal results['bc'] = bc results['bc_norm'] = bc_norm results['max_bc_node'] = max_bc_true # nodal results['ec'] = ec results['ec_norm'] = ec_norm results['max_ec_node'] = max_ec_true # nodal results['clust'] = clust results['clust_norm'] = clust_norm results['max_clust_node'] = max_clust_true # nodal results['ns'] = ns results['ns_norm'] = ns_norm results['max_ns_node'] = max_ns_true # global results['eff'] = eff results['eff_norm'] = eff_norm # global results['trans'] = trans results['trans_norm'] = trans_norm # nodal results['par'] = par # edge results['edge_bc'] = edge_bc results['edge_bc_norm'] = edge_bc_norm return (results)
scores_all = dict() for toi in tois: cls_all = [] pln_all = [] for subject in subjects: cls = np.load(source_folder + "graph_data/%s_classic_corr_%s_orth.npy" % (subject, toi)) pln = np.load(source_folder + "graph_data/%s_plan_corr_%s_orth.npy" % (subject, toi)) cls_all.append(cls.mean(axis=0)) pln_all.append(pln.mean(axis=0)) data_cls = np.asarray([bct.eigenvector_centrality_und(g) for g in cls_all]) data_pln = np.asarray([bct.eigenvector_centrality_und(g) for g in pln_all]) X = np.vstack([data_cls, data_pln]) y = np.concatenate([np.zeros(len(data_cls)), np.ones(len(data_pln))]) cv = StratifiedKFold(n_splits=6, shuffle=True) cv_params = { "learning_rate": np.arange(0.1, 1.1, 0.1), 'n_estimators': np.arange(1, 80, 2) } grid = GridSearchCV(
from jumeg.connectivity import plot_degree_circle, plot_lines_and_blobs import matplotlib.pyplot as plt orig_labels_fname = get_jumeg_path() + '/data/desikan_label_names.yaml' yaml_fname = get_jumeg_path( ) + '/data/desikan_aparc_cortex_based_grouping.yaml' con_fname = get_jumeg_path() + '/data/sample,aparc-con.npy' # real connectivity con = np.load(con_fname) con = con[0, :, :, 2] + con[0, :, :, 2].T degrees = mne.connectivity.degree(con, threshold=0.2) import bct eigenvec_centrality = bct.eigenvector_centrality_und(con) fig, ax = plot_lines_and_blobs(con, degrees, yaml_fname, orig_labels_fname, figsize=(8, 8), show_node_labels=False, show_group_labels=True, n_lines=100, out_fname=None, degsize=10) ax.set_title('Eigen vector centrality: Coh,alpha') fig.tight_layout() # test connections
def centrality(self, sbj_number, nodes_number, atlas, make_symmetric=True, upper_threshold=None, lower_threshold=None, binarize=False): ''' Computing centrality measures of the adjencency matrix Parameters ---------- sbj_number: int | number of subjects nodes_number: int| number of nodes atlas: excel file | please se example available in the repo (e.g. new_atlas_coords.xlsx) make_symmetric: Boolean| True indicate that the matrix is either upper or lower triangular and need to be symmetrize False indicate that the matrix is a full matrix already upper_threshold: int | an integer value ranging from 0 to 100 representing the percentage of values as respect to maximum. The value under that threshold will be 0 (Default is None) lower_threshold: int | an integer value ranging from 0 to 100 representing the percentage of values as respect to maximum. The value above that threshold will be 0 (Default is None) binarize= Boolean| True will make the connectivity matrix binary Default is False Returns ------- dict: : dictonary with the following keys | edge_betweeness_bin: | np.ndarray Edge betweenness centrality is the fraction of all shortest paths in the network that contain a given edge. Edges with high values of betweenness centrality participate in a large number of shortest paths. It will return node betweenness centrality vector. edge_betweeness_wei: | np.ndarray Edge betweenness centrality is the fraction of all shortest paths in the network that contain a given edge. Edges with high values of betweenness centrality participate in a large number of shortest paths. It will return node betweenness centrality vector. eigenvector_centrality_und: | np.ndarray Eigenector centrality is a self-referential measure of centrality: nodes have high eigenvector centrality if they connect to other nodes that have high eigenvector centrality. The eigenvector centrality of node i is equivalent to the ith element in the eigenvector corresponding to the largest eigenvalue of the adjacency matrix. It will return the eigenvector associated with the largest eigenvalue of the matrix coreness_kcoreness_centrality_bu: | np.ndarray The k-core is the largest subgraph comprising nodes of degree at least k. The coreness of a node is k if the node belongs to the k-core but not to the (k+1)-core. This function computes the coreness of all nodes for a given binary undirected connection matrix. It will return the node coreness. kn_kcoreness_centrality_bu: | np.ndarray The k-core is the largest subgraph comprising nodes of degree at least k. The coreness of a node is k if the node belongs to the k-core but not to the (k+1)-core. This function computes the coreness of all nodes for a given binary undirected connection matrix. It will return the size of k-core module_degree_zscore: | np.ndarray The within-module degree z-score is a within-module version of degree centrality. It will return within-module degree Z-score participation_coef: | np.ndarray Participation coefficient is a measure of diversity of intermodular connections of individual nodes. It will return the participation coefficient subgraph_centrality: | np.ndarray The subgraph centrality of a node is a weighted sum of closed walks of different lengths in the network starting and ending at the node. This function returns a vector of subgraph centralities for each node of the network. It will return the subgraph centrality ''' with open(self.net_label_txt) as f: net = f.read().splitlines() self.atlas = pd.read_excel(atlas, header=None) self.atlas = np.array(self.atlas) self.ci_original = self.atlas[:, 8] self.centrality = { "edge_betweeness_bin": np.zeros([sbj_number, nodes_number]), "edge_betweeness_wei": np.zeros([sbj_number, nodes_number]), "eigenvector_centrality_und": np.zeros([sbj_number, nodes_number]), "coreness_kcoreness_centrality_bu": np.zeros([sbj_number, nodes_number]), "kn_kcoreness_centrality_bu": np.zeros([sbj_number, nodes_number]), "module_degree_zscore": np.zeros([sbj_number, nodes_number]), "participation_coef": np.zeros([sbj_number, nodes_number]), "subgraph_centrality": np.zeros([sbj_number, nodes_number]) } for subj in range(len(self.matrices_files)): self.matrix = pd.read_csv(self.matrices_files[subj], sep=' ', header=None) self.matrix = np.array(self.matrix) if make_symmetric == True: self.matrix = self.matrix + self.matrix.T - np.diag( self.matrix.diagonal()) else: self.matrix = self.matrix self.max = np.max(self.matrix.flatten()) if upper_threshold == None: self.matrix = self.matrix else: self.matrix[self.matrix < upper_threshold * self.max / 100] = 0 if lower_threshold == None: self.matrix = self.matrix else: self.matrix[self.matrix > lower_threshold * self.max / 100] = 0 self.matrix_bin = bct.algorithms.binarize(self.matrix) self.matrix_weight = self.matrix if binarize == True: self.matrix = bct.algorithms.binarize(self.matrix) else: self.matrix = self.matrix np.fill_diagonal(self.matrix, 0) np.fill_diagonal(self.matrix_bin, 0) np.fill_diagonal(self.matrix_weight, 0) self.BC = bct.betweenness_bin(self.matrix_bin) self.centrality['edge_betweeness_bin'][subj] = self.BC self.BC_w = bct.betweenness_wei(self.matrix_weight) self.centrality['edge_betweeness_wei'][subj] = self.BC_w self.v = bct.eigenvector_centrality_und(self.matrix) self.centrality['eigenvector_centrality_und'][subj] = self.v self.coreness, self.kn = bct.kcoreness_centrality_bu( self.matrix_bin) self.centrality['coreness_kcoreness_centrality_bu'][ subj] = self.coreness self.centrality['kn_kcoreness_centrality_bu'][subj] = self.kn self.Z = bct.module_degree_zscore(self.matrix, ci=self.ci_original) self.centrality['module_degree_zscore'][subj] = self.Z self.P = bct.participation_coef(self.matrix, ci=self.ci_original) self.centrality['participation_coef'][subj] = self.P self.Cs = bct.subgraph_centrality(self.matrix_bin) self.centrality['subgraph_centrality'][subj] = self.Cs return self.centrality
for toi in tois: cls_all = [] pln_all = [] for subject in subjects: cls = np.load(source_folder + "graph_data/%s_classic_corr_%s_orth.npy" % (subject, toi)) pln = np.load(source_folder + "graph_data/%s_plan_corr_%s_orth.npy" % (subject, toi)) cls_all.append(cls.mean(axis=0)) pln_all.append(pln.mean(axis=0)) data_cls = np.asarray( [bct.eigenvector_centrality_und(g) for g in cls_all]) data_pln = np.asarray( [bct.eigenvector_centrality_und(g) for g in pln_all]) X = np.vstack([data_cls, data_pln]) y = np.concatenate([np.zeros(len(data_cls)), np.ones(len(data_pln))]) cv = StratifiedKFold(n_splits=6, shuffle=True) cv_params = { "learning_rate": np.arange(0.1, 1.1, 0.1), 'n_estimators': np.arange(1, 80, 2) } grid = GridSearchCV(AdaBoostClassifier(), cv_params,
for subject in subjects: cls = np.load(source_folder + "graph_data/%s_classic_pow_pln.npy" % subject).item() pln = np.load(source_folder + "graph_data/%s_plan_pow_pln.npy" % subject).item() cls_all.append(cls) pln_all.append(pln) for k, band in enumerate(bands.keys()): data_cls = [] for j in range(len(cls_all)): tmp = cls_all[j][band] data_cls.append(np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_pln = [] for j in range(len(pln_all)): tmp = pln_all[j][band] data_pln.append(np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_cls = np.asarray(data_cls) data_pln = np.asarray(data_pln) X = np.vstack([data_cls, data_pln]) y = np.concatenate([np.zeros(len(data_cls)), np.ones(len(data_pln))]) cv = StratifiedShuffleSplit(y, test_size=0.1)
for subject in subjects: cls = np.load(source_folder + "graph_data/%s_classic_pow_post.npy" % subject).item() pln = np.load(source_folder + "graph_data/%s_plan_pow_post.npy" % subject).item() cls_all.append(cls) pln_all.append(pln) for k, band in enumerate(bands.keys()): data_cls = [] for j in range(len(cls_all)): tmp = cls_all[j][band] data_cls.append( np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_pln = [] for j in range(len(pln_all)): tmp = pln_all[j][band] data_pln.append( np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_cls = np.asarray(data_cls) data_pln = np.asarray(data_pln) X = np.vstack([data_cls, data_pln]) y = np.concatenate([np.zeros(len(data_cls)), np.ones(len(data_pln))]) cv = StratifiedKFold(y, n_folds=6, shuffle=True)
def nodal_degree_vulnerability(self, sbj_number, nodes_number, make_symmetric=True, binarize=False, threshold=None, recalculate=False, attack_type='target', metric2use='degree'): ''' Performs robustness analysis based on nodal degree. Parameters ---------- sbj_number: int | number of subjects nodes_number: int| number of nodes make_symmetric: Boolean| True indicate that the matrix is either upper or lower triangular and need to be symmetrize False indicate that the matrix is a full matrix already binarize: Boolean| True will make the connectivity matrix binary Default is False recalculate: Boolean| It will use sequential (recalculate = True) or simultaneous (recalculate = False) approach. Default is False attack_type: str | It can be either 'target' or 'random' Returns ------- vulnerability: np.array | The overall vulnerability of the network ''' self.all_vulnerability = np.zeros([sbj_number]) self.all_x = np.zeros([sbj_number, nodes_number]) self.all_y = np.zeros([sbj_number, nodes_number]) self.all_largest_comp = np.zeros([sbj_number, nodes_number]) for subj in range(len(self.matrices_files)): self.matrix = pd.read_csv(self.matrices_files[subj], sep=' ', header=None) self.matrix = np.array(self.matrix) if make_symmetric == True: self.matrix = self.matrix + self.matrix.T - np.diag( self.matrix.diagonal()) else: self.matrix = self.matrix if binarize == True: self.matrix = bct.algorithms.binarize(self.matrix) else: self.matrix = self.matrix if threshold == None: self.matrix = self.matrix else: self.matrix[self.matrix < threshold * np.max(self.matrix.flatten()) / 100] = 0 np.fill_diagonal(self.matrix, 0) if attack_type == 'target': if metric2use == 'degree': self.deg = bct.algorithms.degrees_und(self.matrix) elif metric2use == 'eigenvector_centrality': self.deg = bct.eigenvector_centrality_und(self.matrix) elif metric2use == 'betweenness_bin': self.deg = bct.betweenness_bin(self.matrix) elif metric2use == 'betweenness_wei': self.deg = bct.betweenness_wei(self.matrix) self.g = networkx.convert_matrix.from_numpy_array(self.matrix) self.m = dict(enumerate(self.deg.flatten(), 0)) self.l = sorted(self.m.items(), key=operator.itemgetter(1), reverse=True) self.x = [] self.y = [] self.lcomp = [] self.largest_component = max(networkx.connected_components( self.g), key=len) self.n = len(self.g.nodes()) self.x.append(0) self.y.append(len(self.largest_component) * 1. / self.n) self.lcomp.append(len(self.largest_component)) self.R = 0.0 for i in range(1, self.n): self.g.remove_node(self.l.pop(0)[0]) if recalculate: self.matrix = networkx.convert_matrix.to_numpy_array( self.g) self.g = networkx.convert_matrix.from_numpy_array( self.matrix) if metric2use == 'degree': self.deg = bct.algorithms.degrees_und(self.matrix) elif metric2use == 'eigenvector_centrality': self.deg = bct.eigenvector_centrality_und( self.matrix) elif metric2use == 'betweenness_bin': self.deg = bct.betweenness_bin(self.matrix) elif metric2use == 'betweenness_wei': self.deg = bct.betweenness_wei(self.matrix) self.m = dict(enumerate(self.deg.flatten(), 0)) self.l = sorted(self.m.items(), key=operator.itemgetter(1), reverse=True) self.largest_component = max(networkx.connected_components( self.g), key=len) self.x.append(i * 1. / self.n) self.R += len(self.largest_component) * 1. / self.n self.y.append(len(self.largest_component) * 1. / self.n) self.lcomp.append(len(self.largest_component)) elif attack_type == 'random': self.g = networkx.convert_matrix.from_numpy_array(self.matrix) self.l = [(self.node, 0) for self.node in self.g.nodes()] random.shuffle(self.l) self.x = [] self.y = [] self.lcomp = [] self.largest_component = max(networkx.connected_components( self.g), key=len) self.n = len(self.g.nodes()) self.x.append(0) self.y.append(len(self.largest_component) * 1. / self.n) self.lcomp.append(len(self.largest_component)) self.R = 0.0 for i in range(1, self.n): self.g.remove_node(self.l.pop(0)[0]) self.largest_component = max(networkx.connected_components( self.g), key=len) self.x.append(i * 1. / self.n) self.R += len(self.largest_component) * 1. / self.n self.y.append(len(self.largest_component) * 1. / self.n) self.lcomp.append(len(self.largest_component)) self.all_x[subj] = np.array(self.x) self.all_y[subj] = np.array(self.y) self.all_vulnerability[subj] = np.array(0.5 - self.R / self.n) self.all_largest_comp[subj] = np.array(self.lcomp) return self.all_vulnerability, self.all_x, self.all_y, self.all_largest_comp
def load_network(kind, parcel, data="lau", weights='log', hemi="both", version=1, subset="all", path=None): ''' Function to load a dictionary containing information about the specified brain network. Parameters ---------- kind : string Either 'SC' or 'FC'. hemi : string Either "both", "L" or "R". weights " string The weights of the edges. The options "normal", "log" or "binary". The default is "log". data : string Either "HCP" or "lau". parcel : string Either "68", "114", ... [if 'lau'] / "s400", "s800" [if "HCP"] version : int Version of the network. subset : string Either 'discov', 'valid' or 'all' path : string path to the "data" folder in which the data will be stored. If none, then assumes that path is current folder. Returns ------- Network : dictionary Dictionary storing relevant attributes about the network ''' # Initialize dictionary + store basic information about the network Network = {} Network["info"] = {} Network["info"]["kind"] = kind Network["info"]["parcel"] = parcel Network["info"]["data"] = data Network["info"]["hemi"] = hemi Network["info"]["weights"] = weights Network["info"]["version"] = version Network["info"]["subset"] = subset # Modify parameter names to what they are in file names version = '' if version == 1 else '_v' + str(version) subset = '' if subset == 'all' else subset hemi = '' if hemi == 'both' else hemi # Store important paths for loading the relevant data main_path = path + "/brainNetworks/" + data + "/" network_path = (main_path + "matrices/consensus/" + subset + kind + parcel + hemi + version + "/") matrix_path = network_path + "/" + weights # Store general information about the network's parcellation parcel_info = get_general_parcellation_info(parcel) Network['order'] = parcel_info[0] Network['noplot'] = parcel_info[1] Network['lhannot'] = parcel_info[2] Network['rhannot'] = parcel_info[3] Network['atlas'] = parcel_info[4] # Load the cammoun_id of the parcellation, if Cammoun (i.e. 033, 060, etc.) if parcel[0] != 's': Network['cammoun_id'] = parcel_to_n(parcel) # masks masks = get_node_masks(Network, path=main_path) Network['node_mask'] = masks[0] Network['hemi_mask'] = masks[1] Network['subcortex_mask'] = masks[2] # hemisphere Network['hemi'] = get_hemi(Network, path=main_path) # coordinates Network['coords'] = get_coordinates(Network, path=main_path) # Adjacency matrix Network['adj'], last_modified = get_adjacency(Network, matrix_path, minimal_processing=True, return_last_modified=True) # Test whether the network is connected. Raise a warning if not... if not np.all(bct.reachdist(Network['adj'])[0]): warnings.warn(("This brain network appears to be disconnected. This " "might cause problem for the computation of the other " "measures")) # node strength Network["str"] = np.sum(Network['adj'], axis=0) # Inverse of adjacency matrix inv = Network['adj'].copy() inv[Network['adj'] > 0] = 1 / inv[Network['adj'] > 0] Network["inv_adj"] = inv # distance Network["dist"] = cdist(Network["coords"], Network["coords"]) # clustering coefficient Network["cc"] = bct.clustering_coef_wu(Network['adj']) # shortest path Network['sp'] = get_shortest_path(Network, matrix_path=matrix_path, last_modified=last_modified) # diffusion embedding de = compute_diffusion_map(Network['adj'], n_components=10, return_result=True, skip_checks=True) Network["de"] = de[0] Network["de_extra"] = de[1] # Principal components Network['PCs'], Network['PCs_ev'] = getPCs(Network['adj']) # eigenvector centrality Network["ec"] = bct.eigenvector_centrality_und(Network['adj']) # mean first passage time Network["mfpt"] = bct.mean_first_passage_time(Network['adj']) # betweenness centrality Network['bc'] = get_betweenness(Network, matrix_path=matrix_path, last_modified=last_modified) # routing efficiency Network["r_eff"] = efficiency(Network) # diffusion efficiency Network["d_eff"] = efficiency_diffusion(Network) # subgraph centrality Network["subc"] = bct.subgraph_centrality(Network["adj"]) # closeness centrality Network['clo'] = 1 / np.mean(Network['sp'], axis=0) # communities + participation coefficient path = matrix_path + "/communities/" if os.path.exists(path): files = [] for i in os.listdir(path): if os.path.isfile(os.path.join(path, i)) and 'ci_' in i: files.append(i) if len(files) > 0: Network["ci"] = [] for file in files: Network["ci"].append(np.load(os.path.join(path, file))) Network["ppc"] = [] for i in range(len(files)): ppc = bct.participation_coef(Network['adj'], Network["ci"][i]) Network["ppc"].append(ppc) # Edge lengths if (data == "HCP") and (kind == "SC"): path = main_path + "matrices/" + subset + kind + parcel + hemi + "_lengths.npy" if os.path.exists(path): Network["lengths"] = np.load(path) # streamline connection lengths path = network_path + "/len.npy" if os.path.exists(path): Network['len'] = np.load(path) # ROI names if parcel[0] != "s": Network['ROInames'] = get_ROInames(Network) # geodesic distances between nodes if parcel[0] == "s": n = parcel[1:] fname_l = n + "Parcels7Networks_lh_dist.csv" fname_r = n + "Parcels7Networks_rh_dist.csv" else: fname_l = "scale" + Network['cammoun_id'] + "_lh_dist.csv" fname_r = "scale" + Network['cammoun_id'] + "_rh_dist.csv" Network['geo_dist_L'] = pd.read_csv(main_path + "/geodesic/medial/" + fname_l, header=None).values Network['geo_dist_R'] = pd.read_csv(main_path + "/geodesic/medial/" + fname_r, header=None).values return Network
for subject in subjects: cls = np.load(source_folder + "graph_data/%s_classic_pow_pre.npy" % subject).item() pln = np.load(source_folder + "graph_data/%s_plan_pow_pre.npy" % subject).item() cls_all.append(cls) pln_all.append(pln) for k, band in enumerate(bands.keys()): data_cls = [] for j in range(len(cls_all)): tmp = cls_all[j][band] data_cls.append( np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_pln = [] for j in range(len(pln_all)): tmp = pln_all[j][band] data_pln.append( np.asarray([bct.eigenvector_centrality_und(g) for g in tmp]).mean(axis=0)) data_cls = np.asarray(data_cls) data_pln = np.asarray(data_pln) X = np.vstack([data_cls, data_pln]) y = np.concatenate([np.zeros(len(data_cls)), np.ones(len(data_pln))]) cv = StratifiedKFold(y, n_folds=6, shuffle=True)
def ec(self): """eigenvector centrality""" return bct.eigenvector_centrality_und(self.adj)
def process(data): return bct.eigenvector_centrality_und(data)
def calc_graph_vector(filename, thresholds) : ''' This function calculates graph measures for connectivity matrix loaded from textfile and save results under the same name with additional superscript +'_GV' (in same dir filename is located) Input arguments: filename(str): name of file containing connectivity matrix (txt extension) thresholds(list): list containing thresholds of interest # Kamil Bonna, 14.08.2018 ''' #--- check inputs import os if not os.path.exists(filename): raise Exception('{} does not exist'.format(filename)) if type(thresholds) != list: raise Exception('thresholds should be a list!') import numpy as np import bct #=== inner variables N_rep_louvain = 10 # number of Louvain algorithm repetitions N_measures = 10 # number of graph measures gamma = 1 # Louvain resolution parameter #--- load matrix A_raw = np.loadtxt(filename) N = A_raw.shape[0] # number of nodes M_sat = N*(N-1)/2 # max number of connections #=== calculate output graph_measures = np.zeros([ len(thresholds), N_measures ]) # create empty output matrix for thr in range(len(thresholds)) : #--- thresholding A = bct.threshold_proportional( A_raw, p=thresholds[thr], copy=True ); A[np.nonzero(A<0)] = 0 # ensure only positive weights M_act = A[np.nonzero(A>0)].shape[0] / 2 # actual number of nonzero connections #--- calculate measures #-- mean connection strenght S = np.sum(A)/M_act #-- connection strenght std Svar = np.std(A[np.nonzero(A)]) #-- modularity [M,Q] = bct.modularity_louvain_und(A, gamma) for i in range(N_rep_louvain) : [Mt,Qt] = bct.modularity_louvain_und(A, gamma) if Qt > Q : Q = Qt M = Mt #-- participation coefficient P = np.mean(bct.participation_coef_sign(A, M)) #-- clustering C = np.mean(bct.clustering_coef_wu(A)) #-- transitivity T = bct.transitivity_wu(A) #-- assortativity Asso = bct.assortativity_wei(A) #-- global & local efficiency Eglo = bct.efficiency_wei(A) Eloc = np.mean(bct.efficiency_wei(A, local=True)) #-- mean eigenvector centralit Eig = np.mean(bct.eigenvector_centrality_und(A)) #--- write vector to matrix graph_measures[thr] = [ S, Svar, Q, P, C, T, Asso, Eglo, Eloc, Eig ] #=== save results to file np.savetxt( filename[:-4]+'_GV.txt', graph_measures )