论文复现：《复杂网络中节点重要度评估的节点收缩方法》

• 背景介绍
• 论文中的基本理论
• • 节点收缩
  • 网络凝聚度
  • 节点重要度评估
  • 算法伪代码
• 论文中的算例
• 代码实现
• • 节点收缩法子程序
  • 重要度子程序
  • 测试主程序
• 计算结果
• 引用

背景介绍

我在做毕业论文实验的时候，需要用到凝聚度作为电力节点的重要度指标。在网上找到一篇博客，是用Matlab复现的，但是我运行了他写的代码之后，发现他的代码有点问题，采用论文中的算例得出来的结果跟论文中的结果不太一样，这是那篇博客的地址：matlab实现复杂网络中节点重要度评估的节点收缩方法。 于是我自己用python复现了这篇论文，采用与原文同样的算例后，结果跟论文中也是一致的。我所使用的为Python 3.6，所用的包为networkx 2.5.1。

论文中的基本理论

节点收缩

假设$v_i$是图$G=(V,E)$中的一个节点，我们用$G\ast v_i$表示将节点$v_i$收缩后所得到的图。所谓将节点$v_i$收缩是指将与节点$v_i$相连接的$k_i$个节点都与节点$v_i$融合，即用一个新节点代替这$k_i+1$个节点，原先与它们关联的边现在都与新节点关联，如图1所示。

网络凝聚度

网络的凝聚度首先取决于网络中各个节点之间的联通能力，我们用节点之间的平均路径长度$l$来衡量，即所有节点对之间最短距离的算数平均值。其次，网络的凝聚度还取决于网络中节点节点数目$n$。例如在一个社会关系网里，人员之间联系越方便（$l$越小）、人数越少（$n$越小），整个网络的凝聚程度就越高。我们将网络的凝聚度定义为节点数$n$与平均路径长度$l$乘积的倒数。
定义1 我们称$$\partial [\mathbf{G}]=\frac{1}{n\cdot l}=\frac{1}{n\cdot \frac{{\sum }_{i\ne j\in V}{d}_{ij}}{n(n-1)}}=\frac{n-1}{{\sum }_{i\ne j\in V}{d}_{ij}}\text{\hspace{1em}(1)}$$为图$G$的凝聚度，其中$n\ge 2$，$d_{ij}$代表节点$i$和$j$之间的最短距离。
当$n=1$时，我们令$\partial =1$。显然$0<\partial \le 1$，当网络中只有一个节点时，$\partial$取最大值1。

节点重要度评估

定义2 我们称$$\mathbf{I}\mathbf{M}\mathbf{C}(v_i)=1-\frac{\partial [\mathbf{G}]}{\partial [\mathbf{G}\ast v_i]}\text{\hspace{1em}(2)}$$为节点$v_i$的重要度，其中$G\ast v_i$表示将节点$v_i$收缩后所得到的图。
由定义1和定义2我们可以得到：$$\mathbf{I}\mathbf{M}\mathbf{C}(v_i)=1-\frac{\partial [\mathbf{G}]}{\partial [\mathbf{G}\ast v_i]}=1-\frac{\frac{1}{n\cdot l(\mathbf{G})}}{\frac{1}{(n-k_i)\cdot l(\mathbf{G}\ast v_i)}}=\frac{n\cdot l(\mathbf{G})-(n-k_i)\cdot l(\mathbf{G}\ast v_i)}{n\cdot l(\mathbf{G})}\text{\hspace{1em}(3)}$$又因为$1\le l(\mathbf{G}\ast v_i)<l(\mathbf{G})$，$k_i\ge 1$，所以$$0<\frac{1}{n}<\mathbf{I}\mathbf{M}\mathbf{C}(v_i)\le 1-\frac{1}{n\cdot l(\mathbf{G})}<1\text{\hspace{1em}(4)}$$当且仅当$v_i$为星型网络中的中心节点时，式(4)中等号成立。此时，$k_i=n-1,l(\mathbf{G})=\frac{2(n-1)}{n},l(\mathbf{G}\ast v_i)=1,\mathbf{I}\mathbf{M}\mathbf{C}(v_i)=1-\frac{1}{n\cdot l(\mathbf{G})}=1-\frac{1}{2(n-1)}$。
由式(3)可以看出，节点$v_i$的重要度取决于两个因素：一是节点$v_i$的连接度$k_i$，另外一个是节点$v_i$在网络中的位置。相同条件下，如果节点$v_i$的连接度$k_i$越大，则将该节点收缩以后网络中节点的数目就越少，网络的凝聚度就越大，该节点越重要。另外，如果节点$v_i$处于“要塞”位置，则很多节点对之间的最短路径都要经过该节点，那么当把$v_i$收缩以后网络的平均路径长度将大大减少，从而获得较大的网络凝聚度。

