[python] 基于NetworkX实现网络图的绘制_networkx相关矩阵网络

NETWORK CHART(网络图)

代码下载地址
网络图 （或图表或图形）显示了一组实体之间的互连。每个实体由一个或多个节点表示。节点之间的连接通过链接（或边）表示。网络的理论与实现是一个广阔的研究领域。整个网络都可以致力于此。例如，网络可以是有向的或无向的，加权的或未加权的。有许多不同的输入格式。为了指导您该领域，我建议按照建议的顺序执行以下示例。请注意关于该工具，我主要依靠NetworkX库(2.4版本)。但是请注意，还应考虑使用Graph Tool，尤其是在涉及高维网络时。该章节主要内容有：

1. 来自pandas基础网格图绘制 Basic Network from pandas data frame
2. 自定义NetworkX图形外观 Custom NetworkX graph appearance
3. 网络布局的可能性 Network layout possibilities
4. 有向或无向网络 Directed or Undirected network
5. 将颜色映射到网络节点 Map a color to network nodes
6. 将颜色映射到网络的边 Map colour to the edges of a Network
7. 网络图的背景颜色 Background colour of network chart
8. 来自相关性矩阵的网络 Network from correlation matrix
   NetworkX安装：

pip install networkx==2.4
1

本文参考：

https://python-graph-gallery.com/network-chart/

from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" 
1
2

1. 自pandas基础网格图绘制 Basic Network from pandas data frame

该示例可能是您可以实现的最基本的网络图表。网络图由节点组成。这些节点通过边相互连接。因此，基本格式是数据帧，其中每行描述一个连接。在这里，我们用4条线构造一个数据框，描述此图的4个连接！因此，如果您的连接带有一个csv文件，请加载该文件并准备对其进行可视化！FROM表示起点，to表示终点。

# libraries 导入模块
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
1
2
3
4
5

# Build a dataframe with 4 connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
df
 
# Build your graph
# 绘制网络图，每次结果可能不一样
G=nx.from_pandas_edgelist(df, 'from', 'to')
 
# Plot it
nx.draw(G, with_labels=True)
plt.show()
1
2
3
4
5
6
7
8
9
10
11

2. 自定义NetworkX图形外观 Custom NetworkX graph appearance

现在，让我们看一下自定义图表外观的参数。自定义分为三个主要类别：节点，节点标签和边：

• 节点 Nodes
• 标签 Labels
• 边 Edges
• 总结 All

## 节点 Nodes

# libraries 载入库
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
df
 
# Build your graph 建立表格
G=nx.from_pandas_edgelist(df, 'from', 'to')
 
# Graph with Custom nodes: 自定义表格
# with_labels是否显示标签，node_size节点大小，node_color节点颜色，node_shape节点形状，alpha透明度，linewidths线条宽度
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", node_shape="s", alpha=0.5, linewidths=10)
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

## 标签 Labels
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to')
 
# Custom the edges:
# font_size标签字体大小，font_color标签字体颜色,font_weight字体形式
nx.draw(G, with_labels=True, node_size=1500, font_size=25, font_color="yellow", font_weight="bold")
plt.show()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

## 边 Edges
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to')
 
# Chart with Custom edges:
# width边线条宽，edge_color边线条颜色
nx.draw(G, with_labels=True, width=10, edge_color="skyblue", style="solid")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

## 总结 All
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to')
 
# All together we can do something fancy
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", node_shape="o", alpha=0.5, linewidths=4, font_size=25, font_color="grey", font_weight="bold", width=2, edge_color="grey")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

3. 网络布局的可能性 Network layout possibilities

实际上，有一种算法可以计算每个节点的最佳位置。NetworkX已开发并提出了几种算法。此页面通过采用相同的小型数据集并对其应用不同的布局算法来说明此概念。如果您不知道哪一个最适合您，则默认情况下将其设置为默认值！默认Spring布局

# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A','E','F','E','G','G','D','F'], 'to':['D', 'A', 'E','C','A','F','G','D','B','G','C']})
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to')
1
2
3
4
5
6
7
8
9
10
11
12

# Fruchterman Reingold Fruchterman Reingold引导布局算法布局
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", pos=nx.fruchterman_reingold_layout(G))
plt.title("fruchterman_reingold")
1
2
3

Text(0.5, 1.0, 'fruchterman_reingold')
1

# Circular 环形布局
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", pos=nx.circular_layout(G))
plt.title("circular")
1
2
3

Text(0.5, 1.0, 'circular')
1

# Random 随机布局
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", pos=nx.random_layout(G))
plt.title("random")
1
2
3

Text(0.5, 1.0, 'random')
1

