def computeBetweenessCentrality(G, NodeAttributes):
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
BetweenessNodeList = list()
BetweenessEdgeList = list()
snap.GetBetweennessCentr(G, Nodes, Edges, 1.0)
for node in Nodes:
NodeAttributes[node]['Betweeness'] = Nodes[node]
BetweenessNodeList.append((node, Nodes[node]))
for edge in Edges:
#print "edge: (%d, %d) centrality: %f" % (edge.GetVal1(), edge.GetVal2(), Edges[edge])
BetweenessEdgeList.append(
(edge.GetVal1(), edge.GetVal2(), Edges[edge]))
BetweenessNodeList.sort(key=lambda x: x[1], reverse=True)
BetweenessEdgeList.sort(key=lambda x: x[2], reverse=True)
#print BetweenessNodeList[0], BetweenessNodeList[-1]
minBetweeness = BetweenessNodeList[-1][1]
maxBetweeness = BetweenessNodeList[0][1]
for (node, betweeness) in BetweenessNodeList:
normBetweeness = (betweeness - minBetweeness) / (maxBetweeness -
minBetweeness)
NodeAttributes[node]['normBetweeness'] = normBetweeness
#print NodeAttributes[1669]
#print NodeAttributes[884]
return NodeAttributes
def get_betweenness_centr(net, label, outpath):
"""
get betweenness centrality.
:param net:
:param label:
:param outpath:
:return:
"""
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(net, Nodes, Edges, 1.0)
node_betweenness_centr_file = open(outpath + label + '-node_btweennesss_centr', 'w')
node_betweenness_centr_top_file = open(outpath + label + '-node_betweenness_centr-top100', 'w')
node_betweenness_centr = {}
for item in Nodes:
node_betweenness_centr[item] = Nodes[item]
node_betweenness_centr = sorted(node_betweenness_centr.items(), key=operator.itemgetter(1), reverse=True)
id, value = zip(*node_betweenness_centr)
for i in range(len(id)):
node_betweenness_centr_file.write(str(id[i]) + '\t' + str(value[i]) + '\n')
for i in range(100):
node_betweenness_centr_top_file.write(str(id[i]) + '\t' + str(value[i]) + '\n')
node_betweenness_centr_file.close()
node_betweenness_centr_top_file.close()
return id, value
def compute_betwenness_centrality(self, graph):
nodes_betweenness_centrality = snap.TIntFltH()
edges_betweenness_centrality = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, nodes_betweenness_centrality,
edges_betweenness_centrality, 1.0)
return nodes_betweenness_centrality, edges_betweenness_centrality
def generate_scores(self):
scores = {}
common_neighbor_scores = {}
for e in self.g.Edges():
# common_neighbor_scores[(e.GetSrcNId(), e.GetDstNId())] = snap.GetCmnNbrs(self.g, e.GetSrcNId(), e.GetDstNId())
n1 = snap.TIntV()
n2 = snap.TIntV()
snap.GetNodesAtHop(self.g, e.GetSrcNId(), 1, n1, True)
snap.GetNodesAtHop(self.g, e.GetDstNId(), 1, n2, True)
common_neighbor_scores[(e.GetSrcNId(), e.GetDstNId())] = len(set(n1) & set(n2))
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(self.g, Nodes, Edges, self.node_frac, True)
edge_betweenness_scores = {}
for e in Edges:
edge_betweenness_scores[(e.GetVal1(), e.GetVal2())] = Edges[e]
max_cn = max(common_neighbor_scores.values())
max_eb = max(edge_betweenness_scores.values())
print(common_neighbor_scores)
print(edge_betweenness_scores)
for e in self.g.Edges():
src = e.GetSrcNId()
dst = e.GetDstNId()
scores[(src, dst)] = self.l * common_neighbor_scores[(src,dst)] / max_cn + (1-self.l) * edge_betweenness_scores[(src,dst)] / max_eb
return scores
def getBetweennessCentr(self):
nodesKeyCentrVals = snap.TIntFltH()
edgesKeyCentrVals = snap.TIntPrFltH()
snap.GetBetweennessCentr(self.G, nodesKeyCentrVals, edgesKeyCentrVals,
1.0)
return nodesKeyCentrVals
def betweenness_test(name):
if os.path.isfile(DATA_PATH + name + ".between"):
print "Skipping", name
return
start = time.time()
G, coords = osmParser.simpleLoadFromFile(name)
print "Calculating betweenness", name
nodeToBetweenness = snap.TIntFltH()
edgeToBetweenness = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, nodeToBetweenness, edgeToBetweenness, 0.25)
betweenness = {}
for node in nodeToBetweenness:
betweenness[node] = nodeToBetweenness[node]
betweenOut = open(DATA_PATH + name + ".between", 'w')
pickle.dump(betweenness, betweenOut, 1)
plotTopK(name, betweenness, coords, "GnBu")
end = time.time()
print "took", end - start, "seconds"
def CalculateBetweennessCentrality(graph):
nodes = snap.TIntFltH()
edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, nodes, edges, 1.0)
output = {}
for node in nodes:
output[node] = nodes[node]
return output
def nodes_centrality_betweeness():
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, Nodes, Edges, 1.0)
sorted_Bet = sorted(Nodes, key=lambda key: Nodes[key], reverse=True)
# print top n nodes with highest Betweeness
for item in sorted_Bet[0:5]: #top 5
print(item, Nodes[item])
def BetweennessCentrality(self):
lstNodeBet = {}
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(self.graph, Nodes, Edges, 1.0)
for node in Nodes:
lstNodeBet[node] = Nodes[node]
return lstNodeBet
def getMaxBetweennessCentrality(graph):
nodeTable = snap.TIntFltH()
edgeTable = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, nodeTable, edgeTable, 1.0)
betweennessCentralities = [nodeTable[node] for node in nodeTable]
numNodes = graph.GetNodes()
# Normalize by the max betweenness centrality that a node in this graph could have
return 2 * np.max(betweennessCentralities) / ((numNodes - 1) *
(numNodes - 2))
def calc_BetweenessCentrality(Graph, node_to_g):
prot_to_betweeness_centrality = {}
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0)
for node in Nodes:
my_prot = node_to_g[node]
prot_to_betweeness_centrality[my_prot] = Nodes[node]
return prot_to_betweeness_centrality
def getNodeAttributes(self,UGraph):
attriList=[]
for index in range(UGraph.GetNodes()):
nodelist=[]
attriList.append(nodelist)
#page rank
PRankH = snap.TIntFltH()
snap.GetPageRank(UGraph, PRankH)
counter=0
for item in PRankH:
attriList[counter].append(PRankH[item])
counter+=1
#HIN
counter=0
NIdHubH = snap.TIntFltH()
NIdAuthH = snap.TIntFltH()
snap.GetHits(UGraph, NIdHubH, NIdAuthH)
for item in NIdHubH:
attriList[counter].append(NIdHubH[item])
attriList[counter].append(NIdAuthH[item])
counter+=1
# Betweenness Centrality
counter=0
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(UGraph, Nodes, Edges, 1.0)
for node in Nodes:
attriList[counter].append(Nodes[node])
counter+=1
# closeness centrality
counter=0
for NI in UGraph.Nodes():
CloseCentr = snap.GetClosenessCentr(UGraph, NI.GetId())
attriList[counter].append(CloseCentr)
counter+=1
# farness centrality
counter=0
for NI in UGraph.Nodes():
FarCentr = snap.GetFarnessCentr(UGraph, NI.GetId())
attriList[counter].append(FarCentr)
counter+=1
# node eccentricity
counter=0
for NI in UGraph.Nodes():
attriList[counter].append(snap.GetNodeEcc(UGraph, NI.GetId(), True))
counter+=1
atrriMarix=np.array(attriList)
return atrriMarix
def BetweennessCentrality(G):
centrality = {}
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, Nodes, Edges, 0.8)
for node in Nodes:
centrality[node] = round(Nodes[node], 6)
return centrality
def getBetweennessCentrality(Graph):
centrality = []
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(Graph, Nodes, Edges, 1.0, True)
nodeid_centrality = {}
for node in Nodes:
nodeid_centrality[node] = Nodes[node]
for node_id in sorted(nodeid_centrality):
centrality.append(nodeid_centrality[node_id])
return centrality
def GetMaxKBetweennessCentrality(self, k):
lstNodeBet = []
nodesId = []
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(self.graph, Nodes, Edges, 1.0)
for node in Nodes:
nodesId.append(node)
lstNodeBet.append(Nodes[node])
return self.GetMaxK(lstNodeBet, nodesId, k)
def betweenessCentrality(graph, x):
betCent = []
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, Nodes, Edges, 1.0)
for node in Nodes:
# print "node: %d centrality: %f" % (node, Nodes[node])
betCent.append([node, Nodes[node]])
betCent = sorted(betCent, key=lambda x: x[1], reverse=True)
betCent = betCent[:int(x)]
# print(betCent)
return betCent
def testExactEdgeCentrality():
testG = snap.GenPrefAttach(NUM_NODES, OUT_DEGREE, Rnd)
centrality = ExactEdgeCentrality(testG)
unusedNodes = snap.TIntFltH()
expectedCentrality = snap.TIntPrFltH()
snap.GetBetweennessCentr(testG, unusedNodes, expectedCentrality, 1.0)
for key in expectedCentrality:
(v, w) = key.GetVal1(), key.GetVal2()
expected = expectedCentrality[key]
if abs(centrality[(v, w)] - expected) >= 1e-8:
print centrality[(v, w)], expected
assert abs(centrality[(v, w)] - expected) < 1e-8
def getUndirAttribute(filename, node_num, weighted=None, param=1.0):
UGraph = snap.LoadEdgeList(snap.PUNGraph, filename, 0, 1)
attributeNames = [
'Graph', 'Id', 'Degree', 'NodeBetweennessCentrality', 'PageRank',
'EgonetDegree', 'AvgNeighborDeg', 'EgonetConnectivity'
]
if weighted:
attributeNames += [
'WeightedDegree', 'EgoWeightedDegree', 'AvgWeightedNeighborDeg',
'EgonetWeightedConnectivity'
]
attributes = pd.DataFrame(np.zeros((node_num, len(attributeNames))),
columns=attributeNames)
attributes['Graph'] = [filename.split('/')[-1].split('.')[0]
] * node_num #node_num
# Degree
attributes['Id'] = range(0, node_num)
degree = np.zeros((node_num, ))
OutDegV = snap.TIntPrV()
snap.GetNodeOutDegV(UGraph, OutDegV)
for item in OutDegV:
degree[item.GetVal1()] = item.GetVal2()
attributes['Degree'] = degree
getEgoAttr(UGraph, node_num, attributes, directed=False)
if weighted:
df = getWeightedDegree(filename, node_num, attributes, directed=False)
getWeightedEgoAttr(UGraph, node_num, attributes, df, directed=False)
# Betweenness Centrality
betCentr = np.zeros((node_num, ))
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(UGraph, Nodes, Edges, param)
for node in Nodes:
betCentr[node] = Nodes[node]
attributes['NodeBetweennessCentrality'] = betCentr
# PageRank
pgRank = np.zeros((node_num, ))
PRankH = snap.TIntFltH()
snap.GetPageRank(UGraph, PRankH)
for item in PRankH:
pgRank[item] = PRankH[item]
attributes['PageRank'] = pgRank
return attributes
def GetOverlap(filePathName, Graph, t):
# l is here the final ranking of the nodes
# Intially, we just put all the nodes in this
# and afterwards we sort it
l = [i for i in range(Graph.GetNodes())]
# The reference vector whose information is used to sort l
ref_vect = [0 for i in range(Graph.GetNodes())]
# if Type 1, then fill ref_vect with closeness centrality measure
if (t == 1):
for NI in Graph.Nodes():
ref_vect[NI.GetId()] = snap.GetClosenessCentr(Graph, NI.GetId())
# if Type 2, then fill ref_vect with betweenness centrality measure
if (t == 2):
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
# Setting NodeFrac parameter as 0.8 as instructed
snap.GetBetweennessCentr(Graph, Nodes, Edges, 0.8)
for node in Nodes:
ref_vect[node] = Nodes[node]
# if Type 3, then fill ref_vect with PageRank scores
if (t == 3):
PRankH = snap.TIntFltH()
# Taking the limit as 1e-6 as used in gen_centrality.py
snap.GetPageRank(Graph, PRankH, 0.8, 1e-6, 100)
for item in PRankH:
ref_vect[item] = PRankH[item]
# Now we sort l using the ref_vect
l.sort(
key=cmp_to_key(lambda item1, item2: ref_vect[item2] - ref_vect[item1]))
# make a set containing top 100 nodes of l
S1 = set(l[:100])
# make another set containing top 100 nodes from the text files
S2 = set()
f = open(filePathName, 'r')
for _ in range(100):
s = f.readline()
a, b = s.split()
S2.add(int(a))
# return the number of overlaps in S1 and S2
return len(S1.intersection(S2))
def _betweennessOverlap(elistPath, nodeFrac=0.8):
"""
Compute overlap between our values of betweenness centrality and SNAP's internal implementation
Parameters
----------
elistPath: str or pathlib.Path
Edge list of the graph to compute centralities on
nodeFrac: float, default = 0.8
Node Fraction to randomly sample nodes when using SNAP's internal betweenness centrality function
----------
Returns
----------
calculatedNodes: set
Top 100 nodes by betweenness centrality according to our implementation
SNAPNodes: set
Top 100 nodes by betweenness centrality according to the SNAP implementation (snap.GetBetweennessCentr)
len(overlap): int
Count of overlapping nodes between the 2 sets
----------
Reads from file our values of betweenness centrality and then calls the SNAP function
Once we have 2 sets of top 100 nodes, perform a set.intersection() call for common elements between both sets
"""
adjGraph = AdjGraph(elistPath, separator=" ")
graph = adjGraph.SNAPGraph
calculatedNodes = readNodes("betweenness.txt")
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, Nodes, Edges, nodeFrac)
SNAPBC = {}
for node in Nodes:
SNAPBC[node] = Nodes[node]
SNAPBC = {
k: v
for k, v in sorted(SNAPBC.items(), key=lambda x: x[1], reverse=True)
}
SNAPNodes = list(SNAPBC.keys())[:100]
SNAPNodes = set([int(node) for node in SNAPNodes])
overlap = SNAPNodes.intersection(calculatedNodes)
return (calculatedNodes, SNAPNodes, len(overlap))
def genGraphInfoBetweeness(self, centrality):
print "\n+++++++++++ %s ++++++++++++" % (centrality)
print "Calculating centrality values..."
start_time = time.clock()
nodesKeyCentrVals = snap.TIntFltH()
edgesKeyCentrVals = snap.TIntPrFltH()
snap.GetBetweennessCentr(self.G, nodesKeyCentrVals, edgesKeyCentrVals,
1.0)
print "Computation time: %f secs." % (time.clock() - start_time)
outputFileName = self.getOutputFileName(centrality)
print "Generating the output -> %s" % (outputFileName)
output, topNodes = self.getHashmapText(nodesKeyCentrVals)
self.writeOutput(outputFileName, output)
print "Top node labels: \n %s" % (topNodes)
return nodesKeyCentrVals
def partB():
print "\nCalculating nodes' betweenness centrality..."
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(MaxWCC, Nodes, Edges, 1.0)
print '\n20 ACTORS WITH THE HIGHEST BETWEENNESS CENTRALITY:'
betweennesses = {node_id: Nodes[node_id] for node_id in Nodes}
sorted_betweennesses = sorted(betweennesses.items(),
key=operator.itemgetter(1))
for i, keyval in enumerate(reversed(sorted_betweennesses[-20:])):
actor_id, betweenness = keyval
actor_name = legend[actor_id]
number_of_films = full_lines[actor_id][1]
print ' #%d - %s: %s %s' % (i + 1, actor_name, betweenness,
number_of_films)
def testApproxEdgeCentrality():
testG = snap.GenPrefAttach(NUM_NODES, OUT_DEGREE, Rnd)
centrality = ApproxEdgeCentrality(
testG, testG.GetNodes() / 10, 5 * testG.GetNodes())
unusedNodes = snap.TIntFltH()
expectedCentrality = snap.TIntPrFltH()
snap.GetBetweennessCentr(testG, unusedNodes, expectedCentrality, 1.0)
errorSum = 0.0
for key in expectedCentrality:
(v, w) = key.GetVal1(), key.GetVal2()
expected = expectedCentrality[key]
errorSum += (centrality[(v, w)] - expected)**2
print errorSum
print np.sqrt(errorSum / len(expectedCentrality))
def model_between(G):
x = []
y = []
title_name = 'Betweenness Centrality'
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, Nodes, Edges, 1.0)
for node in Nodes:
x.append(node)
y.append(Nodes[node])
picture(x, y, title_name, 'node', 'betweenness centrality')
data = pd.DataFrame({'x': x, 'y': y})
data = data.sort_index(by="y", ascending=True)
# # 写入
data.to_csv('./data/picture/model_between.csv')
def EdgeBetweenness(self, graph):
"""
Get the table of edge betweenness.
:param graph: (TUNGraph) a undirected graph
:return: (Dictionary) hash table that mapped edges with their betweenness
"""
result = {}
# Compute betweeness
# nodes_btwn: output as key-value pairs: key-node id, value-btwness
# edges_btwn: output as key-value pairs: key-(nid1, nid2), value-btwness
nodes_btwn = snap.TIntFltH()
edges_btwn = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, nodes_btwn, edges_btwn)
for edge in edges_btwn:
pair = (edge.GetVal1(), edge.GetVal2())
result[pair] = edges_btwn[edge]
return result
def analyze(graph, file1, file2, file3):
####### closeness centrality #######
t0 = time.time()
closeness_dict = {}
for node in graph.Nodes():
closeness_dict[node.GetId()] = snap.GetClosenessCentr(graph,node.GetId())
closeness_dict = {k:v for k,v in sorted(closeness_dict.items(), key=lambda item: item[1], reverse=True)}
ans1 = get_overlaps(closeness_dict, file1)
######## betweenness centrality #######
vertices_bt_dict = snap.TIntFltH()
edge_bt_dict = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, vertices_bt_dict, edge_bt_dict, 0.8)
betweenness_dict = {}
for node in graph.Nodes():
betweenness_dict[node.GetId()] = vertices_bt_dict[node.GetId()]
betweenness_dict = {k:v for k,v in sorted(betweenness_dict.items(), key=lambda item: item[1], reverse=True)}
ans2 = get_overlaps(betweenness_dict, file2)
########## PageRank #############
pr_dict = snap.TIntFltH()
snap.GetPageRank(graph, pr_dict, 0.8)
pagerank = {}
for node in graph.Nodes():
pagerank[node.GetId()] = pr_dict[node.GetId()]
pagerank = {k:v for k,v in sorted(pagerank.items(), key=lambda item: item[1], reverse=True)}
ans3 = get_overlaps(pagerank, file3)
print("#overlaps for Closeness Centrality: {}".format(ans1))
print("#overlaps for Betweenness Centrality: {}".format(ans2))
print("#overlaps for PageRank Centrality: {}".format(ans3))
def betweenNess(graph, userId):
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, Nodes, Edges, 1.0)
df = pd.DataFrame(columns=('Node', 'Centrality'))
for node in Nodes:
if Nodes[node] != 0:
#print 'node: %d centrality: %f' % (node, Nodes[node])
df.loc[node] = [node, Nodes[node]]
for edge in Edges:
break
#print 'edge: (%d, %d) centrality: %f' % (edge.GetVal1(), edge.GetVal2(), Edges[edge])
df.to_csv(write_DIR + 'betweenness_{}.csv'.format(userId),
sep=',',
index=False)
def calculate_betweenness_centrality(graph, hashtag):
start = time.time()
print("Calculating betweenness centrality...")
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(graph, Nodes, Edges, 1.0)
print("Saving results to file...")
with open(hashtag+"_betweenness_centrality_nodes.csv", "w") as fout:
fout.write("Node,Betweenness Centrality\n")
for node in Nodes:
if Nodes[node] == 0:
continue
fout.write(",".join([str(node), str(Nodes[node])])+"\n")
with open(hashtag+"_betweenness_centrality_edges.csv", "w") as fout:
fout.write("Source,Target,Betweenness Centrality\n")
for edge in Edges:
if Edges[edge] == 0:
continue
fout.write(",".join([str(edge.GetVal1()), str(edge.GetVal2()), str(Edges[edge])])+"\n")
end = time.time()
print("Completed in: %s" % timedelta(seconds=(int(end-start))))
def analyzeBetweenness(FNGraph):
t1 = time.time()
print "Started calculating Betweenness scores: \n"
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(FNGraph, Nodes, Edges, 1.0)
Nodes.Sort(False, False)
nodesPrinted = 0
for node in Nodes:
if(nodesPrinted < 25):
print "\tNode: %d \t Betweenness: %.7f" % (node, Nodes[node])
else:
break
nodesPrinted += 1
print "\nFinished calculating in %.3f seconds\n" % (time.time()-t1)
def calculate_betweeness_centrality(G,GName,Nodes,nodes,edges):
print "Initialting Calculations of Betweeness Centrality using inbuilt function"
start_time = time.time()
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(G, Nodes, Edges, 0.8)
# for node in Nodes:
# print "node: %d centrality: %f" % (node, Nodes[node])
betweeness_centralities = []
for Node in Nodes:
betweeness_centralities.append([Nodes[Node],Node])
betweeness_centralities.sort(reverse=True)
time_taken = time.time() - start_time
print "Execution for Betweeness Centrality completed in ",time_taken//60," mins and ",(time_taken//1)%60, "seconds"
return betweeness_centralities