算法伪代码

输入：$\mathbf{H}$（邻接矩阵）
输出：$\mathbf{I}\mathbf{M}\mathbf{C}$（节点重要度）
1）计算所有节点对之间的最短距离矩阵$D=[d_{ij}]$ \\Floyd算法；
2）根据式(1)计算网络初始凝聚度$\partial [\mathbf{G}]$;
3）$\mathbf{F}\mathbf{O}\mathbf{R}i=1ton$ \\主循环，评估所有节点重要度；
{ 计算节点$v_i$收缩后所有节点对之间的最短距离矩阵$D^{(i)}=[D_{st}^{(i)}]$；
根据式(1)计算节点$v_i$收缩后网络的凝聚度$\partial [\mathbf{G}\ast v_i]$；
根据式(2)计算$\mathbf{I}\mathbf{M}\mathbf{C}(v_i)$；
}

论文中的算例

图2为论文所采用的算例的拓扑结构图，该网络中有10个节点，10条边。节点收缩后的结果如图3所示。

其中$(a)$为节点$v_1$、$v_2$、$v_9$或$v_{10}$收缩后的图；$(b)$为节点$v_3$或$v_8$收缩后的图；$(c)$为节点$v_4$或$v_7$收缩后的图；$(d)$为节点$v_5$或$v_6$收缩后的图。

代码实现

节点收缩法子程序

节点收缩法的子程序主要作用是：生成原始网络的每个节点收缩后的网络的集合。采用的方法是，先找出节点$i$的邻居节点集合$S$，然后在网络中删除节点$i$，并将节点$i$的所有节点都更改为$i$，最后删除节点$i$收缩后的网络中的重复边。

# 输入为原始状态下的网络图，输出节点收缩后的图的集合
def node_shrink(Graph):  # 节点收缩法
    Graphs = []
    for i in list(Graph.nodes):  # 计算每个节点收缩后的图
        subGraph = nx.Graph()
        neighboor_nodes = [n for n in Graph.neighbors(i)]  # i节点的邻居节点
        Graph_int = copy.deepcopy(Graph)  # 深拷贝Graph
        Graph_int.remove_node(i)  # 删除节点i
        remove_edge = list([list(i) for i in Graph_int.edges])  # 删除节点i后，图中的边
        for j in range(len(remove_edge)):  # 将节点i的邻居节点都改成节点i实现节点收缩
            for k in range(len(neighboor_nodes)):
                if remove_edge[j][0] == neighboor_nodes[k]:
                    remove_edge[j][0] = i
                elif remove_edge[j][1] == neighboor_nodes[k]:
                    remove_edge[j][1] = i
                else:
                    continue
        subGraph.add_edges_from(remove_edge)
        subGraph.name = str(i)  # 给图赋属性，排序用
        Graphs.append(subGraph)

    # 冒泡排序
    for i in range(len(Graphs)):
        # Last i elements are already in place
        for j in range(0, len(Graphs) - i - 1):
            if int(Graphs[j].name) > int(Graphs[j + 1].name):
                Graphs[j], Graphs[j + 1] = Graphs[j + 1], Graphs[j]
    return Graphs  # 返回排序后节点收缩图的集合

重要度子程序

按照式(1)计算原始网络和节点$i$收缩后的网络的凝聚度，然后按照式(2)计算节点$i$对应的重要度指标。

def IMCs(graph_int, Graphs):  # 计算重要度
    njd_int = 1 / (len(list(graph_int.nodes)) * nx.average_shortest_path_length(graph_int))  # 原始网络凝聚度
    IMCs = []
    for graph in Graphs:
        njd = 1 / (len(list(graph)) * nx.average_shortest_path_length(graph))
        IMC = 1 - njd_int / njd
        IMCs.append(IMC)
    return IMCs

测试主程序

将论文中算例的网络拓扑结构用networx包中的Gaph函数函数表示，并计算节点重要度指标。

if __name__ == '__main__':
    # 论文测试算例
    edges = [(1, 3), (2, 3), (3, 4), (4, 5), (4, 7), (5, 6), (6, 7), (7, 8), (8, 9), (8, 10)]
    Graph = nx.Graph()
    for i in range(len(edges)):
        Graph.add_edge(edges[i][0], edges[i][1])
    Graph.add_edges_from(edges)
    shrink_Graphs = node_shrink(Graph)  # 节点收缩后的图
    IMCs = IMCs(Graph, shrink_Graphs)  # 节点重要度

计算结果

程序的计算结果如图4所示，可以看出跟论文中的结果是一致的。

引用

[1]谭跃进, 吴俊, 邓宏钟. 复杂网络中节点重要度评估的节点收缩方法[J]. 系统工程理论与实践, 2006, 26(11):6.