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)