def test_partition_distance():
q = load_sample_group_qball()
d = load_sample_group_dsi()
q = np.mean(q, axis=2)
d = np.mean(d, axis=2)
qi, _ = bct.modularity_und(q)
di, _ = bct.modularity_und(d)
vi, mi = bct.partition_distance(qi, di)
print(vi, mi)
assert np.allclose(vi, 0.1964, atol=0.01)
assert np.allclose(mi, 0.6394, atol=0.01)
def test_modularity_finetune_und():
x = load_sample(thres=.4)
seed = 94885236
_, q = bct.modularity_finetune_und(x, seed=seed)
assert np.allclose(q, .25879794)
fails = 0
for i in range(100):
_, q = bct.modularity_finetune_und(x)
try:
assert np.allclose(q, .25, atol=0.03)
except AssertionError:
if fails >= 5:
raise
else:
fails += 1
seed = 71040925
ci, oq = bct.modularity_louvain_und(x, seed=seed)
_, q = bct.modularity_finetune_und(x, ci=ci, seed=seed)
print(q, oq)
# assert np.allclose(q, .25892588)
assert np.allclose(q, .25856714)
assert q - oq >= -1e6
ci, oq = bct.modularity_und(x)
for i in range(100):
_, q = bct.modularity_finetune_und(x, ci=ci)
assert np.allclose(q, .25, atol=0.002)
assert q - oq >= -1e6
def test_modularity_finetune_und():
x = load_sample(thres=.4)
seed = 94885236
_, q = bct.modularity_finetune_und(x, seed=seed)
assert np.allclose(q, .25879794)
fails = 0
for i in range(100):
_, q = bct.modularity_finetune_und(x)
try:
assert np.allclose(q, .25, atol=0.03)
except AssertionError:
if fails >= 5:
raise
else:
fails += 1
seed = 71040925
ci, oq = bct.modularity_louvain_und(x, seed=seed)
_, q = bct.modularity_finetune_und(x, ci=ci, seed=seed)
print(q, oq)
# assert np.allclose(q, .25892588)
assert np.allclose(q, .25856714)
assert q - oq >= -1e6
ci, oq = bct.modularity_und(x)
for i in range(100):
_, q = bct.modularity_finetune_und(x, ci=ci)
assert np.allclose(q, .25, atol=0.002)
assert q - oq >= -1e6
def comod_test(a1, a2):
ma, qa = bct.modularity_und(a1)
mb, qb = bct.modularity_und(a2)
n = len(ma)
if len(mb) != n:
raise BCTParamError('Comodularity must be done on equally sized '
'matrices')
f, F = (0,) * 2
for e1 in xrange(n):
for e2 in xrange(n):
if e2 >= e1:
continue
# node pairs
comod_a = ma[e1] == ma[e2]
comod_b = mb[e1] == mb[e2]
# node pairs sharing a module in at least one graph
if comod_a or comod_b:
F += 1
# node pairs sharing a module in both graphs
if comod_a and comod_b:
f += 1
m1 = np.max(ma)
m2 = np.max(mb)
eta = []
gamma = []
for i in xrange(m1):
eta.append(np.size(np.where(ma == i + 1)))
for i in xrange(m2):
gamma.append(np.size(np.where(mb == i + 1)))
scale, conscale = (0,) * 2
for h in eta:
for g in gamma:
# print h,g
conscale += (h * g) / (n * (h + g) - h * g)
scale += (h * h * g * g) / (n ** 3 * (h + g) - n * h * g)
print m1, m2
# print conscale
print scale
return (f / F) / scale
def comod_test(a1, a2):
ma, qa = bct.modularity_und(a1)
mb, qb = bct.modularity_und(a2)
n = len(ma)
if len(mb) != n:
raise BCTParamError('Comodularity must be done on equally sized '
'matrices')
f, F = (0, ) * 2
for e1 in xrange(n):
for e2 in xrange(n):
if e2 >= e1:
continue
# node pairs
comod_a = ma[e1] == ma[e2]
comod_b = mb[e1] == mb[e2]
# node pairs sharing a module in at least one graph
if comod_a or comod_b:
F += 1
# node pairs sharing a module in both graphs
if comod_a and comod_b:
f += 1
m1 = np.max(ma)
m2 = np.max(mb)
eta = []
gamma = []
for i in xrange(m1):
eta.append(np.size(np.where(ma == i + 1)))
for i in xrange(m2):
gamma.append(np.size(np.where(mb == i + 1)))
scale, conscale = (0, ) * 2
for h in eta:
for g in gamma:
# print h,g
conscale += (h * g) / (n * (h + g) - h * g)
scale += (h * h * g * g) / (n**3 * (h + g) - n * h * g)
print m1, m2
# print conscale
print scale
return (f / F) / scale
def calculate_modules(self,thres):
import bct
thres_adj=self.adj.copy()
thres_adj[thres_adj < thres] = 0
self.verbose_msg('Threshold for modularity calculation: %s'%str(thres))
modvec,_=bct.modularity_und(thres_adj)
self.modules = bct.ci2ls(modvec)
self.nr_modules = len(self.modules)
def test_consensus():
x = load_sample(thres=.38)
ci = bct.consensus_und(x, .1, reps=50)
print(np.max(ci), 4)
assert np.max(ci) == 4
_, q = bct.modularity_und(x, kci=ci)
print(q, 0.27)
assert np.allclose(q, 0.27, atol=.01)
def test_consensus():
x = load_sample(thres=.38)
ci = bct.consensus_und(x, .1, reps=50)
print(np.max(ci), 4)
assert np.max(ci) == 4
_, q = bct.modularity_und(x, kci=ci)
print(q, 0.27)
assert np.allclose(q, 0.27, atol=.01)
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 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 comodularity_und(a1, a2):
'''
Returns the comodularity, an experimental measure I am developing.
The comodularity evaluates the correspondence between two community
structures A and B. Let F be the set of nodes that are co-modular (in the
same module) in at least one of these community structures. Let f be the
set of nodes that are co-modular in both of these community structures.
The comodularity is |f|/|F|
This is actually very similar to the Jaccard index which turns out not
to be a terribly useful property. At high similarity a the variability
of information is better. It may be that the degenerate cross modularity
is even better though.
'''
ma, qa = bct.modularity_und(a1)
mb, qb = bct.modularity_und(a2)
n = len(ma)
if len(mb) != n:
raise bct.BCTParamError('Comodularity must be done on equally sized '
'matrices')
E, F, f, G, g, H, h = (0,) * 7
for e1 in xrange(n):
for e2 in xrange(n):
if e2 >= e1:
continue
# node pairs
comod_a = ma[e1] == ma[e2]
comod_b = mb[e1] == mb[e2]
# node pairs sharing a module in at least one graph
if comod_a or comod_b:
F += 1
# node pairs sharing a module in both graphs
if comod_a and comod_b:
f += 1
# edges in either graph common to any module
if a1[e1, e2] != 0 or a2[e1, e2] != 0:
# edges that exist in at least one graph which prepend a shared
# module in at least one graph:
# EXTREMELY NOT USEFUL SINCE THE SHARED MODULE MIGHT BE THE OTHER
# GRAPH WITH NO EDGE!
if comod_a or comod_b:
G += 1
# edges that exist in at least one graph which prepend a shared
# module in both graphs:
if comod_a and comod_b:
g += 1
# edges that exist at all
E += 1
# edges common to a module in both graphs
if a1[e1, e2] != 0 and a2[e1, e2] != 0:
# edges that exist in both graphs which prepend a shared module
# in at least one graph
if comod_a or comod_b:
H += 1
# edges that exist in both graphs which prepend a shared module
# in both graphs
if comod_a and comod_b:
h += 1
m1 = np.max(ma)
m2 = np.max(mb)
P = m1 + m2 - 1
# print f,F
print m1, m2
print 'f/F', f / F
print '(f/F)*p', f * P / F
print 'g/E', g / E
print '(g/E)*p', g * P / E
print 'h/E', h / E
print '(h/E)*p', h * P / E
print 'h/H', h / H
print '(h/H)*p', h * P / E
print 'q1, q2', qa, qb
# print 'f/F*sqrt(qa*qb)', f*np.sqrt(qa*qb)/F
return f / F
import numpy as np
import bct as BCT
import sys
fn = raw_input()
print(fn)
M = np.loadtxt(fn)
Q_vec = np.zeros(len(np.arange(0.02, 0.21, 0.01)))
for i, th in enumerate(np.arange(0.02, 0.21, 0.01)):
Q_vec[i] = BCT.modularity_und(BCT.threshold_proportional(M, th))[1]
Q = Q_vec.mean()
print(Q)
import numpy as np
import bct as BCT
import sys
fn = raw_input()
print(fn)
M = np.loadtxt(fn)
Q_vec = np.zeros(len(np.arange(0.02, 0.21, 0.01)))
for i, th in enumerate(np.arange(0.02, 0.21, 0.01)):
Q_vec[i] = BCT.modularity_und(BCT.threshold_proportional(M, th))[1]
Q = Q_vec.mean()
print(Q)
10 34
14 34
15 34
16 34
19 34
20 34
21 34
23 34
24 34
27 34
28 34
29 34
30 34
31 34
32 34
33 34
""".strip()
arr = np.zeros((34, 34), dtype=np.uint8)
for row in s.split('\n'):
first, second = row.split(' ')
arr[int(first) - 1, int(second) - 1] += 1
arr = bct.binarize(arr + arr.T)
np.random.seed(1991)
eff = bct.efficiency_bin(arr)
mod = bct.modularity_und(arr)
rand = bct.randmio_und_connected(arr, 5)
def test_modularity_und():
x = load_sample(thres=.4)
_, q = bct.modularity_und(x)
print(q)
assert np.allclose(q, 0.24097717)
def resample_network(A, n_perm, e_f, type_to_remove, final_electrodes):
# type to remove : 1 for white matter, 0 for grey matter
# e_f : Following Erin + John convention. This is the fraction of nodes to
# keep in the network (ex.. ef=.2 means we remove 80% of the nodes)
e_f = np.array(e_f)
nch = A.shape[0]
n_f = e_f.shape[0]
# create sub dataframes for only the grey and white matter elec
wm = final_electrodes[final_electrodes.iloc[:, 2] > 0]
gm = final_electrodes[final_electrodes.iloc[:, 2] == 0]
# numbers of each electrode type
numWhite = wm.shape[0]
numGrey = gm.shape[0]
# fraction to remove
if (type_to_remove == 1):
e_n = numWhite - np.ceil(e_f * numWhite)
else:
e_n = numGrey - np.ceil(e_f * numGrey)
# control centrality
all_c_c = np.zeros((nch, n_f, n_perm))
all_c_c[:] = np.nan
cc_reg = np.zeros((nch, n_f, n_perm))
cc_reg[:] = np.nan
all_cc_norm = np.zeros((nch, n_f, n_perm))
all_cc_norm[:] = np.nan
#init node strengths
all_ns = np.zeros((nch, n_f, n_perm))
all_ns[:] = np.nan
all_ns_norm = np.zeros((nch, n_f, n_perm))
all_ns_norm[:] = np.nan
# init betweenness centrality
all_bc = np.zeros((nch, n_f, n_perm))
all_bc[:] = np.nan
all_bc_norm = np.zeros((nch, n_f, n_perm))
all_bc_norm[:] = np.nan
# synch
all_sync = np.zeros((n_f, n_perm))
all_sync[:] = np.nan
all_sync_norm = np.zeros((n_f, n_perm))
all_sync_norm[:] = np.nan
# efficiency
all_eff = np.zeros((n_f, n_perm))
all_eff[:] = np.nan
all_eff_norm = np.zeros((n_f, n_perm))
all_eff_norm[:] = np.nan
# eigenvector centrality
all_ec = np.zeros((nch, n_f, n_perm))
all_ec[:] = np.nan
all_ec_norm = np.zeros((nch, n_f, n_perm))
all_ec_norm[:] = np.nan
# clustering coeff
all_clust = np.zeros((nch, n_f, n_perm))
all_clust[:] = np.nan
all_clust_norm = np.zeros((nch, n_f, n_perm))
all_clust_norm[:] = np.nan
# participation coeff
all_par = np.zeros((nch, n_f, n_perm))
all_par[:] = np.nan
# transistivity
all_trans = np.zeros((n_f, n_perm))
all_trans[:] = np.nan
all_trans_norm = np.zeros((n_f, n_perm))
all_trans_norm[:] = np.nan
# edge bc
all_edge_bc = []
all_edge_bc_norm = []
# get true particpation
Ci, ignore = bct.modularity_und(A)
true_par = bct.participation_coef(A, Ci)
avg_par_removed = np.zeros((n_f, n_perm))
avg_par_removed[:] = np.nan
# get the true bc
true_bc = betweenness_centrality(A)
avg_bc_removed = np.zeros((n_f, n_perm))
avg_bc_removed[:] = np.nan
# loop over all removal fractions and permutations
for f in range(0, n_f):
all_edge_bc_cur_fraction = []
all_edge_bc_norm_cur_fraction = []
for i_p in range(0, n_perm):
if (i_p % 100 == 0):
print(
"Doing permutation {0} for removal of fraction {1}".format(
i_p, f))
# make a copy of the adjacency matrix (we will edit this each time)
A_tmp = A.copy()
# picking the nodes to remove
if (type_to_remove == 1):
to_remove = wm.sample(int(e_n[f])).iloc[:, 0]
else:
to_remove = gm.sample(int(e_n[f])).iloc[:, 0]
# take these electrodes out of the adjacency matrix
A_tmp = np.delete(A_tmp, to_remove, axis=0)
A_tmp = np.delete(A_tmp, to_remove, axis=1)
# create a new array to hold the identity of the channels
ch_ids = np.arange(0, nch)
ch_ids = np.delete(ch_ids, to_remove)
# get the new metrics from A_tmp
r = get_true_network_metrics(A_tmp)
# edge metric
all_edge_bc_cur_fraction.append(r['edge_bc'])
all_edge_bc_norm_cur_fraction.append(r['edge_bc_norm'])
# populate the nodal measures
for i in range(0, ch_ids.shape[0]):
all_c_c[ch_ids[i], f, i_p] = r['control_centrality'][i]
all_ns[ch_ids[i], f, i_p] = r['ns'][i]
all_bc[ch_ids[i], f, i_p] = r['bc'][i]
all_par[ch_ids[i], f, i_p] = r['par'][i]
all_ec[ch_ids[i], f, i_p] = r['ec'][i]
all_clust[ch_ids[i], f, i_p] = r['clust'][i]
all_cc_norm[ch_ids[i], f,
i_p] = r['control_centrality_norm'][i]
all_ns_norm[ch_ids[i], f, i_p] = r['ns_norm'][i]
all_bc_norm[ch_ids[i], f, i_p] = r['bc_norm'][i]
all_ec_norm[ch_ids[i], f, i_p] = r['ec_norm'][i]
all_clust_norm[ch_ids[i], f, i_p] = r['clust_norm'][i]
# populate the global measures
all_sync[f, i_p] = r['sync']
all_sync_norm[f, i_p] = r['sync_norm']
all_eff[f, i_p] = r['eff']
all_eff_norm[f, i_p] = r['eff_norm']
all_trans[f, i_p] = r['trans']
all_trans_norm[f, i_p] = r['trans_norm']
all_edge_bc.append(all_edge_bc_cur_fraction)
all_edge_bc_norm.append(all_edge_bc_norm_cur_fraction)
# construct the output dictionary from a resampling
#nodal
results = {}
results['control_centrality'] = all_c_c
results['control_centrality_norm'] = all_cc_norm
# global measure
results['sync'] = all_sync
results['sync_norm'] = all_sync_norm
# nodal
results['bc'] = all_bc
results['bc_norm'] = all_bc_norm
# nodal
results['ec'] = all_ec
results['ec_norm'] = all_ec_norm
# nodal
results['clust'] = all_clust
results['clust_norm'] = all_clust_norm
# nodal
results['ns'] = all_ns
results['ns_norm'] = all_ns_norm
# global
results['eff'] = all_eff
results['eff_norm'] = all_eff_norm
# global
results['trans'] = all_trans
results['trans_norm'] = all_trans_norm
# nodal
results['par'] = all_par
#edge
results['edge_bc'] = all_edge_bc
results['edge_bc_norm'] = all_edge_bc_norm
return (results)
threshVal = 0.0
threshVal = input("Enter threshold: ")
#testDir = '/Users/heiland/Documents/Heiland/BioVis14/contest_subject_networks/'
#fname = 'U050E1IO_adjacency_matrix_pcc.txt'
fname = '1X4I9DF0_adjacency_matrix_pcc.txt'
#d = np.genfromtxt(testDir + fname, delimiter='\t')
try:
A = np.genfromtxt(fname, delimiter='\t')
except:
print "Error opening " + fname
bct.threshold_absolute(A, threshVal)
# Calculate the network's modularity
[Ci, Q] = bct.modularity_und(A)
print Ci
for i in range(len(Ci)):
for j in range(i + 1, len(Ci)):
# print i,j
if Ci[i] > Ci[j]:
temp = Ci[i]
Ci[i] = Ci[j]
Ci[j] = temp
print str(i) + ' <-> ' + str(j)
A[[i, j]] = A[[j, i]] # swap rows
A[:, [i, j]] = A[:, [j, i]] # swap cols
print Ci
#Ci=array([1, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 1, 1, 1, 1, 1, 3, 3, 4, 3, 1, 3, 3, ...
root_fname = sys.argv[1]
#nw_fname = sys.argv[2]
nw_fname = "1X4I9DF0_adjacency_matrix_pcc.txt"
threshold = float(sys.argv[2])
print 'threshold=',threshold
adjMtx = np.genfromtxt(nw_fname, delimiter='\t')
"""Rubinov,Sporns 2010: all self-connections or negative connections
(such as functional anticorrelations) must currently be removed
from the networks prior to analysis"""
bct.threshold_absolute(adjMtx,threshold)
# NB! be sure to put before masking the matrix
[Ci,Q]=bct.modularity_und(adjMtx)
roi_legend = 'roi_legend.txt'
try:
fp_roi =open(roi_legend, 'r')
except:
print("Error opening " + roi_legend)
# Create a dictionary mapping ID --> RGB
vc = {} # vertex color dictionary
count = 0
# colors (rgb) for modules (Q: what's the max # of modules we'll have??)
# rf. http://www.rapidtables.com/web/color/RGB_Color.htm
# Red,Green,Yellow,Blue,...
module_rgb_dict = {1:'255 0 0', 2: '0 255 0', 3: '255 255 0', 4: '0 0 255', 5: '255 0 255', 6: '51 255 255'}
count = 0
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 entropic_similarity(a1, a2):
ma, _ = bct.modularity_und(a1)
mb, _ = bct.modularity_und(a2)
vi, _ = bct.partition_distance(ma, mb)
return 1 - vi
#connected component:
# G = nx.erdos_renyi_graph(100, 0.03, seed=seed)
# Adj = np.asarray(nx.to_numpy_matrix(G))
# a = bct.get_components(Adj)
# print a[0], len(a[0]) #component number
# print a[1], len(a[1]) #vector of component sizes
# community detection:
# ml = bct.community_louvain(Adj, 1, B='modularity') # gamma=1 for 4 cluster
# print ml[0] #communities
# print ml[1] #modularity
# print max(ml[0]) #n_community
# print bct.transitivity_bu(Adj)
# print np.mean(bct.clustering_coef_bu(Adj))
mod = bct.modularity_und(Adj, gamma=1)
# print mod[0]
# print mod[1] # maximized modularity metric
#shortest path
# dist = bct.distance_bin(Adj)
# np.savetxt('distance.txt', dist, fmt='%d')
#characteristic path length
# ch = bct.charpath(dist)
# print ch[0] # lambda
# print ch[1] #efficiency
# # print ch[2] #ecc
# print ch[3] #radius
# print ch[4] #diameter
# ecc = np.max(dist, axis=1)
def process(data):
ci, q = bct.modularity_und(data, gamma=1)
return ci # TODO: report q?
def test_modularity_und():
x = load_sample(thres=.4)
_, q = bct.modularity_und(x)
print(q)
assert np.allclose(q, 0.24097717)
root_fname = sys.argv[1]
#nw_fname = sys.argv[2]
nw_fname = "1X4I9DF0_adjacency_matrix_pcc.txt"
threshold = float(sys.argv[2])
print 'threshold=', threshold
adjMtx = np.genfromtxt(nw_fname, delimiter='\t')
"""Rubinov,Sporns 2010: all self-connections or negative connections
(such as functional anticorrelations) must currently be removed
from the networks prior to analysis"""
bct.threshold_absolute(adjMtx, threshold)
# NB! be sure to put before masking the matrix
[Ci, Q] = bct.modularity_und(adjMtx)
roi_legend = 'roi_legend.txt'
try:
fp_roi = open(roi_legend, 'r')
except:
print("Error opening " + roi_legend)
# Create a dictionary mapping ID --> RGB
vc = {} # vertex color dictionary
count = 0
# colors (rgb) for modules (Q: what's the max # of modules we'll have??)
# rf. http://www.rapidtables.com/web/color/RGB_Color.htm
# Red,Green,Yellow,Blue,...
module_rgb_dict = {
1: '255 0 0',
def entropic_similarity(a1, a2):
ma, _ = bct.modularity_und(a1)
mb, _ = bct.modularity_und(a2)
vi, _ = bct.partition_distance(ma, mb)
return 1 - vi
threshVal=0.0
threshVal=input("Enter threshold: ")
#testDir = '/Users/heiland/Documents/Heiland/BioVis14/contest_subject_networks/'
#fname = 'U050E1IO_adjacency_matrix_pcc.txt'
fname = '1X4I9DF0_adjacency_matrix_pcc.txt'
#d = np.genfromtxt(testDir + fname, delimiter='\t')
try:
A = np.genfromtxt(fname, delimiter='\t')
except:
print "Error opening " + fname
bct.threshold_absolute(A,threshVal)
# Calculate the network's modularity
[Ci,Q]=bct.modularity_und(A)
print Ci
for i in range(len(Ci)):
for j in range(i+1,len(Ci)):
# print i,j
if Ci[i] > Ci[j]:
temp = Ci[i]
Ci[i] = Ci[j]
Ci[j] = temp
print str(i) + ' <-> ' + str(j)
A[[i,j]] = A[[j,i]] # swap rows
A[:,[i,j]] = A[:,[j,i]] # swap cols
print Ci
#Ci=array([1, 1, 3, 3, 1, 3, 3, 3, 1, 3, 3, 1, 1, 1, 1, 1, 3, 3, 4, 3, 1, 3, 3, ...
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)
def comodularity_und(a1, a2):
'''
Returns the comodularity, an experimental measure I am developing.
The comodularity evaluates the correspondence between two community
structures A and B. Let F be the set of nodes that are co-modular (in the
same module) in at least one of these community structures. Let f be the
set of nodes that are co-modular in both of these community structures.
The comodularity is |f|/|F|
This is actually very similar to the Jaccard index which turns out not
to be a terribly useful property. At high similarity a the variability
of information is better. It may be that the degenerate cross modularity
is even better though.
'''
ma, qa = bct.modularity_und(a1)
mb, qb = bct.modularity_und(a2)
n = len(ma)
if len(mb) != n:
raise bct.BCTParamError('Comodularity must be done on equally sized '
'matrices')
E, F, f, G, g, H, h = (0, ) * 7
for e1 in xrange(n):
for e2 in xrange(n):
if e2 >= e1:
continue
# node pairs
comod_a = ma[e1] == ma[e2]
comod_b = mb[e1] == mb[e2]
# node pairs sharing a module in at least one graph
if comod_a or comod_b:
F += 1
# node pairs sharing a module in both graphs
if comod_a and comod_b:
f += 1
# edges in either graph common to any module
if a1[e1, e2] != 0 or a2[e1, e2] != 0:
# edges that exist in at least one graph which prepend a shared
# module in at least one graph:
# EXTREMELY NOT USEFUL SINCE THE SHARED MODULE MIGHT BE THE OTHER
# GRAPH WITH NO EDGE!
if comod_a or comod_b:
G += 1
# edges that exist in at least one graph which prepend a shared
# module in both graphs:
if comod_a and comod_b:
g += 1
# edges that exist at all
E += 1
# edges common to a module in both graphs
if a1[e1, e2] != 0 and a2[e1, e2] != 0:
# edges that exist in both graphs which prepend a shared module
# in at least one graph
if comod_a or comod_b:
H += 1
# edges that exist in both graphs which prepend a shared module
# in both graphs
if comod_a and comod_b:
h += 1
m1 = np.max(ma)
m2 = np.max(mb)
P = m1 + m2 - 1
# print f,F
print m1, m2
print 'f/F', f / F
print '(f/F)*p', f * P / F
print 'g/E', g / E
print '(g/E)*p', g * P / E
print 'h/E', h / E
print '(h/E)*p', h * P / E
print 'h/H', h / H
print '(h/H)*p', h * P / E
print 'q1, q2', qa, qb
# print 'f/F*sqrt(qa*qb)', f*np.sqrt(qa*qb)/F
return f / F
