Python networkx.degree_centrality() Examples

def _calc_graph_func(p):
    con, times_chunk, graph_func = p
    vals = []
    now = time.time()
    for run, t in enumerate(times_chunk):
        utils.time_to_go(now, run, len(times_chunk), 10)
        con_t = con[:, :, t]
        g = nx.from_numpy_matrix(con_t)
        if graph_func == 'closeness_centrality':
            x = nx.closeness_centrality(g)
        elif graph_func == 'degree_centrality':
            x = nx.degree_centrality(g)
        elif graph_func == 'eigenvector_centrality':
            x = nx.eigenvector_centrality(g, max_iter=10000)
        elif graph_func == 'katz_centrality':
            x = nx.katz_centrality(g, max_iter=100000)
        else:
            raise Exception('Wrong graph func!')
        vals.append([x[k] for k in range(len(x))])
    vals = np.array(vals)
    return vals, times_chunk 

def test_degree_centrality_1(self):
        d = nx.degree_centrality(self.K5)
        exact = dict(zip(range(5), [1]*5))
        for n,dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_2(self):
        d = nx.degree_centrality(self.P3)
        exact = {0:0.5, 1:1, 2:0.5}
        for n,dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_3(self):
        d = nx.degree_centrality(self.K)
        exact = {0:.444, 1:.444, 2:.333, 3:.667, 4:.333,
                 5:.556, 6:.556, 7:.333, 8:.222, 9:.111}
        for n,dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc)) 

def test_degree_centrality_4(self):
        d = nx.degree_centrality(self.F)
        names = sorted(self.F.nodes())
        dcs = [0.071, 0.214, 0.143, 0.214, 0.214, 0.071, 0.286, 
               0.071, 0.429, 0.071, 0.214, 0.214, 0.143, 0.286, 0.214]
        exact = dict(zip(names, dcs))
        for n,dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc)) 

def calc_closeness_centrality(p):
    con, times_chunk = p
    vals = []
    now = time.time()
    for run, t in enumerate(times_chunk):
        utils.time_to_go(now, run, len(times_chunk), 10)
        con_t = con[:, :, t]
        g = nx.from_numpy_matrix(con_t)
        # x = nx.closeness_centrality(g)
        x = nx.degree_centrality(g)
        vals.append([x[k] for k in range(len(x))])
    vals = np.array(vals)
    return vals, times_chunk 

def degree_centrality_dist(graph, plot=False):
    """
    Calculate and plot distribution for degree centrality for all nodes in protein network

    Parameters
    ----------
    graph: networkx object
        Residue interaction graph object
    plot: bool
        Default = False. Display distribution
    Returns
    -------
    dc: dictionary
        Mapping between node to degree centrality values
    """

    dc = nx.degree_centrality(graph)
    centrality_values = []
    for key, value in reversed(sorted(dc.items(), key=lambda item: (item[1], item[0]))):
        print("%s: %s" % (key, value))
        centrality_values += [value]
    if plot:
        sns.distplot(centrality_values)
        plt.xlabel("Degree Centrality")
        plt.ylabel("Frequency")
        plt.title("Degree Centrality Distribution")
        plt.show()
    return dc 

def test_degree_centrality_1(self):
        d = nx.degree_centrality(self.K5)
        exact = dict(zip(range(5), [1] * 5))
        for n, dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_2(self):
        d = nx.degree_centrality(self.P3)
        exact = {0: 0.5, 1: 1, 2: 0.5}
        for n, dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_3(self):
        d = nx.degree_centrality(self.K)
        exact = {0: .444, 1: .444, 2: .333, 3: .667, 4: .333,
                 5: .556, 6: .556, 7: .333, 8: .222, 9: .111}
        for n, dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc)) 

def test_degree_centrality_4(self):
        d = nx.degree_centrality(self.F)
        names = sorted(self.F.nodes())
        dcs = [0.071, 0.214, 0.143, 0.214, 0.214, 0.071, 0.286,
               0.071, 0.429, 0.071, 0.214, 0.214, 0.143, 0.286, 0.214]
        exact = dict(zip(names, dcs))
        for n, dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc)) 

def test_small_graph_centrality(self):
        G = nx.empty_graph(create_using=nx.DiGraph)
        assert_equal({}, nx.degree_centrality(G))
        assert_equal({}, nx.out_degree_centrality(G))
        assert_equal({}, nx.in_degree_centrality(G))

        G = nx.empty_graph(1, create_using=nx.DiGraph)
        assert_equal({0: 1}, nx.degree_centrality(G))
        assert_equal({0: 1}, nx.out_degree_centrality(G))
        assert_equal({0: 1}, nx.in_degree_centrality(G)) 

def test_degree_centrality_1(self):
        d = nx.degree_centrality(self.K5)
        exact = dict(zip(range(5), [1]*5))
        for n,dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_2(self):
        d = nx.degree_centrality(self.P3)
        exact = {0:0.5, 1:1, 2:0.5}
        for n,dc in d.items():
            assert_almost_equal(exact[n], dc) 

def test_degree_centrality_3(self):
        d = nx.degree_centrality(self.K)
        exact = {0:.444, 1:.444, 2:.333, 3:.667, 4:.333,
                 5:.556, 6:.556, 7:.333, 8:.222, 9:.111}
        for n,dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc)) 

def test_degree_centrality_4(self):
        d = nx.degree_centrality(self.F)
        names = sorted(self.F.nodes())
        dcs = [0.071, 0.214, 0.143, 0.214, 0.214, 0.071, 0.286, 
               0.071, 0.429, 0.071, 0.214, 0.214, 0.143, 0.286, 0.214]
        exact = dict(zip(names, dcs))
        for n,dc in d.items():
            assert_almost_equal(exact[n], float("%5.3f" % dc))