Python networkx.average_clustering方法代碼示例

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def avg_transitivity(graph, communities, **kwargs):
    """Average transitivity.

    The average transitivity of a community is defined the as the average clustering coefficient of its nodes w.r.t. their connection within the community itself.

    :param graph: a networkx/igraph object
    :param communities: NodeClustering object
    :param summary: boolean. If **True** it is returned an aggregated score for the partition is returned, otherwise individual-community ones. Default **True**.
    :return: If **summary==True** a FitnessResult object, otherwise a list of floats.

    Example:

    >>> from cdlib.algorithms import louvain
    >>> from cdlib import evaluation
    >>> g = nx.karate_club_graph()
    >>> communities = louvain(g)
    >>> scd = evaluation.avg_transitivity(g,communities)
    """

    return __quality_indexes(graph, communities,
                             lambda graph, coms: nx.average_clustering(nx.subgraph(graph, coms)),
                             **kwargs) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def plot_clustering_coefficient(_g, _plot_img, interval=30):
    """Plot the clustering coefficient transition
    :param _g: Transaction graph
    :param _plot_img: Output image file
    :param interval: Simulation step interval for plotting
    (it takes too much time to compute clustering coefficient)
    :return:
    """
    date_list = get_date_list(_g)

    gg = nx.Graph()
    edges = defaultdict(list)
    for k, v in nx.get_edge_attributes(_g, "date").items():
        e = (k[0], k[1])
        edges[v].append(e)

    sample_dates = list()
    values = list()
    for i, t in enumerate(date_list):
        gg.add_edges_from(edges[t])
        if i % interval == 0:
            v = nx.average_clustering(gg) if gg.number_of_nodes() else 0.0
            sample_dates.append(t)
            values.append(v)
            print("Clustering coefficient at %s: %f" % (str(t), v))

    plt.figure(figsize=(16, 12))
    plt.clf()
    plt.plot(sample_dates, values, 'bo-')
    plt.title("Clustering Coefficient Transition")
    plt.xlabel("date")
    plt.ylabel("Clustering Coefficient")
    plt.savefig(_plot_img) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def get_clustering_coeff(edge_list):
    G = nx.from_edgelist(edgelist=edge_list)
    clust_coeff = nx.average_clustering(G)
    # print(nx.number_of_nodes(G), ' : ',clust_coeff)
    return clust_coeff 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_k5(self):
        G = nx.complete_graph(5)
        assert_equal(list(nx.clustering(G,weight='weight').values()),[1, 1, 1, 1, 1])
        assert_equal(nx.average_clustering(G,weight='weight'),1)
        G.remove_edge(1,2)
        assert_equal(list(nx.clustering(G,weight='weight').values()),
                     [5./6., 1.0, 1.0, 5./6., 5./6.])
        assert_equal(nx.clustering(G,[1,4],weight='weight'),{1: 1.0, 4: 0.83333333333333337}) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_average_clustering():
    G=nx.cycle_graph(3)
    G.add_edge(2,3)
    assert_equal(nx.average_clustering(G),(1+1+1/3.0)/4.0)
    assert_equal(nx.average_clustering(G,count_zeros=True),(1+1+1/3.0)/4.0)
    assert_equal(nx.average_clustering(G,count_zeros=False),(1+1+1/3.0)/3.0) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_petersen():
    # Actual coefficient is 0
    G = nx.petersen_graph()
    assert_equal(average_clustering(G, trials=int(len(G)/2)),
                 nx.average_clustering(G)) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_dodecahedral():
    # Actual coefficient is 0
    G = nx.dodecahedral_graph()
    assert_equal(average_clustering(G, trials=int(len(G)/2)),
                 nx.average_clustering(G)) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_empty():
    G = nx.empty_graph(5)
    assert_equal(average_clustering(G, trials=int(len(G)/2)), 0) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_complete():
    G = nx.complete_graph(5)
    assert_equal(average_clustering(G, trials=int(len(G)/2)), 1)
    G = nx.complete_graph(7)
    assert_equal(average_clustering(G, trials=int(len(G)/2)), 1) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_random_reference():
    G = nx.connected_watts_strogatz_graph(50, 6, 0.1, seed=rng)
    Gr = random_reference(G, niter=1, seed=rng)
    C = nx.average_clustering(G)
    Cr = nx.average_clustering(Gr)
    assert_true(C > Cr)

    assert_raises(nx.NetworkXError, random_reference, nx.Graph())
    assert_raises(nx.NetworkXNotImplemented, random_reference, nx.DiGraph())

    H = nx.Graph(((0, 1), (2, 3)))
    Hl = random_reference(H, niter=1, seed=rng) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_k5(self):
        G = nx.complete_graph(5, create_using=nx.DiGraph())
        assert_equal(list(nx.clustering(G).values()), [1, 1, 1, 1, 1])
        assert_equal(nx.average_clustering(G), 1)
        G.remove_edge(1, 2)
        assert_equal(list(nx.clustering(G).values()),
                     [11. / 12., 1.0, 1.0, 11. / 12., 11. / 12.])
        assert_equal(nx.clustering(G, [1, 4]), {1: 1.0, 4: 11. /12.})
        G.remove_edge(2, 1)
        assert_equal(list(nx.clustering(G).values()),
                     [5. / 6., 1.0, 1.0, 5. / 6., 5. / 6.])
        assert_equal(nx.clustering(G, [1, 4]), {1: 1.0, 4: 0.83333333333333337}) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_average_clustering():
    G = nx.cycle_graph(3)
    G.add_edge(2, 3)
    assert_equal(nx.average_clustering(G), (1 + 1 + 1 / 3.0) / 4.0)
    assert_equal(nx.average_clustering(G, count_zeros=True), (1 + 1 + 1 / 3.0) / 4.0)
    assert_equal(nx.average_clustering(G, count_zeros=False), (1 + 1 + 1 / 3.0) / 3.0) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_petersen():
    # Actual coefficient is 0
    G = nx.petersen_graph()
    assert_equal(average_clustering(G, trials=int(len(G) / 2)),
                 nx.average_clustering(G)) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_petersen_seed():
    # Actual coefficient is 0
    G = nx.petersen_graph()
    assert_equal(average_clustering(G, trials=int(len(G) / 2), seed=1),
                 nx.average_clustering(G)) 

# 需要導入模塊: import networkx [as 別名]
# 或者: from networkx import average_clustering [as 別名]
def test_tetrahedral():
    # Actual coefficient is 1
    G = nx.tetrahedral_graph()
    assert_equal(average_clustering(G, trials=int(len(G) / 2)),
                 nx.average_clustering(G))