def compose_graph(uid_pid_pairs):
# set up graph
g = Graph()
g.vp['pid'] = v_pid_p = g.new_vertex_property('string')
g.vp['count'] = v_count_p = g.new_vertex_property('int')
g.ep['count'] = e_count_p = g.new_edge_property('int')
pid_v_map = {}
uid_last_v_map = {}
vv_e_map = {}
for uid, pid in uid_pid_pairs:
# vertex
v = pid_v_map.get(pid)
if v is None:
v = g.add_vertex()
v_pid_p[v] = pid
v_count_p[v] = 0
pid_v_map[pid] = v
v_count_p[v] += 1
# edge
last_v = uid_last_v_map.get(uid)
uid_last_v_map[uid] = v
if last_v is None:
continue
vv = (last_v, v)
e = vv_e_map.get(vv)
if e is None:
e = g.add_edge(*vv)
e_count_p[e] = 0
vv_e_map[vv] = e
e_count_p[e] += 1
# calculate closeness
g.vp['closeness'] = v_closeness_p = g.new_vertex_property('float')
e_inverse_count_p = g.new_edge_property('int')
e_inverse_count_p.a = e_count_p.a.max()-e_count_p.a
debug('e_inverse_count_p.a: {}', e_inverse_count_p.a)
closeness(g, weight=e_inverse_count_p, vprop=v_closeness_p)
debug('v_closeness_p.a : {}', v_closeness_p.a)
v_closeness_p.a = nan_to_num(v_closeness_p.a)
debug('v_closeness_p.a : {}', v_closeness_p.a)
# fillter
g.vp['picked'] = v_picked_p = g.new_vertex_property('bool')
debug('v_count_p.a.mean() : {}', v_count_p.a.mean())
v_picked_p.a = v_count_p.a > v_count_p.a.mean()
debug('v_picked_p.a : {}', v_picked_p.a)
g.set_vertex_filter(v_picked_p)
g.set_vertex_filter(None)
return g
def _closeness(graph, nodes, weights):
if weights is True and graph.is_weighted():
weights = graph.edge_properties[weight]
else:
weights = None
c = closeness(graph, weight=weights)
if nodes is None:
return c.a
return c.a[nodes]
def calculate_measures(g, tmp_measures=None, measure_list=['BC', 'T', 'E']):
if tmp_measures is None:
tmp_measures = dict((k, []) for k in measure_list)
tmp_measures['BC'].append(np.mean(gtc.betweenness(g)[0].get_array()))
tmp_measures['T'].append(gtclust.global_clustering(g)[0])
tmp_measures['E'].append(np.mean(gtc.closeness(g,harmonic=True).get_array()))
return tmp_measures
def calculate_measures(g, tmp_measures=None, measure_list=['BC', 'T', 'E']):
if tmp_measures is None:
tmp_measures = dict((k, []) for k in measure_list)
tmp_measures['BC'].append(np.mean(gtc.betweenness(g)[0].get_array()))
tmp_measures['T'].append(gtclust.global_clustering(g)[0])
tmp_measures['E'].append(
np.mean(gtc.closeness(g, harmonic=True).get_array()))
return tmp_measures
def find_roles(self):
"""Compute mediators, outsermosts and leaders"""
g = self.network.graph
# outsiders = self.find_outsiders()
closeness_pm = centrality.closeness(g)
closeness = [closeness_pm[v] for v in g.vertices()]
m, sd = mean(closeness), std(closeness)
leaders = self.find_leaders(closeness_pm, m + 1 * sd)
outermosts = self.find_outermosts(closeness_pm, m - 1 * sd)
self.closeness = closeness
return leaders, outermosts
def set_properties(self, subgraph): v_betweenness, e_betweenness = betweenness(subgraph) subgraph.vertex_properties["vertex_betweenness"] = v_betweenness subgraph.edge_properties["edge_betweenness"] = e_betweenness v_closeness = closeness(subgraph) subgraph.vertex_properties["closeness"] = v_closeness l_clustering = local_clustering(subgraph) subgraph.vertex_properties["local_clustering"] = l_clustering bicomp, articulation, nc = label_biconnected_components(subgraph) subgraph.vertex_properties["articulation"] = articulation return subgraph
def closeness_influent_nodes(graph):
vertex_prop = gc.closeness(graph)
gd.graph_draw(graph,
vertex_fill_color=vertex_prop,
vertex_size=gd.prop_to_size(vertex_prop, mi=5, ma=15),
vcmap=matplotlib.cm.gist_heat,
vorder=vertex_prop,
output_size=(1920, 1080),
output=FIGURES_PATH + CLOSENESS_VIZ)
print("Visualization finished and saved...")
def plot_centralities(network, title="Centrality measures"):
g = network.graph
comm_size = g.num_vertices()
closeness = centrality.closeness(g).get_array().tolist()
max_eigenval, eigenvec = centrality.eigenvector(g)
# eigenvector = [x/max_eigenval for x in eigenvec.get_array().tolist()] #normalize!
eigenvector = eigenvec.get_array().tolist()
betw, _edges = centrality.betweenness(g, norm=True)
betweenness = betw.get_array().tolist()
P.suptitle(title)
# P.figure()
print "nans", len([x for x in closeness if isnan(x)])
closeness = [0 if isnan(x) else x for x in closeness]
# closeness = [x for x in closeness if not isnan(x)]
closeness = _filtered(closeness, comm_size)
print "closeness", closeness
print "non zeros", len([x for x in closeness if x != 0])
P.subplot(2, 2, 1)
plot_hist(closeness)
P.xlabel("Closeness centrality")
P.ylabel("Number of nodes (total={})".format(len(closeness)))
counts, degrees = stats.vertex_hist(g, "in", float_count=False)
print "counts : ", len(counts), counts
print "degrees: ", len(degrees), degrees
counts = list(counts)
counts.append(0)
P.subplot(2, 2, 2)
P.bar(degrees, counts, align='center', color="#348ABD")
# P.hist(counts, bins=degrees, )
P.xlabel("Degree centrality (in)")
P.ylabel("Number of nodes (total={})".format(sum(counts)))
P.xlim(0, max(degrees))
betweenness = _filtered(betweenness, comm_size)
print "betweenness", betweenness
P.subplot(2, 2, 3)
plot_hist(betweenness)
P.xlabel("Betweenness centrality")
P.ylabel("Number of nodes (total={})".format(len(betweenness)))
eigenvector = _filtered(eigenvector, comm_size)
print "eigenvector", eigenvector
P.subplot(2, 2, 4)
plot_hist(eigenvector)
P.xlabel("Eigenvector centrality")
P.ylabel("Number of nodes (total={})".format(len(eigenvector)))
P.show()
def get_dataframe_all_topolog_metrics(self):
graph = self.get_graph()
eprop_trust = graph.new_edge_property('double')
start_time = time.time()
for e in graph.edges():
v_name_s = graph.vertex_properties['name_proteins'][e.source()]
v_number_s = self.dict_genes[v_name_s]
v_name_t = graph.vertex_properties['name_proteins'][e.target()]
v_number_t = self.dict_genes[v_name_t]
eprop_trust[e] = self.adjacency_matrix[v_number_s, v_number_t]
graph.edge_properties['trust'] = eprop_trust
print('confidence score за :',
'--- %s seconds ---' % (time.time() - start_time))
list_metrics = [
'betweenness', 'pagerank', 'closeness', 'katz', 'hits_authority',
'hits_hub', 'eigenvector', 'eigentrust'
] # 'trust_transitivity'
dict_map = {}
start_time = time.time()
dict_map['betweenness'] = ct.betweenness(graph)[0]
dict_map['pagerank'] = ct.pagerank(graph)
dict_map['closeness'] = ct.closeness(graph)
dict_map['katz'] = ct.katz(graph)
dict_map['hits_authority'] = ct.hits(graph)[1]
dict_map['hits_hub'] = ct.hits(graph)[2]
dict_map['eigenvector'] = ct.eigenvector(graph)[1]
#print('trust_transitivity')
#"dict_map['trust_transitivity'] = ct.trust_transitivity(graph, graph.edge_properties["trust"])
print('все метрики кроме eigentrust за :',
'--- %s seconds ---' % (time.time() - start_time))
start_time = time.time()
dict_map['eigentrust'] = ct.eigentrust(graph,
graph.edge_properties['trust'],
max_iter=10**6)
print('eigentrust за :',
'--- %s seconds ---' % (time.time() - start_time))
start_time = time.time()
dict_metrics = {}
for key in list_metrics:
dict_metrics[key] = []
for v in graph.vertices():
for metric in list_metrics:
dict_metrics[metric].append(dict_map[metric][v])
dataframe_all_topolog_metrics = pd.DataFrame(dict_metrics)
dataframe_all_topolog_metrics.index = graph.vertex_properties[
'name_proteins']
print('получила датафрейм с метриками за :',
'--- %s seconds ---' % (time.time() - start_time))
return dataframe_all_topolog_metrics
def execute(now):
session = store.get_session()
topology = NetworkTopology(session, now)
(node_betweenness, link_betweenness) = gt.betweenness(topology.topology)
closeness = gt.closeness(topology.topology)
for v in topology.nodes:
topology.node_information[v].degree = topology.nodes[v].out_degree()
topology.node_information[v].closeness = closeness[topology.nodes[v]]
topology.node_information[v].betweenness = node_betweenness[topology.nodes[v]]
for l in topology.links:
topology.link_information[l].betweenness = link_betweenness[topology.links[l]]
session.commit()
fileTime = open(
output_directory + "/close_" + str(maxRadius) + "_" + str(thresholdIncrement) + "_" + str(x) + "_" +
file.split('/')[-1] + '.txt', 'a')
fileTime.write('radius, threshold, execution time\n')
for r in range(1, maxRadius + 1):
for t in range(startingThreshold, finalThreshold + 1, thresholdIncrement):
print("Generating graph: radius = " + str(r) + " threshold = " + str(t))
startTime = time.time()
graph = generateGraph(Graph(emptyGraph), imgArray, width, height, r, t)
# ,weight=graph.ep.weight
closeness_vp = centrality.closeness(graph, weight=graph.ep.weight, harmonic=False)
text = (str(r) + ',' + str(t) + ',' + str(time.time() - startTime) + '\n')
fileTime.write(text)
fileTime.flush()
betDict[str(r) + " " + str(t)] = numpy.nan_to_num(closeness_vp.get_array())
fileTime.close()
imgDict = dict()
for r in range(1, maxRadius + 1):
for t in range(startingThreshold, finalThreshold + 1, thresholdIncrement):
print("Generating images for plotting: radius = " + str(r) + " threshold = " + str(t))
def computeMetric(img, metric, max_radius, starting_threshold, final_threshold,
threshold_increment, iteration_count, input_directory,
output_directory, image_name):
width, height = img.size
img_array = numpy.array(img)
empty_graph = generateEmptyGraph(width, height)
bet_dict = dict()
# set Outputs formats
file_time = open(
output_directory + "/time_" + str(max_radius) + "_" +
str(threshold_increment) + "_" + str(iteration_count) + "_" +
input_directory.split('/')[-1] + '.txt', 'a')
file_time.write('radius, threshold, execution time\n')
file_degrees = open(
output_directory + "/degrees_" + str(max_radius) + "_" +
str(threshold_increment) + "_" + str(iteration_count) + "_" +
input_directory.split('/')[-1] + '.txt', 'a')
file_metric = open(
output_directory + "/" + metric + "_" + str(max_radius) + "_" +
str(threshold_increment) + "_" + str(iteration_count) + "_" +
input_directory.split('/')[-1] + '.txt', 'a')
# Iterates in radius value
for r in range(1, max_radius + 1):
# Iterates in Threshold values
for t in range(starting_threshold, final_threshold + 1,
threshold_increment):
print("Generating graph: radius = " + str(r) + " threshold = " +
str(t))
startTime = time.time()
graph = generateGraph(Graph(empty_graph), img_array, width, height,
r, t)
vertices = graph.get_vertices().tolist()
in_degrees = []
closeness = []
if (metric == 'closeness'):
closeness_vp = centrality.closeness(graph,
weight=graph.ep.weight)
in_degrees = graph.get_in_degrees(vertices)
closeness = numpy.nan_to_num(closeness_vp.get_array())
final_time = (str(r) + ',' + str(t) + ',' +
str(time.time() - startTime) + '\n')
file_time.write(final_time)
in_degrees.tofile(file_degrees, sep=",", format="%s")
file_degrees.write('\n')
closeness.tofile(file_metric, sep=",", format="%s")
file_metric.write('\n')
bet_dict[str(r) + " " + str(t)] = numpy.nan_to_num(
closeness_vp.get_array())
file_degrees.close()
file_metric.close()
file_time.close()
img_dict = dict()
for r in range(1, max_radius + 1):
for t in range(starting_threshold, final_threshold + 1,
threshold_increment):
print("Generating images for plotting: radius = " + str(r) +
" threshold = " + str(t))
key = str(r) + " " + str(t)
bet = bet_dict.get(key)
img_map = numpy.empty([width, height])
for i in range(0, width):
for j in range(0, height):
img_map[i][j] = bet[((i * width) + j)]
key = str(r) + " " + str(t)
img_dict[key] = img_map
figure, axesArray = plt.subplots(max_radius,
iteration_count + 1,
figsize=(5 * max_radius,
5 * iteration_count + 1),
squeeze=False)
plotX = 0
for r in range(1, max_radius + 1):
plotY = 0
for t in range(starting_threshold, final_threshold + 1,
threshold_increment):
print("Generating subplots: radius = " + str(r) + " threshold = " +
str(t))
key = str(r) + " " + str(t)
value = img_dict.get(key)
img = axesArray[plotX][plotY].imshow(value,
cmap='hot',
clim=(value.min(),
value.max()))
figure.colorbar(img, ax=axesArray[plotX][plotY])
axesArray[plotX][plotY].set_axis_off()
axesArray[plotX][plotY].set_title(key)
# axesArray[plotX,plotY+1] = figure.colorbar(axesArray[plotX,plotY])
plotY += 1
plotX += 1
# fig, ax = plt.subplots()
# cax = plt.imshow(imgMap, cmap='hot', clim=(0, 1))
# cbar = fig.colorbar(cax)
plt.savefig(output_directory + "/close_9090_" + str(max_radius) + "_" +
str(threshold_increment) + "_" + str(iteration_count) + "_" +
(input_directory + image_name).split('/')[-1])
# pos = nx.get_node_attributes(graph, 'pos')
""""
nx.draw(graph,pos,with_labels=True)
labels = nx.get_edge_attributes(graph, 'weight')
nx.draw_networkx_edge_labels(graph, pos, edge_labels=labels)
plt.savefig("Outputs/test_graph.jpg")
"""
return closeness
def save_centrality(g, node_out_fname, edge_out_fname, weight=None):
"""
:param g: `Graph` instance
:return: None
"""
df = pd.DataFrame()
df['node'] = pd.Series(np.array([int(v) for v in g.vertices()]))
# degree
print('Degree')
num_nodes = len(g.get_vertices())
denom = num_nodes - 1
if g.is_directed():
unnormalized_in_degree = np.array([v.in_degree() for v in g.vertices()])
unnormalized_out_degree = np.array([v.out_degree() for v in g.vertices()])
df['unnormalized_in_degree'] = unnormalized_in_degree
df['unnormalized_out_degree'] = unnormalized_out_degree
df['in_degree'] = unnormalized_in_degree / denom
df['out_degree'] = unnormalized_out_degree / denom
else:
# check whether weighted graph or not
if weight:
unnormalized_degree = np.zeros(num_nodes)
edge_weights = np.array(weight.get_array())
for edge, w in zip(g.get_edges(), edge_weights):
for node in edge[:2]:
unnormalized_degree[node] += w
df['unnormalized_degree'] = unnormalized_degree
df['degree'] = unnormalized_degree / denom
else:
unnormalized_degree = np.array([v.out_degree() for v in g.vertices()])
df['unnormalized_degree'] = unnormalized_degree
df['degree'] = unnormalized_degree / denom
# closeness
print('Closeness')
df['unnormalized_closeness'] = np.array(closeness(g, weight=weight, norm=False).get_array())
df['closeness'] = np.array(closeness(g, weight=weight, norm=True).get_array())
# pageRank
print('PageRank')
df['pagerank'] = np.array(pagerank(g, weight=weight).get_array())
# betweenness
print('Betweenness')
un_node_between, un_edge_between = betweenness(g, weight=weight, norm=False)
node_between, edge_between = betweenness(g, weight=weight, norm=True)
df['unnormalized_betweenness'] = np.array(un_node_between.get_array())
df['betweenness'] = np.array(node_between.get_array())
df.to_csv(node_out_fname, index=False)
# edge
sources = []
targets = []
for e in g.edges():
source, target = list(map(int, [e.source(), e.target()]))
sources.append(source)
targets.append(target)
df = pd.DataFrame()
df['source'] = pd.Series(np.array(sources))
df['target'] = np.array(targets)
# betweenness
df['unnormalized_betweenness'] = np.array(un_edge_between.get_array())
df['betweenness'] = np.array(edge_between.get_array())
df.to_csv(edge_out_fname, index=False)
def closeness_centrality(g: Graph):
return centrality.closeness(g, weight=g.edge_properties['weight'])
def calculate_cen_b(pre_u, type, pos_type):
# if type == "DeC":
if type == "BetC":
v_be = pre_u.new_vertex_property("float")
v_betweenness = gtc.betweenness(pre_u, vprop=v_be)
pre_u.vertex_properties['betweenness'] = v_be
if type == "CloC":
v_clo = pre_u.new_vertex_property("float")
v_closeness = gtc.closeness(pre_u, vprop=v_clo)
pre_u.vertex_properties['closeness'] = v_clo
# if type == "EigenveC":
# if type == "KatzC":
# if type == "EigentrustC":
if pos_type == "FD":
pos = gt.sfdp_layout(pre_u, p=2.6, K=40, C=1)
if pos_type == "FR":
pos = gt.fruchterman_reingold_layout(pre_u, n_iter=100, r=100, a=10)
nodes = []
convert = []
for v in pre_u.vertices():
s_node = {}
s_node["name"] = v_userid[v]["userid"]
s_node['race'] = v_race[v]["race"]
s_node['cohort'] = v_cohort[v]['cohort']
s_node['gender'] = v_gender[v]['gender']
s_node['c1net'] = v_c1net[v]['c1net']
s_node['c2net'] = v_c2net[v]['c2net']
s_node['c3net'] = v_c3net[v]['c3net']
s_node['c4net'] = v_c4net[v]['c4net']
s_node['c5net'] = v_c5net[v]['c5net']
s_node['c6net'] = v_c6net[v]['c6net']
s_node['c7net'] = v_c7net[v]['c7net']
s_node["out-degree"] = v.out_degree()
s_node["in-degree"] = v.in_degree()
s_node["cx"] = (pos[v][0])
s_node["cy"] = (pos[v][1])
if 'v_be' in locals().keys():
s_node["BetC"] = v_be[v]
if 'v_clo' in locals().keys():
if math.isnan(v_clo[v]):
v_clo[v] = 0
s_node["CloC"] = v_clo[v]
convert.append(v_userid[v]["userid"])
# o_node={}
# o_node[v_userid[v]["userid"]]=s_node
nodes.append(s_node)
all_data = {}
all_data['nodes'] = nodes
links = []
for e in pre_u.edges():
s_edge = {}
s_edge['source'] = convert.index(str(e_source[e]))
s_edge['target'] = convert.index(str(e_target[e]))
s_edge['type'] = e_type[e]['type']
s_edge['year'] = e_year[e]['year']
s_edge['weight'] = len(pre_u.edge(e.target(), e.source(), all_edges=True, add_missing=False)) + \
len(pre_u.edge(e.source(), e.target(),
all_edges=True, add_missing=False))
links.append(s_edge)
all_data['links'] = links
return (all_data)
def calculate_cen(pre_u, type, pos_type):
# if type == "DeC":
if type == "BetC":
v_be = pre_u.new_vertex_property("float")
v_betweenness = gtc.betweenness(pre_u, vprop=v_be)
pre_u.vertex_properties['betweenness'] = v_be
if type == "CloC":
v_clo = pre_u.new_vertex_property("float")
v_closeness = gtc.closeness(pre_u, vprop=v_clo)
pre_u.vertex_properties['closeness'] = v_clo
# if type == "EigenveC":
# if type == "KatzC":
# if type == "EigentrustC":
if pos_type == "FD":
pos = gt.sfdp_layout(pre_u, p=2.6, K=40, C=1)
if pos_type == "FR":
pos = gt.fruchterman_reingold_layout(pre_u, n_iter=100, r=100, a=10)
nodes = []
convert = []
for v in pre_u.vertices():
s_node = {}
s_node["name"] = v_userid[v]["userid"]
s_node['gender'] = v_gender[v]["gender"]
s_node['schregion'] = v_schregion[v]['schregion']
s_node['school'] = v_school[v]['school']
s_node['major'] = v_major[v]['major']
s_node['marriage'] = v_marriage[v]['marriage']
s_node['grade'] = v_grade[v]['grade']
s_node['liveplace'] = v_liveplace[v]['liveplace']
s_node['height'] = v_height[v]['height']
s_node['weight'] = v_weight[v]['weight']
s_node['scorelevel'] = v_scorelevel[v]['scorelevel']
s_node['birthyear'] = v_birthyear[v]['birthyear']
s_node["out-degree"] = v.out_degree()
s_node["in-degree"] = v.in_degree()
s_node["cx"] = pos[v][0]
s_node["cy"] = pos[v][1]
if 'v_be' in locals().keys():
s_node["BetC"] = v_be[v]
if 'v_clo' in locals().keys():
if math.isnan(v_clo[v]):
v_clo[v] = 0
s_node["CloC"] = v_clo[v]
# print(v_clo[v])
convert.append(v_userid[v]["userid"])
# o_node={}
# o_node[v_userid[v]["userid"]]=s_node
nodes.append(s_node)
all_data = {}
all_data['nodes'] = nodes
links = []
for e in pre_u.edges():
s_edge = {}
s_edge['source'] = convert.index(str(e_source[e]))
s_edge['target'] = convert.index(str(e_target[e]))
s_edge['date'] = e_date[e]['date']
s_edge['dailycount'] = e_dailycount[e]['dailycount']
s_edge['weight'] = len(pre_u.edge(e.target(), e.source(), all_edges=True, add_missing=False)) + \
len(pre_u.edge(e.source(), e.target(),
all_edges=True, add_missing=False))
links.append(s_edge)
all_data['links'] = links
return(all_data)
