def get_ev_centr_sum(G, n1, n2, reset=False):
global NIdEigenH
if reset or NIdEigenH is None:
print 'Initializing EV Centrality...'
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(G, NIdEigenH, 1e-2, 50)
return NIdEigenH[n1] + NIdEigenH[n2]
def rank_eigvec(self):
""" Return dictionary of node ID and its eigenvector
centrality score, in score order """
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(self._graph, NIdEigenH)
assert len(NIdEigenH) == self._num_nodes, 'Number of nodes in centrality result must match number of nodes in graph'
return snap_hash_to_dict(NIdEigenH)
def calc_EigenvectorCentrality(Graph, node_to_g):
prot_to_eigenvector_centrality = {}
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(Graph, NIdEigenH)
for node in NIdEigenH:
my_prot = node_to_g[node]
prot_to_eigenvector_centrality[my_prot] = NIdEigenH[node]
return prot_to_eigenvector_centrality
def EigenvectorCentrality(self):
lstEigenVector = {}
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(self.graph, NIdEigenH)
for i in NIdEigenH:
lstEigenVector[i] = NIdEigenH[i]
return lstEigenVector
def CalculateEigenVectorCentr(graph):
output = {}
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(graph, NIdEigenH)
for item in NIdEigenH:
#print "node: %d have centrality: %f" % (item, NIdEigenH[item])
output[item] = NIdEigenH[item]
return output
def model_eigenvector(G):
x = []
y = []
title_name = 'Eigenvector Centrality'
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(G, NIdEigenH)
for item in NIdEigenH:
x.append(item)
y.append(NIdEigenH[item])
picture(x, y, title_name, 'node', 'eigenvector centrality')
def getEigenVectorCentrality(Graph):
centrality = []
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(Graph, NIdEigenH)
nodeid_centrality = {}
for node in NIdEigenH:
nodeid_centrality[node] = NIdEigenH[node]
for node_id in sorted(nodeid_centrality):
centrality.append(nodeid_centrality[node_id])
return centrality
def GetMaxKEigenvectorCentrality(self, k):
lstEigenVector = []
nodesId = []
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(self.graph, NIdEigenH)
for i in NIdEigenH:
nodesId.append(i)
lstEigenVector.append(NIdEigenH[i])
return self.GetMaxK(lstEigenVector, nodesId, k)
def calculate_eigenvector_centrality(graph, hashtag):
start = time.time()
print("Calculating eigenvector centrality...")
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(graph, NIdEigenH)
print("Saving results to file...")
with open(hashtag+"_eigenvector_centrality.csv", "w") as fout:
fout.write("Node,Eigenvector Centrality\n")
for item in NIdEigenH:
fout.write(",".join([str(item), str(NIdEigenH[item])])+"\n")
end = time.time()
print("Completed in: %s" % timedelta(seconds=(int(end-start))))
def TopKEigCent(graph, K):
eigscore = np.zeros((graph.GetNodes(), 2))
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(graph, NIdEigenH)
i = 0
for item in NIdEigenH:
eigscore[i, 0] = int(item)
eigscore[i, 1] = NIdEigenH[item]
i+=1
ind_sorted = np.argsort(-eigscore[:,1])
eigscore = eigscore[ind_sorted, :]
return eigscore[:K, :]
def get_eigenvector_centrality(graph, gtype='snap'):
nids, ev_centr = [], []
if gtype == 'snap':
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(snap_graph, NIdEigenH)
for item in NIdEigenH:
nids.append(item)
ev_centr.append(NIdEigenH[item])
elif gtype == 'nx':
centrality = nx.eigenvector_centrality(graph)
nids, ev_centr = [], []
for node in np.sort(list(centrality.keys())):
nids.append(node)
ev_centr.append(centrality[node])
return np.asarray(nids, dtype='uint32'), np.asarray(ev_centr,
dtype='float32')
def eigenvector_centrality(self, Eps=1e-4, MaxIter=100):
'''
Computes eigenvector centrality of all nodes in Graph.
Eigenvector Centrality of a node N is defined recursively as the average of centrality values of N’s neighbors in the network.
:param Eps: Convergence difference.
:param MaxIter: Maximum number of iterations.
'''
snap = self.snap
ret = []
NIdEigenH = snap.TIntFlt64H()
snap.GetEigenVectorCentr(self.graph, NIdEigenH, Eps, MaxIter)
for item in NIdEigenH:
ret.append((item, NIdEigenH[item]))
return ret
def main(genre):
G_Multi, G_Directed, G_Undirected, dict = load_genre_graphs(genre)
# clean up graph
print(G_Undirected.GetNodes())
G_Undirected = snap.GetKCore(G_Undirected, 3)
print(G_Undirected.GetNodes())
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(G_Undirected, NIdEigenH)
centralities = []
for item in NIdEigenH:
centralities.append((dict[item], NIdEigenH[item]))
centralities.sort(reverse=True, key=lambda l: l[1])
for centrality in centralities:
print centrality
def get_eigen_vector_centr(net, label, outpath):
"""
get eigen vector centrality. For undirected graph
:param net:
:param label:
:param outpath:
:return:
"""
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(net, NIdEigenH)
eigen_vector_centr_file = open(outpath + label + '-eigen_vector_centr', 'w')
eigen_vector_centr_top_file = open(outpath + label + '-eigen_vector_centr-top100', 'w')
eigen_vector_centr = {}
for item in NIdEigenH:
eigen_vector_centr[item] = NIdEigenH[item]
eigen_vector_centr = sorted(eigen_vector_centr.items(), key=operator.itemgetter(1), reverse=True)
id, value = zip(*eigen_vector_centr)
for i in range(len(id)):
eigen_vector_centr_file.write(str(id[i]) + '\t' + str(value[i]) + '\n')
for i in range(100):
eigen_vector_centr_top_file.write(str(id[i]) + '\t' + str(value[i]) + '\n')
eigen_vector_centr_file.close()
eigen_vector_centr_top_file.close()
return id, value
for item in pg_vec:
pg_dict[item] = pg_vec[item]
pg_sort = sorted(pg_dict.values(), reverse=True)
pg_count10 = 0
for value in pg_sort:
for key1, val1 in pg_dict.iteritems():
if val1 == value:
print val1, key1
pg_count10 += 1
break
if pg_count10 == 10:
break
evCntr_Vector = snap.TIntFltH()
snap.GetEigenVectorCentr(ugraph, evCntr_Vector)
evCntr_dict = dict()
for item in evCntr_Vector:
evCntr_dict[item] = evCntr_Vector[item]
evCntr_sort = sorted(evCntr_dict.values(), reverse=True)
evCntr_count10 = 0
for value in evCntr_sort:
for key1, val1 in evCntr_dict.iteritems():
if val1 == value:
print val1, key1
evCntr_count10 += 1
break
if evCntr_count10 == 10:
for b in idratedbyu])
if business.GetId() not in averateReceivedRate:
averateReceivedRate[business.GetId()]=np.mean([user_to_rating[u]
for u in idratedb])
features.append(
averageSentRate[user.GetId()] * averateReceivedRate[
business.GetId()])
results[(user.GetId(), business.GetId())]=features
# Get page ranks.
PRankH=snap.TIntFltH()
snap.GetPageRank(G, PRankH)
NIdEigenH=snap.TIntFltH()
snap.GetEigenVectorCentr(G, NIdEigenH)
matrix=[]
pair_to_node={}
i=0
for key in results:
u, b=key
results[key].append(PRankH[u] + PRankH[b])
results[key].append(NIdEigenH[u] + NIdEigenH[b])
matrix.append(results[key])
pair_to_node[key]=i
i += 1
feats=np.array(matrix)
feats=(feats - np.mean(feats, axis=0)) / np.std(feats, axis=0)
return pair_to_node, feats
return cmap
def generate_legend(legend):
return '\n'.join((f'{centr} : {color}' for centr, color in legend.items()))
#draw the graph
#snap.DrawGViz(g_rnd,snap.gvlNeato,"rnd_test.png","Random Network")
deg_centr = all_node_centrality(g_rnd, snap.GetDegreeCentr)
close_centr = all_node_centrality(g_rnd, snap.GetClosenessCentr)
nodes_betwn_centr = snap.TIntFlt64H()
edges_betwn_centr = snap.TIntPrFlt64H()
snap.GetBetweennessCentr(g_rnd, nodes_betwn_centr, edges_betwn_centr)
eigen_centr = snap.TIntFlt64H()
snap.GetEigenVectorCentr(g_rnd, eigen_centr)
pr_centr = snap.TIntFlt64H()
snap.GetPageRank(g_rnd, pr_centr)
centralities = {
'degree': deg_centr,
'closeness': close_centr,
'betweenness': nodes_betwn_centr,
'eigenvector': eigen_centr,
'pagerank': pr_centr
}
color_names = cycle(('red', 'green', 'purple', 'blue', 'orange'))
pct = 0.05
combined_cmap = snap.TIntStr64H()
legend = {}
for k, v in centralities.items():
color = next(color_names)
for line in lines:
tokens = line.split('||')
if tokens[2] != '':
nId = nameToNId[tokens[1]]
uIdToNId[int(tokens[0])] = nId
graph = snap.ConvertGraph(snap.PUNGraph, network)
degCenters = {}
closeCenters = {}
pageRanks = snap.TIntFltH()
eigenCenters = snap.TIntFltH()
# btwnCenters = snap.TIntFltH()
# edgeHash = snap.TIntPrFltH()
print('Running PageRank...')
snap.GetPageRank(graph, pageRanks)
print('Running Eigenvector centrality...')
snap.GetEigenVectorCentr(graph, eigenCenters)
# print('Running Betweeness...')
# snap.GetBetweennessCentr(graph, btwnCenters, edgeHash)
print('Running Degree and Closeness...')
for uId, nId in uIdToNId.iteritems():
print uId, nId
degCenters[uId] = snap.GetDegreeCentr(graph, nId)
closeCenters[uId] = snap.GetClosenessCentr(graph, nId)
outfile = open('csv/centralities.csv', 'w')
for uId, nId in uIdToNId.iteritems():
outfile.write(str(uId) + ',' + str(pageRanks[nId]) + ',' +\
str(eigenCenters[nId]) + ',' +\
str(degCenters[uId]) + ',' + str(closeCenters[uId]) + '\n')
outfile.close()
def getAttribute(filename):
UGraph = snap.LoadEdgeList(snap.PUNGraph, filename, 0, 1)
UGraph.Dump()
attributes = pd.DataFrame(np.zeros(shape=(UGraph.GetNodes(), 12)),
columns=['Graph', 'Id', 'Degree', 'DegreeCentrality', 'NodeBetweennessCentrality',
'ClosenessCentrality', 'FarnessCentrality', 'PageRank', 'HubsScore',
'AuthoritiesScore', 'NodeEccentricity', 'EigenvectorCentrality'])
attributes['Graph'] = [filename] * UGraph.GetNodes()
# Degree
id = []
degree = []
OutDegV = snap.TIntPrV()
snap.GetNodeOutDegV(UGraph, OutDegV)
for item in OutDegV:
id.append(item.GetVal1())
degree.append(item.GetVal2())
attributes['Id'] = id
attributes['Degree'] = degree
# Degree, Closeness, Farness Centrality, Node Eccentricity
degCentr = []
cloCentr = []
farCentr = []
nodeEcc = []
for NI in UGraph.Nodes():
degCentr.append(snap.GetDegreeCentr(UGraph, NI.GetId()))
cloCentr.append(snap.GetClosenessCentr(UGraph, NI.GetId()))
farCentr.append(snap.GetFarnessCentr(UGraph, NI.GetId()))
nodeEcc.append(snap.GetNodeEcc(UGraph, NI.GetId(), False))
attributes['DegreeCentrality'] = degCentr
attributes['ClosenessCentrality'] = cloCentr
attributes['FarnessCentrality'] = farCentr
attributes['NodeEccentricity'] = nodeEcc
# Betweenness Centrality
betCentr = []
Nodes = snap.TIntFltH()
Edges = snap.TIntPrFltH()
snap.GetBetweennessCentr(UGraph, Nodes, Edges, 1.0)
for node in Nodes:
betCentr.append(Nodes[node])
attributes['NodeBetweennessCentrality'] = betCentr
# PageRank
pgRank = []
PRankH = snap.TIntFltH()
snap.GetPageRank(UGraph, PRankH)
for item in PRankH:
pgRank.append(PRankH[item])
attributes['PageRank'] = pgRank
# Hubs, Authorities score
hubs = []
auth = []
NIdHubH = snap.TIntFltH()
NIdAuthH = snap.TIntFltH()
snap.GetHits(UGraph, NIdHubH, NIdAuthH)
for item in NIdHubH:
hubs.append(NIdHubH[item])
for item in NIdAuthH:
auth.append(NIdAuthH[item])
attributes['HubsScore'] = hubs
attributes['AuthoritiesScore'] = auth
# Eigenvector Centrality
eigenCentr = []
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(UGraph, NIdEigenH)
for item in NIdEigenH:
eigenCentr.append(NIdEigenH[item])
attributes['EigenvectorCentrality'] = eigenCentr
return attributes
1)
Graph3 = snap.LoadEdgeList(snap.PUNGraph, 'American_recipes.elist.txt', 0, 1)
Graph4 = snap.LoadEdgeList(snap.PUNGraph, 'India_recipes.elist.txt', 0, 1)
#metrics
#1. Eigen Vector Centrality - most influencing ingredients
#2. Degree Centrality - most used ingredients
#Graph1
eigen1 = set()
degree1 = set()
#Eigen Vector Centrality - Graph1
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(Graph1, NIdEigenH)
maxd = 0.0
maxnode = 0
for node in NIdEigenH:
if maxd < NIdEigenH[node]:
maxd = NIdEigenH[node]
maxnode = node
eigen1.add(NIdEigenH[node])
print "Max Eigen node ->", maxnode
print "Max Eigen Value ->", maxd
#Degree Centrality - Graph1
maxd = 0.0
maxnode = 0
for node in Graph1.Nodes():
def eigenvector_centrality(graph, eps=1e-4, max_iter=100):
nodes = sp.TIntFltH()
sp.GetEigenVectorCentr(graph, nodes, eps, max_iter)
return [nodes[n] for n in nodes]
gf_comm.AddNode(id)
for id in node_id_list:
ni = gf.GetNI(id)
deg = ni.GetDeg()
for nbr_i in xrange(deg):
nbr_id = ni.GetNbrNId(nbr_i)
if not gf_comm.IsNode(nbr_id):
gf_comm.AddNode(nbr_id)
gf_comm.AddEdge(id, nbr_id)
return gf_comm
if __name__ == "__main__":
gf_file = "comm_graph_edge.txt"
gf = snap.LoadEdgeList(snap.PUNGraph, gf_file, 0, 1)
print "Load graph! With nodes ", gf.GetNodes(), " and edges ", gf.GetEdges(
)
tmp_NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(gf, tmp_NIdEigenH)
tmp_eignv_map = {}
for key in tmp_NIdEigenH:
tmp_eignv_map[key] = tmp_NIdEigenH[key]
tmp_sorted_eignv = sorted(tmp_eignv_map.items(),
key=operator.itemgetter(1),
reverse=True)
tmp_sorted_id_eignv = [item[0] for item in tmp_sorted_eignv]
##--dump file
eignv_file = "eignv_comm_gf.pkl"
with open(eignv_file, "wb") as fl:
pickle.dump(tmp_sorted_id_eignv, fl)
PRankH = snap.TIntFltH()
snap.GetPageRank(UGraph, PRankH)
with open('na_power_pageranks.csv', 'w') as csvfile: #print pageranks to CSV
fieldnames = ['node_id', 'page_rank']
page_writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
page_writer.writeheader()
for item in PRankH:
page_writer.writerow({'node_id': item, 'page_rank': PRankH[item]})
#Eigenvector Centrality
#epsilon = 10^-4, max_iters = 100
NIdEigenH = snap.TIntFltH()
snap.GetEigenVectorCentr(UGraph, NIdEigenH)
with open('na_power_eigcentr.csv',
'w') as csvfile: #print eig centralities to CSV
fieldnames = ['node_id', 'eig_centr']
eig_writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
eig_writer.writeheader()
for item in NIdEigenH:
eig_writer.writerow({'node_id': item, 'eig_centr': NIdEigenH[item]})
#Degree Centrality
#for some reason I get an error when I try to print all three in a single execution of the code;
#works if you comment one block out
with open('na_power_degcentr.csv', 'w') as csvfile: #print degree centralities
fieldnames = ['node_id', 'deg_centr']
deg_writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
