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