# Spectral 光谱式布局
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", pos=nx.spectral_layout(G))
plt.title("spectral")
1
2
3

Text(0.5, 1.0, 'spectral')
1

# Spring 跳跃式布局
nx.draw(G, with_labels=True, node_size=1500, node_color="skyblue", pos=nx.spring_layout(G))
plt.title("spring")
1
2
3

Text(0.5, 1.0, 'spring')
1

4. 有向或无向网络 Directed or Undirected network

网络图可以在2个主要类别进行分割：有向网络和无向网络。如果它是定向的，那么在两个节点之间就有一个流的概念，这样就留下了一个去其他地方的地方。就像钱从A公司流向B公司一样。这就是为什么你可以看到（某种程度上）左边图表上的箭头，它给出了方向。例如，流量从B流向A。如果它是无向的，则这两个节点之间只有一个链接，例如，先生A和先生B是朋友。
生成图形时，必须使用适合您需要的函数：Graph（）用于无向（默认），DiGraph用于有向图

# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
##  DIRECTED 有向图
 
# Build a dataframe with your connections
# This time a pair can appear 2 times, in one side or in the other!
df = pd.DataFrame({ 'from':['D', 'A', 'B', 'C','A'], 'to':['A', 'D', 'A', 'E','C']})
df
 
# Build your graph. Note that we use the DiGraph function to create the graph!
# create_using=nx.DiGraph()创建有向图,默认是无向图
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.DiGraph())
 
# Make the graph 有向图
nx.draw(G, with_labels=True, node_size=1500, alpha=0.3, arrows=True)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# UNDIRECTED 无向图
 
# Build a dataframe with your connections
# This time a pair can appear 2 times, in one side or in the other!
df = pd.DataFrame({ 'from':['D', 'A', 'B', 'C','A'], 'to':['A', 'D', 'A', 'E','C']})
df
 
# Build your graph. Note that we use the Graph function to create the graph!
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph())
 
# Make the graph
nx.draw(G, with_labels=True, node_size=1500, alpha=0.3, arrows=True)
plt.title("UN-Directed")
1
2
3
4
5
6
7
8
9
10
11
12
13

Text(0.5, 1.0, 'UN-Directed')
1

5. 将颜色映射到网络节点 Map a color to network nodes

一个常见的任务是按照节点的功能为网络图表的每个节点着色（我们称其为映射颜色）。它允许在图表中显示更多信息。有两种可能性：

1. 您要映射的要素是一个数值。然后，我们将使用连续的色标。在左图上，A比C暗，比B暗。
2. 该功能是分类的。在右图上，A和B属于同一组，D和E分组在一起，而C在他的组中单独存在。我们使用了分类色标。

通常我们使用2个表。第一个提供节点之间的链接。第二个提供每个节点的功能。您可以如下链接这两个文件。

• 连续颜色
• 分类颜色

## Continuous color scale 连续颜色
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
 
# And a data frame with characteristics for your nodes
carac = pd.DataFrame({ 'ID':['A', 'B', 'C','D','E'], 'myvalue':['123','25','76','12','34'] })
# 设置值
carac
# Build your graph 建立图
G =nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph() )
 
# The order of the node for networkX is the following order:
# 节点顺序
G.nodes()
# Thus, we cannot give directly the 'myvalue' column to netowrkX, we need to arrange the order!
# Here is the tricky part: I need to reorder carac, to assign the good color to each node
# 根据myvalue设置颜色,并匹配节点顺序和ID号
carac = carac.set_index('ID')
carac =carac.reindex(G.nodes())
carac
# Plot it, providing a continuous color scale with cmap:
# node_color设定颜色，输入的必须是float数组或者int值；cmap颜色条
nx.draw(G, with_labels=True, node_color=np.array(carac['myvalue'].values,dtype='float32'), cmap=plt.cm.Blues)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

NodeView(('A', 'D', 'B', 'C', 'E'))
1

## Categorical color scale 连续颜色
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C']})
 
# And a data frame with characteristics for your nodes
carac = pd.DataFrame({ 'ID':['A', 'B', 'C','D','E'], 'myvalue':['group1','group1','group2','group3','group3'] })
 
# Build your graph
# 建立图
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph() )
 
# The order of the node for networkX is the following order:
# 打印节点顺序
G.nodes()
# Thus, we cannot give directly the 'myvalue' column to netowrkX, we need to arrange the order!
 
# Here is the tricky part: I need to reorder carac to assign the good color to each node
carac= carac.set_index('ID')
# 根据节点顺序设定值
carac=carac.reindex(G.nodes())
 
# And I need to transform my categorical column in a numerical value: group1->1, group2->2...
# 设定类别
carac['myvalue']=pd.Categorical(carac['myvalue'])
carac['myvalue'].cat.codes
    
