networkX-03-连通度、全局网络效率、局部网络效率、聚类系数计算

教程仓库地址：github networkx_tutorial
本文从指标公式出发，计算网络的连通度、全局效率、局部效率、聚类系数，有需要的同学可在仓库下载ipynb文件进行练习.

1.连通度

• 文字部分来自GPT-4
  
  

import networkx as nx
import matplotlib. pyplot as plt
# 创建一个无向图
G = nx.Graph()
# 添加边
G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0), (0, 2)])
# # 绘制图形
nx.draw(G,node_size=500,with_labels=True)
1
2
3
4
5
6
7
8

​

​

1.1 检查图是否连通

# 检查图是否连通
is_connected = nx.is_connected(G)
print(f"The graph is connected: {is_connected}")
1
2
3

The graph is connected: True
1

1.2 检查有向图是否为强连通

# 创建一个有向图
DG = nx.DiGraph()
DG.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (4, 0), (0, 2)])
nx.draw(DG,node_size=500,with_labels=True)
1
2
3
4

​

​

# 检查图是否强连通
is_strongly_connected = nx.is_strongly_connected(DG)
print(f"The directed graph is strongly connected: {is_strongly_connected}")
1
2
3

The directed graph is strongly connected: True
1

1.3 点连通度、边连通度：

# 计算点连通度
node_connectivity = nx.node_connectivity(G)
print("节点连通度：", node_connectivity)
# 计算边连通度
edge_connectivity = nx.edge_connectivity(G)
print("边连通度：", edge_connectivity)
1
2
3
4
5
6

节点连通度： 2
边连通度： 2
1
2

2.网络效率

2.1全局效率

# 创建一个简单的无向图
G = nx.Graph()
G.add_nodes_from([1, 2, 3, 4])
G.add_edges_from([(1, 2), (1, 3), (2, 3), (3, 4)])

# 绘制图形
pos = nx.spring_layout(G)
nx.draw(G, pos, with_labels=True, node_color='lightblue', node_size=500, font_size=16, font_weight='bold')
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=labels, font_size=12, font_color='red')
plt.show()
1
2
3
4
5
6
7
8
9
10
11

​

​

#计算指定节点对之间的效率：节点之间最短路径的倒数
nx.efficiency(G,2,4)  # 2,4 之间的最短路径长度为2,则两节点之间的效率为1/2
1
2

0.5
1

# 全局网络效率官方函数
nx.global_efficiency(G)
1
2

0.8333333333333334
1

# 源码
def global_effi(G):
    n = len(G)
    denom =  n * (n - 1)
    if denom != 0:
        lengths = nx.all_pairs_dijkstra_path_length(G)
        g_eff = 0
        for source, targets in lengths:
            for target, distance in targets.items():
                if distance > 0:
                    g_eff += 1 / distance
        g_eff /= denom
        # g_eff = sum(1 / d for s, tgts in lengths
        #                   for t, d in tgts.items() if d > 0) / denom
    else:
        g_eff = 0
    # path lengths in parallel.
    return g_eff

global_effi(G=G)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

0.8333333333333334
1

2.2 局部效率

2.2.1 查找子图

# 定义要查找的节点子集
node_subset = [1, 2, 3]
# 查找诱导子图
induced_subgraph = G.subgraph(node_subset)
nx.draw(induced_subgraph,with_labels = True)
1
2
3
4
5

​

​

# 查找生成子图
spanning_subgraph = G.subgraph(G.nodes())
nx.draw(spanning_subgraph,with_labels = True)
1
2
3

​

​

2.2.3 局部效率源码分析

nx.local_efficiency(G) 
1

0.5833333333333334
1

# 源码
sum = 0  # 初始化 ，所有节点和其构成的子图 ，对应的全局效率的值
len(G)  # G的节点数

for v in G:  # 遍历每个节点
    print('---{}节点的子图是----'.format(v))
    # 找到每个节点的和其邻居构成的子图
    # fig,ax = plt.subplots()
    # nx.draw(G.subgraph(G[v]),with_labels = True,ax=ax)
    g_effi = nx.global_efficiency(G.subgraph(G[v]))
    print('邻居节点{}全局效率为：{}'.format(v,g_effi))
    sum = sum+ g_effi
    
print("local_efficiency",sum/len(G))  #0.9166666666666667
     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---1节点的子图是----
邻居节点1全局效率为：1.0
---2节点的子图是----
邻居节点2全局效率为：1.0
---3节点的子图是----
邻居节点3全局效率为：0.3333333333333333
---4节点的子图是----
邻居节点4全局效率为：0
local_efficiency 0.5833333333333334
1
2
3
4
5
6
7
8
9

3.聚类系数（Clustering Coefficient）

3.1 聚类系统源码分析

# 官方函数
for node in G.nodes():
    c = nx.clustering(G = G,nodes=node)
    print(f"节点 {node} 的聚类系数为 {c}")
1
2
3
4

节点 1 的聚类系数为 1.0
节点 2 的聚类系数为 1.0
节点 3 的聚类系数为 0.3333333333333333
节点 4 的聚类系数为 0
1
2
3
4

# 1. 计算节点的k ,ki：
# test_node : 3 
node = 3
# 邻居
neighbors = list(G.neighbors(node))
# 度
k = len(neighbors)
k  # 节点3对应的k为3
1
2
3
4
5
6
7
8

3
1

# 2. ei的计算
neighbors
for i in range(k):
    for j in range(i + 1, k):
        if G.has_edge(neighbors[i], neighbors[j]):
            # print(neighbors[i], neighbors[j])
            triplets += 1
triplets # 节点3对应的ei为3
1
2
3
4
5
6
7
8

2
1

节点的聚类系数

# 计算每个节点的聚类系数
for node in G.nodes():
    # 获取节点的邻居节点
    neighbors = list(G.neighbors(node))
    k = len(neighbors)
    if k < 2:
        # 如果邻居节点数少于 2，聚类系数为 0
        clustering = 0
    else:
        # 计算节点的三元组数量
        triplets = 0
        for i in range(k):
            for j in range(i + 1, k):
                if G.has_edge(neighbors[i], neighbors[j]):
                    triplets += 1
        # 计算聚类系数
        clustering = 2 * triplets / (k * (k - 1))
    print(f"节点 {node} 的聚类系数为 {clustering}")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

节点 1 的聚类系数为 1.0
节点 2 的聚类系数为 1.0
节点 3 的聚类系数为 0.3333333333333333
节点 4 的聚类系数为 0
1
2
3
4

整个网络的聚类系数C

nx.average_clustering(G=G)
1

0.5833333333333334
1