从网络图有效地创建邻接矩阵(反之亦然)Python NetworkX

Efficiently create adjacency matrix from network graph (vice versa) Python NetworkX(从网络图有效地创建邻接矩阵(反之亦然)Python NetworkX)

问题描述

我正在尝试创建网络图并从中生成稀疏矩阵.从维基百科 拉普拉斯矩阵 示例中，我决定尝试使用 networkx

I'm trying to get into creating network graphs and generating sparse matrices from them. From the wikipedia Laplacian matrix example, I decided to try and recreate the following network graph using networkx

如何在邻接矩阵和网络图之间有效地转换?

How can one EFFICIENTLY convert between an adjacency matrix and a network graph?

例如，如果我有一个网络图，如何快速将其转换为邻接矩阵，如果我有一个邻接图，如何有效地将其转换为网络图.

For example, if I have a network graph, how can I quickly convert it to an adjacency matrix and if I have an adjacency graph how can I efficiently convert it to a network graph.

下面是我的代码，我觉得对于大型网络来说效率很低.

Below is my code for doing it and I feel like it's pretty inefficient for larger networks.

#!/usr/bin/python

import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
import pandas as pd

%matplotlib inline

#Adjacent matrix
adj_matrix = np.matrix([[0,1,0,0,1,0],[1,0,1,0,1,0],[0,1,0,1,0,0],[0,0,1,0,1,1],[1,1,0,1,0,0],[0,0,0,1,0,0]])
adj_sparse = sp.sparse.coo_matrix(adj_matrix, dtype=np.int8)
labels = range(1,7)
DF_adj = pd.DataFrame(adj_sparse.toarray(),index=labels,columns=labels)
print DF_adj

#   1  2  3  4  5  6
#1  0  1  0  0  1  0
#2  1  0  1  0  1  0
#3  0  1  0  1  0  0
#4  0  0  1  0  1  1
#5  1  1  0  1  0  0
#6  0  0  0  1  0  0

#Network graph
G = nx.Graph()
G.add_nodes_from(labels)

#Connect nodes
for i in range(DF_adj.shape[0]):
    col_label = DF_adj.columns[i]
    for j in range(DF_adj.shape[1]):
        row_label = DF_adj.index[j]
        node = DF_adj.iloc[i,j]
        if node == 1:
            G.add_edge(col_label,row_label)


#Draw graph
nx.draw(G,with_labels = True)

#DRAWN GRAPH MATCHES THE GRAPH FROM WIKI

#Recreate adjacency matrix
DF_re = pd.DataFrame(np.zeros([len(G.nodes()),len(G.nodes())]),index=G.nodes(),columns=G.nodes())
for col_label,row_label in G.edges():
    DF_re.loc[col_label,row_label] = 1
    DF_re.loc[row_label,col_label] = 1
print G.edges()
#[(1, 2), (1, 5), (2, 3), (2, 5), (3, 4), (4, 5), (4, 6)]

print DF_re
#   1  2  3  4  5  6
#1  0  1  0  0  1  0
#2  1  0  1  0  1  0
#3  0  1  0  1  0  0
#4  0  0  1  0  1  1
#5  1  1  0  1  0  0
#6  0  0  0  1  0  0

推荐答案

如何从图转换为邻接矩阵:

How to convert from graph to adjacency matrix:

import scipy as sp
import networkx as nx
G=nx.fast_gnp_random_graph(100,0.04)
adj_matrix = nx.adjacency_matrix(G)

这里是文档.

从邻接矩阵到图:

H=nx.Graph(adj_matrix)  #if it's directed, use H=nx.DiGraph(adj_matrix)

这是文档.

这篇关于从网络图有效地创建邻接矩阵(反之亦然)Python NetworkX的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持编程学习网！