300字范文 > 一文读懂Python复杂网络分析库networkx | CSDN博文精选

一文读懂Python复杂网络分析库networkx | CSDN博文精选

时间：2018-09-19 06:29:15

作者 |yyl424525来源 | CSDN博客

文章目录

1. 简介

安装

支持四种图

绘制网络图基本流程

2. Graph-无向图节点边属性有向图和无向图互转3. DiGraph-有向图

一些精美的图例子

环形树状图

权重图

Giant Component

Random Geometric Graph 随机几何图

节点颜色渐变

边的颜色渐变

Atlas

画个五角星

Club

画一个多层感知机

绘制一个DNN结构图

一些图论算法

最短路径

4. 问题

一些其他神经网络绘制工具列表

5. 参考1 简介networkx是一个用Python语言开发的图论与复杂网络建模工具，内置了常用的图与复杂网络分析算法，可以方便的进行复杂网络数据分析、仿真建模等工作。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型、设计新的网络算法、进行网络绘制等。networkx支持创建简单无向图、有向图和多重图（multigraph）；内置许多标准的图论算法，节点可为任意数据；支持任意的边值维度，功能丰富，简单易用。networkx以图（graph）为基本数据结构。图既可以由程序生成，也可以来自在线数据源，还可以从文件与数据库中读取。安装安装的话，跟其他包的安装差不多，用的是anaconda就不用装了。其他就用pip install networkx。查看版本：

1>>>importnetworkx

2>>>networkx.__version__

3'1.11'

升级

1pipinstall--upgradenetworkx

下面配合使用的一些库，可以选择性安装：

后面可能用到pygraphviz，安装方法如下（亲测有效）：

1sudoapt-getinstallgraphviz

2sudoapt-getinstallgraphvizlibgraphviz-devpkg-config

3sudoapt-getinstallpython-pippython-virtualenv

4pipinstallpygraphviz

windows的安装参考这篇博客：/fadai1993/article/details/82491657#2____linux_9安装cv2：

1pipinstallopencv-python#安装非常慢，用下面的方式，从清华源下载

2pip3install-ihttps://pypi.tuna./simpleopencv-python

支持四种图

Graph：无多重边无向图

DiGraph：无多重边有向图

MultiGraph：有多重边无向图

MultiDiGraph：有多重边有向图

空图对象的创建方式

1importnetworkxasnx

2G=nx.Graph()

3G=nx.DiGraph()

4G=nx.MultiGraph()

5G=nx.MultiDiGraph()

6G.clear()#清空图

绘制网络图基本流程

导入networkx，matplotlib包

建立网络

绘制网络 nx.draw()

建立布局 pos = nx.spring_layout美化作用

最基本画图程序

1importimportnetworkxasnx#导入networkx包

2importmatplotlib.pyplotasplt

3G=nx.random_graphs.barabasi_albert_graph(100,1)#生成一个BA无标度网络G

4nx.draw(G)#绘制网络G

5plt.savefig("ba.png")#输出方式1:将图像存为一个png格式的图片文件

6plt.show()#输出方式2:在窗口中显示这幅图像

networkx 提供画图的函数

1draw（G，[pos,ax,hold]）

2draw_networkx(G，[pos,with_labels])

3draw_networkx_nodes(G,pos,[nodelist])绘制网络G的节点图

4draw_networkx_edges(G,pos[edgelist])绘制网络G的边图

5draw_networkx_edge_labels(G,pos[,…])绘制网络G的边图，边有label

6—有layout布局画图函数的分界线—

7draw_circular(G,**kwargs)DrawthegraphGwithacircularlayout.

8draw_random(G,**kwargs)DrawthegraphGwitharandomlayout.

9draw_spectral(G,**kwargs)DrawthegraphGwithaspectrallayout.

10draw_spring(G,**kwargs)DrawthegraphGwithaspringlayout.

11draw_shell(G,**kwargs)Drawnetworkxgraphwithshelllayout.

12draw_graphviz(G[,prog])Drawnetworkxgraphwithgraphvizlayout.

networkx 画图函数里的一些参数

pos(dictionary, optional): 图像的布局，可选择参数；如果是字典元素，则节点是关键字，位置是对应的值。如果没有指明，则会是spring的布局；也可以使用其他类型的布局，具体可以查阅networkx.layout

