def compareGraphs(g1, g2):
"""#Compares the quantitative properties of two graph. So I can check the coarse graining. """
#Nodes and edges
print 'Graph1: #(Nodes, Edges) = (' + str(len(g1.nodes())) + ', ' + str(len(g1.edges())) + ')'
print 'Graph2: #(Nodes, Edges) = (' + str(len(g2.nodes())) + ', ' + str(len(g2.edges())) + ')'
#Connected Components
#print '\n#CCs for graph 1: ' + str(len(nx.connected_components(g1)))
#print '#CCs for graph 2: ' + str(len(nx.connected_components(g2)))
plt.hist([len(i) for i in nx.connected_components(g1)])
plt.hist([len(i) for i in nx.connected_components(g2)])
plt.title('Cluster Size')
plt.xlabel('Cluster Size')
plt.ylabel('#Cluster')
show()
#Degree Distribution
plt.hist(nx.degree_histogram(g1))
plt.hist(nx.degree_histogram(g2))
plt.title('Degree Distribution' )
plt.xlabel('Degree')
plt.ylabel('#Nodes')
show()
#Betweeness --- this is by far the most compuationally demanding.
plt.hist(nx.betweenness_centrality(g1, normalized = False).values())
plt.hist(nx.betweenness_centrality(g2, normalized = False).values())
plt.title('Distribution of Betweenness' )
plt.xlabel('Betweenness')
plt.ylabel('#Nodes')
show()
def degree_stats(graph_ref_list, graph_pred_list, is_parallel=False):
''' Compute the distance between the degree distributions of two unordered sets of graphs.
Args:
graph_ref_list, graph_target_list: two lists of networkx graphs to be evaluated
'''
sample_ref = []
sample_pred = []
# in case an empty graph is generated
graph_pred_list_remove_empty = [G for G in graph_pred_list if not G.number_of_nodes() == 0]
prev = datetime.now()
if is_parallel:
with concurrent.futures.ProcessPoolExecutor() as executor:
for deg_hist in executor.map(degree_worker, graph_ref_list):
sample_ref.append(deg_hist)
with concurrent.futures.ProcessPoolExecutor() as executor:
for deg_hist in executor.map(degree_worker, graph_pred_list_remove_empty):
sample_pred.append(deg_hist)
else:
for i in range(len(graph_ref_list)):
degree_temp = np.array(nx.degree_histogram(graph_ref_list[i]))
sample_ref.append(degree_temp)
for i in range(len(graph_pred_list_remove_empty)):
degree_temp = np.array(nx.degree_histogram(graph_pred_list_remove_empty[i]))
sample_pred.append(degree_temp)
print(len(sample_ref),len(sample_pred))
mmd_dist = mmd.compute_mmd(sample_ref, sample_pred, kernel=mmd.gaussian_emd)
elapsed = datetime.now() - prev
if PRINT_TIME:
print('Time computing degree mmd: ', elapsed)
return mmd_dist
def main(): global g global expanded set_g() degree_dict = get_degree_dict() print len(g.nodes()) label_ordered_list = get_ordered_label_list(degree_dict) for item in label_ordered_list: print item print len(item[1]) print nx.degree_histogram(g) draw(g)
def plot_degree_histogram(graph):
plt.rcParams['text.usetex'] = False
plt.loglog(nx.degree_histogram(graph),'b-', marker='o')
n = graph.number_of_nodes()
er = nx.erdos_renyi_graph(n, 0.05)
ba = nx.barabasi_albert_graph(n, 5)
plt.loglog(nx.degree_histogram(er), 'r-', marker='o')
plt.loglog(nx.degree_histogram(ba), 'k-', marker='o')
plt.xlabel("degree")
plt.ylabel("rank")
plt.savefig('degree_histogram.png', dpi=75, transparent=False)
def degree_distribution_comparison(g, g1, title, model_name):
# get the degree histogram
hist = nx.degree_histogram(g)
hist1 = nx.degree_histogram(g1)
plt.plot(range(0, len(hist)), hist, ".", markersize=10, label="Actor Network")
plt.plot(range(0, len(hist1)), hist1, "r.", markersize=10, label=model_name)
plt.title(title, fontsize=15)
plt.xlabel("Degree", fontsize=10, labelpad=-2)
plt.ylabel("#Nodes", fontsize=10, labelpad=-2)
plt.tick_params(axis='x', labelsize=9)
plt.tick_params(axis='y', labelsize=9)
plt.loglog()
plt.legend(numpoints=1, loc=0, fontsize="x-small")
plt.show()
def hist_Graph(self): # sauvegarde les données de l'individu ayant la plus basse fitness
individu_min=self.pop[pop1.f[0][1]]
distri = nx.degree_histogram(individu_min.graphe)
liste = []
#print "distri"+ str(distri)
for i in range(0,len(distri)) :
for j in range(0,distri[i]) :
liste.append(i)
plt.hist(liste)
plt.xlabel("degree")
plt.ylabel("nombre de noeud")
plt.show()
plt.savefig("data/histogram.png")
plt.close()
# Affichage des distributions de clustering
distrib=individu_min.loi_clustering_best()
plt.plot(distrib[0],distrib[1],'bo')
plt.plot(distrib[0],distrib[2],'r')
plt.xlabel("k")
plt.ylabel("C(k)")
plt.show()
plt.savefig("data/distrib_clique.png")
plt.close()
# Affichage des distributions de clustering
distribp=individu_min.loi_puissance_best()
plt.loglog()
plt.plot(distribp[0],distribp[1],'bo')
plt.plot(distribp[0],distribp[2],'r')
plt.xlabel("k")
plt.ylabel("P(k)")
plt.show()
plt.savefig("data/distrib_puissance.png")
plt.close()
def getGraphStats(threshold=0.5, sector=None, lib="nx"): th = re.sub(r'([0-9]*)\.([0-9]*)',r'\1\2',str(threshold)) if sector != None: filename = PROCESSED_FILE_LOC + PREFIX + CRITERIA + "stock_graph_"+lib+"_"+sector+"_th"+th+".xml" outFilename = PROCESSED_FILE_LOC + PREFIX + CRITERIA + "stock_graph_stats_"+lib+"_"+sector+"_th"+th else: filename = PROCESSED_FILE_LOC + PREFIX + CRITERIA + "stock_graph_"+lib+"_th"+th+".xml" outFilename = PROCESSED_FILE_LOC + PREFIX + CRITERIA + "stock_graph_stats_"+lib+"_th"+th stats = dict() if lib == "nx": stats = dict() g = nx.read_graphml(filename) stats['num_nodes'] = g.number_of_nodes() stats['num_edges'] = g.number_of_edges() #stats['diameter'] = nx.diameter(g) stats['clustering_coeff'] = nx.average_clustering(g) stats['avg_degree'] = np.average(nx.degree(g).values()) stats['degree_hist'] = nx.degree_histogram(g) y = stats['degree_hist'] x = range(len(y)) f = open(outFilename + ".txt", "wb") f.write(str(stats)) f.close() plt.plot(x, y) plt.savefig(outFilename + ".png") plt.show() return stats
def drawNetwork(graph,k):
pl.figure(k)
pl.subplot(211)
#pos = nx.shell_layout(graph) # positions for all nodes
pos = nx.spring_layout(graph) # positions for all nodes
# nodes
nx.draw_networkx_nodes(graph,pos,node_size=200)
# edges
nx.draw_networkx_edges(graph,pos,
width=3)
# labels
# nx.draw_networkx_labels(graph,pos,font_size=20,font_family='sans-serif')
plt.axis('off')
# plot degree distribution
dd = nx.degree_histogram(graph)
fig = pl.figure(k)
ax = pl.subplot(212)
plt.bar(np.arange(len(dd)), dd, width = 0.1)
plt.axis([0,len(dd),0,max(dd)])
plt.title("Degree distribution")
plt.xlabel("degree")
plt.ylabel("number of nodes")
#plt.figtext(2, 6, stats, fontsize=15)
plt.draw() # display
return
def calGraph(infile, mode = 1): #init Parameter inputpath = 'edge_list/' outputpath = 'network_output/' n = mode Data_G = inputpath+infile+'_'+str(n)+'.edgelist' #init Graph G = nx.read_edgelist(Data_G, create_using=nx.DiGraph()) GU = nx.read_edgelist(Data_G) #basci info print nx.info(G),'\n', nx.info(GU) average_degree = float(sum(nx.degree(G).values()))/len(G.nodes()) print 'average degree :', average_degree degree_histogram = nx.degree_histogram(G) print 'degree histogram max :', degree_histogram[1] desity = nx.density(G) print 'desity :', desity #Approximation #Centrality degree_centrality = nx.degree_centrality(G) print 'degree centrality top 10 !', sorted_dict(degree_centrality)[:2] out_degree_centrality = nx.out_degree_centrality(G) print 'out degree centrality top 10 !', sorted_dict(out_degree_centrality)[:2]
def test_approx_coloring(self):
KR = kapoor_rizzi()
degree = 40
partition_n_nodes = 15
# generate random graph
g = graph_util().generate_random_regular_bipartite(partition_n_nodes, degree)
# generate arbitrary partitions for approximation algo
arbitrary = [graph_util().generate_random_regular_bipartite(partition_n_nodes, 1) for i in xrange((degree % 2) + 1)]
# algorithm is destructive so save these for later comparisons
original_nodes = g.nodes()
arbitrary_edges = reduce(lambda x,y: x+y, (m.edges() for m in arbitrary))
original_edges = g.edges() + arbitrary_edges
solution = KR.solve(degree, g, arbitrary)
# check the amount of matchings
self.assertEqual(len(solution), degree + len(arbitrary), "Didn't get enough matchings")
# check each matching:
for matching in solution:
# matching preserves nodes
self.assertEquals(matching.nodes(), original_nodes)
# every node has degree 1
self.assertEquals(nx.degree_histogram(matching), [0, 2*partition_n_nodes])
# matchings preserve edges
matching_edges = reduce(lambda x,y: x+y, (m.edges() for m in solution))
self.assertEquals(sorted(matching_edges), sorted(original_edges))#, "Mismatch between input and output edges")
def pic(c,n):
G = nx.Graph()
if c=='gsm':
with open('E:/data/degree-distribution/'+c+'/305-7-level'+str(n)+'.txt', 'r') as f:
for position, line in enumerate(f):
if line.strip().split(' ')[0]!=line.strip().split(' ')[1]:
u= line.strip().split(' ')[0]
n=line.strip().split(' ')[1]
G.add_edge(u, n)
else:
with open('E:/data/degree-distribution/'+c+'/49-24-level'+str(n)+'.txt', 'r') as f:
for position, line in enumerate(f):
if line.strip().split(' ')[0]!=line.strip().split(' ')[1]:
u= line.strip().split(' ')[0]
n=line.strip().split(' ')[1]
G.add_edge(u, n)
degree_hist = nx.degree_histogram(G)
x = range(len(degree_hist))[1:]
# print(x)
y = [float(i+1) / float(sum(degree_hist)) for i in degree_hist[1:]]
bin_x, bin_y = bining_data(x, y, 8)
d = []
pd =[]
for i in range(0, len(bin_x)):
d.append(np.median(bin_x[i]))
pd.append(np.median(bin_y[i]))
return d, pd
def __init__(self, graph, slow_stuff = False):
graph.info()
# paolo - 20070919 - computing also the strongly connected
# components directly on the directed graph. Changing a
# directed graph into an undirected usually destroys a lot of
# its structure and meaning. Let see. while in the published
# API there is a method
# strongly_connected_component_subgraphs(graph), I don't have it
# on my machine (probably I have an older networkx version),
# so for now I commented the following code. the method
# strongly_connected_component_subgraphs(graph) was added on
# 07/21/07. See https://networkx.lanl.gov/changeset/640 . On
# my machine I have "python-networkx/feisty uptodate 0.32-2"
# while on networkx svn there is already version 0.35.1
if False:
self.strongconcom_subgraphs = component.strongly_connected_component_subgraphs(graph)
strongconcom_subgraph_size = map(len, self.strongconcom_subgraphs)
print "size of largest strongly connected components:",
print ", ".join(map(str, strongconcom_subgraph_size[:10])), "..."
print "%nodes in largest strongly connected component:",
print 1.0 * strongconcom_subgraph_size[0] / len(graph)
undir_graph = graph.to_undirected()
self.concom_subgraphs = component.connected_component_subgraphs(undir_graph)
concom_subgraph_size = map(len, self.concom_subgraphs)
print "size of largest connected components:",
print ", ".join(map(str, concom_subgraph_size[:10])), "..."
print "%nodes in largest connected component:",
print 1.0 * concom_subgraph_size[0] / len(graph)
#only work on connected graphs, maybe we could run it on the
#largest strongly connected component.
#print "diameter:", distance.diameter(G)
#print "radius:", distance.radius(graph)
print "density:", networkx.density(graph)
print "degree histogram:", networkx.degree_histogram(graph)[:15]
print "average_clustering:", cluster.average_clustering(graph)
print "transitivity:", cluster.transitivity(graph)
if slow_stuff:
#not yet in my networkx revision -- try try except
print "number_of_cliques", cliques.number_of_cliques(graph)
"""this returns a dict with the betweenness centrality of
every node, maybe we want to compute the average
betweenness centrality but before it is important to
understand which measures usually are usually reported in
papers as peculiar for capturing the characteristics and
structure of a directed graph."""
print "betweenness_centrality:",
print centrality.betweenness_centrality(graph)
def P_k(DiG,T,WalkerNum):
#WalkerNum = 10
#T = 100000
final = final_state(DiG,T,WalkerNum)
degree_Num = {}
kin = DiG.in_degree().values()
k = DiG.degree().values()
degree_Num_k = {}
degree_histogram,_ = np.histogram(kin,np.arange(0,max(kin)+2,1))
degree_histogram2 = nx.degree_histogram(DiG)
#degree_histogram = nx.degree_histogram(DiG)
for node in final:
k = DiG.in_degree(node)
if k in degree_Num:
degree_Num[k]+=1
else:
degree_Num[k] = 1
for node in final:
k = DiG.degree(node)
if k in degree_Num_k:
degree_Num_k[k]+=1
else:
degree_Num_k[k] = 1
degree_Probability = {}
for degree in degree_Num:
degree_Probability[degree] = 1.0/degree_histogram[degree]*degree_Num[degree]/WalkerNum
degree_Probability_k = {}
for degree in degree_Num_k:
degree_Probability_k[degree] = 1.0/degree_histogram2[degree]*degree_Num_k[degree]/WalkerNum
return degree_Probability, degree_Probability_k
def degreeAnalysis(G):
'''
Analyze the degree distribution
'''
print('--------Node Degree Analysis:--------')
tempY=nx.degree_histogram(G)
tempX=list(range(len(tempY))) # isolated node's degree = 0
X=[];Y=[]
print('Number of Isolated Node: ',tempY[0])
for i in range(1,len(tempY)):# here I discard all isolated nodes.
if tempY[i]!=0:
Y.append(np.log(tempY[i]))
X.append(np.log(tempX[i]))
A=np.array([X,np.ones(len(X))])
k=np.linalg.lstsq(A.T,Y)[0]
X=np.array(X)
regressionLine=k[0]*X+k[1]
print('Slope of regression line: ',k[0])
#plt.plot(X,Y,'o',X,regressionLine,label='$Y = %dx$'% k[0])
plt.plot(X,Y,'o')
plt.plot(X,regressionLine,'r',label='$Y = %fx+%f$'% (k[0], k[1]))
plt.legend()
plt.xlabel('log(k)')
plt.ylabel('logN(k)')
plt.title('Node degree analysis')
plt.show()
def _compute_rc(G):
"""Returns the rich-club coefficient for each degree in the graph
`G`.
`G` is an undirected graph without multiedges.
Returns a dictionary mapping degree to rich-club coefficient for
that degree.
"""
deghist = nx.degree_histogram(G)
total = sum(deghist)
# Compute the number of nodes with degree greater than `k`, for each
# degree `k` (omitting the last entry, which is zero).
nks = (total - cs for cs in accumulate(deghist) if total - cs > 1)
# Create a sorted list of pairs of edge endpoint degrees.
#
# The list is sorted in reverse order so that we can pop from the
# right side of the list later, instead of popping from the left
# side of the list, which would have a linear time cost.
edge_degrees = sorted((sorted(map(G.degree, e)) for e in G.edges()),
reverse=True)
ek = G.number_of_edges()
k1, k2 = edge_degrees.pop()
rc = {}
for d, nk in enumerate(nks):
while k1 <= d:
if len(edge_degrees) == 0:
ek = 0
break
k1, k2 = edge_degrees.pop()
ek -= 1
rc[d] = 2 * ek / (nk * (nk - 1))
return rc
def pic(c,n):
G = nx.Graph()
if c=='gsm':
with open('E:/data/degree-distribution/'+c+'/305-7-level'+str(n)+'.txt', 'r') as f:
for position, line in enumerate(f):
if line.strip().split(' ')[0]!=line.strip().split(' ')[1]:
u= line.strip().split(' ')[0]
n=line.strip().split(' ')[1]
G.add_edge(u, n)
else:
with open('E:/data/degree-distribution/'+c+'/49-24-level'+str(n)+'.txt', 'r') as f:
for position, line in enumerate(f):
if line.strip().split(' ')[0]!=line.strip().split(' ')[1]:
u= line.strip().split(' ')[0]
n=line.strip().split(' ')[1]
G.add_edge(u, n)
degree_hist = nx.degree_histogram(G)
x = range(len(degree_hist))[1:]
print(degree_hist)
y = [float(i+1) / float(sum(degree_hist)) for i in degree_hist[1:]]
plt.loglog(x, y, 'bo', linewidth = 2)
plt.title('Degree Distribution')
plt.ylabel('Probability')
plt.xlabel('Degree')
return x, y
def analyse_data(data, threshold=0.66):
""" perform graph theory analysis on data
Parameters
----------
data: dict
the keys are the names of the datasets
and the values are dicts that include 'corr' which represents
the corr matrix from which to derive the graph
Returns
-------
result: dict of graph theory results
the keys are the names of the datasets
the values are another dict containing
'L' - the average shortest path length
'CC' - the average clustering coefficient
'DD' - the degree histogram
'Nodes' - the number of nodes in the graph
'Edges' - the number of edges in the graph
"""
result = dict()
for label, dataset in data.items():
summary = dict()
corr = dataset['corr']
graph, _ = corr_matrix_to_graph(corr, threshold=threshold)
summary['L'] = nx.average_shortest_path_length(graph)
summary['CC'] = nx.average_clustering(graph)
summary['DD'] = nx.degree_histogram(graph)
summary['Nodes'] = graph.number_of_nodes()
summary['Edges'] = graph.number_of_edges()
result[label] = summary
return result
def analyze_graph(G):
print nx.info(G)
degree_freq = nx.degree_histogram(G)
diameter = nx.diameter(G)
print "Diameter: {0}".format(diameter)
triangles = nx.triangles(G)
triangles_values = sorted(triangles.values(), reverse=True)
print "Triangles: {0}".format(triangles_values)
def cum_deg_histogram(G):
"""Cumulative degree histogram."""
from numpy import cumsum
from networkx import degree_histogram
deg_hist = degree_histogram(G)
deg_hist.reverse()
cum_deg_hist = list(cumsum(deg_hist))
cum_deg_hist.reverse()
return cum_deg_hist
def degree_distribution(g):
hist = nx.degree_histogram(g) # get the degree histogram
plt.plot(range(0, len(hist)), hist, ".")
plt.title("Degree Distribution")
plt.xlabel("Degree")
plt.ylabel("#Nodes")
plt.loglog() #Draw LogLog distribution
plt.savefig("network_distribution.png")
plt.show()#show result
def make_histogram(aGraph):
fig = pylab.figure()
pylab.title(aGraph.name)
hist = nx.degree_histogram(aGraph)
pylab.bar(range(len(hist)), hist, align = 'center')
pylab.xlim((0, len(hist)))
pylab.xlabel("Degree of node")
pylab.ylabel("Number of nodes")
return fig
def get_graphinfo(graph_fn):
graph = nx.read_gml(graph_fn)
cells_inhib = np.array(nx.get_node_attributes(graph, 'inh').values(),
dtype=np.int)
graph_edges = nx.edges(graph)
number_of_nodes = nx.number_of_nodes(graph)
degree_histogram = nx.degree_histogram(graph)
return cells_inhib, graph_edges,number_of_nodes,degree_histogram
def degreedist(): if created == 0: print 'No graph created!' elif created == 1: try: dist = [histogram/G.number_of_nodes() for histogram in nx.degree_histogram(G)] print dist print 'The degree values are the index in the list.' except nx.NetworkXError, e: print e
def degree_distrib(graph, n):
g = nx.read_adjlist(graph)
dc = nx.degree_histogram(g)
fileName = open(BASE_PATH+"histogram_"+str(n)+".txt", "w")
nx.set_node_attributes(g, 'degree_cent', dc)
#degcent_sorted = sorted(dc.items(), key = operator.itemgetter(1), reverse = True)
for key, value in enumerate(dc):
fileName.write("\nThe degree " + str(key) + " frequency is "+ str(value))
fileName.close()
return dc
def isCycle(graph):
""" This function takes a networkx graph object as input and returns True if the graph is a cycle
Note: A graph is a cycle iff degree of every node is two and the graph is connected.
"""
if graph:
degree_hist = nx.degree_histogram(graph) # get frequency of degree of all nodes
if degree_hist[2] == len(graph.nodes()) and nx.is_connected(graph): # if all nodes have degree = 2 => cycle
Debuglogger.debug("Is a cycle")
return True
Debuglogger.debug("Is not a cycle")
return False
def plotDegreeDistribution(G, log=False):
deg = nx.degree_histogram(G)
if log:
deg = [i+1 for i in deg]
plt.yscale('log')
plt.xscale('log')
l = plt.plot(range(len(deg)), deg)
plt.xlabel('Degree')
plt.ylabel('Number of nodes')
plt.title('Degree distribution of the network')
plt.show()
def degree_distribution(g, title):
# get the degree histogram
hist = nx.degree_histogram(g)
plt.plot(range(0, len(hist)), hist, ".", markersize=10)
plt.title(title, fontsize=14)
plt.xlabel("Degree", fontsize=10, labelpad=-2)
plt.ylabel("#Nodes", fontsize=10, labelpad=-2)
plt.tick_params(axis='x', labelsize=9)
plt.tick_params(axis='y', labelsize=9)
plt.loglog()
plt.show()
def degree_nodes():
"""
Degree of nodes histogram.
d[0] : list of pathes for the graphs (here v34 experiment)
"""
for i in d[0][::5]:
g = nx.read_gpickle(i)
hist = nx.degree_histogram(g)
n = nx.number_of_nodes(g)
np.save('/home/yuliya/codes/lengths/v34/degree' + i[30:-10] + '.npy', np.asarray(hist)/float(n))
def make_histogram(self):
fig = pylab.figure()
# ax = fig.add_subplot(1,1,1)
pylab.title(self.G.name)
hist = nx.degree_histogram(self.G)
pylab.bar(range(len(hist)), hist, align = 'center')
pylab.xlim((0, len(hist)))
# ax.set_xscale('log')
# ax.set_yscale('log')
pylab.xlabel("Degree of node")
pylab.ylabel("Number of nodes")
return fig
def process_network(G, namespace):
print 'Nodes:', len(G)
print 'Edges:', G.number_of_edges()
if namespace.clustering_coefficient:
print 'Clustering Coefficient:', nx.average_clustering(G)
if namespace.components:
components = nx.connected_component_subgraphs(G)
print 'Number of Components:', len(components)
isles = [c for c in components if len(c) == 1]
print 'Isles:', len(isles)
print 'Largest Component Size:', len(components[0])
else: components = None
if namespace.cpl:
if namespace.approximate_cpl:
average_shortest_path_length = approximate_cpl
else:
print 'Using full slow CPL'
average_shortest_path_length = nx.average_shortest_path_length
if components is None:
components = nx.connected_component_subgraphs(G)
for i, g in enumerate(g for g in components if
float(len(g))/float(len(G)) >
namespace.component_size):
print 'CPL %d: (%f)' % (i, float(len(g))/float(len(G)))
print average_shortest_path_length(g)
if namespace.assortativity:
print 'Assortativity: NOT IMPLEMENTED.'
if namespace.degree_distribution:
hst = nx.degree_histogram(G)
plt.subplot(121)
plt.xscale('log')
plt.yscale('log')
plt.title("Degree Distribution")
plt.ylabel("Occurrencies")
plt.xlabel("Degree")
plt.plot(range(len(hst)), hst, marker='+')
plt.subplot(122)
ccdf = pynetsym.mathutil.ccdf(hst)
plt.xscale('log')
plt.yscale('log')
plt.title("CCDF Degree Distribution")
plt.ylabel("$P(X>x)$")
plt.xlabel("Degree")
plt.plot(range(len(ccdf)), ccdf, color='red')
if namespace.degree_distribution_out is None:
plt.show()
else:
plt.save_fig(namespace.degree_distribution_out)
# -*- coding: UTF-8 -*-
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
actor_edge = pd.read_csv('network_actor_rankavgbox.csv') #导入演员网络边的csv文件,导入后为Dataframe格式
print(actor_edge.head(3)) #显示表的前3行
weight_edge = []
for _,row in actor_edge.iterrows(): #把边及边的权重加入列表，数据格式为（节点，节点，权重）
weight_edge.append((row['ActorID_1'],row['ActorID_2'],row['rankaveragebox']))
AW = nx.Graph() #初始化无向图
AW.add_weighted_edges_from(weight_edge) #把带权重边的信息加入无向图中
degree_hist = nx.degree_histogram(AW) #返回图中所有节点的度分布序列
x = range(len(degree_hist)) #生成x轴序列
y = [z / float(sum(degree_hist)) for z in degree_hist] #生产y轴序列，将频次转换为频率
plt.loglog(x,y,color="blue",linewidth=2) #在双对数坐标轴上绘制度分布曲线
plt.title('Degree Distribution Actor ') #图表标题
plt.xlabel('Degree') #x轴标题
plt.ylabel('Probability') #y轴标题
plt.savefig('Degree Distribution Actor.png') #保存图片
plt.show() #显示图表
for files in ls:
if files.endswith(".txt"):
name = files
edges = gid.loadGraphEdges(name)
rewire = gid.loadGraphRewire(name)
n = gid.loadGraphN(name)
pos = gid.loadGraphPositions(n)
g = nx.Graph(edges)
gRew = nx.Graph(rewire)
l0 = 23.336
c0 = 0.442651428571
print "Links Totales: {0}".format(nx.number_of_edges(g))
print "Links de rewiring: {0}".format(nx.number_of_edges(gRew))
t = time.clock()
#print "Camino minimo medio: {0}".format(nx.average_shortest_path_length(g))
print time.clock() - t
#print "Clustering medio: {0}".format(nx.average_clustering(g))
plt.plot(nx.degree_histogram(g),'ro-')
#nx.draw(g,pos)
plt.show()
#nx.draw(g,pos,edge_color = 'r',node_size=50)
#plt.show()
#print nx.number_of_edges(gRew)
#nx.draw(gRew,pos,edge_color = 'g',node_size=50)
#plt.show()
# crawler_list = ['mod']
for crawler_type in crawler_list:
for i in range(0, MAX_GEN):
for ad_p_remove in os.listdir(directory):
# for ad_p_remove in ["0", "0.01", "0.05", "0.1", "0.2", "0.3", "0.4","0.5"]:
fname = directory + str(ad_p_remove) + '/' + \
dataset + '/' + crawler_type + '/' + \
dataset + '_' + str(i+1) + '_1'
G = _mylib.read_file(fname)
node_count = G.number_of_nodes()
if ad_p_remove == "0":
com_G = get_community(G, fname)
node_G = G.nodes()
deg_hist_G = nx.degree_histogram(G)
continue
else:
com_adv = get_community(G, fname)
node_adv = G.nodes()
deg_hist_adv = nx.degree_histogram(G)
d, p = stats.ks_2samp(deg_hist_G, deg_hist_adv)
int_ = len(set(node_G).intersection(set(node_adv)))
union_ = len(set(node_G).union(set(node_adv)))
jaccard = 1. * int_ / union_
# node_cov_size = 1.*len(node_adv) / len(node_G)
coverage_dist = 1. * (abs(len(node_adv) - len(node_G))) / (
abs(len(node_adv)) + abs(len(node_G)))
node_cov_sim = 1. - coverage_dist
def main():
# parse the command line
parser = argparse.ArgumentParser()
parser.add_argument(
"-m",
"--markPos",
help=
"specifies the seed marker position of the haplotypes used to draw the graph",
action="store",
required=True)
args = parser.parse_args()
#g = nx.read_weighted_edgelist(os.getcwd() + "lrrkPairsAtSite_" + args.markPos + ".out", delimiter=",", nodetype=int)
#nx.write_pajek(g, os.getcwd()+args.markPos+".net")
g = nx.read_weighted_edgelist(
"/projects/sequence_analysis/vol4/CHAT_simGWAS/Chat1.2Lrrk2Graph/lrrkPairsAtSite_3999.out",
comments='h',
delimiter=",",
nodetype=str)
nx.write_pajek(
g,
"/projects/sequence_analysis/vol4/CHAT_simGWAS/Chat1.2Lrrk2Graph/lrrk_ego/lrrkPairsAtSite_3999.net"
)
gc.collect() #garbage collection
del g
g = nx.read_pajek(
"/projects/sequence_analysis/vol4/CHAT_simGWAS/Chat1.2Lrrk2Graph/lrrkPairsAtSite_8003.net"
)
#assign graph attributes
#g.graph['marker'] = args.markPos
g.graph['marker'] = '3999'
#use nx.info() to see whether the network has been loaded correctly
#display basic information of the network (num of nodes, edges, average degree)
nx.info(g)
#calculate degree distribution
dh = nx.degree_histogram(g)
#Plot using same method as http://networkx.lanl.gov/examples/drawing/degree_histogram.html
#pos=nx.spring_layout(g)
P.figure(figsize=(8, 8))
P.loglog(dh, 'b-', marker='o')
P.title("Degree distribution (log-log)")
P.ylabel("Degree")
P.xlabel("Frequency")
#Draw graph in inset
#P.axes([0.45,0.45,0.45,0.45])
#P.axis('off')
#nx.draw_networkx_nodes(g,pos,node_size=10)
#nx.draw_networkx_edges(g,pos,alpha=0.4)
P.savefig("8003_degDist.png")
P.clf()
#igraph version
#Generate a sorted list of connected components, largest first.
[len(c) for c in sorted(nx.connected_components(G), key=len, reverse=True)]
#Get the largest connected component
largest_cc = max(nx.connected_components(G), key=len)
from itertools import combinations
top_overlap = [list(combinations(c, 2)) for c in components if len(c) > 1]
top_overlap = [item for sublist in top_overlap for item in sublist]
#top_overlap
#[(1, 3), (1, 2), (3, 2)]
#Caution: the following step is memory intensive
c = list(nx.k_clique_communities(g, 3))
def __init__(self, graph, Time):
#------------------------ MDP problem Parameters ----------------
self.isQuad = False
self.R = None
# rewards matrix
self.C = None
# constant part of the reward
self.P = None
self.Time = Time
# number of time steps
self.States = None
# number of states
self.Actions = None
# number of actions
self.constrainedState = None
self.constrainedUpperBound = None
#------------ Underlying Network parameters -------------------
self.G = None
self.graphPos = None
# for drawing
#--------------- LP CVX Parameters ---------------------
self.yijt = None
self.lpObj = None
self.exactPenalty = None
#----------- LP Constraints--------------------
self.positivity = None
self.initialCondition = None
self.massConservation = None
#-------exact penalty parameters--------------
self.epsilon = 0.1
# for exact penalty
self.optimalDual = None
# ---------- choose type of underlying graph---------------------------
if graph.type is "grid":
self.G = nx.grid_graph([graph.rowSize, graph.colSize])
self.G = nx.convert_node_labels_to_integers(self.G)
self.graphPos = nx.spring_layout(self.G)
self.States = graph.rowSize * graph.colSize
self.Actions = 5
# up, down left, right, stay
self.P, c = mdp.generateGridMDP(self.States,
self.Actions,
self.G,
test=True)
self.R = np.zeros((self.States, self.Actions, Time))
self.constrainedUpperBound = 0.2
for t in range(Time):
self.R[:, :, t] = 1.0 * c
# seattle graph
elif graph.type is "seattle":
self.graphPos, self.G = fG.NeighbourGen(False)
self.States = self.G.number_of_nodes()
self.Actions = len(nx.degree_histogram(self.G))
self.P, c = mdp.generateMDP(self.States, self.Actions, self.G)
self.R = np.zeros((self.States, self.Actions, Time))
for t in range(Time):
self.R[:, :, t] = 1.0 * c
# seattle graph
elif graph.type is "seattleQuad":
self.graphPos, self.G, distances = fG.NeighbourGen(False)
self.States = self.G.number_of_nodes()
self.Actions = len(nx.degree_histogram(self.G))
self.P, c, d = mdp.generateQuadMDP(self.States, self.Actions,
self.G, distances)
self.R = np.zeros((self.States, self.Actions, Time))
self.C = np.zeros((self.States, self.Actions, Time))
for t in range(Time):
self.R[:, :, t] = 1.0 * d
self.C[:, :, t] = 1.0 * c
def get_subgraph(V,E,label_filepath,dataset_name,level=1,subgraph_count=5,ignore_deg=None,root_node=None):
"""
# total_points: total number of data points
# feature_dm: number of features per datapoint
# number_of_labels: total number of labels
# X: feature matrix of dimension total_points * feature_dm
# Y: list of size total_points. Each element of the list containing labels corresponding to one datapoint
# V: list of all labels (nodes)
# E: dict of edge tuple -> weight, eg. {(1, 4): 1, (2, 7): 3}
"""
# get a dict of label -> textual_label
label_dict = get_label_dict(label_filepath)
# an utility function to relabel nodes of upcoming graph with textual label names
def mapping(v):
"""
An utility function to relabel nodes of upcoming graph with textual label names
:param v: label id (int)
:return: returns the texual label of the node id [v]
"""
v = int(v)
if v in label_dict:
return label_dict[v]
return str(v)
# build a unweighted graph of all edges
g = nx.Graph()
g.add_edges_from(E.keys())
# Below section will try to build a smaller subgraph from the actual graph for visualization
subgraph_lists = []
for sg in range(subgraph_count):
if root_node is None:
# select a random vertex to be the root
np.random.shuffle(V)
v = V[0]
else:
v = root_node
# two files to write the graph and label information
# Remove characters like \, /, <, >, :, *, |, ", ? from file names,
# windows can not have file name with these characters
label_info_filepath = 'samples/'+str(dataset_name)+'_Info[{}].txt'.format(str(int(v)) + '-' + remove_special_chars(mapping(v)))
label_graph_filepath = 'samples/'+str(dataset_name)+'_G[{}].graphml'.format(str(int(v)) + '-' + remove_special_chars(mapping(v)))
# label_graph_el = 'samples/'+str(dataset_name)+'_E[{}].el'.format(str(int(v)) + '-' + mapping(v)).replace(' ','_')
print('Label:[' + mapping(v) + ']')
label_info_file = open(label_info_filepath,'w')
label_info_file.write('Label:[' + mapping(v) + ']' + "\n")
# build the subgraph using bfs
bfs_q = Queue()
bfs_q.put(v)
bfs_q.put(0)
node_check = {}
ignored = []
sub_g = nx.Graph()
lvl = 0
while not bfs_q.empty() and lvl <= level:
v = bfs_q.get()
if v == 0:
lvl += 1
bfs_q.put(0)
continue
elif node_check.get(v,True):
node_check[v] = False
edges = list(g.edges(v))
# label_info_file.write('\nNumber of edges: ' + str(len(edges)) + ' for node: ' + mapping(v) + '[' +
# str(v) + ']' + '\n')
if ignore_deg is not None and len(edges) > ignore_deg:
# label_info_file.write('Ignoring: [' + mapping(v) + '] \t\t\t degree: [' + str(len(edges)) + ']\n')
ignored.append("Ignoring: deg [" + mapping(v) + "] = [" + str(len(edges)) + "]\n")
continue
for uv_tuple in edges:
edge = tuple(sorted(uv_tuple))
sub_g.add_edge(edge[0],edge[1],weight=E[edge])
bfs_q.put(uv_tuple[1])
else:
continue
# relabel the nodes to reflect textual label
nx.relabel_nodes(sub_g,mapping,copy=False)
print('sub_g:',sub_g)
label_info_file.write(str('\n'))
# Writing some statistics about the subgraph
label_info_file.write(str(nx.info(sub_g)) + '\n')
label_info_file.write('density: ' + str(nx.density(sub_g)) + '\n')
label_info_file.write('list of the frequency of each degree value [degree_histogram]: ' +
str(nx.degree_histogram(sub_g)) + '\n')
for nodes in ignored:
label_info_file.write(str(nodes) + '\n')
# TODO: Add other statistics for better understanding of the subgraph.
# subg_edgelist = nx.generate_edgelist(sub_g,label_graph_el)
label_info_file.close()
nx.write_graphml(sub_g,label_graph_filepath)
subgraph_lists.append(sub_g)
print('Graph generated at: ' + label_graph_filepath)
if root_node:
print("Root node provided, will generate only one graph file.")
break
return subgraph_lists
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from util import *
import pandas as pd
import scipy.stats as stats
from networkx.utils import py_random_state
G = nx.read_gml('power.gml', None)
degreeFrequencies = np.array(nx.degree_histogram(G))
degrees = [i[1] for i in G.degree]
# print(nx.info(G))
'''
Number of nodes: 4941
Number of edges: 6594
Average degree: 2.6691
'''
'''
density = nx.density(G) # 0.0005403026973346214
globalclusteringCoefficient = nx.transitivity(G) # 0.10315322452860086
localClusteringCoefficients = nx.clustering(G)
aspl = nx.average_shortest_path_length(G) # 18.989185424445708
'''
# Normal Scale
# plotDegreeDistribution(degreeFrequencies, logScale=False)
# Logoritmic scale
# plotDegreeDistribution(degreeFrequencies, logScale=True)
#Confirm that the produces networks which follow the Power law by plotting the degree distribution on a log-log scale.
#Producing the divergence duplication model:
G_dupli = duplication_div(1, 0.2, 0.3, 0.5, 1000)
plt.figure()
nx.draw(G_dupli, node_size=10)
plt.savefig("Graph_dupli.png", format="PNG", node_color='blue')
#Producing the divergence duplication model:
G_part = partial_dupli(1, 0.2, 0.3, 1000)
plt.figure()
nx.draw(G_part, node_size=10)
plt.savefig("Graph_part.png", format="PNG", node_color='blue')
#Plotting the Degree Distribution of the 2 graphs
degree_sequence = nx.degree_histogram(G_dupli)
plt.figure()
plt.loglog(degree_sequence, 'b-', marker='o')
plt.title("Degree rank plot of duplication divergence model")
plt.ylabel("degree")
plt.xlabel("rank")
plt.savefig('degree_rank_duplication')
degree_sequence = nx.degree_histogram(G_part)
plt.figure()
plt.loglog(degree_sequence, 'b-', marker='o')
plt.title("Degree rank plot of partial model")
plt.ylabel("degree")
plt.xlabel("rank")
plt.savefig('degree_rank_partial_model')
newib = -maxVector(-IB,-maxVector(np.dot(ib,pi) + E,np.zeros(N)))
delta = abs(ib - newib)
# sum = sum + 1
# print(sum)
contagion = set(np.where(ib - newib > 0)[0])
contagion = contagion.difference(fundamental) # 传染违约银行集合
return newib,fundamental,contagion
global N # 银行个数
N = 80
G = nx.barabasi_albert_graph(N,1) # 创建无标度网络
average_clustering = nx.average_clustering(G) # 计算平均聚集度
average_degree_connectivity = nx.average_degree_connectivity(G) # 计算平均连接度
degree = G.degree() # 得到每个节点的度
degree_histogram = nx.degree_histogram(G) # 网络度分布
g = nx.to_numpy_array(G) # 得到信用关系矩阵(不含借贷方向)
r,R = relation(g,0,0) # 得到信用关系矩阵(含借贷方向)
L = balanceSheet(r,100,2) # 得到借贷规模矩阵
IL = sum(L) # 银行间贷款
L = L.T
IB = sum(L) # 银行间借款
p = 0.4 # 杠杆
data = generateData(IL,IB,p) # 得到资产负债表数据
temp = np.array(data < 0)
if True in temp:
print('error')
shock = abs(np.random.normal(0,0.3,(N))) # 给出冲击
ib,fundamental,contagion = clearVector(data,L,shock) # 得到清算向量与违约银行集合
LGD = 1 - ib / data['银行间借款'] # 计算违约损失率
LGD_avg = 1 - ib.sum() / data['银行间借款'].sum() # 计算平均违约损失率
def test_degree_histogram(self):
assert_equal(nx.degree_histogram(self.G), [1, 1, 1, 1, 1])
def test_degree_distribution(self):
for n in range(1, 10):
G = nx.hypercube_graph(n)
expected_histogram = [0] * n + [2**n]
assert nx.degree_histogram(G) == expected_histogram
#!/usr/bin/env python """ ======================== Expected Degree Sequence ======================== Random graph from given degree sequence. """ # Author: Aric Hagberg ([email protected]) # Copyright (C) 2006-2019 by # Aric Hagberg <*****@*****.**> # Dan Schult <*****@*****.**> # Pieter Swart <*****@*****.**> # All rights reserved. # BSD license. import networkx as nx from networkx.generators.degree_seq import expected_degree_graph # make a random graph of 500 nodes with expected degrees of 50 n = 500 # n nodes p = 0.1 w = [p * n for i in range(n)] # w = p*n for all nodes G = expected_degree_graph(w) # configuration model print("Degree histogram") print("degree (#nodes) ****") dh = nx.degree_histogram(G) for i, d in enumerate(dh): print("%2s (%2s) %s" % (i, d, '*' * d))
def degree(self, brain, outfilebase="brain", append=True):
# node degrees
outfile = outfilebase + '_degrees_nodes'
boolVal = self.fileCheck(outfile, append)
# open file to write to
if append and boolVal:
# case where file is appended
f = open(outfile, "ab")
nodewriter = DictWriter(f, fieldnames=brain.G.nodes())
else:
# case where a new file is created
f = open(outfile, "wb")
nodewriter = DictWriter(f, fieldnames=brain.G.nodes())
# write header based on node names
headers = dict((n, n) for n in brain.G.nodes())
nodewriter.writerow(headers)
# get degrees of each node
degs = brain.G.degree()
degstowrite = dict((n, None) for n in brain.G.nodes())
for node in degs.keys():
degstowrite[node] = degs[node]
# write out
nodewriter.writerow(degstowrite)
f.close()
## ===========================================================================
## hub degrees
if brain.hubs != []:
outfile = outfilebase + '_degrees_hubs'
hubidfile = outfilebase + '_degrees_hubs_ids'
# move old file if necessary
boolOF = self.fileCheck(outfile, append)
self.fileCheck(hubidfile, append)
# open files to write to
# bit dodgy, should check both files before "ab" opening...
if append and boolOF:
f = open(outfile, "ab")
g = open(hubidfile, "ab")
else:
f = open(outfile, "wb")
g = open(hubidfile, "wb")
# hubs within largest connected graph component
deghubs = [hub for hub in brain.hubs if hub in brain.G]
# write hub identifies to file
idwriter = DictWriter(f, fieldnames=brain.hubs)
hubwriter = DictWriter(g, fieldnames=brain.hubs)
headers = dict((n, n) for n in brain.hubs)
hubwriter.writerow(headers)
# empty dictionary to populate with degree data
degstowrite = dict((n, None) for n in brain.hubs)
# get degrees of hubs
try:
degs = brain.G.degree(deghubs)
for node in degs.keys():
degstowrite[node] = degs[node]
except:
# why not check for this specifically beforehand than using try...except?
print "no hubs in largest connected component"
# write to file
idwriter.writerow(degstowrite)
f.close()
g.close()
## =======================================================================
## write degree histogram
outfileHist = outfilebase + '_degreehistogram'
histBool = self.fileCheck(outfileHist, append)
# open file
if append and histBool:
f = open(outfileHist, "ab")
else:
f = open(outfileHist, "wb")
# get histogram
degreeHist = degree_histogram(brain.G)
# write histogram to file
histwriter = writer(f)
histwriter.writerow(degreeHist)
f.close()
def test_degree_histogram(self):
assert nx.degree_histogram(self.G) == [1, 1, 1, 1, 1]
top16_clo_cc, top17_clo_cc, top18_clo_cc, top19_clo_cc, top20_clo_cc)
#%%
# =============================================================================
# Degree Distribution2
# =============================================================================
# def plot_degree_distribution(G):
# degree_sequence = sorted([d for n, d in G.degree()], reverse=True) # degree sequence
# degreeCount = collections.Counter(degree_sequence)
# deg, cnt = zip(*degreeCount.items())
# fig, ax = plt.subplots()
# plt.bar(deg, cnt)
# plt.ylabel("Количество")
# plt.xlabel("Степень или валентность вершины")
# plot_degree_distribution(Gx2)
# plt.title("Распределение степеней (узлов, вершин)(2016.1.1-2019.2.1)",
# fontdict=font_dict)
# plt.show()
#%%
degree_freq = np.array(nx.degree_histogram(Gx2))
plt.figure(figsize=(12, 8))
plt.stem(degree_freq)
plt.ylabel("Частота (количество узлов)")
plt.xlabel("Степень одного узла")
plt.title("Распределение степеней узла (01.06.2016-31.05.2017)",
fontdict=font_dict)
plt.show()
for title in list(largest_of_G_paper_fine)
]
#绘图
nx.draw(g,
pos=nx.random_layout(g),
node_color='b',
edge_color='r',
node_size=10,
style='solid',
node_shape='o',
font_size=20)
plt.savefig("paper_group.png", dpi=400, bbox_inches='tight')
plt.show()
#描述
len(G_paper_title)
G_paper_title.number_of_edges()
nx.degree_histogram(G_paper_fine)
#转矩阵
nx.adjacency_matrix(G_paper_title).todense()
dense = nx.adjacency_matrix(G_paper_title).todense()
sparse.coo_matrix(dense)
##储存中间结果
path_pkl = 'D:/bigdatahw/dissertation/pre_defence/nod/paper_group1_metrix.pkl'
paper_dict_file = open(path_pkl, 'wb')
pkl.dump(dense, paper_dict_file)
paper_dict_file.close()
from pylab import *
import networkx as nx
from scipy import stats as st
n = 10000
ba = nx.barabasi_albert_graph(n, 5)
Pk = [float(x) / n for x in nx.degree_histogram(ba)]
domain = range(len(Pk))
ccdf = [sum(Pk[k:]) for k in domain]
logkdata = []
logFdata = []
prevF = ccdf[0]
for k in domain:
F = ccdf[k]
if F != prevF:
logkdata.append(log(k))
logFdata.append(log(F))
prevF = F
a, b, r, p, err = st.linregress(logkdata, logFdata)
print 'Estimated CCDF: F(k) =', exp(b), '* k^', a
print 'r =', r
print 'p-value =', p
plot(logkdata, logFdata, 'o')
kmin, kmax = xlim()
plot([kmin, kmax],[a * kmin + b, a * kmax + b])
xlabel('log k')
ylabel('log F(k)')
show()
nodetype=int)
#G = nx.read_edgelist('/home/larry/programs/Python/networkx/loc-brightkite_edges.txt', create_using=nx.Graph(), nodetype=int)
# nx.write_gml(g, "facebook_combined.gml")
print(nx.info(G))
import matplotlib.pyplot as plt #导入科学绘图的matplotlib包
import matplotlib as mpl
plt.switch_backend('agg')
mpl.rcParams['agg.path.chunksize'] = 100000
print('*' * 20, '度分布曲线', '*' * 20)
plt.figure()
plt.clf()
degree = nx.degree_histogram(G) # 返回每个度, 对应的节点个数
degree_num = [i * j for i, j in enumerate(degree)]
print("平均度数", sum(degree_num) / sum(degree))
degree_x = range(len(degree)) #生成x轴序列，从0到最大度
degree_y = [z / sum(degree) for z in degree] # 每个度的节点个数， 对总节点的占比
plt.scatter(degree_x, degree_y, marker='.')
plt.title("degree distribute")
plt.xlabel("degree")
plt.ylabel("frequency")
plt.savefig("degree distribute") #显示图表\
print('*' * 20, '点度中心性', '*' * 20)
def print_basic_graph_info(self):
print("Info:")
print(nx.info(self.graph))
print("\nDegree histogram: " + str(nx.degree_histogram(self.graph)))
print("Density: " + str(nx.density(self.graph)))
partners = tie[2:6]
for partner in partners: #could have multiple partners
if partner != -2 and partner !=-9: #could it have another tie to same partner?
form = aggform = consolform = 1
if partner < 1000: #only DBFs
# if partner > 1000:
# cur.execute("SELECT form, aggform, consolform FROM Partners WHERE pid="+str(partner))
# parts = cur.fetchall()
# form, aggform, consolform = parts[0]
if fid != partner: #no self loops
g.add_edge(fid, partner, nih=int(nih), form=int(form), aggform=int(aggform), consolform=int(consolform))
n = nx.number_of_nodes(g)
e = nx.number_of_edges(g)
d = nx.degree_histogram(g)
t = nx.transitivity(g)
kc = nx.core_number(g)
nx.set_node_attributes(g,'k_core',kc)
dc=nx.degree_centrality(g)
nx.set_node_attributes(g,'dc',dc)
# nihs=nx.get_edge_attributes(g,'nih')
print "Graph has %d nodes and %d edges and %f transitivity" %(n, e, t)
#grab initial pairs
pairs = list(nx.preferential_attachment(g))
pairs += list(nx.preferential_attachment(g,g.edges()))
yr = int(str(year)[0:4])
for pair in pairs:
def net_degrees(self):
#n = self._net.original_graph.to_undirected().degree_histogram() # SAGE compatible
n = degree_histogram(self._net.original_graph) # networkx compatible
return sorted([i for i, j in enumerate(n) if j])
def degree_worker(G):
return np.array(nx.degree_histogram(G))
counts = update_cooffenders(crime_dict, offenders)
num_lone = len(list(filter(lambda x: len(counts[x]) == 0, counts)))
#if load_from_file:
# print(len(offenders))
# overall = nx.read_gpickle("graph.p")
# print(len(offenders))
#else:
# print(len(offenders))
overall = create_cooffending_network(offenders)["overall"]
print(len(offenders))
#nx.write_gpickle(overall,"graph.p")
print("number of nodes:", nx.number_of_nodes(overall))
print("number of lone_wolves:", num_lone)
print("number of edges:", nx.number_of_edges(overall))
deg_freq = nx.degree_histogram(overall)
degrees = np.arange(len(deg_freq))
connected_components = [
c for c in sorted(nx.connected_components(overall), key=len, reverse=True)
]
largest_component = connected_components[0]
print("number of connected components:", len(connected_components))
print("num of nodes in largest cc:", len(largest_component))
plotDist(degrees, deg_freq, "Number of Degrees", "Frequency of Degrees",
"Frequency of nodes with degrees")
"""
Problem 5.3
"""
def sort_dict_by_value(data_dict, reverse=False):
def adaptive_SEIR_simulation(Graph, beta, eta, gamma, a, w, init_exp, init_inf,
t_max):
G = Graph.copy()
N = nx.number_of_nodes(G)
# Initialize activation/deletion rates
alpha = a(0)
omega = w(0)
# Get edges/possible edges
all_possible_edges = [(i, j) for i in nx.nodes(G) for j in nx.nodes(G)
if i < j]
edges = list(nx.edges(G))
non_edges = list(set(all_possible_edges) - set(edges))
# Initialize epidemic variables
times, S, E, I, R = [[0], [N - len(init_exp + init_inf)], [len(init_exp)],
[len(init_inf)], [0]]
infected_nodes = init_inf.copy()
exposed_nodes = init_exp.copy()
recovered_nodes = []
neighbors = []
#Initialize network variables
#Get degree distributions
degrees = nx.degree_histogram(G)
k = [sum([k * degrees[k] / N for k in range(len(degrees))])]
k2_k = [sum([k * (k - 1) * degrees[k] / N for k in range(len(degrees))])]
phi = [nx.transitivity(G)]
# Get all the neighbors of infected nodes
for i in infected_nodes:
temp = list(nx.neighbors(G, i))
neigh_temp = [x for x in temp if x not in neighbors]
neighbors = neighbors + neigh_temp
at_risk_nodes = [
node for node in neighbors
if node not in infected_nodes + exposed_nodes + recovered_nodes
]
# Get force of infection
infectious_neighbors = [0 for i in range(N)]
for i in at_risk_nodes:
infectious_neighbors[i] = len(
list(
set(infected_nodes).intersection(set(list(nx.neighbors(G,
i))))))
infection_rate = [beta * i for i in infectious_neighbors]
# Total Rates
total_activation_rate = alpha * len(non_edges)
total_deletion_rate = omega * len(edges)
total_infection_rate = sum(infection_rate)
total_latency_rate = eta * len(exposed_nodes)
total_recovery_rate = gamma * len(infected_nodes)
#
total_rate = total_infection_rate + total_latency_rate + total_recovery_rate + total_activation_rate + total_deletion_rate
time = np.random.exponential(1 / total_rate)
while (time < t_max) and (total_rate > 0):
r = np.random.uniform(0, total_rate)
#print("At Risk == Nonzero inf neigh?",len(at_risk_nodes)==len([x for x in infectious_neighbors if x != 0]))
#Recovery
if r < total_recovery_rate:
u = rand.choice(infected_nodes)
infected_nodes = [inf for inf in infected_nodes if inf != u]
recovered_nodes.append(u)
for i in list(
set(at_risk_nodes).intersection(set(nx.neighbors(G, u)))):
if infectious_neighbors[i] == 1:
infectious_neighbors[i] = 0
at_risk_nodes.remove(i)
elif infectious_neighbors[i] > 1:
infectious_neighbors[i] -= 1
d_k, d_k2_k, d_T = [0, 0, 0]
#Become Infectious
elif total_recovery_rate <= r < total_recovery_rate + total_latency_rate:
u = rand.choice(exposed_nodes)
exposed_nodes = [exp for exp in exposed_nodes if exp != u]
infected_nodes.append(u)
for i in list(nx.neighbors(G, u)):
if i not in at_risk_nodes + infected_nodes + exposed_nodes + recovered_nodes:
infectious_neighbors[i] = 1
at_risk_nodes.append(i)
elif i in at_risk_nodes:
infectious_neighbors[i] += 1
d_k, d_k2_k, d_T = [0, 0, 0]
#Exposure
elif total_recovery_rate + total_latency_rate <= r < total_recovery_rate + total_latency_rate + total_infection_rate:
#probs = [beta*inf/total_infection_rate for inf in infectious_neighbors if inf != 0]
#u = np.random.choice(sorted(at_risk_nodes),p=probs)
probs = [
beta * infectious_neighbors[at_risk_nodes[i]] /
total_infection_rate for i in range(len(at_risk_nodes))
]
u = np.random.choice(at_risk_nodes, p=probs)
at_risk_nodes = [node for node in at_risk_nodes if node != u]
exposed_nodes.append(u)
infectious_neighbors[u] = 0
d_k, d_k2_k, d_T = [0, 0, 0]
#Link Activation
elif total_recovery_rate + total_latency_rate + total_infection_rate <= r < total_recovery_rate + total_latency_rate + total_infection_rate + total_activation_rate:
if len(edges) == N * (N - 1) / 2:
pass
else:
#Get a random non-edge
node1, node2 = rand.choice(non_edges)
n1 = nx.degree(G, node1)
n2 = nx.degree(G, node2)
#Add the edge
non_edges.remove((node1, node2))
edges.append((node1, node2))
G.add_edge(node1, node2)
if node1 in infected_nodes:
if node2 not in at_risk_nodes + infected_nodes + exposed_nodes + recovered_nodes:
at_risk_nodes.append(node2)
infectious_neighbors[node2] = 1
elif node2 in at_risk_nodes:
infectious_neighbors[node2] += 1
elif node2 in infected_nodes:
if node1 not in at_risk_nodes + infected_nodes + exposed_nodes + recovered_nodes:
at_risk_nodes.append(node1)
infectious_neighbors[node1] = 1
elif node1 in at_risk_nodes:
infectious_neighbors[node1] += 1
d_k = 2 / N
d_k2_k = 2 * (n1 + n2) / N
d_T = len(
set(nx.neighbors(G, node1)) & set(nx.neighbors(G, node2)))
#Link Removal
else:
if len(edges) == 0:
pass
else:
#Random Edge
node1, node2 = rand.choice(edges)
n1 = nx.degree(G, node1)
n2 = nx.degree(G, node2)
#Remove the edge
non_edges.append((node1, node2))
edges.remove((node1, node2))
G.remove_edge(node1, node2)
if node1 in at_risk_nodes and node2 in infected_nodes:
if infectious_neighbors[node1] == 1:
at_risk_nodes.remove(node1)
infectious_neighbors[node1] = 0
else:
infectious_neighbors[node1] -= 1
elif node2 in at_risk_nodes and node1 in infected_nodes:
if infectious_neighbors[node2] == 1:
at_risk_nodes.remove(node2)
infectious_neighbors[node2] = 0
else:
infectious_neighbors[node2] -= 1
d_k = -2 / N
d_k2_k = (4 - 2 * (n1 + n2)) / N
d_T = -len(
set(nx.neighbors(G, node1)) & set(nx.neighbors(G, node2)))
#Update Variable Lists
times.append(time)
S.append(N - len(infected_nodes + exposed_nodes + recovered_nodes))
E.append(len(exposed_nodes))
I.append(len(infected_nodes))
R.append(len(recovered_nodes))
k.append(k[-1] + d_k)
k2_k.append(k2_k[-1] + d_k2_k)
phi.append(6 * (phi[-1] * N * k2_k[-2] / 6 + d_T) / (N * k2_k[-1]))
#Update Rates
alpha = a(time)
omega = w(time)
total_activation_rate = alpha * len(non_edges)
total_deletion_rate = omega * len(edges)
total_latency_rate = eta * len(exposed_nodes)
total_recovery_rate = gamma * len(infected_nodes)
total_infection_rate = beta * sum(infectious_neighbors)
total_rate = total_infection_rate + total_latency_rate + total_recovery_rate + total_activation_rate + total_deletion_rate
if total_rate != 0:
time = time + np.random.exponential(1 / total_rate)
return [times, S, E, I, R, k, k2_k, phi]
def create_network(n, m):
m0 = 20
G = nx.Graph()
for ni in range(1, m0 + 1):
G.add_node(ni)
for nj in range(1, ni):
if nj != ni:
G.add_edge(ni, nj)
nconnected = m0 + 1
gsize = G.size(weight = 'weight')
for ni in range(m0 + 1, n + 1):
for mi in range(1, m + 1):
attached = False
while not attached:
for nj in range(1, nconnected):
if ni != nj and not G.has_edge(ni, nj):
p = G.degree(nj, weight = 'weight') / gsize
if random.uniform(0, 1) < p:
G.add_edge(ni, nj)
attached = True
gsize += 1
break
nconnected += 1
nx.draw_networkx(G, node_size = 4, with_labels = False)
plt.title('n = ' + str(n) + ', m = ' + str(m))
filename = 'ba_n' + str(n) + '_m' + str(m) + '_net.png'
plt.savefig(filename)
# plt.show()
plt.clf()
histo = nx.degree_histogram(G)
total = sum(histo)
norm_histo = np.divide(histo, total)
length = len(norm_histo)
kn = np.arange(length)
knm = np.add(kn, m)
plt.plot(kn, norm_histo, 'r-', label = 'empirical')
exponential = np.empty(length)
for k in range(0, length):
exponential[k] = (k + 1) ** (-3)
total = sum(exponential)
norm_exponential = np.divide(exponential, total)
plt.plot(knm, norm_exponential, 'b-', label = 'exponential(-3)')
plt.title('n = ' + str(n) + ', m = ' + str(m))
plt.xlabel('Grado k')
plt.ylabel('Fracción de nodos')
plt.legend(loc = 1)
filename = 'ba_n' + str(n) + '_m' + str(m) + '_dg.png'
plt.savefig(filename)
# plt.show()
plt.clf()
if n >= 1000:
plt.plot(kn, norm_histo, 'r-', label = 'empirical')
plt.plot(knm, norm_exponential, 'b-', label = 'exponential(-3)')
plt.title('n = ' + str(n) + ', m = ' + str(m) + ' (log-log)')
plt.xlabel('Grado k')
plt.ylabel('Fracción de nodos')
plt.xscale('log')
plt.yscale('log')
plt.legend(loc = 3)
filename = 'ba_n' + str(n) + '_m' + str(m) + '_dg_log_log.png'
plt.savefig(filename)
# plt.show()
plt.clf()
plt.bar(kn, histo, align='center', label = 'empirical')
plt.title('n = ' + str(n) + ', m = ' + str(m) + ' (bar-log-log)')
plt.xlabel('Grado k')
plt.ylabel('Fracción de nodos')
plt.xscale('log')
plt.yscale('log')
plt.legend(loc = 1)
filename = 'ba_n' + str(n) + '_m' + str(m) + '_dg_bar_log_log.png'
plt.savefig(filename)
# plt.show()
plt.clf()
filename = 'ba_n' + str(n) + '_m' + str(m) + '_dg.txt'
file = open(filename, 'w')
for i in range(length):
file.write(str(i) + ' ' + str(histo[i]) + '\n')
file.close()
return
import sys
# connected_watts_strogatz_graph(n, k, p, tries=100, seed=None)
# Returns a connected Watts–Strogatz small-world graph.
# Attempts to generate a connected graph by repeated generation of Watts–Strogatz small-world graphs. An
# exception is raised if the maximum number of tries is exceeded.
# Parameters
# • n (int) – The number of nodes
# • k (int) – Each node is joined with its k nearest neighbors in a ring topology.
# • p (float) – The probability of rewiring each edge
# • tries (int) – Number of attempts to generate a connected graph.
# • seed (integer, random_state, or None (default)) – Indicator of random number generation state.
# Notes
# First create a ring over 𝑛 nodes1. Then each node in the ring is joined to its 𝑘 nearest neighbors (or 𝑘 − 1
# neighbors if 𝑘 is odd). Then shortcuts are created by replacing some edges as follows: for each edge (𝑢, 𝑣)
# in the underlying “𝑛-ring with 𝑘 nearest neighbors” with probability 𝑝 replace it with a new edge (𝑢,𝑤) with
# uniformly random choice of existing node 𝑤. The entire process is repeated until a connected graph results.
# Define number of nodes in the employee graph
numberOfNodes = 2000
G = nx.connected_watts_strogatz_graph(numberOfNodes, 4, 0.250)
#Write an GRAPHML file -- THIS WORKS WITH NETLOGO!!
nx.write_graphml(G, "SmallWorld-2000Nodes-Ver1.graphml")
print("\n")
print(nx.info(G))
print(nx.degree_histogram(G))
print("Clustering Coefficient: " + str(nx.average_clustering(G)))
print("Average Shortest Path length: " +
str((nx.average_shortest_path_length(G))))
def entropy1(g):
if nx.number_of_nodes(g) == 0:
return 0
diff_degrees = sum(x > 0 for x in nx.degree_histogram(g)) - 1
return diff_degrees / nx.number_of_nodes(g)
import networkx as nx
import matplotlib.pyplot as plt
from functions import bipartite_poisson_generator
# %% Generate bipartite network with two Poisson degree distributions
N = 200 #Number of Individuals
M = 50 #Number of Mixing Locations
lamb1 = 2 #Average Individual Degree (Bipartite Network)
G, G_bipartite = bipartite_poisson_generator(N,M,lamb1)
#Degree Distribution
degree_dist = list(nx.degree_histogram(G)).copy()
degrees = [d for d in range(len(degree_dist)) for i in range(degree_dist[d])]
#####################
# %% Plots
# Figure 3a - Mixing Network
plt.figure(figsize=(12,4))
color = ['#47aee6' for i in range(N)] + ['#123AA1' for i in range(M)]
size = [20 for i in range(N)] + [50 for i in range(M)]
nx.draw(G_bipartite,node_color=color, node_size = size, width=0.2,pos=nx.bipartite_layout(G_bipartite,nx.bipartite.sets(G_bipartite)[1],align='horizontal'))
#plt.savefig("Figure3a.png")
# chamar a funcao
g = graph_func()
# info of graph
print(nx.info(g))
# mostrar graficamente o grafo
plt.figure(figsize=(10, 10))
plt.title("Graph Network")
nx.draw(g, node_size=250, node_color='red', with_labels=True)
nx.draw_networkx_labels(g)
plt.show()
# degree distribution
degree_distribution = nx.degree_histogram(g)
d_h = pd.DataFrame(degree_distribution)
ax = d_h.plot(kind='bar', legend=False)
plt.title("Degree Distribution")
ax.set_xlabel("Degree")
ax.set_ylabel("Frequency")
plt.show()
# betweenness centrality
bc = nx.betweenness_centrality(g)
print(
sorted(nx.betweenness_centrality(g).items(),
key=operator.itemgetter(1),
reverse=True))
def test_degree_distribution(self):
m, n = 5, 6
G = nx.grid_2d_graph(m, n)
expected_histogram = [0, 0, 4, 2 * (m + n) - 8, (m - 2) * (n - 2)]
assert nx.degree_histogram(G) == expected_histogram
