NetworkX：部分失败的图形/网络的邻接矩阵

Question

回想一下，如果连接了两个节点，邻接矩阵给我们1否则给我们0 ，我想为所有节点都active的正则图计算一个矩阵，为其中几个节点发生failed 的同一图计算一个矩阵。

让我们考虑一个2x2节点的莱迪思网络。 其邻接矩阵（A）为：

0  1  1  0
1  0  0  1
1  0  0  1
0  1  1  0

产生此图：

现在，让我们删除节点0 ：

G.remove_node(0)

这就是新的邻接矩阵（A1）的样子：

0  0  1
0  0  1
1  1  0

返回此图：

现在，两个矩阵的大小明显不同。

我的问题 ：如何确定矩阵A1的大小与矩阵A相同？ 这就是说，如果节点0因为失败而不会出现，我希望将0 对应于第0-th行和0-th列放入A1 中 ，以便矩阵的大小保持不变。 为了比较和计算，我需要这样做。 但是要做到这一点，我假设我需要访问创建邻接矩阵的函数。 我可以用更简单的方式做到吗？

节点0失败的示例：

0  0  0  0
0  0  0  1
0  0  0  1
0  1  1  0

这就是我创建2x2网络并生成邻接矩阵的方式：

import networkx as nx

N=2
G=nx.grid_2d_graph(N,N)
pos = dict( (n, n) for n in G.nodes() )
labels = dict( ((i,j), i + (N-1-j) * N ) for i, j in G.nodes() )
nx.relabel_nodes(G,labels,False)
inds=labels.keys()
vals=labels.values()
inds.sort()
vals.sort()
pos2=dict(zip(vals,inds))
nx.draw_networkx(G, pos=pos2, with_labels=True, node_size = 200)

A=nx.adjacency_matrix(G)
A.toarray()

#G.remove_node(i) to remove node i

Answer 1

尝试使用G.remove_edges_from(G.edges(0)) ，它将删除所有0的边而不是整个节点。 然后生成邻接矩阵。

Answer 2

根据一些研究和Joel的建议，我提出了这种方法。 我想在这里发布它，以便任何有意愿的人都可以提出改进建议。

对于常规的3x3网络，这是我们以公允的方式获取邻接矩阵的方式：

#Create the graph (see question above)
A=nx.adjacency_matrix(G, nodelist=range(N*N))
A=A.todense()

这将产生一个N^2xN^2矩阵，其中每个行/列对应一个特定节点（使用nodelist允许打印出要打印的行/列，排序为0到K ，其中K是节点总数）：

[[0 1 0 1 0 0 0 0 0]
 [1 0 1 0 1 0 0 0 0]
 [0 1 0 0 0 1 0 0 0]
 [1 0 0 0 1 0 1 0 0]
 [0 1 0 1 0 1 0 1 0]
 [0 0 1 0 1 0 0 0 1]
 [0 0 0 1 0 0 0 1 0]
 [0 0 0 0 1 0 1 0 1]
 [0 0 0 0 0 1 0 1 0]]

如果节点0发生故障，我们将不得不用不存在的连接（ 0 ）替换其连接（ 1 ），同时保留邻接矩阵的大小。 在这种情况下，行0和列0将填入0 。 然后，我的解决方案如下：

P=K #Total number of nodes before failures

def nodes_connected(i, j):
     try: 
        if i in G.neighbors(j):
            return 1
     except nx.NetworkXError:
        return False          

A1=numpy.zeros((P*P,P*P))

for i in range(0,P*P,1):
    for j in range(0,P*P,1):              
        if i not in G.nodes():
            A1[i][:]=0
            A1[:][i]=0
        elif i in G.nodes():
            A1[i][j]=nodes_connected(i,j)
                A1[j][i]=A1[i][j]
for i in range(0,P*P,1):
    for j in range(0,P*P,1):
            if math.isnan(A1[i][j]):
                A1[i][j]=0              
print(A1)

这将产生以下结果：

[[ 0.  0.  0.  0.  0.  0.  0.  0.  0.]
 [ 0.  0.  1.  0.  1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.  1.  0.  0.  0.]
 [ 0.  0.  0.  0.  1.  0.  1.  0.  0.]
 [ 0.  1.  0.  1.  0.  1.  0.  1.  0.]
 [ 0.  0.  1.  0.  1.  0.  0.  0.  1.]
 [ 0.  0.  0.  1.  0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.  0.  1.  0.  1.]
 [ 0.  0.  0.  0.  0.  1.  0.  1.  0.]]

现在，矩阵A1告诉我们节点0没有任何连接。 它还告诉我们，类似于矩阵A，节点1连接到节点2和4 。

如果有人有更正的建议，欢迎您提出。