arrows :布尔值，默认True; 对于有向图，如果是True则会画出箭头

with_labels: 节点是否带标签（默认为True）

ax：坐标设置，可选择参数；依照设置好的Matplotlib坐标画图

nodelist：一个列表，默认G.nodes(); 给定节点

edgelist：一个列表，默认G.edges();给定边

node_size: 指定节点的尺寸大小(默认是300，单位未知，就是上图中那么大的点)

node_color: 指定节点的颜色 (默认是红色，可以用字符串简单标识颜色，例如’r’为红色，'b’为绿色等，具体可查看手册)，用“数据字典”赋值的时候必须对字典取值（.values()）后再赋值

node_shape: 节点的形状（默认是圆形，用字符串’o’标识，具体可查看手册）

alpha: 透明度 (默认是1.0，不透明，0为完全透明)

cmap：Matplotlib的颜色映射，默认None; 用来表示节点对应的强度

vmin,vmax：浮点数，默认None;节点颜色映射尺度的最大和最小值

linewidths：[None|标量|一列值];图像边界的线宽

width: 边的宽度 (默认为1.0)

edge_color: 边的颜色(默认为黑色)

edge_cmap：Matplotlib的颜色映射，默认None; 用来表示边对应的强度

edge_vmin,edge_vmax：浮点数，默认None;边的颜色映射尺度的最大和最小值

style: 边的样式(默认为实现，可选：solid|dashed|dotted,dashdot)

labels：字典元素，默认None;文本形式的节点标签

font_size: 节点标签字体大小 (默认为12)

font_color: 节点标签字体颜色（默认为黑色）

node_size：节点大小

font_weight：字符串，默认’normal’

font_family：字符串，默认’sans-serif’

布局指定节点排列形式

circular_layout：节点在一个圆环上均匀分布

random_layout：节点随机分布shell_layout：节点在同心圆上分布

spring_layout：用Fruchterman-Reingold算法排列节点，中心放射状分布

spectral_layout：根据图的拉普拉斯特征向量排列节点

布局也可用pos参数指定，例如，nx.draw(G, pos = spring_layout(G)) 这样指定了networkx上以中心放射状分布.

2 Graph-无向图如果添加的节点和边是已经存在的，是不会报错的，NetworkX会自动忽略掉已经存在的边和节点的添加。节点常用函数

nodes(G)：在图节点上返回一个迭代器

number_of_nodes(G)：返回图中节点的数量

all_neighbors(graph, node)：返回图中节点的所有邻居

non_neighbors(graph, node)：返回图中没有邻居的节点

common_neighbors(G, u, v)：返回图中两个节点的公共邻居

1importnetworkxasnx

2importmatplotlib.pyplotasplt

3G=nx.Graph()#建立一个空的无向图G

4#增加节点

5G.add_node('a')#添加一个节点1

6G.add_nodes_from(['b','c','d','e'])#加点集合

7G.add_cycle(['f','g','h','j'])#加环

8H=nx.path_graph(10)#返回由10个节点的无向图

9G.add_nodes_from(H)#创建一个子图H加入G

10G.add_node(H)#直接将图作为节点

12nx.draw(G,with_labels=True,node_color='red')

13plt.show()

15#访问节点

16print('图中所有的节点',G.nodes())

17#图中所有的节点[0,1,2,3,'a','c','f',7,8,9,<networkx.classes.graph.Graphobjectat0x7fdf7d0d2780>,'g','e','h','b',4,6,5,'j','d']

19print('图中节点的个数',G.number_of_nodes())

20#图中节点的个数20

22#删除节点

23G.remove_node(1)#删除指定节点

24G.remove_nodes_from(['b','c','d','e'])#删除集合中的节点

边

常用函数

edges(G[, nbunch])：返回与nbunch中的节点相关的边的视图

number_of_edges(G)：返回图中边的数目

non_edges(graph)：返回图中不存在的边

1importnetworkxasnx

2importmatplotlib.pyplotasplt

4#添加边方法1

6F=nx.Graph()#创建无向图

7F.add_edge(11,12)#一次添加一条边

9#添加边方法2

10e=(13,14)#e是一个元组

11F.add_edge(*e)#这是python中解包裹的过程

13#添加边方法3

14F.add_edges_from([(1,2),(1,3)])#通过添加list来添加多条边

16H=nx.path_graph(10)#返回由10个节点的无向图

17#通过添加任何ebunch来添加边

18F.add_edges_from(H.edges())#不能写作F.add_edges_from(H)

20nx.draw(F,with_labels=True)

21plt.show()

23#访问边

24print('图中所有的边',F.edges())

25#图中所有的边[(0,1),(1,2),(1,3),(2,3),(3,4),(4,5),(5,6),(6,7),(7,8),(8,9),(11,12),(13,14)]

27print('图中边的个数',F.number_of_edges())

28#图中边的个数12

32#删除边

33F.remove_edge(1,2)

34F.remove_edges_from([(11,12),(13,14)])

36nx.draw(F,with_labels=True)

37plt.show()

使用邻接迭代器遍历每一条边

1importnetworkxasnx

2importmatplotlib.pyplotasplt

4#快速遍历每一条边，可以使用邻接迭代器实现，对于无向图，每一条边相当于两条有向边

5FG=nx.Graph()

6FG.add_weighted_edges_from([(1,2,0.125),(1,3,0.75),(2,4,1.2),(3,4,0.275)])

7forn,nbrsinFG.adjacency_iter():

8fornbr,eattrinnbrs.items():

9data=eattr['weight']

10print('(%d,%d,%0.3f)'%(n,nbr,data))

11#(1,2,0.125)

12#(1,3,0.750)

13#(2,1,0.125)

14#(2,4,1.200)

15#(3,1,0.750)

16#(3,4,0.275)

17#(4,2,1.200)

18#(4,3,0.275)

20print('***********************************')

22#筛选weight小于0.5的边：

23FG=nx.Graph()

24FG.add_weighted_edges_from([(1,2,0.125),(1,3,0.75),(2,4,1.2),(3,4,0.275)])

25forn,nbrsinFG.adjacency_iter():

26fornbr,eattrinnbrs.items():

27data=eattr['weight']

28ifdata<0.5:

29print('(%d,%d,%0.3f)'%(n,nbr,data))

30#(1,2,0.125)

31#(2,1,0.125)

32#(3,4,0.275)

33#(4,3,0.275)

35print('***********************************')

37#一种方便的访问所有边的方法:

38foru,v,dinFG.edges(data='weight'):

39print((u,v,d))

40#(1,2,0.125)

41#(1,3,0.75)

42#(2,4,1.2)

43#(3,4,0.275)

属性属性诸如weight,labels,colors,或者任何对象，都可以附加到图、节点或边上。对于每一个图、节点和边都可以在关联的属性字典中保存一个（多个）键-值对。默认情况下这些是一个空的字典，但是可以增加或者是改变这些属性。图的属性

1#图的属性

3importnetworkxasnx

5G=nx.Graph(day='Monday')#可以在创建图时分配图的属性

6print(G.graph)

8G.graph['day']='Friday'#也可以修改已有的属性

9print(G.graph)

11G.graph['name']='time'#可以随时添加新的属性到图中

12print(G.graph)

14输出：

15{'day':'Monday'}

16{'day':'Friday'}

17{'day':'Friday','name':'time'}

节点的属性

1#节点的属性

2importnetworkxasnx

4G=nx.Graph(day='Monday')

5G.add_node(1,index='1th')#在添加节点时分配节点属性

6#print(G.node(data=True))#TypeError:'dict'objectisnotcallable

7print(G.node)

8#{1:{'index':'1th'}}

11G.node[1]['index']='0th'#通过G.node[][]来添加或修改属性

12print(G.node)

13#{1:{'index':'0th'}}

16G.add_nodes_from([2,3],index='2/3th')#从集合中添加节点时分配属性

17print(G.node)

18#{1:{'index':'0th'},2:{'index':'2/3th'},3:{'index':'2/3th'}}

边的属性

1#边的属性

2importnetworkxasnx

4G=nx.Graph(day='manday')

5G.add_edge(1,2,weight=10)#在添加边时分配属性

6print(G.edges(data=True))

7#[(1,2,{'weight':10})]

9G.add_edges_from([(1,3),(4,5)],len=22)#从集合中添加边时分配属性

10print(G.edges(data='len'))

11#[(1,2,None),(1,3,22),(4,5,22)]

13G.add_edges_from([(3,4,{'hight':10}),(1,4,{'high':'unknow'})])

14print(G.edges(data=True))

15#[(1,2,{'weight':10}),(1,3,{'len':22}),(1,4,{'high':'unknow'}),(3,4,{'hight':10}),(4,5,{'len':22})]

18G[1][2]['weight']=100000#通过G[][][]来添加或修改属性

19print(G.edges(data=True))

20#[(1,2,{'weight':100000}),(1,3,{'len':22}),(1,4,{'high':'unknow'}),(3,4,{'hight':10}),(4,5,{'len':22})]

有向图和无向图互转有向图和多重图的基本操作与无向图一致。无向图与有向图之间可以相互转换，转化方法如下：

1#有向图转化成无向图

3H=DG.to_undirected()

4#或者

5H=nx.Graph(DG)

7#无向图转化成有向图

9F=H.to_directed()

10#或者

11F=nx.DiGraph(H)

3、DiGraph-有向图

1importnetworkxasnx

2importmatplotlib.pyplotasplt

4G=nx.DiGraph()

5G.add_node(1)

6G.add_node(2)

7G.add_nodes_from([3,4,5,6])

8G.add_cycle([1,2,3,4])

9G.add_edge(1,3)

10G.add_edges_from([(3,5),(3,6),(6,7)])

11nx.draw(G,node_color='red')

12plt.savefig("youxiangtu.png")

13plt.show()

1from__future__importdivision

2importmatplotlib.pyplotasplt

3importnetworkxasnx

5G=nx.generators.directed.random_k_out_graph(10,3,0.5)

6pos=nx.layout.spring_layout(G)

8node_sizes=[3+10*iforiinrange(len(G))]

9M=G.number_of_edges()

10edge_colors=range(2,M+2)

11edge_alphas=[(5+i)/(M+4)foriinrange(M)]

13nodes=nx.draw_networkx_nodes(G,pos,node_size=node_sizes,node_color='blue')

14edges=nx.draw_networkx_edges(G,pos,node_size=node_sizes,arrowstyle='->',

15arrowsize=10,edge_color=edge_colors,

16edge_cmap=plt.cm.Blues,width=2)

17#setalphavalueforeachedge

18foriinrange(M):

19edges[i].set_alpha(edge_alphas[i])

21ax=plt.gca()

22ax.set_axis_off()

23plt.savefig("directed.jpg")

24plt.show()

一些精美的图例子

环形树状图

1importmatplotlib.pyplotasplt

2importnetworkxasnx

4try:

5importpygraphviz

6fromnetworkx.drawing.nx_agraphimportgraphviz_layout

7exceptImportError:

8try:

9importpydot

10fromnetworkx.drawing.nx_pydotimportgraphviz_layout

11exceptImportError:

12raiseImportError("ThisexampleneedsGraphvizandeither"

13"PyGraphvizorpydot")

15G=nx.balanced_tree(3,5)

16pos=graphviz_layout(G,prog='twopi',args='')

17plt.figure(figsize=(8,8))

18nx.draw(G,pos,node_size=20,alpha=0.5,node_color="blue",with_labels=False)

19plt.axis('equal')

20plt.show()

权重图

1importmatplotlib.pyplotasplt

2importnetworkxasnx

4G=nx.Graph()

6G.add_edge('a','b',weight=0.6)

7G.add_edge('a','c',weight=0.2)

8G.add_edge('c','d',weight=0.1)

9G.add_edge('c','e',weight=0.7)

10G.add_edge('c','f',weight=0.9)

11G.add_edge('a','d',weight=0.3)

13elarge=[(u,v)for(u,v,d)inG.edges(data=True)ifd['weight']>0.5]

14esmall=[(u,v)for(u,v,d)inG.edges(data=True)ifd['weight']<=0.5]

16pos=nx.spring_layout(G)#positionsforallnodes

18#nodes

19nx.draw_networkx_nodes(G,pos,node_size=700)

21#edges

22nx.draw_networkx_edges(G,pos,edgelist=elarge,

23width=6)

24nx.draw_networkx_edges(G,pos,edgelist=esmall,

25width=6,alpha=0.5,edge_color='b',style='dashed')

27#labels

28nx.draw_networkx_labels(G,pos,font_size=20,font_family='sans-serif')

30plt.axis('off')

31plt.savefig("weight.jpg")

32plt.show()

Giant Component

1importmath

4importmatplotlib.pyplotasplt

5importnetworkxasnx

7try:

8importpygraphviz

9fromnetworkx.drawing.nx_agraphimportgraphviz_layout

10layout=graphviz_layout

11exceptImportError:

12try:

13importpydot

14fromnetworkx.drawing.nx_pydotimportgraphviz_layout

15layout=graphviz_layout

16exceptImportError:

17print("PyGraphvizandpydotnotfound;\n"

18"drawingwithspringlayout;\n"

19"willbeslow.")

20layout=nx.spring_layout

22n=150#150nodes

23#pvalueatwhichgiantcomponent(ofsizelog(n)nodes)isexpected

24p_giant=1.0/(n-1)

25#pvalueatwhichgraphisexpectedtobecomecompletelyconnected

26p_conn=math.log(n)/float(n)

28#thefollowingrangeofpvaluesshouldbeclosetothethreshold

29pvals=[0.003,0.006,0.008,0.015]

31region=220#forpylab2x2subplotlayout

32plt.subplots_adjust(left=0,right=1,bottom=0,top=0.95,wspace=0.01,hspace=0.01)

33forpinpvals:

34G=nx.binomial_graph(n,p)

35pos=layout(G)

36region+=1

37plt.subplot(region)

38plt.title("p=%6.3f"%(p))

39nx.draw(G,pos,

40with_labels=False,

41node_size=10

42)

43#identifylargestconnectedcomponent

44Gcc=sorted(nx.connected_component_subgraphs(G),key=len,reverse=True)

45G0=Gcc[0]

46nx.draw_networkx_edges(G0,pos,

47with_labels=False,

48edge_color='r',

49width=6.0

50)

51#showotherconnectedcomponents

52forGiinGcc[1:]:

53iflen(Gi)>1:

54nx.draw_networkx_edges(Gi,pos,

55with_labels=False,

56edge_color='r',

57alpha=0.3,

58width=5.0

59)

60plt.show()

Random Geometric Graph 随机几何图

1importmatplotlib.pyplotasplt

2importnetworkxasnx

4G=nx.random_geometric_graph(200,0.125)

5#positionisstoredasnodeattributedataforrandom_geometric_graph

6pos=nx.get_node_attributes(G,'pos')

8#findnodenearcenter(0.5,0.5)

9dmin=1

10ncenter=0

11forninpos:

12x,y=pos[n]

13d=(x-0.5)**2+(y-0.5)**2

14ifd<dmin:

15ncenter=n

16dmin=d

18#colorbypathlengthfromnodenearcenter

19p=dict(nx.single_source_shortest_path_length(G,ncenter))

21plt.figure(figsize=(8,8))

22nx.draw_networkx_edges(G,pos,nodelist=[ncenter],alpha=0.4)

23nx.draw_networkx_nodes(G,pos,nodelist=list(p.keys()),

24node_size=80,

25node_color=list(p.values()),

26cmap=plt.cm.Reds_r)

28plt.xlim(-0.05,1.05)

29plt.ylim(-0.05,1.05)

30#plt.axis('off')

31plt.show()

节点颜色渐变

1importnetworkxasnx

2importmatplotlib.pyplotasplt

3G=nx.cycle_graph(24)

4pos=nx.spring_layout(G,iterations=200)

5nx.draw(G,pos,node_color=range(24),node_size=800,cmap=plt.cm.Blues)

6plt.savefig("node.jpg")

7plt.show()

边的颜色渐变

1importmatplotlib.pyplotasplt

2importnetworkxasnx

4G=nx.star_graph(20)

5pos=nx.spring_layout(G)#布局为中心放射状

6colors=range(20)

7nx.draw(G,pos,node_color='#A0CBE2',edge_color=colors,

8width=4,edge_cmap=plt.cm.Blues,with_labels=False)

9plt.show()

Atlas

1importrandom

3try:

4importpygraphviz

5fromnetworkx.drawing.nx_agraphimportgraphviz_layout

6exceptImportError:

7try:

8importpydot

9fromnetworkx.drawing.nx_pydotimportgraphviz_layout

10exceptImportError:

11raiseImportError("ThisexampleneedsGraphvizandeither"

12"PyGraphvizorpydot.")

14importmatplotlib.pyplotasplt

16importnetworkxasnx

17fromnetworkx.algorithms.isomorphism.isomorphimportgraph_could_be_isomorphicasisomorphic

18fromnetworkx.generators.atlasimportgraph_atlas_g

21defatlas6():

22"""Returntheatlasofallconnectedgraphsof6nodesorless.

23Attempttocheckforisomorphismsandremove.

24"""

26Atlas=graph_atlas_g()[0:208]#208

27#removeisolatednodes,onlyconnectedgraphsareleft

28U=nx.Graph()#graphforunionofallgraphsinatlas

29forGinAtlas:

30zerodegree=[nforninGifG.degree(n)==0]

31forninzerodegree:

32G.remove_node(n)

33U=nx.disjoint_union(U,G)

35#iteratorofgraphsofallconnectedcomponents

36C=(U.subgraph(c)forcinnx.connected_components(U))

38UU=nx.Graph()

39#doquickisomorphic-likecheck,notatrueisomorphismchecker

40nlist=[]#listofnonisomorphicgraphs

41forGinC:

42#checkagainstallnonisomorphicgraphssofar

43ifnotiso(G,nlist):

44nlist.append(G)

45UU=nx.disjoint_union(UU,G)#unionthenonisomorphicgraphs

46returnUU

49defiso(G1,glist):

50"""Quickanddirtynonisomorphismcheckerusedtocheckisomorphisms."""

51forG2inglist:

52ifisomorphic(G1,G2):

53returnTrue

54returnFalse

57if__name__=='__main__':

58G=atlas6()

60print("graphhas%dnodeswith%dedges"

61%(nx.number_of_nodes(G),nx.number_of_edges(G)))

62print(nx.number_connected_components(G),"connectedcomponents")

64plt.figure(1,figsize=(8,8))

65#layoutgraphswithpositionsusinggraphvizneato

66pos=graphviz_layout(G,prog="neato")

67#colornodesthesameineachconnectedsubgraph

68C=(G.subgraph(c)forcinnx.connected_components(G))

69forginC:

70c=[random.random()]*nx.number_of_nodes(g)#randomcolor...

71nx.draw(g,

72pos,

73node_size=40,

74node_color=c,

75vmin=0.0,

76vmax=1.0,

77with_labels=False

78)

79plt.show()

画个五角星

1importnetworkxasnx

2importmatplotlib.pyplotasplt

3#画图！

4G=nx.Graph()

5G.add_node(1)

6G.add_nodes_from([2,3,4,5])

7foriinrange(5):

8forjinrange(i):

9if(abs(i-j)notin(1,4)):

10G.add_edge(i+1,j+1)

11nx.draw(G,

12with_labels=True,#这个选项让节点有名称

13edge_color='b',#bstandsforblue!

14pos=nx.circular_layout(G),#这个是选项选择点的排列方式，具体可以用help(nx.drawing.layout)查看

15#主要有spring_layout(default),random_layout,circle_layout,shell_layout

16#这里是环形排布，还有随机排列等其他方式

17node_color='r',#r=red

18node_size=1000,#节点大小

19width=3,#边的宽度

20)

21plt.savefig("star.jpg")

22plt.show()

Club

1importmatplotlib.pyplotasplt

2importnetworkxasnx

3importnetworkx.algorithms.bipartiteasbipartite

5G=nx.davis_southern_women_graph()

6women=G.graph['top']

7clubs=G.graph['bottom']

9print("Biadjacencymatrix")

10print(bipartite.biadjacency_matrix(G,women,clubs))

12#projectbipartitegraphontowomennodes

13W=bipartite.projected_graph(G,women)

14print('')

15print("#Friends,Member")

16forwinwomen:

17print('%d%s'%(W.degree(w),w))

19#projectbipartitegraphontowomennodeskeepingnumberofco-occurence

20#thedegreecomputedisweightedandcountsthetotalnumberofsharedcontacts

21W=bipartite.weighted_projected_graph(G,women)

22print('')

23print("#Friendmeetings,Member")

24forwinwomen:

25print('%d%s'%(W.degree(w,weight='weight'),w))

27nx.draw(G,node_color="red")

28plt.savefig("club.jpg")

29plt.show()

画一个多层感知机

1importmatplotlib.pyplotasplt

2importnetworkxasnx

3left,right,bottom,top,layer_sizes=.1,.9,.1,.9,[4,7,7,2]

4#网络离上下左右的距离

5#layter_sizes可以自己调整

6importrandom

7G=nx.Graph()

8v_spacing=(top-bottom)/float(max(layer_sizes))

9h_spacing=(right-left)/float(len(layer_sizes)-1)

10node_count=0

11fori,vinenumerate(layer_sizes):

12layer_top=v_spacing*(v-1)/2.+(top+bottom)/2.

13forjinrange(v):

14G.add_node(node_count,pos=(left+i*h_spacing,layer_top-j*v_spacing))

15node_count+=1

16#这上面的数字调整我想了好半天，汗

17forx,(left_nodes,right_nodes)inenumerate(zip(layer_sizes[:-1],layer_sizes[1:])):

18foriinrange(left_nodes):

19forjinrange(right_nodes):

20G.add_edge(i+sum(layer_sizes[:x]),j+sum(layer_sizes[:x+1]))

22pos=nx.get_node_attributes(G,'pos')

23#把每个节点中的位置pos信息导出来

24nx.draw(G,pos,

25node_color=range(node_count),

26with_labels=True,

27node_size=200,

28edge_color=[random.random()foriinrange(len(G.edges))],

29width=3,

30cmap=plt.cm.Dark2,#matplotlib的调色板，可以搜搜，很多颜色

31edge_cmap=plt.cm.Blues

32)

33plt.savefig("mlp.jpg")

34plt.show()

绘制一个DNN结构图

1#-*-coding:utf-8-*-

2importnetworkxasnx

3importmatplotlib.pyplotasplt

5#创建DAG

6G=nx.DiGraph()

8#顶点列表

9vertex_list=['v'+str(i)foriinrange(1,22)]

10#添加顶点

11G.add_nodes_from(vertex_list)

13#边列表

14edge_list=[

15('v1','v5'),('v1','v6'),('v1','v7'),('v1','v8'),('v1','v9'),

16('v2','v5'),('v2','v6'),('v2','v7'),('v2','v8'),('v2','v9'),

17('v3','v5'),('v3','v6'),('v3','v7'),('v3','v8'),('v3','v9'),

18('v4','v5'),('v4','v6'),('v4','v7'),('v4','v8'),('v4','v9'),

19('v5','v10'),('v5','v11'),('v5','v12'),('v5','v13'),('v5','v14'),('v5','v15'),

20('v6','v10'),('v6','v11'),('v6','v12'),('v6','v13'),('v6','v14'),('v6','v15'),

21('v7','v10'),('v7','v11'),('v7','v12'),('v7','v13'),('v7','v14'),('v7','v15'),

22('v8','v10'),('v8','v11'),('v8','v12'),('v8','v13'),('v8','v14'),('v8','v15'),

23('v9','v10'),('v9','v11'),('v9','v12'),('v9','v13'),('v9','v14'),('v9','v15'),

24('v10','v16'),('v10','v17'),('v10','v18'),

25('v11','v16'),('v11','v17'),('v11','v18'),

26('v12','v16'),('v12','v17'),('v12','v18'),

27('v13','v16'),('v13','v17'),('v13','v18'),

28('v14','v16'),('v14','v17'),('v14','v18'),

29('v15','v16'),('v15','v17'),('v15','v18'),

30('v16','v19'),

31('v17','v20'),

32('v18','v21')

33]

34#通过列表形式来添加边

35G.add_edges_from(edge_list)

37#绘制DAG图

38plt.title('DNNforiris')#图片标题

40nx.draw(

41G,

42node_color='red',#顶点颜色

43edge_color='black',#边的颜色

44with_labels=True,#显示顶点标签

45font_size=10,#文字大小

46node_size=300#顶点大小

47)

48#显示图片

49plt.show()

可以看到，在代码中已经设置好了这22个神经元以及它们之间的连接情况，但绘制出来的结构如却是这样的：

这显然不是想要的结果，因为各神经的连接情况不明朗，而且很多神经都挤在了一起，看不清楚。之所以出现这种情况，是因为没有给神经元设置坐标，导致每个神经元都是随机放置的。接下来，引入坐标机制，即设置好每个神经元节点的坐标，使得它们的位置能够按照事先设置好的来放置，其Python代码如下：