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 modularity_and_efficiency(data):
mod_scores = []
eff_scores = []
for i, x in enumerate(data):
matrix = mp.preprocess_matrix(x)
mod_score = bct.modularity_und(matrix)[1]
eff_score = bct.efficiency_wei(matrix)
mod_scores.append(mod_score)
eff_scores.append(eff_score)
return mod_scores, eff_scores
def extract_epoch_graph_features(W):
import bct
L = bct.weight_conversion(W, "lengths")
L[W == 0] = np.inf
D, _ = bct.distance_wei(L)
l, eff, ecc, radius, diameter = bct.charpath(D, include_infinite=False)
return [
bct.clustering_coef_wu(W),
bct.efficiency_wei(W, local=True),
bct.betweenness_wei(L),
ecc,
[l, eff, radius, diameter],
]
def generate_null(layout, task, session, mask):
null_dist = pd.DataFrame(index=subjects, columns=["mean", "sdev"])
avg_corr = avg_corrmat(layout, task, session, mask)
eff_perm = []
j = 1
while j < 3:
effs = []
W = null_model_und_sign(avg_corr.values)
for thresh in np.arange(0.21, 0.31, 0.03):
thresh_corr = bct.threshold_proportional(W, thresh)
leff = bct.efficiency_wei(thresh_corr)
effs.append(leff)
effs_arr = np.asarray(effs)
leff_auc = np.trapz(effs_arr, dx=0.03, axis=0)
eff_perm.append(leff_auc)
j += 1
null_dist.at[(sesh[session], task, conds[i], mask),
"mean"] = np.mean(eff_perm)
null_dist.at[(sesh[session], task, conds[i], mask),
"sdev"] = np.std(eff_perm)
return null_dist
nb_trials = 100
N = 200
k = 4
# Pre-allocate arrays
prob = 10**(-3 * np.random.random(nb_trials))
SWI = np.zeros(nb_trials)
Eglob = np.zeros(nb_trials)
Eloc = np.zeros(nb_trials)
# Calculate statistics
for i, p in enumerate(prob):
CIJ = NetworkWattsStrogatz(N, k, p)
SWI[i] = SmallWorldIndex(CIJ)
Eglob[i] = bct.efficiency_wei(CIJ, local=False)
Eloc[i] = np.mean(bct.efficiency_wei(CIJ, local=True))
# Plot figures
plt.figure(1)
plt.semilogx(prob, SWI, marker='.', linestyle='none')
plt.xlabel('Rewiring probability')
plt.ylabel('Small World Index')
plt.figure(2)
plt.subplot(211)
plt.semilogx(prob, Eglob, marker='.', linestyle='none')
plt.xlabel('Rewiring probability')
plt.ylabel('Global efficiency')
plt.subplot(212)
plt.semilogx(prob, Eloc, marker='.', linestyle='none')
participants = ['c1','c2','c3','c5','c6','c7','c8']
all_measures = np.empty(shape=[68,len(participants),5])
adjmats = np.empty(shape=[68,68,len(participants)])
counter = 0
for participant in participants:
adjmat = sio.loadmat(participant + '_FA.mat')
adjmat = adjmat['adjacency_matrix']
labels = get_parcellation_labels(generate_ROI_file(FreeSurfer_ROI_file)).values
labels,adjmat = remove_non_cortical_ROIs(labels,adjmat)
all_measures[:,counter,0] = bct.degrees_und(adjmat)
all_measures[:,counter,1] = bct.strengths_und(adjmat)
all_measures[:,counter,2] = bct.clustering_coef_wu(adjmat)
all_measures[:,counter,3] = bct.betweenness_wei(adjmat)
all_measures[:,counter,4] = bct.efficiency_wei(adjmat,local=True)
adjmats[:,:,counter] = adjmat
counter += 1
mean_measures = np.mean(all_measures,axis=1)
if group == 'patient':
patient = pd.DataFrame(mean_measures, index=labels,columns=['patient.NodeDegree','patient.Strength','patient.ClustCoeff','patient.BetweenCent','patient.LocEff'])
patient_measures = all_measures
patient_adjmats = adjmats
elif group == 'control':
control = pd.DataFrame(mean_measures, index=labels,columns=['control.NodeDegree','control.Strength','control.ClustCoeff','control.BetweenCent','control.LocEff'])
control_measures = all_measures
control_adjmats = adjmats
# Getting the expression values
all_measures = np.empty(shape=[68, len(participants), 5])
adjmats = np.empty(shape=[68, 68, len(participants)])
counter = 0
for participant in participants:
adjmat = sio.loadmat(participant + '_FA.mat')
adjmat = adjmat['adjacency_matrix']
labels = get_parcellation_labels(
generate_ROI_file(FreeSurfer_ROI_file)).values
labels, adjmat = remove_non_cortical_ROIs(labels, adjmat)
all_measures[:, counter, 0] = bct.degrees_und(adjmat)
all_measures[:, counter, 1] = bct.strengths_und(adjmat)
all_measures[:, counter, 2] = bct.clustering_coef_wu(adjmat)
all_measures[:, counter, 3] = bct.betweenness_wei(adjmat)
all_measures[:, counter, 4] = bct.efficiency_wei(adjmat, local=True)
adjmats[:, :, counter] = adjmat
counter += 1
mean_measures = np.mean(all_measures, axis=1)
if group == 'patient':
patient = pd.DataFrame(mean_measures,
index=labels,
columns=[
'patient.NodeDegree', 'patient.Strength',
'patient.ClustCoeff', 'patient.BetweenCent',
'patient.LocEff'
])
patient_measures = all_measures
patient_adjmats = adjmats
elif group == 'control':
#steps of 5 or 10 percent
#citation for integrating over the range is likely in the Fundamentals of Brain Network Analysis book
#(http://www.danisbassett.com/uploads/1/1/8/5/11852336/network_analysis_i__ii.pdf)
#typically done: make sure your metric's value is stable across your range of thresholds
#the more metrics you use, the more you have to correct for multiple comparisons
#make sure this is hypothesis-driven and not fishing
for p in thresh_range:
ge = []
cc = []
ntwk_corrmat_thresh = bct.threshold_proportional(
network_correlation_matrix, p, copy=True)
#np.savetxt(join(sink_dir, sessions[i], s, '{0}_corrmat_Laird2011_thresh_{1}.csv'.format(s, p)), ntwk_corrmat_thresh, delimiter=',')
#measures of interest here
#global efficiency
le = bct.efficiency_wei(ntwk_corrmat_thresh)
ge.append(le)
#clustering coefficient
c = bct.clustering_coef_wu(ntwk_corrmat_thresh)
cc.append(c)
network[p] = ge
network_wise[p] = cc
ntwk_df = pd.Series(network).T
#ntwk_df.columns = ['total positive', 'total negative', 'efficiency', 'path length', 'modularity']
ntwk_wise_df = pd.Series(network_wise).T
#ntwk_wise_df.columns = ['betweenness', 'degree', 'positive weights', 'negative weights',
# 'community index', 'clustering coefficient']
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.efficiency_wei(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.efficiency_wei(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)
cv_params = {
def threshold_omst_global_cost_efficiency(mtx, n_msts=None):
""" Threshold a graph by optimizing the formula GE-C via orthogonal MSTs.
.. [Dimitriadis2017a] Dimitriadis, S. I., Salis, C., Tarnanas, I., & Linden, D. E. (2017). Topological Filtering of Dynamic Functional Brain Networks Unfolds Informative Chronnectomics: A Novel Data-Driven Thresholding Scheme Based on Orthogonal Minimal Spanning Trees (OMSTs). Frontiers in neuroinformatics, 11.
.. [Dimitriadis2017n] Dimitriadis, S. I., Antonakakis, M., Simos, P., Fletcher, J. M., & Papanicolaou, A. C. (2017). Data-driven Topological Filtering based on Orthogonal Minimal Spanning Trees: Application to Multi-Group MEG Resting-State Connectivity. Brain Connectivity, (ja).
.. [Basset2009] Bassett, D. S., Bullmore, E. T., Meyer-Lindenberg, A., Apud, J. A., Weinberger, D. R., & Coppola, R. (2009). Cognitive fitness of cost-efficient brain functional networks. Proceedings of the National Academy of Sciences, 106(28), 11747-11752.
Parameters
----------
mtx : array-like, shape(N, N)
Symmetric, weighted and undirected connectivity matrix.
n_msts : int or None
Maximum number of OMSTs to compute. Default `None`; an exhaustive
computation will be performed.
Returns
-------
nCIJtree : array-like, shape(n_msts, N, N)
A matrix containing all the orthogonal MSTs.
CIJtree : array-like, shape(N, N)
Resulting graph.
degree : float
The mean degree of the resulting graph.
global_eff : float
Global efficiency of the resulting graph.
global_cost_eff_max : float
The value where global efficiency - cost is maximized.
cost_max : float
Cost of the network at the maximum global cost efficiency.
"""
imtx = np.copy(mtx)
imtx_uptril = np.copy(mtx)
N, _ = np.shape(imtx)
for k in range(N):
for l in range(k + 1, N):
imtx_uptril[l, k] = 0.0
np.fill_diagonal(imtx_uptril, 0.0)
# Find the number of orthogonal msts according to the desired mean degree
num_edges = len(np.where(imtx > 0.0)[0])
if n_msts is None:
num_msts = np.round(num_edges / (N - 1)) + 1
else:
num_msts = n_msts
pos_num_msts = np.round(num_edges / (N - 1))
if num_msts > pos_num_msts:
num_msts = pos_num_msts
CIJnotintree = imtx
# Keep the N-1 connections of the num_msts MSTs
num_msts = np.int32(num_msts)
mst_conn = np.zeros((num_msts * (N - 1), 2))
nCIJtree = np.zeros((num_msts, N, N)) #, dtype=np.int32)
omst = np.zeros((num_msts, N, N), dtype=np.float32)
# Repeat N-2 times
count = 0
CIJtree = np.zeros((N, N))
for no in range(num_msts):
tmp_mtx = 1.0 / CIJnotintree
# ugly code ~_~
graph = nx.from_numpy_matrix(tmp_mtx)
# graph = nx.Graph()
# for x in range(N):
# for y in range(x+1, N):
# graph.add_edge(x, y, weight=tmp_mtx[x][y])
mst = nx.minimum_spanning_tree(graph)
links = list(mst.edges())
new_mst = np.zeros((N, N))
mst_num_links = len(links)
for k in range(mst_num_links):
link1 = links[k][0]
link2 = links[k][1]
CIJtree[link1, link2] = imtx[link1, link2]
CIJtree[link2, link1] = imtx[link1, link2]
mst_conn[count, 0] = link1
mst_conn[count, 1] = link2
new_mst[link1, link2] = imtx[link1, link2]
new_mst[link2, link1] = imtx[link1, link2]
count += 1
iCIJtree = np.ones((N, N))
iCIJtree[np.where(CIJtree != 0.0)] = 0
CIJnotintree = CIJnotintree * iCIJtree
nCIJtree[no, :, :] = CIJtree
omst[no, :, :] = new_mst
global_eff_ini = bct.efficiency_wei(imtx_uptril) * 2.0
cost_ini = np.sum(imtx_uptril[:])
# Insert the 1st MST
graph = np.zeros((N, N))
global_cost_eff = np.zeros((num_msts, 1))
degrees = np.zeros((num_msts, 1))
cost = np.zeros((num_msts, 1))
for k in range(num_msts):
graph = nCIJtree[k, :, :]
degree = bct.degrees_und(graph)
mean_degree = np.mean(degree)
degrees[k] = mean_degree
cost[k] = np.sum(graph) / cost_ini
global_eff = bct.efficiency_wei(graph)
global_cost_eff[k] = global_eff / global_eff_ini - cost[k]
# Get the OMST where the formula GE-C is maximized
indx_max = np.argmax(global_cost_eff)
# Final output
degree = degrees[indx_max]
CIJtree = nCIJtree[indx_max, :, :]
cost_max = cost[indx_max]
global_eff = bct.efficiency_wei(1.0 / CIJtree)
global_cost_eff_max = global_cost_eff[indx_max]
# import matplotlib.pyplot as plt
# plt.figure()
# plt.plot(cost, global_cost_eff)
# plt.plot(cost_max, global_cost_eff_max, 'b*', label='Max Global Cost Efficiency')
# plt.title('Economical small-world network at max Global Cost Efficiency')
# plt.xlabel('Cost')
# plt.ylabel('Global Cost Efficiency')
# plt.legend()
# plt.show()
# return nCIJtree, CIJtree, degree, global_eff, global_cost_eff_max, cost_max
return nCIJtree, CIJtree, degree, global_eff, global_cost_eff_max, cost_max, cost, global_cost_eff
def cal_indiv_graph():
'''loop through subjects and get PC/WMD/Q/eG/CI'''
### loop through subjects, 1 to 156
gordon_files = glob.glob("Data/*Gordon*.netcc")
yeo_files = glob.glob("Data/*Yeo*.netcc")
files = gordon_files + yeo_files
for f in files:
if f in gordon_files:
cmd = "cat %s | tail -n 352 > Data/test" %f
roi='gordon'
if f in yeo_files:
cmd = "cat %s | tail -n 422 > Data/test" %f #422 for Yeo
roi='yeo'
sub = f[5:8]
os.system(cmd)
# load matrix
matrix = np.genfromtxt('Data/test',delimiter='\t',dtype=None)
matrix[np.isnan(matrix)] = 0.0
matrix[matrix<0]=0.0
# step through costs, do infomap, return final infomap across cost
max_cost = .15
min_cost = .01
partition = ave_consensus_costs_parition(matrix, min_cost, max_cost)
partition = np.array(partition) + 1
# calculate modularity, efficiency?
Q = cal_modularity_w_imposed_community(matrix,partition)
Eg = bct.efficiency_wei(matrix)
# import thresholded matrix to BCT, import partition, run WMD/PC
PCs = np.zeros((len(np.arange(min_cost, max_cost+0.01, 0.01)), matrix.shape[0]))
WMDs = np.zeros((len(np.arange(min_cost, max_cost+0.01, 0.01)), matrix.shape[0]))
for i, cost in enumerate(np.arange(min_cost, max_cost, 0.01)):
tmp_matrix = threshold(matrix.copy(), cost)
#PC
PCs[i,:] = bct.participation_coef(tmp_matrix, partition)
#WMD
WMDs[i,:] = bct.module_degree_zscore(matrix, partition)
PC = np.mean(PCs, axis=0) # ave across thresholds
WMD = np.mean(WMDs, axis=0)
fn = "Graph_output/%s_%s_PC" %(sub, roi)
np.savetxt(fn, PC)
fn = "Graph_output/%s_%s_WMD" %(sub, roi)
np.savetxt(fn, WMD)
fn = "Graph_output/%s_%s_Q" %(sub, roi)
np.savetxt(fn, np.array(Q, ndmin=1))
fn = "Graph_output/%s_%s_Eg" %(sub, roi)
np.savetxt(fn, np.array(Eg, ndmin=1))
fn = "Graph_output/%s_%s_Partition" %(sub, roi)
np.savetxt(fn, partition)
null_dist = pd.DataFrame(index=index, columns=["mean", "sdev"])
for session in sessions:
print(session, datetime.datetime.now())
for task in tasks.keys():
print(task, datetime.datetime.now())
for i in np.arange(0, len(tasks[task][0]["conditions"])):
condition = tasks[task][0]["conditions"][i]
print(condition, datetime.datetime.now())
for mask in masks:
print(mask, datetime.datetime.now())
avg_corr = avg_corrmat(data_dir, subjects, task, condition,
session, mask)
eff_perm = []
j = 1
while j < 3:
effs = []
W = null_model_und_sign(avg_corr.values)
for thresh in np.arange(0.21, 0.31, 0.03):
thresh_corr = bct.threshold_proportional(W, thresh)
leff = bct.efficiency_wei(thresh_corr)
effs.append(leff)
effs_arr = np.asarray(effs)
leff_auc = np.trapz(effs_arr, dx=0.03, axis=0)
eff_perm.append(leff_auc)
j += 1
null_dist.at[(sesh[session], task, conds[i], mask),
"mean"] = np.mean(eff_perm)
null_dist.at[(sesh[session], task, conds[i], mask),
"sdev"] = np.std(eff_perm)
null_dist.to_csv(join(sink_dir, "null_dist-local_efficiency.csv"))
def get_graph_metrics(connectivity_vector) :
# reshape into matrix
connectivity_matrix = np.reshape(connectivity_vector, (90, 90))
# convert to networkx graph
connectivity_graph = nwx.from_numpy_matrix(connectivity_matrix)
# convert to distance graph as some metrics need this instead
distance_matrix = connectivity_matrix
distance_matrix[distance_matrix == 0] = np.finfo(np.float32).eps
distance_matrix = 1.0 / distance_matrix
distance_graph = nwx.from_numpy_matrix(distance_matrix)
# intialise vector of metrics
metrics = np.zeros((21,))
# fill the vector of metrics
# 1 and 2: degree distribution
degrees = np.sum(connectivity_matrix, axis = 1)
metrics[0] = np.mean(degrees)
metrics[1] = np.std(degrees)
# 3 and 4: weight distribution
weights = np.tril(connectivity_matrix, k = -1)
metrics[2] = np.mean(weights)
metrics[3] = np.std(weights)
# 5: average shortest path length
# transform weights to distances so this makes sense
metrics[4] = nwx.average_shortest_path_length(distance_graph, weight='weight')
# 6: assortativity
metrics[5] = nwx.degree_assortativity_coefficient(connectivity_graph, weight='None')
# 7: clustering coefficient
metrics[6] = nwx.average_clustering(connectivity_graph, weight='weight')
# 8: transitivity
metrics[7] = nwx.transitivity(connectivity_graph)
# 9 & 10: local and global efficiency
metrics[8] = np.mean(bct.efficiency_wei(connectivity_matrix, local=True))
metrics[9] = bct.efficiency_wei(connectivity_matrix, local=False)
# 11: Clustering coefficient
metrics[10] = np.mean(nwx.clustering(connectivity_graph, weight='weight').values())
# 12 & 13: Betweeness centrality
metrics[11] = np.mean(nwx.betweenness_centrality(distance_graph, weight='weight').values())
metrics[12] = np.mean(nwx.current_flow_betweenness_centrality(distance_graph, weight='weight').values())
# 14: Eigenvector centrality
metrics[13] = np.mean(nwx.eigenvector_centrality(distance_graph, weight='weight').values())
# 15: Closeness centrality
metrics[14] = np.mean(nwx.closeness_centrality(distance_graph, distance='weight').values())
# 16: PageRank
metrics[15] = np.mean(nwx.pagerank(connectivity_graph, weight='weight').values())
# 17: Rich club coefficient
metrics[16] = np.mean(nwx.rich_club_coefficient(connectivity_graph).values())
# 18: Density
metrics[17] = bct.density_und(connectivity_matrix)[0]
# 19, 20, 21: Eccentricity, radius, diameter
spl_all = nwx.shortest_path_length(distance_graph, weight='weight')
eccs = np.zeros(90,)
for i in range(90) :
eccs[i] = np.max(spl_all[i].values())
metrics[18] = np.mean(eccs)
metrics[19] = np.min(eccs)
metrics[20] = np.max(eccs)
return metrics
def advanced_network_analysis(graph, kstep=1, sstep=600., outdir=None):
""" Map structural cores to delineate network modules, and to identify
hub regions that link distinct clusters.
Definition:
The k-core is the largest subnetwork comprising nodes of degree at
least k.
The s-core is the largest subnetwork comprising nodes of strength at
least s.
The optimal community structure is a subdivision of the
network into nonoverlapping groups of nodes which maximizes the number
of within-group edges and minimizes the number of between-group edges.
The rich club coefficient, R, at level k is the fraction of edges that
connect nodes of degree k or higher out of the maximum number of edges
that such nodes might share.
Network features:
kcores:
each node associated k-core number.
klevels:
size of s-cores when the s-level increase.
scores:
each node associated s-core number.
slevels:
size of s-cores when the s-level increase.
community:
the computed community structure.
qstat:
the objective modularity function optimized q-statistic.
rich_clubs:
vector of rich-club coefficients for levels 1 to klevel=the maximum
degree of the adjacency matrix.
global_efficiency:
the global efficiency is the average of inverse shortest path
length, and is inversely related to the characteristic path length.
local_efficiency:
the local efficiency is the global efficiency computed on the
neighborhood of the node, and is related to the clustering coefficient.
Parameters
----------
graph: Graph
the graph reprensenting the connectome network.
kstep: int (optional, default 1)
the k-core size increment.
sstep: float (optional, default 600.)
the s-core size increment.
outdir: str (optional, default None)
if specified save some snapshots.
Returns
-------
outputs: dict
the network features.
snaps: list of file
the generates snaps.
"""
adjacency_matrix = numpy.ascontiguousarray(nx.to_numpy_matrix(graph))
# Efficiency
global_efficiency = bct.efficiency_wei(adjacency_matrix)
local_efficiency = bct.efficiency_wei(adjacency_matrix, local=True)
# K-core decomposition
k = 0
kcores = numpy.zeros(adjacency_matrix.shape[0], dtype=int)
klevels = []
kxs = []
processed_indices = set()
while True:
if not graph.is_directed():
kcore, kn, peelorder, peellevel = bct.kcore_bu(adjacency_matrix,
k,
peel=True)
klevels.append(kn)
kxs.append(k)
else:
kcore, kn, peelorder, peellevel = bct.kcore_bd(adjacency_matrix,
k,
peel=True)
for indices in peelorder:
new_indices = set(indices) - processed_indices
processed_indices = processed_indices.union(new_indices)
kcores[list(new_indices)] = k
if kn == 0:
break
k += 1
# S-core decompositon
scores = numpy.zeros(adjacency_matrix.shape[0], dtype=int)
slevels = []
sxs = []
processed_indices = set()
s = 0
while True:
if not graph.is_directed():
score, sn = bct.score_wu(adjacency_matrix, s)
slevels.append(sn)
sxs.append(s)
else:
raise NotImplementedError
ff = numpy.where(score == 0)
for node_index in ff[0]:
if node_index in processed_indices:
continue
if not (score[node_index, :] == 0).all():
continue
scores[node_index] = s
processed_indices.add(node_index)
if sn == 0:
break
s += sstep
# Community detection
community, qstat = bct.community_louvain(adjacency_matrix,
gamma=1,
ci=None,
B="modularity",
seed=None)
# Hub detection
if not graph.is_directed():
rich_clubs = bct.rich_club_wu(adjacency_matrix, klevel=None)
else:
rich_clubs = bct.rich_club_wd(adjacency_matrix, klevel=None)
# Summarize results in a dictionnary
params = locals()
outputs = dict([
(name, params[name])
for name in ("kcores", "klevels", "kxs", "scores", "slevels", "sxs",
"community", "qstat", "rich_clubs", "global_efficiency",
"local_efficiency")
])
# Snaps
snaps = []
if outdir is not None:
import pylab as plt
if not os.path.isdir(outdir):
raise ValueError("'{0}' is not a valid directory.".format(outdir))
for x, measures, label in [(kxs, klevels, "klevels"),
(sxs, slevels, "slevels")]:
outfile = os.path.join(outdir, label + ".png")
snaps.append(outfile)
plt.figure()
plt.plot(x, measures, "-bo")
plt.xlabel(label)
plt.ylabel("Number of nodes")
plt.savefig(outfile)
plt.close()
return outputs, snaps
#####################################################################
########### testing graph theoretic measures (eff, leff) ############
# geffs = pd.DataFrame(index=df.index, columns=np.arange(0,1,0.1))
for i in df.index:
corrmat = pd.read_csv(
join(data_dir, "out", "{0}-phy-corrmat-regionwise.csv".format(i)),
header=0,
index_col=0,
)
gw = []
for p in np.arange(0, 1, 0.1):
corrmat_thresh = bct.threshold_proportional(corrmat.values, p)
gw.append(bct.efficiency_wei(corrmat_thresh))
# geffs.at[i] = gw
df.at[i, "Global Efficiency Physics"] = np.trapz(gw[4:9], dx=0.1)
corrmat = pd.read_csv(
join(data_dir, "out", "{0}-gen-corrmat-regionwise.csv".format(i)),
header=0,
index_col=0,
)
gw = []
for p in np.arange(0, 1, 0.1):
corrmat_thresh = bct.threshold_proportional(corrmat.values, p)
gw.append(bct.efficiency_wei(corrmat_thresh))
# geffs.at[i] = gw
df.at[i, "Global Efficiency General"] = np.trapz(gw[4:9], dx=0.1)
f, ax = plt.subplots()
def process(data):
return bct.efficiency_wei(data, local=False)
def localEfficiency(network):
bct.efficiency_wei(network, local=True)
def main():
parser = _build_arg_parser()
args = parser.parse_args()
assert_inputs_exist(parser, [args.in_length_matrix, args.in_conn_matrix])
if args.verbose:
logging.basicConfig(level=logging.DEBUG)
if not args.append_json:
assert_outputs_exist(parser, args, args.out_json)
else:
logging.debug('Using --append_json, make sure to delete {} '
'before re-launching a group analysis.'.format(
args.out_json))
if args.append_json and args.overwrite:
parser.error('Cannot use the append option at the same time as '
'overwrite.\nAmbiguous behavior, consider deleting the '
'output json file first instead.')
conn_matrix = load_matrix_in_any_format(args.in_conn_matrix)
len_matrix = load_matrix_in_any_format(args.in_length_matrix)
if args.filtering_mask:
mask_matrix = load_matrix_in_any_format(args.filtering_mask)
conn_matrix *= mask_matrix
len_matrix *= mask_matrix
N = len_matrix.shape[0]
if args.avg_node_wise:
func_cast = avg_cast
else:
func_cast = list_cast
gtm_dict = {}
betweenness_centrality = bct.betweenness_wei(len_matrix) / ((N - 1) *
(N - 2))
gtm_dict['betweenness_centrality'] = func_cast(betweenness_centrality)
ci, gtm_dict['modularity'] = bct.modularity_louvain_und(conn_matrix,
seed=0)
gtm_dict['assortativity'] = bct.assortativity_wei(conn_matrix, flag=0)
gtm_dict['participation'] = func_cast(
bct.participation_coef_sign(conn_matrix, ci)[0])
gtm_dict['clustering'] = func_cast(bct.clustering_coef_wu(conn_matrix))
gtm_dict['nodal_strength'] = func_cast(bct.strengths_und(conn_matrix))
gtm_dict['local_efficiency'] = func_cast(
bct.efficiency_wei(len_matrix, local=True))
gtm_dict['global_efficiency'] = func_cast(bct.efficiency_wei(len_matrix))
gtm_dict['density'] = func_cast(bct.density_und(conn_matrix)[0])
# Rich club always gives an error for the matrix rank and gives NaN
with warnings.catch_warnings():
warnings.simplefilter("ignore")
tmp_rich_club = bct.rich_club_wu(conn_matrix)
gtm_dict['rich_club'] = func_cast(tmp_rich_club[~np.isnan(tmp_rich_club)])
# Path length gives an infinite distance for unconnected nodes
# All of this is simply to fix that
empty_connections = np.where(np.sum(len_matrix, axis=1) < 0.001)[0]
if len(empty_connections):
len_matrix = np.delete(len_matrix, empty_connections, axis=0)
len_matrix = np.delete(len_matrix, empty_connections, axis=1)
path_length_tuple = bct.distance_wei(len_matrix)
gtm_dict['path_length'] = func_cast(path_length_tuple[0])
gtm_dict['edge_count'] = func_cast(path_length_tuple[1])
if not args.avg_node_wise:
for i in empty_connections:
gtm_dict['path_length'].insert(i, -1)
gtm_dict['edge_count'].insert(i, -1)
if args.small_world:
gtm_dict['omega'], gtm_dict['sigma'] = omega_sigma(len_matrix)
if os.path.isfile(args.out_json) and args.append_json:
with open(args.out_json) as json_data:
out_dict = json.load(json_data)
for key in gtm_dict.keys():
if isinstance(out_dict[key], list):
out_dict[key].append(gtm_dict[key])
else:
out_dict[key] = [out_dict[key], gtm_dict[key]]
else:
out_dict = {}
for key in gtm_dict.keys():
out_dict[key] = [gtm_dict[key]]
with open(args.out_json, 'w') as outfile:
json.dump(out_dict,
outfile,
indent=args.indent,
sort_keys=args.sort_keys)
format(subject, session, task, conditions[i],
mask),
),
delimiter=" ",
)
leff_s = []
coef_s = []
for p in np.arange(kappa_upper, kappa_lower, 0.02):
thresh = bct.threshold_proportional(corrmat,
p,
copy=True)
# network measures of interest here
# global efficiency
le = bct.efficiency_wei(thresh, local=True)
leff_s.append(le)
leff_s = np.asarray(leff_s)
leff = np.trapz(leff_s, dx=0.01, axis=0)
for j in np.arange(0, leff.shape[0]):
df.at[(subject, session, task, conds[i], mask),
"lEff{0}".format(j), ] = leff[j]
lab_notebook.at[(subject, session, task, conds[i],
mask),
"end"] = str(datetime.datetime.now())
except Exception as e:
print(e, subject, session)
lab_notebook.at[(subject, session, task, conds[i],
mask), "errors"] = [
def process(data):
# average first, then calculate. Because calculation is too slow.
return bct.efficiency_wei(data, local=True)
subject,
"fc left central executive-right central executive {0}".format(condition),
] = corrmats[condition][14, 17]
ge = []
le = {}
loceff = {}
loceff["default mode"] = []
loceff["left central executive"] = []
loceff["right central executive"] = []
for p in thresh_range:
corrmat_thresh = bct.threshold_proportional(
corrmats[condition], p, copy=True
)
# measures of interest here
# global efficiency
geff = bct.efficiency_wei(corrmat_thresh)
ge.append(geff)
# local efficiency
leff = bct.efficiency_wei(corrmat_thresh, local=True)
# print leff[2]
for network in networks:
# print network
loceff[labels[network]].append(leff[network])
# loceff['{0}, {1}'.format(labels[network], condition)].append(leff[network])
# print loceff
le["{0}, {1}".format(p, condition)] = loceff
# print 'global efficiency is {0}'.format(ge)
df.at[subject, "global efficiency {0}".format(condition)] = np.trapz(ge, dx=0.1)
np.savetxt(join(sink_dir, sesh[session], subject, '{0}-session-{1}-rest_network_corrmat_craddock2012.csv'.format(subject, session)), craddock_corrmat, delimiter=",")
#craddock_corrmat = np.genfromtxt(join(sink_dir, session, 'resting-state', subject, '{0}_network_corrmat_craddock2012.csv'.format(subject)), delimiter=",")
ge_s = []
ge_c = []
cp_s = []
cp_c = []
md_s = []
md_c = []
for p in np.arange(0.1, 1, 0.1):
ntwk = []
shen_thresh = bct.threshold_proportional(shen_corrmat, p, copy=True)
craddock_thresh = bct.threshold_proportional(craddock_corrmat, p, copy=True)
#network measures of interest here
#global efficiency
ge = bct.efficiency_wei(shen_thresh)
ge_s.append(ge)
ge = bct.efficiency_wei(craddock_thresh)
ge_c.append(ge)
#characteristic path length
cp = bct.charpath(shen_thresh)
cp_s.append(cp[0])
cp = bct.charpath(craddock_thresh)
cp_c.append(cp[0])
#modularity
md = bct.modularity_louvain_und(shen_thresh)
md_s.append(md[1])
md = bct.modularity_louvain_und(craddock_thresh)
md_c.append(md[1])
def test_glob_eff():
x = load_sample(thres=.4)
geff = bct.efficiency_wei(x)
print(geff, 1.8784)
assert np.allclose(geff, 1.8784, atol=1e-4)
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)
nb_trials = 100
N = 200
k = 4
# Pre-allocate arrays
prob = 10**(-3*np.random.random(nb_trials))
SWI = np.zeros(nb_trials)
Eglob = np.zeros(nb_trials)
Eloc = np.zeros(nb_trials)
# Calculate statistics
for i, p in enumerate(prob):
CIJ = NetworkWattsStrogatz(N, k, p)
SWI[i] = SmallWorldIndex(CIJ)
Eglob[i] = bct.efficiency_wei(CIJ, local=False)
Eloc[i] = np.mean(bct.efficiency_wei(CIJ, local=True))
# Plot figures
plt.figure(1)
plt.semilogx(prob, SWI, marker='.', linestyle='none')
plt.xlabel('Rewiring probability')
plt.ylabel('Small World Index')
plt.figure(2)
plt.subplot(211)
plt.semilogx(prob, Eglob, marker='.', linestyle='none')
plt.xlabel('Rewiring probability')
plt.ylabel('Global efficiency')
plt.subplot(212)
plt.semilogx(prob, Eloc, marker='.', linestyle='none')
'{0}-session-{1}_{2}-{3}_{4}-corrmat.csv'.format(
subject, session, task, conditions[i], mask)),
delimiter=' ')
ge_s = []
cp_s = []
md_s = []
for p in np.arange(kappa_upper, kappa_lower, 0.01):
ntwk = []
thresh = bct.threshold_proportional(corrmat,
p,
copy=True)
#network measures of interest here
#global efficiency
ge = bct.efficiency_wei(thresh)
ge_s.append(ge)
#characteristic path length
cp = bct.charpath(thresh)
cp_s.append(cp[0])
#modularity
md = bct.modularity_louvain_und(thresh)
md_s.append(md[1])
df.at[(subject, session, task, conds[i], mask),
'efficiency'] = np.trapz(ge_s, dx=0.01)
df.at[(subject, session, task, conds[i], mask),
'charpath'] = np.trapz(cp_s, dx=0.01)
df.at[(subject, session, task, conds[i], mask),
def graph_estimates(cm, th):
#dictionary for storing our results
d = OrderedDict()
#thresholding moved here for other matrices than MatLab matrices
#removes negative weights
cm = bct.threshold_absolute(cm, 0.0)
cm = threshold_connected(cm, th)
#for binarizing the connectivity matrices,
#we work with weighted so this is turned off
#bin_cm = bct.binarize(cm)
#invert the connectivity for computing shortest paths
cm_inv = bct.invert(cm)
#modularity_und is found in modularity.py
modularity_und = bct.modularity_und(cm)
#the community_affiliation vector that gets input to some of the functions
community_affiliation = modularity_und[0]
#distance_wei and charpath is found in distance.py
distance_wei = bct.distance_wei(cm_inv)
charpath = bct.charpath(distance_wei[0], False, False)
#clustering_coef_wu is found in clustering.py
clustering_coef_wu = bct.clustering_coef_wu(cm)
avg_clustering_coef_wu = np.mean(clustering_coef_wu)
#assortativity_wei is found in core.py
d['assortativity_wei-r'] = bct.assortativity_wei(cm, flag=0)
#just taking the average of clustering_coef_wu
d['avg_clustering_coef_wu:C'] = avg_clustering_coef_wu
d['charpath-lambda'] = charpath[0]
#d['charpath-efficiency'] = charpath[1]
#d['charpath-ecc'] = charpath[2]
#d['charpath-radius'] = charpath[3]
#d['charpath-diameter'] = charpath[4]
d['clustering_coef_wu-C'] = clustering_coef_wu
d['efficiency_wei-Eglob'] = bct.efficiency_wei(cm)
#d['efficiency_wei-Eloc'] = bct.efficiency_wei(cm, True)
#d['modularity_und-ci'] = modularity_und[0]
d['modularity_und-Q'] = modularity_und[1]
d['small_worldness:S'] = compute_small_worldness(cm,
avg_clustering_coef_wu,
charpath[0])
#transitivity_wu can be found in clustering.py
d['transitivity_wu-T'] = bct.transitivity_wu(cm)
#EXAMPLES for local measures and binary measures. Comment in to use.
#VECTOR MEASURES
#d['betweenness_wei-BC'] = bct.betweenness_wei(cm_inv)
# d['module_degree_zscore-Z'] = bct.module_degree_zscore(cm, community_affiliation)
#d['degrees_und-deg'] = bct.degrees_und(cm)
#d['charpath-ecc'] = charpath[2]
#BINARIES
# d['clustering_coef_bu-C'] = bct.clustering_coef_bu(bin_cm)
# d['efficiency_bin-Eglob'] = bct.efficiency_bin(bin_cm)
# d['efficiency_bin-Eloc'] = bct.efficiency_bin(bin_cm, True)
# d['modularity_und_bin-ci'] = modularity_und_bin[0]
# d['modularity_und_bin-Q'] = modularity_und_bin[1]
# d['transitivity_bu-T'] = bct.transitivity_bu(bin_cm)
# d['betweenness_bin-BC'] = bct.betweenness_bin(bin_cm)
# modularity_und_bin = bct.modularity_und(bin_cm)
#d['participation_coef'] = bct.participation_coef(cm, community_affiliation)
######## charpath giving problems with ecc, radius and diameter
# np.seterr(invalid='ignore')
return d
def test_loc_eff():
x = load_sample(thres=.4)
leff = bct.efficiency_wei(x, local=True)
print(np.sum(leff), 315.6225)
assert np.allclose(np.sum(leff), 315.6225, atol=0.1)
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.efficiency_wei(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.efficiency_wei(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_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.efficiency_wei(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.efficiency_wei(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)
cv_params = {
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 )