# Custom the nodes:
nx.draw(G, with_labels=True, node_color=carac['myvalue'].cat.codes, cmap=plt.cm.Set1, node_size=1500)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

NodeView(('A', 'D', 'B', 'C', 'E'))






ID
A    0
D    2
B    0
C    1
E    2
dtype: int8
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6. 将颜色映射到网络的边 Map colour to the edges of a Network

我们假设我们对网络的每个边缘都有一个功能，例如，此功能可以是此链接表示的金额（数字值），也可以是发生在哪个洲（类别值）。我们希望边缘根据此变量而有所不同。

• 数值型 numerical
• 类别型 categorical

## 数值型 numerical
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
# value设定链接值
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C'], 'value':[1, 10, 5, 5]})
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph() )
 
# Custom the nodes:
# edge_color设置边的颜色
nx.draw(G, with_labels=True, node_color='skyblue', node_size=1500, edge_color=df['value'], width=10.0, edge_cmap=plt.cm.Blues)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

## 类别型 categorical
# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
# value设置类型
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C'], 'value':['typeA', 'typeA', 'typeB', 'typeB']})
df
 
# And I need to transform my categorical column in a numerical value typeA->1, typeB->2...
# 转换为类别
df['value']=pd.Categorical(df['value'])
df['value'].cat.codes
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph() )
 
# Custom the nodes:
nx.draw(G, with_labels=True, node_color='skyblue', node_size=1500, edge_color=df['value'].cat.codes, width=10.0, edge_cmap=plt.cm.Set2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

0    0
1    0
2    1
3    1
dtype: int8
1
2
3
4
5

7. 网络图的背景颜色 Background colour of network chart

你可以改变背景颜色您的网络图与 fig.set_facecolor()。 请注意，如果要保留png的背景色，则需要添加fig.get_facecolor。

# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# Build a dataframe with your connections
df = pd.DataFrame({ 'from':['A', 'B', 'C','A'], 'to':['D', 'A', 'E','C'] })
df
 
# Build your graph
G=nx.from_pandas_edgelist(df, 'from', 'to', create_using=nx.Graph() )
 
# Custom the nodes:
fig = plt.figure()
nx.draw(G, with_labels=True, node_color='skyblue', node_size=1500, edge_color='white')
# 设置背景颜色
fig.set_facecolor("#00000F")
 
# If you want to save the figure to png:
# 保存图像需要设定facecolor=fig.get_facecolor() ，否者背景颜色为白色
# plt.savefig('yourname.png', facecolor=fig.get_facecolor()，dpi=300)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

8. 来自相关性矩阵的网络 Network from correlation matrix

本页说明了如何绘制相关网络：基于相关矩阵构建的网络。假设您有10个人，并且知道他们彼此之间的亲密关系。可以在网络中表示这些关系。每个人都是一个节点。如果2个人足够接近（我们设定了一个阈值），则它们由边链接。那将显示人口结构！

# libraries
import pandas as pd
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
 
# I build a data set: 10 individuals and 5 variables for each
ind1=[5,10,3,4,8,10,12,1,9,4]
ind5=[1,1,13,4,18,5,2,11,3,8]
# 建立矩阵
df = pd.DataFrame({ 'A':ind1, 'B':ind1 + np.random.randint(10, size=(10)) , 'C':ind1 + np.random.randint(10, size=(10)) , 'D':ind1 + np.random.randint(5, size=(10)) , 'E':ind1 + np.random.randint(5, size=(10)), 'F':ind5, 'G':ind5 + np.random.randint(5, size=(10)) , 'H':ind5 + np.random.randint(5, size=(10)), 'I':ind5 + np.random.randint(5, size=(10)), 'J':ind5 + np.random.randint(5, size=(10))})
df
 
# Calculate the correlation between individuals. We have to transpose first, because the corr function calculate the pairwise correlations between columns.
# 计算相关性
corr = df.corr()
corr
 
# Transform it in a links data frame (3 columns only):
# 将相关系数矩阵压平
links = corr.stack().reset_index()
# 设置列名
links.columns = ['var1', 'var2','value']
#links
 
# Keep only correlation over a threshold and remove self correlation (cors (A,A)=1)
# 剔除相同编号的行以及相关系数小于0.8的行
links_filtered=links.loc[ (links['value'] > 0.8) & (links['var1'] != links['var2']) ]
#links_filtered
 
# Build your graph
# 作图
G=nx.from_pandas_edgelist(links_filtered, 'var1', 'var2')
 
# Plot the network:
nx.draw(G, with_labels=True, node_color='orange', node_size=500, edge_color='black', linewidths=5, font_size=15)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36