def get_network_property(graph):
"""Returns various property of the graph.
It calculates the richness coefficient, triangles and transitivity
coefficient. To do so, it removes self-loops *in-place*. So, there
is a possibility that the graph passed as parameter has been
changed.
"""
remove_self_loop(graph)
# If number of nodes is less than three
# no point in calculating these property.
if len(graph.nodes()) < 3:
return ({0: 0.0}, 0, 0)
try:
richness = nx.rich_club_coefficient(graph)
except nx.NetworkXAlgorithmError:
# NetworkXAlgorithmError is raised when
# it fails achieve desired swaps after
# maximum number of attempts. It happened
# for a really small graph. But, just to
# guard against those cases.
richness = nx.rich_club_coefficient(graph, False)
triangle = nx.triangles(graph)
transitivity = nx.transitivity(graph)
return (richness, triangle, transitivity)
def rich_club(G, R_list=None, n=10):
'''
This calculates the rich club coefficient for each degree
value in the graph (G).
Inputs:
G ------ networkx graph
R_list - list of random graphs with matched degree distribution
if R_list is None then a random graph is calculated
within the code
if len(R_list) is less than n then the remaining random graphs
are calculated within the code
Default R_list = None
n ------ number of random graphs for which to calculate rich club
coefficients
Default n = 10
Returns:
rc ------ dictionary of rich club coefficients for the real graph
rc_rand - array of rich club coefficients for the n random graphs
'''
# Import the modules you'll need
import networkx as nx
import numpy as np
# First, calculate the rich club coefficient for the regular graph
rc_dict = nx.rich_club_coefficient(G, normalized=False)
# Save the degrees as a numpy array
deg = np.array(rc_dict.keys())
# Save the rich club coefficients as a numpy array
rc = np.array(rc_dict.values())
# Calculate n different random graphs and their
# rich club coefficients
# Start by creating an empty array that will hold
# the n random graphs' rich club coefficients
rc_rand = np.ones([len(rc), n])
for i in range(n):
# If you haven't already calculated random graphs
# or you haven't given this function as many random
# graphs as it is expecting then calculate a random
# graph here
if not R_list or len(R_list) <= i:
R = random_graph(G)
# Otherwise just use the one you already made
else:
R = R_list[i]
# Calculate the rich club coefficient
rc_rand_dict = nx.rich_club_coefficient(R, normalized=False)
# And save the values to the numpy array you created earlier
rc_rand[:, i] = rc_rand_dict.values()
return deg, rc, rc_rand
def rich_club(G, R_list=None, n=10):
'''
This calculates the rich club coefficient for each degree
value in the graph (G).
Inputs:
G ------ networkx graph
R_list - list of random graphs with matched degree distribution
if R_list is None then a random graph is calculated
within the code
if len(R_list) is less than n then the remaining random graphs
are calculated within the code
Default R_list = None
n ------ number of random graphs for which to calculate rich club
coefficients
Default n = 10
Returns:
rc ------ dictionary of rich club coefficients for the real graph
rc_rand - array of rich club coefficients for the n random graphs
'''
# Import the modules you'll need
import networkx as nx
import numpy as np
# First, calculate the rich club coefficient for the regular graph
rc_dict = nx.rich_club_coefficient(G, normalized=False)
# Save the degrees as a numpy array
deg = np.array(rc_dict.keys())
# Save the rich club coefficients as a numpy array
rc = np.array(rc_dict.values())
# Calculate n different random graphs and their
# rich club coefficients
# Start by creating an empty array that will hold
# the n random graphs' rich club coefficients
rc_rand = np.ones([len(rc), n])
for i in range(n):
# If you haven't already calculated random graphs
# or you haven't given this function as many random
# graphs as it is expecting then calculate a random
# graph here
if not R_list or len(R_list) <= i:
R = random_graph(G)
# Otherwise just use the one you already made
else:
R = R_list[i]
# Calculate the rich club coefficient
rc_rand_dict = nx.rich_club_coefficient(R, normalized=False)
# And save the values to the numpy array you created earlier
rc_rand[:, i] = rc_rand_dict.values()
return deg, rc, rc_rand
def test_richclub4():
G = nx.Graph()
G.add_edges_from(
[(0, 1), (0, 2), (0, 3), (0, 4), (4, 5), (5, 9), (6, 9), (7, 9), (8, 9)]
)
rc = nx.rich_club_coefficient(G, normalized=False)
assert rc == {0: 18 / 90.0, 1: 6 / 12.0, 2: 0.0, 3: 0.0}
def rich_club_coefficient(self):
"""
Rich-club coefficient
Returns: A dictionary, keyed by degree, with rich-club coefficient values
"""
undirected_g = self.G.to_undirected()
return nx.rich_club_coefficient(undirected_g, normalized=False)
def rich_club(self, force=False):
'''
Calculate the rich club coefficient of G for each degree between 0 and
``max([degree(v) for v in G.nodes])``. The resulting dictionary of rich
club coefficients can be accessed and manipulated as
``G.graph['rich_club']``
Parameters
----------
force : bool
pass True to recalculate when a dictionary of rich club
coefficients already exists
Returns
-------
dict
a dictionary mapping integer `x` to the rich club coefficient of
G for degree `x`
See Also
--------
:func:`rich_club`
'''
if ('rich_club' not in self.graph) or force:
self.graph['rich_club'] = nx.rich_club_coefficient(
self, normalized=False)
return self.graph['rich_club']
def myrichclubcoefficient(G):
dd = nx.rich_club_coefficient(G,normalized=False)
d=dd.values()
avgrich = np.average(d)
stdrich = np.std(d)
fatrich = fatness(d)
return [avgrich,stdrich,fatrich]
def networkxReport(networkxObj,reportFileName=None):
import collections
report = {}
report['density'] = networkx.density(networkxObj)
report['degDist'] = {
'decription' : "degree distribution",
'value': collections.Counter([d for n, d in networkxObj.degree()])
}
report['RCC'] = {
'decription': "For each degree k, the rich-club coefficient is the ratio of the number of actual to the number of potential edges for nodes with degree greater than k",
'value': networkx.rich_club_coefficient(networkx.Graph(networkxObj), normalized=True)
}
report['s-Metric'] = {
'decription': "The s-metric is defined as the sum of the products deg(u)*deg(v) for every edge (u,v) in G",
'value' : networkx.s_metric(networkxObj, normalized=False)
}
report['degree-centrality'] = {
'decription':"The degree centrality for a node v is the fraction of nodes it is connected to",
'value' : networkx.degree_centrality(networkxObj)
}
if reportFileName:
f = open(reportFileName, "w")
f.write(json.dumps(report))
f.close()
return report
def rich_club_coefficient(G, bins=None, normalized=True, Q=1000, weight='weight'):
import random
for e in G.edges():
G[e[0]][e[1]][weight] = float(G[e[0]][e[1]][weight])
if not (G.is_multigraph() or G.is_directed()):
return nx.rich_club_coefficient(G, normalized, Q)
if bins is None:
bins = np.logspace(0,4.6,num=30) # weight
#bins = np.linspace(0,218,num=30) # count
#bins = sorted(G.degree(weight='weight').values())[:-1]
rc = map(lambda x:_phi_w(G,x,w=weight), bins)
if normalized:
R = G.copy()
rcs = []
for i in range(Q):
for n in R.nodes_iter():
keys = R.edge[n].keys()
vals = map(lambda x: R.edge[n][x], keys)
random.shuffle(vals)
for k,v in zip(keys,vals):
R.edge[n][k] = v
rcs.append(map(lambda x:_phi_w(R,x,w=weight), bins))
rc_n = np.zeros(len(rcs[0]))
for i in range(len(rc_n)):
for j in range(len(rcs)):
rc_n[i] += rcs[j][i]
rc_n[i] = rc_n[i]/Q
rc = map(lambda x,y:x/y, rc, rc_n)
return rc, bins
def test_richclub4():
G = nx.Graph()
G.add_edges_from([(0,1),(0,2),(0,3),(0,4),(4,5),(5,9),(6,9),(7,9),(8,9)])
rc = nx.rich_club_coefficient(G,normalized=False)
assert_equal(rc,{0:18/90.0,
1:6/12.0,
2:0.0,
3:0.0})
def saveRichClubDistribution(G, N, limitDistance):
rc = nx.rich_club_coefficient(G, normalized=True, Q=500)
plt.plot(rc.keys(), rc.values())
pdfName = "richclubModel" + "N" + str(
N) + "limit" + str(limitDistance) + "rand" + str(
random.randrange(1, 100)) + "_rich-club" + ".pdf"
plt.savefig(pdfName, format='pdf')
plt.close()
def compute_dict_measures(ntwk):
"""
Returns a dictionary
"""
iflogger.info('Computing measures which return a dictionary:')
measures = {}
iflogger.info('...Computing rich club coefficient...')
measures['rich_club_coef'] = nx.rich_club_coefficient(ntwk)
return measures
def plotRichClub(G):
try:
rc = nx.rich_club_coefficient(G, normalized=True, Q=500)
plt.plot(rc.keys(), rc.values())
# plt.show()
pdfName = "rich-club.pdf"
plt.savefig(pdfName, format='pdf')
plt.close()
except:
print "new try"
plotRichClub(G)
def rich_cl(Y):
rich_club = []
for one in Y:
G = nx.from_numpy_array(one)
rcv = nx.rich_club_coefficient(G, normalized=False)
a = set(rcv.keys())
b = set(range(68))
add_keys = b.difference(a)
for idx in add_keys:
rcv[idx] = 0
rich_club += [np.array(list(rcv.values()))]
return np.array(rich_club)
def saveRichClub(G):
try:
rc = nx.rich_club_coefficient(G, normalized=True, Q=500)
plt.plot(rc.keys(), rc.values())
pdfName = "hyperbolicModel" + "N" + str(
N) + "limit" + str(limitDistance) + "rand" + str(
random.randrange(1, 100)) + "_rich-club" + ".pdf"
plt.savefig(pdfName, format='pdf')
plt.close()
except:
print "new try"
saveRichClub(G)
def rich_club(self, normalized=True):
"""
Computes Rich club coefficient of network.
"""
Gcc = sorted(nx.connected_components(self.G), key=len, reverse=True)
G0 = self.G.subgraph(Gcc[0])
if normalized:
rich_club_coef = nx.rich_club_coefficient(G0,
normalized=normalized)
title = 'Rich Club Normalized'
else:
rich_club_coef = nx.rich_club_coefficient(self.G,
normalized=normalized)
title = 'Rich Club NonNormalized'
rc_array = np.zeros(len(rich_club_coef))
for i in np.arange(len(rich_club_coef)):
rc_array[i] = rich_club_coef[i]
plt.figure()
plt.plot(rc_array)
plt.title(title)
plt.savefig(self.path + title)
plt.close()
return rc_array
def test_richclub3():
#tests edgecase
G = nx.karate_club_graph()
rc = nx.rich_club_coefficient(G,normalized=False)
assert_equal(rc,{0:156.0/1122,
1:154.0/1056,
2:110.0/462,
3:78.0/240,
4:44.0/90,
5:22.0/42,
6:10.0/20,
7:10.0/20,
8:10.0/20,
9:6.0/12,
10:2.0/6,
11:2.0/6,
12:0.0,
13:0.0,
14:0.0,
15:0.0,})
def rich_club(G):
'''
Calculate the rich club coefficient of G for each degree between 0 and
``max([degree(v) for v in G.nodes])``.
Parameters
----------
G : :class:`networkx.Graph`
a binary graph
Returns
-------
dict
a dictionary mapping integer ``x`` to the rich club coefficient of G
for degree ``x``
See Also
--------
:func:`BrainNetwork.rich_club`
'''
return nx.rich_club_coefficient(G, normalized=False)
def rich_club_coefficient(G,
bins=None,
normalized=True,
Q=1000,
weight='weight'):
import random
for e in G.edges():
G[e[0]][e[1]][weight] = float(G[e[0]][e[1]][weight])
if not (G.is_multigraph() or G.is_directed()):
return nx.rich_club_coefficient(G, normalized, Q)
if bins is None:
bins = np.logspace(0, 4.6, num=30) # weight
#bins = np.linspace(0,218,num=30) # count
#bins = sorted(G.degree(weight='weight').values())[:-1]
rc = map(lambda x: _phi_w(G, x, w=weight), bins)
if normalized:
R = G.copy()
rcs = []
for i in range(Q):
for n in R.nodes_iter():
keys = R.edge[n].keys()
vals = map(lambda x: R.edge[n][x], keys)
random.shuffle(vals)
for k, v in zip(keys, vals):
R.edge[n][k] = v
rcs.append(map(lambda x: _phi_w(R, x, w=weight), bins))
rc_n = np.zeros(len(rcs[0]))
for i in range(len(rc_n)):
for j in range(len(rcs)):
rc_n[i] += rcs[j][i]
rc_n[i] = rc_n[i] / Q
rc = map(lambda x, y: x / y, rc, rc_n)
return rc, bins
def sim_runner(wgf):
wg = wgf
import pyNN.neuron as sim
nproc = sim.num_processes()
node = sim.rank()
print(nproc)
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib as mpl
mpl.rcParams.update({'font.size':16})
#import mpi4py
#threads = sim.rank()
threads = 1
rngseed = 98765
parallel_safe = False
#extra = {'threads' : threads}
import os
import pandas as pd
import sys
import numpy as np
from pyNN.neuron import STDPMechanism
import copy
from pyNN.random import RandomDistribution, NumpyRNG
import pyNN.neuron as neuron
from pyNN.neuron import h
from pyNN.neuron import StandardCellType, ParameterSpace
from pyNN.random import RandomDistribution, NumpyRNG
from pyNN.neuron import STDPMechanism, SpikePairRule, AdditiveWeightDependence, FromListConnector, TsodyksMarkramSynapse
from pyNN.neuron import Projection, OneToOneConnector
from numpy import arange
import pyNN
from pyNN.utility import get_simulator, init_logging, normalized_filename
import random
import socket
#from neuronunit.optimization import get_neab
import networkx as nx
sim = pyNN.neuron
# Get some hippocampus connectivity data, based on a conversation with
# academic researchers on GH:
# https://github.com/Hippocampome-Org/GraphTheory/issues?q=is%3Aissue+is%3Aclosed
# scrape hippocamome connectivity data, that I intend to use to program neuromorphic hardware.
# conditionally get files if they don't exist.
path_xl = '_hybrid_connectivity_matrix_20171103_092033.xlsx'
if not os.path.exists(path_xl):
os.system('wget https://github.com/Hippocampome-Org/GraphTheory/files/1657258/_hybrid_connectivity_matrix_20171103_092033.xlsx')
xl = pd.ExcelFile(path_xl)
dfEE = xl.parse()
dfEE.loc[0].keys()
dfm = dfEE.as_matrix()
rcls = dfm[:,:1] # real cell labels.
rcls = rcls[1:]
rcls = { k:v for k,v in enumerate(rcls) } # real cell labels, cast to dictionary
import pickle
with open('cell_names.p','wb') as f:
pickle.dump(rcls,f)
import pandas as pd
pd.DataFrame(rcls).to_csv('cell_names.csv', index=False)
filtered = dfm[:,3:]
filtered = filtered[1:]
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
weight_distr = RandomDistribution('normal', [45, 1e-1], rng=rng)
sanity_e = []
sanity_i = []
EElist = []
IIlist = []
EIlist = []
IElist = []
for i,j in enumerate(filtered):
for k,xaxis in enumerate(j):
if xaxis == 1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
if xaxis ==-1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
index_exc = list(set(sanity_e))
index_inh = list(set(sanity_i))
import pickle
with open('cell_indexs.p','wb') as f:
returned_list = [index_exc, index_inh]
pickle.dump(returned_list,f)
import numpy
a = numpy.asarray(index_exc)
numpy.savetxt('pickles/'+str(k)+'excitatory_nunber_labels.csv', a, delimiter=",")
import numpy
a = numpy.asarray(index_inh)
numpy.savetxt('pickles/'+str(k)+'inhibitory_nunber_labels.csv', a, delimiter=",")
for i,j in enumerate(filtered):
for k,xaxis in enumerate(j):
if xaxis==1 or xaxis == 2:
source = i
sanity_e.append(i)
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_inh:
EIlist.append((source,target,delay,weight))
else:
EElist.append((source,target,delay,weight))
if xaxis==-1 or xaxis == -2:
sanity_i.append(i)
source = i
target = k
delay = delay_distr.next()
weight = 1.0
if target in index_exc:
IElist.append((source,target,delay,weight))
else:
IIlist.append((source,target,delay,weight))
internal_conn_ee = sim.FromListConnector(EElist)
ee = internal_conn_ee.conn_list
ee_srcs = ee[:,0]
ee_tgs = ee[:,1]
internal_conn_ie = sim.FromListConnector(IElist)
ie = internal_conn_ie.conn_list
ie_srcs = set([ int(e[0]) for e in ie ])
ie_tgs = set([ int(e[1]) for e in ie ])
internal_conn_ei = sim.FromListConnector(EIlist)
ei = internal_conn_ei.conn_list
ei_srcs = set([ int(e[0]) for e in ei ])
ei_tgs = set([ int(e[1]) for e in ei ])
internal_conn_ii = sim.FromListConnector(IIlist)
ii = internal_conn_ii.conn_list
ii_srcs = set([ int(e[0]) for e in ii ])
ii_tgs = set([ int(e[1]) for e in ii ])
for e in internal_conn_ee.conn_list:
assert e[0] in ee_srcs
assert e[1] in ee_tgs
for i in internal_conn_ii.conn_list:
assert i[0] in ii_srcs
assert i[1] in ii_tgs
ml = len(filtered[1])+1
pre_exc = []
post_exc = []
pre_inh = []
post_inh = []
rng = NumpyRNG(seed=64754)
delay_distr = RandomDistribution('normal', [2, 1e-1], rng=rng)
plot_EE = np.zeros(shape=(ml,ml), dtype=bool)
plot_II = np.zeros(shape=(ml,ml), dtype=bool)
plot_EI = np.zeros(shape=(ml,ml), dtype=bool)
plot_IE = np.zeros(shape=(ml,ml), dtype=bool)
for i in EElist:
plot_EE[i[0],i[1]] = int(0)
#plot_ss[i[0],i[1]] = int(1)
if i[0]!=i[1]: # exclude self connections
plot_EE[i[0],i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
assert len(pre_exc) == len(post_exc)
for i in IIlist:
plot_II[i[0],i[1]] = int(0)
if i[0]!=i[1]:
plot_II[i[0],i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in IElist:
plot_IE[i[0],i[1]] = int(0)
if i[0]!=i[1]: # exclude self connections
plot_IE[i[0],i[1]] = int(1)
pre_inh.append(i[0])
post_inh.append(i[1])
for i in EIlist:
plot_EI[i[0],i[1]] = int(0)
if i[0]!=i[1]:
plot_EI[i[0],i[1]] = int(1)
pre_exc.append(i[0])
post_exc.append(i[1])
plot_excit = plot_EI + plot_EE
plot_inhib = plot_IE + plot_II
assert len(pre_inh) == len(post_inh)
num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]
# the network is dominated by inhibitory neurons, which is unusual for modellers.
assert num_inh > num_exc
assert np.sum(plot_inhib) > np.sum(plot_excit)
assert len(num_exc) < ml
assert len(num_inh) < ml
# # Plot all the Projection pairs as a connection matrix (Excitatory and Inhibitory Connections)
import pickle
with open('graph_inhib.p','wb') as f:
pickle.dump(plot_inhib,f, protocol=2)
import pickle
with open('graph_excit.p','wb') as f:
pickle.dump(plot_excit,f, protocol=2)
#with open('cell_names.p','wb') as f:
# pickle.dump(rcls,f)
import pandas as pd
pd.DataFrame(plot_EE).to_csv('ee.csv', index=False)
import pandas as pd
pd.DataFrame(plot_IE).to_csv('ie.csv', index=False)
import pandas as pd
pd.DataFrame(plot_II).to_csv('ii.csv', index=False)
import pandas as pd
pd.DataFrame(plot_EI).to_csv('ei.csv', index=False)
from scipy.sparse import coo_matrix
m = np.matrix(filtered[1:])
bool_matrix = np.add(plot_excit,plot_inhib)
with open('bool_matrix.p','wb') as f:
pickle.dump(bool_matrix,f, protocol=2)
if not isinstance(m, coo_matrix):
m = coo_matrix(m)
Gexc_ud = nx.Graph(plot_excit)
avg_clustering = nx.average_clustering(Gexc_ud)#, nodes=None, weight=None, count_zeros=True)[source]
rc = nx.rich_club_coefficient(Gexc_ud,normalized=False)
print('This graph structure as rich as: ',rc[0])
gexc = nx.DiGraph(plot_excit)
gexcc = nx.betweenness_centrality(gexc)
top_exc = sorted(([ (v,k) for k, v in dict(gexcc).items() ]), reverse=True)
in_degree = gexc.in_degree()
top_in = sorted(([ (v,k) for k, v in in_degree.items() ]))
in_hub = top_in[-1][1]
out_degree = gexc.out_degree()
top_out = sorted(([ (v,k) for k, v in out_degree.items() ]))
out_hub = top_out[-1][1]
mean_out = np.mean(list(out_degree.values()))
mean_in = np.mean(list(in_degree.values()))
mean_conns = int(mean_in + mean_out/2)
k = 2 # number of neighbouig nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ne = len(plot_excit)# size of small world network
small_world_ring_excit = nx.watts_strogatz_graph(ne,mean_conns,0.25)
k = 2 # number of neighbouring nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ni = len(plot_inhib)# size of small world network
small_world_ring_inhib = nx.watts_strogatz_graph(ni,mean_conns,0.25)
nproc = sim.num_processes()
nproc = 8
host_name = socket.gethostname()
node_id = sim.setup(timestep=0.01, min_delay=1.0)#, **extra)
print("Host #%d is on %s" % (node_id + 1, host_name))
rng = NumpyRNG(seed=64754)
#pop_size = len(num_exc)+len(num_inh)
#num_exc = [ i for i,e in enumerate(plot_excit) if sum(e) > 0 ]
#num_inh = [ y for y,i in enumerate(plot_inhib) if sum(i) > 0 ]
#pop_exc = sim.Population(len(num_exc), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
#pop_inh = sim.Population(len(num_inh), sim.Izhikevich(a=0.02, b=0.25, c=-65, d=2, i_offset=0))
#index_exc = list(set(sanity_e))
#index_inh = list(set(sanity_i))
all_cells = sim.Population(len(index_exc)+len(index_inh), sim.Izhikevich(a=0.02, b=0.2, c=-65, d=8, i_offset=0))
#all_cells = None
#all_cells = pop_exc + pop_inh
pop_exc = sim.PopulationView(all_cells,index_exc)
pop_inh = sim.PopulationView(all_cells,index_inh)
#print(pop_exc)
#print(dir(pop_exc))
for pe in pop_exc:
print(pe)
#import pdb
pe = all_cells[pe]
#pdb.set_trace()
#pe = all_cells[i]
r = random.uniform(0.0, 1.0)
pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)
#pop_exc.append(pe)
#pop_exc = sim.Population(pop_exc)
for pi in index_inh:
pi = all_cells[pi]
#print(pi)
#pi = all_cells[i]
r = random.uniform(0.0, 1.0)
pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
#pop_inh.append(pi)
#pop_inh = sim.Population(pop_inh)
'''
for pe in pop_exc:
r = random.uniform(0.0, 1.0)
pe.set_parameters(a=0.02, b=0.2, c=-65+15*r, d=8-r**2, i_offset=0)
for pi in pop_inh:
r = random.uniform(0.0, 1.0)
pi.set_parameters(a=0.02+0.08*r, b=0.25-0.05*r, c=-65, d= 2, i_offset=0)
'''
NEXC = len(num_exc)
NINH = len(num_inh)
exc_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
assert np.any(internal_conn_ee.conn_list[:,0]) < ee_srcs.size
prj_exc_exc = sim.Projection(all_cells, all_cells, internal_conn_ee, exc_syn, receptor_type='excitatory')
prj_exc_inh = sim.Projection(all_cells, all_cells, internal_conn_ei, exc_syn, receptor_type='excitatory')
inh_syn = sim.StaticSynapse(weight = wg, delay=delay_distr)
delay_distr = RandomDistribution('normal', [1, 100e-3], rng=rng)
prj_inh_inh = sim.Projection(all_cells, all_cells, internal_conn_ii, inh_syn, receptor_type='inhibitory')
prj_inh_exc = sim.Projection(all_cells, all_cells, internal_conn_ie, inh_syn, receptor_type='inhibitory')
inh_distr = RandomDistribution('normal', [1, 2.1e-3], rng=rng)
def prj_change(prj,wg):
prj.setWeights(wg)
prj_change(prj_exc_exc,wg)
prj_change(prj_exc_inh,wg)
prj_change(prj_inh_exc,wg)
prj_change(prj_inh_inh,wg)
def prj_check(prj):
for w in prj.weightHistogram():
for i in w:
print(i)
prj_check(prj_exc_exc)
prj_check(prj_exc_inh)
prj_check(prj_inh_exc)
prj_check(prj_inh_inh)
#print(rheobase['value'])
#print(float(rheobase['value']),1.25/1000.0)
'''Old values that worked
noise = sim.NoisyCurrentSource(mean=0.85/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.740/1000.0, stdev=5.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_inh.inject(noise)
#1750.0 pA
'''
noise = sim.NoisyCurrentSource(mean=0.74/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_exc.inject(noise)
#1000.0 pA
noise = sim.NoisyCurrentSource(mean=1.440/1000.0, stdev=4.00/1000.0, start=0.0, stop=2000.0, dt=1.0)
pop_inh.inject(noise)
##
# Setup and run a simulation. Note there is no current injection into the neuron.
# All cells in the network are in a quiescent state, so its not a surprise that xthere are no spikes
##
sim = pyNN.neuron
arange = np.arange
import re
all_cells.record(['v','spikes']) # , 'u'])
all_cells.initialize(v=-65.0, u=-14.0)
# === Run the simulation =====================================================
tstop = 2000.0
sim.run(tstop)
data = None
data = all_cells.get_data().segments[0]
#print(len(data.analogsignals[0].times))
with open('pickles/qi'+str(wg)+'.p', 'wb') as f:
pickle.dump(data,f)
# make data none or else it will grow in a loop
all_cells = None
data = None
noise = None
def create_summary(self,text,corenumber=3,pathsimilarity=0.8,graphtraversedsummary=False,shortestpath=True):
if graphtraversedsummary==True:
definitiongraph=RecursiveGlossOverlap_Classifier.RecursiveGlossOverlapGraph(text)
#This has to be replaced by a Hypergraph Transversal but NetworkX does not have Hypergraphs yet.
#Hence approximating the transversal with a k-core which is the Graph counterpart of
#Hypergraph transversal. Other measures create a summary too : Vertex Cover is NP-hard while Edge Cover is Polynomial Time.
richclubcoeff=nx.rich_club_coefficient(definitiongraph.to_undirected())
print "Rich Club Coefficient of the Recursive Gloss Overlap Definition Graph:",richclubcoeff
kcore=nx.k_core(definitiongraph,corenumber)
print "Text Summarized by k-core(subgraph having vertices of degree atleast k) on the Recursive Gloss Overlap graph:"
print "=========================="
print "Dense subgraph edges:"
print "=========================="
print kcore.edges()
print "=========================="
if shortestpath == False:
for e in kcore.edges():
for s1 in wn.synsets(e[0]):
for s2 in wn.synsets(e[1]):
if s1.path_similarity(s2) > pathsimilarity:
lowestcommonhypernyms=s1.lowest_common_hypernyms(s2)
for l in lowestcommonhypernyms:
for ln in l.lemma_names():
print e[0]," and ",e[1]," are ",ln,".",
else:
#Following is the slightly modified version of shortest_path_distance() function
#in NLTK wordnet - traverses the synset path between 2 synsets instead of distance
summary={}
intermediates=[]
for e in kcore.edges():
for s1 in wn.synsets(e[0]):
for s2 in wn.synsets(e[1]):
s1dict = s1._shortest_hypernym_paths(False)
s2dict = s2._shortest_hypernym_paths(False)
s2dictkeys=s2dict.keys()
for s,d in s1dict.iteritems():
if s in s2dictkeys:
slemmanames=s.lemma_names()
if slemmanames[0] not in intermediates:
intermediates.append(slemmanames[0])
if len(intermediates) > 3:
sentence1=e[0] + " is a " + intermediates[0]
summary[sentence1]=self.relevance_to_text(sentence1,text)
for i in xrange(len(intermediates)-2):
sentence2= intermediates[i] + " is a " + intermediates[i+1] + "."
if sentence2 not in summary:
summary[sentence2]=self.relevance_to_text(sentence2,text)
sentence3=intermediates[len(intermediates)-1] + " is a " + e[1]
summary[sentence3]=self.relevance_to_text(sentence3,text)
intermediates=[]
sorted_summary=sorted(summary,key=operator.itemgetter(1), reverse=True)
print "==================================================================="
print "Sorted summary created from k-core dense subgraph of text RGO"
print "==================================================================="
for s in sorted_summary:
print s,
return (sorted_summary, len(sorted_summary))
else:
definitiongraph_merit=RecursiveGlossOverlap_Classifier.RecursiveGlossOverlapGraph(text)
definitiongraph=definitiongraph_merit[0]
richclubcoeff=nx.rich_club_coefficient(definitiongraph.to_undirected(),normalized=False)
print "Rich Club Coefficient of the Recursive Gloss Overlap Definition Graph:",richclubcoeff
textsentences=text.split(".")
lensummary=0
summary=[]
definitiongraphclasses=RecursiveGlossOverlap_Classifier.RecursiveGlossOverlap_Classify(text)
print "Text Summarized based on the Recursive Gloss Overlap graph classes the text belongs to:"
prominentclasses=int(len(definitiongraphclasses[0])/2)
print "Total number of classes:",len(definitiongraphclasses[0])
print "Number of prominent classes:",prominentclasses
for c in definitiongraphclasses[0][:prominentclasses]:
if len(summary) > len(textsentences) * 0.5:
return (summary,lensummary)
for s in textsentences:
classsynsets=wn.synsets(c[0])
for classsynset in classsynsets:
if self.relevance_to_text(classsynset.definition(), s) > 0.41:
if s not in summary:
summary.append(s)
lensummary += len(s)
print s,
return (summary,lensummary)
#""" xGraphs = [nx.Graph() for i in xrange(len(Graphs))] xFakeGraphs = [nx.Graph() for i in xrange(len(FakeGraphs))] for i in xrange(len(Graphs)): gt.remove_self_loops(Graphs[i]) for e in Graphs[i].edges(): xGraphs[i].add_edge(*e) for i in xrange(len(FakeGraphs)): gt.remove_parallel_edges(FakeGraphs[i]) for e in FakeGraphs[i].edges(): xFakeGraphs[i].add_edge(*e) #print nx.rich_club_coefficient(xGraphs[0], normalized = False) RealClubs = [] print len(xGraphs) for Graph in xGraphs: Coefficients = nx.rich_club_coefficient(Graph, normalized = False) print len(Coefficients) Dummy = np.zeros((len(Coefficients),)) for i in xrange(len(Dummy)): Dummy[i] = Coefficients[i] RealClubs.append(Dummy) FakeClubs = [] for Graph in xFakeGraphs: Coefficients = nx.rich_club_coefficient(Graph, normalized = False) print len(Coefficients) Dummy = np.zeros((len(Coefficients),)) for i in xrange(len(Dummy)): Dummy[i] = Coefficients[i] FakeClubs.append(Dummy) Lines = [] f,ax = plt.subplots()
GCnodes = max(nx.connected_components(H), key=len)
# giant component as a network
G = H.subgraph(GCnodes)
###### drawing the graph --- Kamada-Kawai layout
plt.figure(figsize=[9, 9])
pos = nx.kamada_kawai_layout(G, weight=None) # positions for all nodes
nx.draw_networkx_nodes(G, pos, node_color='salmon', node_size=200)
nx.draw_networkx_edges(G, pos, edge_color='lightblue')
nx.draw_networkx_labels(G, pos, font_size=7, font_color='black')
plt.axis('off')
plt.title('Dolphin social network')
plt.show()
##### Rich club coefficient (original network)
RCdict = nx.rich_club_coefficient(G, normalized=False)
# extracting the degree and rich club coeff from the dictionary
K = [k for k, rc in RCdict.items()]
RCorig = [rc for k, rc in RCdict.items()]
##### Rich club coefficient (random network)
RCrand = np.zeros_like(RCorig)
nIter = 200 # number of random networks to be generated
print('Generating random networks ')
for iIter in range(nIter):
print('.', end='')
if (iIter + 1) % 20 == 0:
print()
# first generating a random network
def rich_club(G):
rc = nx.rich_club_coefficient(G,normalized=False)
return rc
def rich_club_norm(G):
rc = nx.rich_club_coefficient(G,normalized=True)
return rc
print k
#print degree[1]
deg = {}
deg2 = {}
sum = 0.0
for i in G_init.nodes():
deg[i] = G_init.degree(i)
deg2[i] = deg[i] * deg[i]
sum += deg2[i]
degree_max = sorted(deg.items(), key=lambda d: d[1], reverse=True)
print 'max degree'
print degree_max[0]
print 'average_clustering'
print(nx.average_clustering(G_init))
print 'average_shortest_path_length'
D = max(nx.connected_component_subgraphs(G_init), key=len)
print(nx.average_shortest_path_length(D))
#print(nx.average_shortest_path_length(G_init))
print 'assortativity_coefficient'
print round(nx.degree_assortativity_coefficient(G_init), 3)
print "H"
H = round(sum / (float(k * k) * float(G_init.number_of_nodes())), 3)
print H
print "spreading lamida"
lamida = float(k) / (float(sum) / float(G_init.number_of_nodes()) - k)
print round(lamida, 3)
rc = nx.rich_club_coefficient(G_init, normalized=False) #富人俱乐部
#print "rich_club"
print rc
largest_cc = len(max(nx.connected_components(G), key=len))
print largest_cc
def makeMeasures(self, network, exclude):
"""Make the network measures"""
# fazer condicional para cada medida, se não estiver na exclude[],
# fazer medida de tempo e guardar como tupla no
g = network.g
gu = network.gu
timings = []
T = t.time()
self.N = network.g.number_of_nodes()
self.E = network.g.number_of_edges()
self.E_ = network.gu.number_of_edges()
self.edges = g.edges(data=True)
self.nodes = g.nodes(data=True)
timings.append((t.time() - T, "edges and nodes"))
T = t.time()
self.degrees = dict(g.degree())
self.nodes_ = sorted(g.nodes(), key=lambda x: self.degrees[x])
self.degrees_ = [self.degrees[i] for i in self.nodes_]
self.in_degrees = dict(g.in_degree())
self.in_degrees_ = [self.in_degrees[i] for i in self.nodes_]
self.out_degrees = dict(g.out_degree())
self.out_degrees_ = [self.out_degrees[i] for i in self.nodes_]
timings.append((t.time() - T, "in_out_total_degrees"))
T = t.time()
self.strengths = dict(g.degree(weight="weight"))
self.nodes__ = sorted(g.nodes(), key=lambda x: self.strengths[x])
self.strengths_ = [self.strengths[i] for i in self.nodes_]
self.in_strengths = dict(g.in_degree(weight="weight"))
self.in_strengths_ = [self.in_strengths[i] for i in self.nodes_]
self.out_strengths = dict(g.out_degree(weight="weight"))
self.out_strengths_ = [self.out_strengths[i] for i in self.nodes_]
timings.append((t.time() - T, "in_out_total_strengths"))
# symmetry measures
self.asymmetries = asymmetries = []
self.disequilibrium = disequilibriums = []
self.asymmetries_edge_mean = asymmetries_edge_mean = []
self.asymmetries_edge_std = asymmetries_edge_std = []
self.disequilibrium_edge_mean = disequilibrium_edge_mean = []
self.disequilibrium_edge_std = disequilibrium_edge_std = []
for node in self.nodes_:
if not self.degrees[node]:
asymmetries.append(0.)
disequilibriums.append(0.)
asymmetries_edge_mean.append(0.)
asymmetries_edge_std.append(0.)
disequilibrium_edge_mean.append(0.)
disequilibrium_edge_std.append(0.)
else:
asymmetries.append(
(self.in_degrees[node] - self.out_degrees[node]) /
self.degrees[node])
disequilibriums.append(
(self.in_strengths[node] - self.out_strengths[node]) /
self.strengths[node])
edge_asymmetries = ea = []
edge_disequilibriums = ed = []
predecessors = g.predecessors(node)
successors = g.successors(node)
for pred in predecessors:
if pred in successors:
ea.append(0.)
ed.append(
(g[pred][node]['weight'] - g[node][pred]['weight'])
/ self.strengths[node])
else:
ea.append(1.)
ed.append(g[pred][node]['weight'] /
self.strengths[node])
for suc in successors:
if suc in predecessors:
pass
else:
ea.append(-1.)
ed.append(-g[node][suc]['weight'] /
self.strengths[node])
asymmetries_edge_mean.append(n.mean(ea))
asymmetries_edge_std.append(n.std(ea))
disequilibrium_edge_mean.append(n.mean(ed))
disequilibrium_edge_std.append(n.std(ed))
if "weighted_directed_betweenness" not in exclude:
T = t.time()
self.weighted_directed_betweenness = x.betweenness_centrality(
g, weight="weight")
self.weighted_directed_betweenness_ = [
self.weighted_directed_betweenness[i] for i in self.nodes_
]
timings.append((t.time() - T, "weighted_directed_betweenness"))
if "unweighted_directed_betweenness" not in exclude:
T = t.time()
self.unweighted_directed_betweenness = x.betweenness_centrality(g)
timings.append((t.time() - T, "unweighted_directed_betweenness"))
if "weighted_undirected_betweenness" not in exclude:
T = t.time()
self.weighted_undirected_betweenness = x.betweenness_centrality(
gu, weight="weight")
timings.append((t.time() - T, "weighted_undirected_betweenness"))
if "unweighted_undirected_betweenness" not in exclude:
T = t.time()
self.weighted_undirected_betweenness = x.betweenness_centrality(gu)
timings.append((t.time() - T, "unweighted_undirected_betweenness"))
if "wiener" not in exclude:
T = t.time()
self.wiener = x.wiener_index(g, weight="weight")
timings.append((t.time() - T, "weiner"))
if "closeness" not in exclude:
T = t.time()
self.closeness = x.vitality.closeness_vitality(g, weight="weight")
timings.append((t.time() - T, "closeness"))
if "transitivity" not in exclude:
T = t.time()
self.transitivity = x.transitivity(g)
timings.append((t.time() - T, "transitivity"))
if "rich_club" not in exclude:
T = t.time()
self.rich_club = x.rich_club_coefficient(gu)
timings.append((t.time() - T, "rich_club"))
if "weighted_clustering" not in exclude:
T = t.time()
self.weighted_clusterings = x.clustering(network.gu,
weight="weight")
self.weighted_clusterings_ = [
self.weighted_clusterings[i] for i in self.nodes_
]
timings.append((t.time() - T, "weighted_clustering"))
if "clustering" not in exclude:
T = t.time()
self.clusterings = x.clustering(network.gu)
self.clusterings_ = [self.clusterings[i] for i in self.clusterings]
timings.append((t.time() - T, "clustering"))
if "triangles" not in exclude:
T = t.time()
self.triangles = x.triangles(gu)
timings.append((t.time() - T, "clustering"))
if "n_weakly_connected_components" not in exclude:
T = t.time()
self.n_weakly_connected_components = x.number_weakly_connected_components(
g)
timings.append((t.time() - T, "n_weakly_connected_components"))
if "n_strongly_connected_components" not in exclude:
T = t.time()
self.n_strongly_connected_components = x.number_strongly_connected_components(
g)
timings.append((t.time() - T, "n_strongly_connected_components"))
T = t.time()
foo = [i for i in x.connected_component_subgraphs(gu)]
bar = sorted(foo, key=lambda x: x.number_of_nodes(), reverse=True)
self.component = c = bar[0]
timings.append((t.time() - T, "component"))
T = t.time()
self.diameter = x.diameter(c)
self.radius = x.radius(c)
self.center = x.center(c)
self.periphery = x.periphery(c)
timings.append((t.time() - T, "radius_diameter_center_periphery"))
self.timings = timings
T = t.time()
self.n_connected_components = x.number_connected_components(gu)
nodes = []
nodes_components = [
foo.nodes() for foo in x.connected_component_subgraphs(gu)
][:1]
for nodes_ in nodes_components:
nodes += nodes_
self.periphery_ = nodes
self.timings = timings
def _compute_rich_club_coefficient(G: nx.Graph) -> Dict[int, float]:
"""
Source: https://networkx.github.io/documentation/stable/_modules/networkx/algorithms/richclub.html#rich_club_coefficient
"""
return nx.rich_club_coefficient(G)
def test_rich_club_exception2():
with pytest.raises(nx.NetworkXNotImplemented):
G = nx.MultiGraph()
nx.rich_club_coefficient(G)
infomap_clust=gg.community_infomap()
modularity_infomap=infomap_clust.modularity
membership=infomap_clust.membership
numpy.savetxt('/corral-repl/utexas/poldracklab/data/selftracking/analyses/rsfmri_analyses/infomap_assignments/infomap_sess%03d_%.04f.txt'%(sess,edge_density),membership)
sizethresh=2
labels=numpy.array(infomap_clust.membership)
for x in numpy.unique(labels):
if numpy.sum(labels==x)<sizethresh:
labels[labels==x]=0
pi=participation_index.participation_index(adj,labels)
#mean_pi=numpy.mean(pi)
try:
rcc=networkx.rich_club_coefficient(G,normalized=True)
rcc_cutoff=int(numpy.ceil(numpy.mean(degree) + numpy.std(degree)))
rcc_at_cutoff=rcc[rcc_cutoff]
except:
rcc_at_cutoff=0.0
# get small world coefficient
#from the clustering coefficient (CC) and the average path length (PL) =
# CC(actual network)/CC(random graph) divided by PL(actual network)/PL(random graph)
# use just the largest connected component
gcsize=G.number_of_nodes()
apl=networkx.average_shortest_path_length(G)
Gclust=networkx.average_clustering(G)
def data_dump(plot_inhib, plot_excit, plot_EE, plot_IE, plot_II, plot_EI,
filtered):
import pandas as pd
import networkx as nx
import pickle
with open('graph_inhib.p', 'wb') as f:
pickle.dump(plot_inhib, f, protocol=2)
import pickle
with open('graph_excit.p', 'wb') as f:
pickle.dump(plot_excit, f, protocol=2)
#with open('cell_names.p','wb') as f:
# pickle.dump(rcls,f)
import pandas as pd
pd.DataFrame(plot_EE).to_csv('ee.csv', index=False)
import pandas as pd
pd.DataFrame(plot_IE).to_csv('ie.csv', index=False)
import pandas as pd
pd.DataFrame(plot_II).to_csv('ii.csv', index=False)
import pandas as pd
pd.DataFrame(plot_EI).to_csv('ei.csv', index=False)
from scipy.sparse import coo_matrix
m = np.matrix(filtered[1:])
bool_matrix = np.add(plot_excit, plot_inhib)
with open('bool_matrix.p', 'wb') as f:
pickle.dump(bool_matrix, f, protocol=2)
if not isinstance(m, coo_matrix):
m = coo_matrix(m)
Gexc_ud = nx.Graph(plot_excit)
avg_clustering = nx.average_clustering(
Gexc_ud) #, nodes=None, weight=None, count_zeros=True)[source]
rc = nx.rich_club_coefficient(Gexc_ud, normalized=False)
print('This graph structure as rich as: ', rc[0])
gexc = nx.DiGraph(plot_excit)
gexcc = nx.betweenness_centrality(gexc)
top_exc = sorted(([(v, k) for k, v in dict(gexcc).items()]), reverse=True)
in_degree = gexc.in_degree()
top_in = sorted(([(v, k) for k, v in in_degree.items()]))
in_hub = top_in[-1][1]
out_degree = gexc.out_degree()
top_out = sorted(([(v, k) for k, v in out_degree.items()]))
out_hub = top_out[-1][1]
mean_out = np.mean(list(out_degree.values()))
mean_in = np.mean(list(in_degree.values()))
mean_conns = int(mean_in + mean_out / 2)
k = 2 # number of neighbouig nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ne = len(plot_excit) # size of small world network
small_world_ring_excit = nx.watts_strogatz_graph(ne, mean_conns, 0.25)
k = 2 # number of neighbouring nodes to wire.
p = 0.25 # probability of instead wiring to a random long range destination.
ni = len(plot_inhib) # size of small world network
small_world_ring_inhib = nx.watts_strogatz_graph(ni, mean_conns, 0.25)
def test_richclub_exception():
G = nx.DiGraph()
nx.rich_club_coefficient(G)
import networkx as nx
import matplotlib.pyplot as plt
import pylab
G = nx.DiGraph()
G = nx.read_edgelist('wiki.txt')
#print(nx.info(G))
#print(nx.number_of_nodes(G))
#print(nx.number_of_edges(G))
#print(nx.is_directed(G))
#Rich club
rc = nx.rich_club_coefficient(G, normalized=False)
plt.scatter(rc.keys(), rc.values(), marker='x', c='g', s=0.5)
plt.title('Rich-Club coefficient vs node degree')
plt.xlabel('k')
plt.ylabel('Rich-club coefficient of k')
pylab.savefig('rc_coefficient.png')
#Compute degree assortativity of graph.
dac = nx.degree_assortativity_coefficient(G)
print(dac)
#Nearest neighbrt drgree
#knn = nx.k_nearest_neighbors(G)
#plt.scatter(knn.keys(),knn.values(),marker='x', c='r',s = 0.5)
#plt.title('Nearest neghbours average degree vs node degree')
#plt.xlabel('k')
e_weight = G[n1][n2]['weight']
weight_dict[n1] += e_weight
weight_dict[n2] += e_weight
############################################
print nx.attribute_assortativity_coefficient(G,'gender')
node_clustering = nx.clustering(G)
node_degree = nx.degree(G)
btw_list = nx.betweenness_centrality(G)
closeness_list = nx.closeness_centrality(G)
core_list = nx.core_number(G) #not a googd measure
esize = effective_size(G)
core_list = nx.core_number(G)
rc = nx.rich_club_coefficient(G,normalized=False)
rc[23] = 1.0
print rc
print core_list
male_cc = []
male_deg = []
male_btw = []
male_closeness = []
male_esize = []
male_core = []
male_rc = []
male_strength = []
female_cc = []
female_deg = []
def eval_rich_club(graph):
# extracting feature matrix
return list(
nx.rich_club_coefficient(remove_selfloops(graph),
normalized=False).values())
def analyzeGraph(filename, metrics , myformat = 'adjacency'):
# format: adjacency e' la matrice di 0 e 1, valori spaziati da "," e righe termiante da ; DEFAULT
# il formato matlab e' quello invece ce usa matlab per fare le matrici
myfile = open(filename);
#inizializzo la struttura dati
matrix = []
for line in myfile:
print(line)
if myformat == 'matlab' :
line = line.replace('[','')
line = line.replace(']','')
line = line.replace(';','')
print(line)
matrix.append([int(i)for i in line.split(',')])
myfile.close()
topologicalmap = importFromMatlabJava2012FormatToIgraph(matrix)
g = topologicalmap.graph
gx = topologicalmap.gx
Cs = g.vs.select(RC_label = 'C')
Rs = g.vs.select(RC_label = 'R')
indexC = [i.index for i in Cs]
indexR = [i.index for i in Rs]
data = dict()
####################################### Network X
# degree_assortativity
degree_assortativity = nx.degree_assortativity_coefficient(gx)
data['degree_assortativity'] = degree_assortativity
# eccentricity
eccentricity = (len(indexR)+len(indexC))*[0]
for k, v in nx.eccentricity(gx).items():
eccentricity[k] = v
data['eccentricity'] = eccentricity
# mu_eccentricity
data['mu_eccentricity'] = avg(eccentricity)
# katz_centrality
katz_centrality = (len(indexR)+len(indexC))*[0]
for k, v in nx.katz_centrality(gx).items():
katz_centrality[k] = v
data['katz_centrality'] = katz_centrality
# mu_katz_centrality
data['mu_katz_centrality'] = avg(katz_centrality)
# rich_club_coefficient
rich_club_coefficient = nx.rich_club_coefficient(gx)
data['rich_club_coefficient'] = rich_club_coefficient
# mu_rich_club_coefficient
data['mu_rich_club_coefficient'] = avg(rich_club_coefficient)
####################################### Igraph
# numero di nodi
data['nodes'] = len(g.vs())
# numero di R
data['R'] = len(indexR)
# numero di C
data['C'] = len(indexC)
# average path len
data['path_len'] = g.average_path_length()
# diametro
data['diameter'] = g.diameter()
# average degree (densirt)
data['density'] = g.density()
# articulation points, quanti sono
data['articulation_points'] = len(g.articulation_points())
# betweenness
betweenness = g.betweenness()
data['betweenness'] = betweenness
# mean betweenness
data['mu_betweenness'] = avg(betweenness)
# scaled betweenness
scaled_b = [ float(i)/(float(len(betweenness)-1))/(float(len(betweenness))-2) for i in betweenness ]
data['scaled_betweenness'] = scaled_b
# mean scaled betweenness
data['mu_scaled_betweenness'] = avg(scaled_b)
# betweenness scaled solo R
data['Rbetweenness'] = selectLabelArray(scaled_b,indexR)
# average eccentricity solo R
print(eccentricity)
data['Reccentricity'] = selectLabelArray(eccentricity,indexR)
data['mu_Reccentricity'] = avg(data['Reccentricity'])
# average eccentricity solo C
data['Ceccentricity'] = selectLabelArray(eccentricity,indexC)
data['mu_Ceccentricity'] = avg(data['Ceccentricity'])
# average katz_centrality solo R
data['Rkatz_centrality'] = selectLabelArray(katz_centrality,indexR)
data['mu_Rkatz_centrality'] = avg(data['Rkatz_centrality'])
# average katz_centrality solo C
data['Ckatz_centrality'] = selectLabelArray(katz_centrality,indexC)
data['mu_Ckatz_centrality'] = avg(data['Ckatz_centrality'])
# average betweennes scaled solo R
print(data['Rbetweenness'])
data['mu_Rbetweenness'] = avg(data['Rbetweenness'])
# betweenness scaled solo C
data['Cbetweenness'] = selectLabelArray(scaled_b,indexC)
# average betwenness scaled solo C
data['mu_Cbetweenness'] = avg(data['Cbetweenness'])
# closenesss
closeness = g.closeness()
data['closeness'] = closeness
# average closeness
data['mu_closeness'] = avg(closeness)
# closeness solo R
data['Rcloseness'] = selectLabelArray(closeness,indexR)
# avg closeness solo R
data['mu_Rcloseness'] = avg(data['Rcloseness'])
# closeness solo C
data['Ccloseness'] = selectLabelArray(closeness,indexC)
# avg closeness solo C
data['mu_Ccloseness'] = avg(data['Ccloseness'])
# eigenvector centrality
eigenvec = g.eigenvector_centrality()
data['eig'] = eigenvec
# mean eig
data['mu_eig'] = avg(eigenvec)
# eigenvec centrality R
data['Reig'] = selectLabelArray(eigenvec,indexR)
# mean eigenvec centrality R
data['mu_Reig'] = avg(data['Reig'])
# eigenvec centrality C
data['Ceig'] = selectLabelArray(eigenvec,indexC)
# mean eigenvec centrality C
data['mu_Ceig'] = avg(data['Ceig'])
# coreness
coreness = g.coreness()
data['coreness'] = coreness
# mean coreness
data['mu_coreness'] = avg(coreness)
# eigenvec coreness R
data['Rcoreness'] = selectLabelArray(coreness,indexR)
# mean coreness R
data['mu_Rcoreness'] = avg(data['Rcoreness'])
# eigenvec coreness C
data['Ccoreness'] = selectLabelArray(coreness,indexC)
# mean coreness C
data['mu_Ccoreness'] = avg(data['Ccoreness'])
#print ".".join(filename.split(".")[:-1])+ ".png"
#plot(graph,".".join(filename.split(".")[:-1])+".png")
order = dict()
for i in range(len(metrics)) :
order[str(i)] = metrics[i]
stringa = str()
for j in range(len(metrics)):
i = order[str(j)]
stringa+= str(i) + ":\n"
stringa+= str(data[i]) + "\n"
text_file = open(".".join(filename.split(".")[:-1])+"_aggregate_data.log", "w")
text_file.write(str(stringa))
text_file.close()
return data
def richClubCoefficientsFunction():
return nx.rich_club_coefficient(Graph, normalized=True)
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 test_rich_club_exception2():
G = nx.MultiGraph()
nx.rich_club_coefficient(G)
# len_cl = [len(e)for e in cl]
# dict_cl = {e:len_cl.count(e)/float(len(len_cl))for e in set(len_cl)}
# x = dict_cl.keys()
# y = dict_cl.values()
# plt.scatter(x,y,s=size[j],c=colors[j],label=labels[j],marker=markers[j],alpha=alphas[j])
# plt.plot(x,y,c=colors[j])
# j += 1
# plt.legend(loc='upper right')
# plt.xlabel('cliques')
# plt.ylabel('frequency')
# plt.show()
#==============================================================================
#富人俱乐部系数分布
l0 = nx.rich_club_coefficient(G,normalized=False)
l1 = nx.rich_club_coefficient(G1,normalized=False)
l2 = nx.rich_club_coefficient(G2,normalized=False)
j = 0
for l in [l0,l1,l2]:
x = l.keys()
y = l.values()
plt.scatter(x,y,s=size[j],c=colors[j],label=labels[j],marker=markers[j],alpha=alphas[j])
plt.plot(x,y,c=colors[j])
j += 1
plt.legend(loc='upper left')
plt.xlabel('degree')
plt.ylabel('rich_club_coefficient')
plt.show()
#==============================================================================
def eval_rich_club(graph):
"""eval_rich_club"""
return list(
nx.rich_club_coefficient(remove_selfloops(graph),
normalized=False).values())
else: # If no edges are longer than limit just simply connect the node
nodes_to_connect = numpy.argsort(dists)[0:k]
edges_to_add = itertools.product(nodes_to_connect, [curr_node])
elist = list(edges_to_add)
g.add_edges(elist)
fileObject.write(" Degree of bridge nodes:\n " +
str(g.degree(bridge_nodes)) + "\n")
A = g.get_edgelist()
#itt a networkx graph
G = nx.Graph(A)
fileObject.write("\n\n")
rc = nx.rich_club_coefficient(G, normalized=True, Q=1000)
fileObject.write("x: \n" + str(rc.keys()))
fileObject.write("y: \n" + str(rc.values()))
plt.plot(rc.keys(), rc.values())
pdfName = "rich" + str(intervalCounter) + "loop" + str(
loop) + "rand" + str(randrange(1, 100)) + ".pdf"
plt.savefig(pdfName, format='pdf')
plt.close()
print(g.vcount())
global_bridge_degree = bridgeTest(g, bridge_nodes)
outfile = "test_bridge_degrees12.txt"
with open(outfile, 'wb') as csvfile:
writer = csv.writer(csvfile,
delimiter=' ',
def richClubCoefficientsNoNormalisationFunction():
return nx.rich_club_coefficient(Graph, normalized=False)
def rich_club_coefficient(self): return nx.rich_club_coefficient(self.G)
