コード例 #1
0
ファイル: msst_heuristic.py プロジェクト: daureg/magnet
def full_cost(tree_adj, tree, gt_graph, X):
    import graph_tool.centrality as gt
    from bidict import bidict
    vbetween, ebetween = gt.betweenness(gt_graph)
    info, prt = augmented_ancestor(tree_adj, X)
    root = None
    for u, parent in prt.items():
        if parent is None:
            root = u
            break
    assert root is not None
    Xbar = set(tree_adj.keys()) - X
    edge_to_vertex = bidict({})
    raw_edge_features = {}
    for edge in tree:
        tail = edge_tail(edge, prt)[0]
        edge_to_vertex[edge] = tail
        raw_edge_features[edge] = [ebetween[gt_graph.edge(*edge)],
                                   vbetween[gt_graph.vertex(tail)],
                                   info[tail][1]/len(tree_adj),
                                   info[tail][2]/len(X), [], []]
    distances = []
    for i in X:
        for j in Xbar:
            path = actual_tree_path(i, j, prt)
            path_len = len(path)
            distances.append(path_len)
            if j != root:
                raw_edge_features[edge_to_vertex[:j]][4].append(path_len)
            for edge in path:
                raw_edge_features[edge][5].append(path_len)
    return raw_edge_features, sum(distances)/len(distances)
コード例 #2
0
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
コード例 #3
0
def calculate_betweenness(map_object, original_data_source, filtered_name_string):
    betweenness_property_map=betweenness(map_object.graph_object)[0]
    betweennes_list=[]
    for station_name_string in original_data_source.data["station_names"]:
        if station_name_string==filtered_name_string:
            betweennes_list.append(-1)
        else:
            vertex=map_object.station_name_index[station_name_string]
            betweennes_list.append(betweenness_property_map[vertex])
    return betweennes_list
コード例 #4
0
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
コード例 #5
0
 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
コード例 #6
0
ファイル: Plotter.py プロジェクト: kwerenda/role-mining
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()
コード例 #7
0
    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
コード例 #8
0
def betweenness_influent_nodes(graph):
    vertex_prop, edge_prop = gc.betweenness(graph,
                                            weight=graph.edge_properties["weight"])
    gd.graph_draw(graph,
                  vertex_fill_color=vertex_prop,
                  vertex_size=gd.prop_to_size(vertex_prop, mi=5, ma=15),
                  edge_pen_width=gd.prop_to_size(edge_prop, mi=0.5, ma=5),
                  vcmap=matplotlib.cm.gist_heat,
                  vorder=vertex_prop,
                  output_size=(1920, 1080),
                  output=FIGURES_PATH + BETWEENNESS_VIZ)

    print("Visualization finished and saved...")
コード例 #9
0
def graph_betweenness_centrality(graph):
    nodes, edges = betweenness(graph)

    nodes_dataframe = pandas.DataFrame(nodes.get_array())
    edges_dataframe = pandas.DataFrame(edges.get_array())

    nodes_dataframe.columns = [betweenness_centrality_key]
    edges_dataframe.columns = [betweenness_centrality_key]

    nodes_dataframe = sort_for_betweenness_centrality(nodes_dataframe)
    edges_dataframe = sort_for_betweenness_centrality(edges_dataframe)

    return nodes_dataframe, edges_dataframe
コード例 #10
0
def betweenness_correlated_weights(graph,dicProperties,nEdges,nExc):
	lstWeights = np.zeros(nEdges)
	rMin = dicProperties["Min"]
	rMax = dicProperties["Max"]
	vpropBetw,epropBetw = betweenness(graph)
	arrBetw = epropBetw.a.copy()
	arrLogBetw = np.log10(arrBetw)
	rMaxLogBetw = arrLogBetw.max()
	rMinLogBetw = arrLogBetw.min()
	arrLogBetw = -5 + 2 * (arrLogBetw - rMinLogBetw ) / (rMaxLogBetw - rMinLogBetw)
	arrBetw = np.exp(np.log(10) * arrLogBetw)
	rMaxBetw = arrBetw.max()
	rMinBetw = arrBetw.min()
	lstWeights = np.multiply(arrBetw-rMinBetw,rMax/rMaxBetw) + rMin
	return lstWeights
コード例 #11
0
    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()
コード例 #12
0
ファイル: densify.py プロジェクト: daureg/magnet
def build_pivot_generator(N, graph, shared_edges, pivot_strategy, pivot_gen):
    """Return a vertex generator according to the chosen strategy"""
    if shared_edges:
        non_shared = non_shared_vertices(N, shared_edges)
        return iter(lambda: r.choice(non_shared), -1)
    if pivot_strategy is PivotStrategy.weighted:
        assert pivot_gen, "provide your own generator"
        return pivot_gen
    if pivot_strategy in [PivotStrategy.uniform, PivotStrategy.no_pivot]:
        return None
    if pivot_strategy is PivotStrategy.by_degree:
        degs = graph.degree_property_map('total').a
        weights = np.exp(-degs)/np.sum(np.exp(-degs))
        return WeightedRandomGenerator(weights)
    if pivot_strategy is PivotStrategy.by_betweenness:
        vb, _ = centrality.betweenness(graph)
        vb = N*vb.a/5
        weights = np.exp(-vb)/np.sum(np.exp(-vb))
        return WeightedRandomGenerator(weights)
    raise ValueError('check build_pivot_generator call')
コード例 #13
0
def analyze(dir_name):
    g = gload.load_graph(dir_name)
    with open(os.path.join(dir_name, GRAPH_FILE), 'wb') as f:
        pickle.dump(g, f)

    sim = galg.simrank(g)
    with open(os.path.join(dir_name, SIMRANK_FILE), 'wb') as f:
        pickle.dump(sim, f)

    prank = galg.psimrank(g)
    with open(os.path.join(dir_name, PRANK_FILE), 'wb') as f:
        pickle.dump(prank, f)

    gr = grdf.calculate_taxonomy2(g)
    with open(os.path.join(dir_name, GR_FILE), 'wb') as f:
        pickle.dump(gr, f)

    vp, ep = centrality.betweenness(analsis_dict['graph'])

    with open(os.path.join(dir_name, BET_FILE), 'wb') as f:
        pickle.dump(vp, f)
コード例 #14
0
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)
コード例 #15
0
def _get_edge_centrality(graph):
    _, centrality = betweenness(graph, norm=False)
    return centrality
コード例 #16
0
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)
コード例 #17
0
#!/usr/bin/env python3
# This file is part of Project Ruprecht. See COPYING for license.

import sys
import graph_tool as gt
import graph_tool.centrality as centr


def print_top_e(g, eprops):
    names = g.vertex_properties['name']

    ee = list(g.edges())
    ee.sort(key=lambda a: eprops[a], reverse=True)

    for e in ee:
        print(names[e.source()], names[e.target()])


g = gt.load_graph_from_csv(sys.argv[1], csv_options={'delimiter': "\t"})

btwv, btwe = centr.betweenness(g)
print_top_e(g, btwe)
コード例 #18
0
def betweenness_centrality(g: Graph):
    return centrality.betweenness(g, weight=g.edge_properties['weight'])[0]
コード例 #19
0
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)
コード例 #20
0
ファイル: contribution.py プロジェクト: samaritan/services
def _get_vertex_centrality(graph):
    centrality, _ = betweenness(graph, weight=graph.ep.weight, norm=False)
    return centrality