原文链接

摘要： Python复杂网络结构可视化——matplotlib+networkx

什么是networkx？

networkx在02年5月产生，是用python语言编写的软件包，便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型、设计新的网络算法、进行网络绘制等。 ——百度百科

我们可以用networkx做什么？

https://networkx.github.io/documentation/stable/auto_examples/index.html

1.画图

 



2.有向图，无向图，网络图……

 



3.总之各种图

 



 



看到这你是不是心动了呢？今天的教程就是要教会你画出封面上的三层感知机模型图！

Let's get started!

首先导入networkx和matplotlib模块
import networkx as nx
import matplotlib.pyplot as plt 
>>> import networkx as nx
>>> G = nx.Graph() 定义了一个空图
>>> G.add_node(1) 这个图中增加了1节点
>>> G.add_node('A') 增加'A'节点
>>> G.add_nodes_from([2, 3]) 同时加2和3两个节点
>>> G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)]) 
# 增加这么多条边，在下面有举例
>>> H = nx.path_graph(10) 
>>> G.add_nodes_from(H)
>>> G.add_node(H)
G.add_node('a')#添加点a
G.add_node(1,1)#用坐标来添加点
G.add_edge('x','y')#添加边,起点为x，终点为y
G.add_weight_edges_from([('x','y',1.0)])#第三个输入量为权值
#也可以
list = [[('a','b',5.0),('b','c',3.0),('a','c',1.0)]
G.add_weight_edges_from([(list)])


我们来看看上面最后一句是什么意思

import matplotlib.pyplot as plt
import networkx as nx
H = nx.path_graph(10) 
G.add_nodes_from(H)
nx.draw(G, with_labels=True)
plt.show()


 



生成了标号为0到9的十个点！别急，丑是丑了点，一会我们再给他化妆。

再举个栗子

G=nx.Graph()
#导入所有边，每条边分别用tuple表示
G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)]) 
nx.draw(G, with_labels=True, edge_color='b', node_color='g', node_size=1000)
plt.show()
#plt.savefig('./generated_image.png') 如果你想保存图片，去除这句的注释


 



好了，你现在已经知道如何给图添加边和节点了，接下来是构造环：

画个圈圈

import matplotlib.pyplot as plt
import networkx as nx
# H = nx.path_graph(10) 
# G.add_nodes_from(H)
G = nx.Graph()
G.add_cycle([0,1,2,3,4])
nx.draw(G, with_labels=True)
plt.show()


 



画个五角星

import networkx as nx
import matplotlib.pyplot as plt 
#画图！
G=nx.Graph()
G.add_node(1)
G.add_nodes_from([2,3,4,5])
for i in range(5):
    for j in range(i):
        if (abs(i-j) not in (1,4)):    
            G.add_edge(i+1, j+1)
nx.draw(G, 
        with_labels=True, #这个选项让节点有名称
        edge_color='b', # b stands for blue! 
        pos=nx.circular_layout(G), # 这个是选项选择点的排列方式，具体可以用 help(nx.drawing.layout) 查看
     # 主要有spring_layout  (default), random_layout, circle_layout, shell_layout   
     # 这里是环形排布，还有随机排列等其他方式  
        node_color='r', # r = red
        node_size=1000, # 节点大小
        width=3, # 边的宽度
       )
plt.show()


 



import random
G = nx.gnp_random_graph(10,0.3)
for u,v,d in G.edges(data=True):
    d['weight'] = random.random()

edges,weights = zip(*nx.get_edge_attributes(G,'weight').items())

pos = nx.spring_layout(G)
nx.draw(G, pos, node_color='b', edgelist=edges, edge_color=weights, width=10.0, edge_cmap=plt.cm.Blues)
# plt.savefig('edges.png')
plt.show()


 



加入权重

import matplotlib.pyplot as plt
import networkx as nx

G = nx.Graph()

G.add_edge('a', 'b', weight=0.6)
G.add_edge('a', 'c', weight=0.2)
G.add_edge('c', 'd', weight=0.1)
G.add_edge('c', 'e', weight=0.7)
G.add_edge('c', 'f', weight=0.9)
G.add_edge('a', 'd', weight=0.3)

elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] > 0.5]
esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] <= 0.5]

pos = nx.spring_layout(G)  # positions for all nodes

# nodes
nx.draw_networkx_nodes(G, pos, node_size=700)

# edges
nx.draw_networkx_edges(G, pos, edgelist=elarge,
                       width=6)
nx.draw_networkx_edges(G, pos, edgelist=esmall,
                       width=6, alpha=0.5, edge_color='b', style='dashed')

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

plt.axis('off')
plt.show()


 



有向图

from __future__ import division
import matplotlib.pyplot as plt
import networkx as nx

G = nx.generators.directed.random_k_out_graph(10, 3, 0.5)
pos = nx.layout.spring_layout(G)

node_sizes = [3 + 10 * i for i in range(len(G))]
M = G.number_of_edges()
edge_colors = range(2, M + 2)
edge_alphas = [(5 + i) / (M + 4) for i in range(M)]

nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='blue')
edges = nx.draw_networkx_edges(G, pos, node_size=node_sizes, arrowstyle='->',
                               arrowsize=10, edge_color=edge_colors,
                               edge_cmap=plt.cm.Blues, width=2)
# set alpha value for each edge
for i in range(M):
    edges[i].set_alpha(edge_alphas[i])

ax = plt.gca()
ax.set_axis_off()
plt.show()


 



颜色渐变的节点

import matplotlib.pyplot as plt
import networkx as nx

G = nx.cycle_graph(24)
pos = nx.spring_layout(G, iterations=200)
nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues)
plt.show()


 



颜色渐变的边

import matplotlib.pyplot as plt
import networkx as nx

G = nx.star_graph(20)
pos = nx.spring_layout(G)
colors = range(20)
nx.draw(G, pos, node_color='#A0CBE2', edge_color=colors,
        width=4, edge_cmap=plt.cm.Blues, with_labels=False)
plt.show()


 



如何画一个多层感知机？

import matplotlib.pyplot as plt
import networkx as nx 
left, right, bottom, top, layer_sizes = .1, .9, .1, .9, [4, 7, 7, 2]
# 网络离上下左右的距离
# layter_sizes可以自己调整
import random
G = nx.Graph()
v_spacing = (top - bottom)/float(max(layer_sizes))
h_spacing = (right - left)/float(len(layer_sizes) - 1)
node_count = 0
for i, v in enumerate(layer_sizes):
    layer_top = v_spacing*(v-1)/2. + (top + bottom)/2.
    for j in range(v):
        G.add_node(node_count, pos=(left + i*h_spacing, layer_top - j*v_spacing))
        node_count += 1
# 这上面的数字调整我想了好半天，汗
for x, (left_nodes, right_nodes) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
    for i in range(left_nodes):
        for j in range(right_nodes):
            G.add_edge(i+sum(layer_sizes[:x]), j+sum(layer_sizes[:x+1]))    
# 慢慢研究吧
pos=nx.get_node_attributes(G,'pos')
# 把每个节点中的位置pos信息导出来
nx.draw(G, pos, 
        node_color=range(node_count), 
        with_labels=True,
        node_size=200, 
        edge_color=[random.random() for i in range(len(G.edges))], 
        width=3, 
        cmap=plt.cm.Dark2, # matplotlib的调色板，可以搜搜，很多颜色呢
        edge_cmap=plt.cm.Blues
       )
plt.show()


 



差不多就是这个效果了。

后续我会封装为一个类，加入动态演示，比如通过颜色深浅，显示神经网络在优化的时候权重变化。应该会很好玩，嘿嘿。

上面你也可以改变layer_sizes

比如改为233333

 



调皮了

 



layter_sizes = [2, 3, 4, 5, 5, 4, 3, ] 贼丑了

完。

原文发布时间为：2018-08-06

本文作者：DeepWeaver

本文来自云栖社区合作伙伴“ Python爱好者社区”，了解相关信息可以关注“ Python爱好者社区”

Tensorflow基础知识回顾

对于一个基础tensorflow程序来说，需要了解的东西有：

（1）Placeholder，占位符，实际输入值，用它喂数据；

（2）variable，参数变量，weights和biases要用的是它；

（3）reshape，改变shape的值、维数的。

（4）loss，损失函数，预测值与真实值的差别；

（5）optimizer，优化器，已知有误差了，建立一个优化器，准备对损失函数使用，因为我们的训练目标就是降低误差降到越低越好；

（6）train，训练操作，用上面的优化器，减小误差。也就是降低损失函数。

举个最简单的例子，已知loss=……，optimizer=……，则train的一般写法就是：train = optimizer.minimize(loss)，优化器要做的就是用它的minimize方法把误差最小化。

（7）session，有上述placeholder，variable，reshape，loss，optimizer，train，还有神经网络结构，程序还是不能运行，因为还没有执行session。

       把一个tensorflow程序比作一堆管道部件的话，只能说有上述的变量以后，拼成了一个完整的管道，但却没有水在里面流动。因为我们还没有用session：

#第一种

init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
……
sess.close()


#第二种
init = tf.global_variables_initializer()
with tf.Session() as sess:
    sess.run(init)

#这两种都对，写法很多，越简洁越好

       这样整个神经网络的所有参数才能被激活。

（8）上述知识点中需要注意的地方：

tf.matmul()是矩阵乘法，tf.multiply()是点乘，用variable进行参数计算的时候不要用混；
	
With tf.Session() as sess: 用了python的with语句之后，with里面的内容运行完会自动close()；
	
在sess.run()的运行阶段，只要用到placeholder，就要用feed_dict给placeholder喂数据；
	
tensorflow的一些函数和numpy的有区别，比如tf.linspace和np.linspace，前者精度是tf.float32，后者精度是np.float64；
	
练习顺序：（1）MLP（2）CNN；
	
激活函数activation：作用是给神经元添加非线性因素，让数据能够更好地被分类。因为线性模型的表达能力不够明显。例如，我本人是一个神经元，有一堆狗的照片，我喜欢柯基，当我看到柯基的眼睛的时候，我就非常兴奋（我被柯基的眼睛“激活”了），我的数值就会大幅度提高。因此这只柯基就很好的被分类了。
	
Optimizer都是基于学习率的，这个值不能任意取个0.0001之类的常量就算了。有些函数如SGD，学习率应随着epoch加深而变化，原因可查官网文档。
	
从头学的话先上tensorflow中文社区参考一下基础知识，上面有tensorflow的函数讲解和代码示例: http://www.tensorfly.cn/tfdoc/get_started/introduction.html
	
还有很多，比如激活函数、过拟合、损失函数、优化器、保存、加载，等等都在中文社区里有，有忘记的自己复习巩固就好了。
（9）还有一些bug，需要灵活地解决：

比如写卷积的时候维数不对导致出错，又不熟悉调试，简单粗暴的给每层之后输出一个print(xxx.shape)逐层查看，基本能找到问题所在。
	
比如数据处理的时候，遇到不懂的维数问题，就可以去求助师门其他人，比起自己啃来，会高效很多。因为视频和书里可能会教你如何赋值x=np.random.rand()这种的，但是不会教你具体数据具体处理。
	
还有遇到边界处理方式选择不恰当的，padding=same还是valid的问题，可能是卷积核太大，数据维度太小，卷积网络没跑完，神经元的维数就被卷成负数所致报错。
	
比如OOM……不记得具体报错了，参数过大导致电脑显存不足没办法运行，需要修改batch，那些问题自己遇到时现查尽快解决就好了。
	
比如多GPU处理问题，keras不好写，涉及内存占用和显存不足的，我也有点头大。类似还有很多很多，如果感觉遇到的bug比较经典，也可以写进来发到师门群里。
一．函数

       在tensorflow中使用函数，只要将参数设置好，就能节省很多代码空间，让程序不至于那么冗余复杂。如果仅仅是简单的一个tensorflow程序，肯定不会有多么复杂；但是很极端的说，假如一个tensorflow程序中，需要进行很多很多相同的循环操作，多到让人看不清，那么函数就十分有必要了。举个例子。。。：

1.为什么用函数

       有一个字母表：alphabet = [A, B, C, [D, E, [F, G, H, [I, [J, K……]]]]]，类似一个这样的无穷无尽的列表。现在需要在我们的程序里，把它输出一遍，如果你想硬刚这个列表，那就是得这样写：

for once in alphabet:
       if isinstance(once, list):
              for twice in once:
                     if isinstance(twice, list):
                            for third in twice:
                                   if isinstance(third, list):
                                          for fourth in third:
                                                 # 就到这吧……
                                                 print(fourth)
                                   else:
                                          print(third)
                     else:
                            print(twice)
       else:
              print(once)

       写了四个循环我就受不了了，再多的话肯定这个代码可读性就降为0了，因此，选了这么一个极端的例子说明了函数的重要性（虽然用tensorflow写DNN一般不会用这种数组递归，但是函数还是很有必要的）。

2.函数：加一层卷积

       例如，给一个神经网络写一个CNN的函数：

def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)


def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)


def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

       只要想添加一层卷积层，只要写好卷积核的形状和卷积核数，再直接调用就可以。

W = weight_variable([3, 11, 128, 256]) # patch 3x11, in size 128, out size 256
b = bias_variable([256])
conv = tf.nn.relu(conv2d(x, W) + b)

       （默认步长为1，边界处理方式为same的前提下），只要将w的参数设置好（w在此处也就是filter），就能节省很多代码空间。以后每次加一层卷积，就可以简洁的写出。

3.函数：加一层全连接

def add_layer(inputs, in_size, out_size, activation_function=None,):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b)
return outputs

       设置好参数之后，在Weights中，随机生成一个行×列（in_size×out_size）的矩阵；在biases中，生成一个1×out_size的矩阵，再经过一个激活函数，输出的就是经过全连接并激活的神经元的值。（偏移量的默认值不为0，因此用tf.zeros()生成一个全0的矩阵之后，再随意加一个值即可）

4.函数：加几个多测试的数据集

       当模型训练完成后，如果我想用不同几个文件夹里的数据都测试一遍，就不需要重复写好几遍，只改一个参数的路径。只要写一个测试函数即可：

def compute_accuracy(t_xs, t_ys):
    global prediction
    y_pre = sess.run(prediction, feed_dict={xs: t_xs, keep_prob: 1})
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(t_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    result = sess.run(accuracy, feed_dict={xs: t_xs, ys: t_ys, keep_prob: 1})
    return result


       prediction是神经网络输出的已训练好的最后一层，那么只需要修改参数部分的t_xs和t_ys，就可以直接进行预测。要注意一个地方，只要你sess.run()的参数里面用到了placeholder，哪怕外面没显示，也要feed_dict给它喂数据。测试部分不需要dropout，因此保留全部的运行部分，keep_prob=1。

5.总结

       类似的还有很多，不一一赘述。 有了函数，就可以将它转换成模块，共享给他人使用：

创建一个新文件夹，放入函数所在程序；
	
在其中创建一个setup.py文件，内容包含着有关发布的数据；
	
然后执行python3 setup.py sdist，以构建一个发布文件；
	
再将发布安装到本地，sudo python3 setup.py install。
二．类

1.为什么用类

       用class定义自己的数据结构，可以带来很大的便捷，因为python自己的内置数据结构比较简单，有时候写起来很麻烦。这样的话，自己写自己的class，比较容易对症下药跟自己的数据集匹配得更好。

2.定义类

class Myclass:
              def __init__(self):
                     ……
              ……

       类中每定义一个函数（实际上书上都叫def定义的是类的方法），第一个参数都得是self，因为如果有：

a=Myclass()
b=Myclass()

       执行这两句话的时候，就是执行的Myclass().__init__(a)对应着上面写的定义的def __init__(self):里的self。就是把a赋值给self了。

3.在tensorflow程序中写类

       在tensorflow程序中，在类里每定义一个函数，都要把参数中的第一个参数设置为self，这样才能让数据和它对应的实例联系起来，就不在这再写复杂的代码，只说理论就可以了。这样的好处有很多，很工整是最基础的方面了，还能降低代码复杂性，随着给代码多加功能，这样的做法是最高效的了。

       而且类可以放在python模块中，共享给他人使用。柯老师最近强调过的几次学习到的东西要有效的传递，不能人一毕业了什么都带走了，新同学一点都没留下。这样就有个标准化的规范，有助于新老交替的时候，毕业生能给组里新同学留下一些现成的可以学习的东西，毕竟看代码是学习的一个重要途径，看别人的优秀代码学进自己脑子里，也完全是自己的重大收获。分享是好事。

       如果把类写的足够灵活，将来在其他项目里，总会用到自己的类来完成一些其他用途的。将会大大提升代码规范和节约时间。

三．自定义损失函数

1.传统的损失函数

       传统的损失函数，大家见过最普遍的也就是交叉熵，即cross_entropy，它描述了两个概率分布之间的距离，当交叉熵越小说明二者之间越接近，交叉熵要是为0，他俩基本上就是同一个值了。然后cross_entropy输出的不是概率分布，再一般加一个softmax，把它的值转换为概率。 Tensorflow将cross_entropy与softmax统一封装出来一个函数，实现了softmax后的cross_entropy损失函数：

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(y, y_)

       其中y和y_分别是真实值和预测值。（这也对应了上面第一节的内容，写个函数总能省事一些，减少很多麻烦）

2.自定义损失函数

       自定义损失函数的时候，首先有个关键问题，就是：我宁愿把损失值预估多了，也不愿预估少了。因为少了可能就不准了。损失函数说白了就是真实值和预测值的差值（也可能是大量数据集中所有差值之和，即：∑误差函数=损失函数），因此，损失函数越小，函数预测值就越准，损失函数若为0，预测准确率就是100%。

       先拿网上的一个例子举例：如果我是个卖水果的，想自己动手写一个销量预测的值，我们把预测的销量与实际销量的关系，作为损失函数调整的条件，那么大致得到：

loss = tf.reduce.sum(tf.select(tf.greater(v, v’), a*(v-v’), b*(v-v’)))

       就是比较实际的v和预测出来的v’谁更大。如果v更大，就选择一个常量a，和他们的差相乘a*(v-v’)；如果v’更大，就选择一个常量b，和他们的差相乘b*(v-v’)；a和b的选择不一定能保证他们选出来的乘积为正数。这每个选择出来的值，就是一个误差函数，再把每一次的选择相加求和，即得损失函数loss。

       其实吴恩达的deep learning的课讲自定义损失函数的时候，用的就是同样的这个例子，只不过他讲的特别高大上，换成了“预测多了，预测少了”的两个值，生成了模拟数据集还增加了随机量作为不可预测的噪音。原理一样，得出的结果也一样。他还将损失函数的两个常量对换了一下，结果有显著差异，因此得出结论：对于相同的神经网络，不同的损失函数会对训练出来的模型产生重要的影响。直接截个吴恩达讲这个例子的图：



 

3.在自己的项目中，定义损失函数

       举几个简单例子。

       在我看来效率最低的损失函数，就是0-1损失。感知机用的就是这个损失函数，感知机具体的没有看，只了解了一点皮毛。 

       0-1损失就是，预测正确输出1，预测错误输出0，简单粗暴。还有对数损失，指数损失，均方误差……等等tensorflow自己提供的。

       如果我想自己改进一个，比如将均方误差改成一个四次方误差的：

def myloss(y,y’):
       return sum((y-y’)**4, axis = -1)

      这就是一个最简单的改进完成了。。。后面再用优化器训练它缩小误差，让它越准确越好。

      我们要做到的是在句子级别上、帧级别上都设计损失函数，将项目优化到最佳。这个也是我正在不断学习的地方。

四．自定义复杂网络结构

       自定义复杂网络结构想简要的说一下，这个部分不是有很好的讲解思路，怕误导大家。。。网上有很多现有的复杂网络结构，连代码带可视化plt.show()都输出出来写在网页上，可以清晰的看。如ResNet、MobileNet、DenseNet等等多个版本v1v2v3v4……，它们都有分为清晰的模块，每个conv2d、batchnormalization等操作全部打包成函数，可以直接使用。

       涉及到网络多输入或多输出的时候：多输入add时注意维数要匹配，如果维数不匹配就卷积或者别的操作匹配，全部在后面加0凑维数那种操作是不可取的；多输出还好，如果是两个网络的结果合并输出，如将经过神经网络激活后的输入作为输入的一部分和输入一起输进下一层神经网络中，也要对维数有一个对应；同时在sess.run()的时候，多输入多输出也要注意，feed_dict也不能少喂数据。

       自定义复杂的网络结构时，从0开始逐模块构建，从基本网络结构、loss计算、train_optimizer设计、数据集使用上，是一遍系统的学习，多读些现有的成熟代码，能够提高自己的编码能力。自己也在努力提升自己的水平，希望能够不断刷新知识，不断否定错误，持续进步。

 

代码部分的规范，参考：https://morvanzhou.github.io/

 

 

 

 

 

什么是networkx？
networkx在02年5月产生，是用python语言编写的软件包，便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型、设计新的网络算法、进行网络绘制等。 ——百度百科
我们可以用networkx做什么？
画图
2. 有向图，无向图，网络图……
3. 总之各种图
看到这你是不是心动了呢？今天的教程就是要教会你画出封面上的三层感知机模型图！
Let’s get started!
首先导入networkx和matplotlib模块
import networkx as nx
import matplotlib.pyplot as plt
>>> import networkx as nx
>>> G = nx.Graph() 定义了一个空图
>>> G.add_node(1) 这个图中增加了1节点
>>> G.add_node('A') 增加'A'节点
>>> G.add_nodes_from([2, 3]) 同时加2和3两个节点
>>> G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)])
# 增加这么多条边，在下面有举例
>>> H = nx.path_graph(10)
>>> G.add_nodes_from(H)
>>> G.add_node(H)
G.add_node('a')#添加点a
G.add_node(1,1)#用坐标来添加点
G.add_edge('x','y')#添加边,起点为x，终点为y
G.add_weight_edges_from([('x','y',1.0)])#第三个输入量为权值
#也可以
list = [[('a','b',5.0),('b','c',3.0),('a','c',1.0)]
G.add_weight_edges_from([(list)])
我们来看看上面最后一句是什么意思
import matplotlib.pyplot as plt
import networkx as nx
H = nx.path_graph(10)
G.add_nodes_from(H)
nx.draw(G, with_labels=True)
plt.show()
生成了标号为0到9的十个点！别急，丑是丑了点，一会我们再给他化妆。
#再举个栗子
G=nx.Graph()
#导入所有边，每条边分别用tuple表示
G.add_edges_from([(1,2),(1,3),(2,4),(2,5),(3,6),(4,8),(5,8),(3,7)])
nx.draw(G, with_labels=True, edge_color='b', node_color='g', node_size=1000)
plt.show()
#plt.savefig('./generated_image.png') 如果你想保存图片，去除这句的注释
好了，你现在已经知道如何给图添加边和节点了，接下来是构造环：
画个圈圈
import matplotlib.pyplot as plt
import networkx as nx
# H = nx.path_graph(10)
# G.add_nodes_from(H)
G = nx.Graph()
G.add_cycle([0,1,2,3,4])
nx.draw(G, with_labels=True)
plt.show()
画个五角星
import networkx as nx
import matplotlib.pyplot as plt
#画图！
G=nx.Graph()
G.add_node(1)
G.add_nodes_from([2,3,4,5])
for i in range(5):
for j in range(i):
if (abs(i-j) not in (1,4)):
G.add_edge(i+1, j+1)
nx.draw(G,
with_labels=True, #这个选项让节点有名称
edge_color='b', # b stands for blue!
pos=nx.circular_layout(G), # 这个是选项选择点的排列方式，具体可以用 help(nx.drawing.layout) 查看
# 主要有spring_layout (default), random_layout, circle_layout, shell_layout
# 这里是环形排布，还有随机排列等其他方式
node_color='r', # r = red
node_size=1000, # 节点大小
width=3, # 边的宽度
)
plt.show()
import random
G = nx.gnp_random_graph(10,0.3)
for u,v,d in G.edges(data=True):
d['weight'] = random.random()
edges,weights = zip(*nx.get_edge_attributes(G,'weight').items())
pos = nx.spring_layout(G)
nx.draw(G, pos, node_color='b', edgelist=edges, edge_color=weights, width=10.0, edge_cmap=plt.cm.Blues)
# plt.savefig('edges.png')
plt.show()
加入权重
import matplotlib.pyplot as plt
import networkx as nx
G = nx.Graph()
G.add_edge('a', 'b', weight=0.6)
G.add_edge('a', 'c', weight=0.2)
G.add_edge('c', 'd', weight=0.1)
G.add_edge('c', 'e', weight=0.7)
G.add_edge('c', 'f', weight=0.9)
G.add_edge('a', 'd', weight=0.3)
elarge = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] > 0.5]
esmall = [(u, v) for (u, v, d) in G.edges(data=True) if d['weight'] <= 0.5]
pos = nx.spring_layout(G)  # positions for all nodes
# nodes
nx.draw_networkx_nodes(G, pos, node_size=700)
# edges
nx.draw_networkx_edges(G, pos, edgelist=elarge,
width=6)
nx.draw_networkx_edges(G, pos, edgelist=esmall,
width=6, alpha=0.5, edge_color='b', style='dashed')
# labels
nx.draw_networkx_labels(G, pos, font_size=20, font_family='sans-serif')
plt.axis('off')
plt.show()
有向图
from __future__ import division
import matplotlib.pyplot as plt
import networkx as nx
G = nx.generators.directed.random_k_out_graph(10, 3, 0.5)
pos = nx.layout.spring_layout(G)
node_sizes = [3 + 10 * i for i in range(len(G))]
M = G.number_of_edges()
edge_colors = range(2, M + 2)
edge_alphas = [(5 + i) / (M + 4) for i in range(M)]
nodes = nx.draw_networkx_nodes(G, pos, node_size=node_sizes, node_color='blue')
edges = nx.draw_networkx_edges(G, pos, node_size=node_sizes, arrowstyle='->',
arrowsize=10, edge_color=edge_colors,
edge_cmap=plt.cm.Blues, width=2)
# set alpha value for each edge
for i in range(M):
edges[i].set_alpha(edge_alphas[i])
ax = plt.gca()
ax.set_axis_off()
plt.show()
颜色渐变的节点
import matplotlib.pyplot as plt
import networkx as nx
G = nx.cycle_graph(24)
pos = nx.spring_layout(G, iterations=200)
nx.draw(G, pos, node_color=range(24), node_size=800, cmap=plt.cm.Blues)
plt.show()
颜色渐变的边
import matplotlib.pyplot as plt
import networkx as nx
G = nx.star_graph(20)
pos = nx.spring_layout(G)
colors = range(20)
nx.draw(G, pos, node_color='#A0CBE2', edge_color=colors,
width=4, edge_cmap=plt.cm.Blues, with_labels=False)
plt.show()
如何画一个多层感知机？
import matplotlib.pyplot as plt
import networkx as nx
left, right, bottom, top, layer_sizes = .1, .9, .1, .9, [4, 7, 7, 2]
# 网络离上下左右的距离
# layter_sizes可以自己调整
import random
G = nx.Graph()
v_spacing = (top - bottom)/float(max(layer_sizes))
h_spacing = (right - left)/float(len(layer_sizes) - 1)
node_count = 0
for i, v in enumerate(layer_sizes):
layer_top = v_spacing*(v-1)/2. + (top + bottom)/2.
for j in range(v):
G.add_node(node_count, pos=(left + i*h_spacing, layer_top - j*v_spacing))
node_count += 1
# 这上面的数字调整我想了好半天，汗
for x, (left_nodes, right_nodes) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])):
for i in range(left_nodes):
for j in range(right_nodes):
G.add_edge(i+sum(layer_sizes[:x]), j+sum(layer_sizes[:x+1]))
# 慢慢研究吧
pos=nx.get_node_attributes(G,'pos')
# 把每个节点中的位置pos信息导出来
nx.draw(G, pos,
node_color=range(node_count),
with_labels=True,
node_size=200,
edge_color=[random.random() for i in range(len(G.edges))],
width=3,
cmap=plt.cm.Dark2, # matplotlib的调色板，可以搜搜，很多颜色呢
edge_cmap=plt.cm.Blues
)
plt.show()
差不多就是这个效果了。
后续我会封装为一个类，加入动态演示，比如通过颜色深浅，显示神经网络在优化的时候权重变化。应该会很好玩，嘿嘿。
上面你也可以改变layer_sizes
比如改为233333
调皮了
layter_sizes = [2, 3, 4, 5, 5, 4, 3, ] 贼丑了
完。

简单结构通过连接形成复杂网络

简单结构

单一个体，遵循相同的连接规律，拥有相同的功能

比如 单个的蜜蜂，路由器，人...

 

复杂网络

由简单结构形成的整体，

复杂网络形成的条件，机理往往是相同的，

所以复杂网络的模式相似，如股票下跌与雪崩的模式类似，鸟群与鱼群相似...

因为由大量的简单结构组成，因此复杂网络作为一个整体，内部十分复杂，没有人知道网络内部是如何连接的

所以往往只关注相关性，而不关注因果，比如下雨天苹果卖得好，但谁也不知道为什么（瞎编的例子）

 

连接规则

连接规则可能决定复杂网络的特性。

 

复杂网络的特性



上图，

每个点大概率只与身边的点相连接，

很少的概率可以突破距离的限制，与其他圈子内的点相连。

 

假设我们赋予这张图意义，用一个点代表一个人，

则图中表示了，每个人与他身边的人联系概率较大，和远离他圈子的人联系概率较少。

 

这里产生出了一个问题：为什么每个点联系的机率不一样大？

如果联系概率一样大的话，就代表一个人的朋友应该平均分布在世界各地。这显然是不对滴。

我们与他人建立连接的机会是不平均的。

也就是说我们建立一个连接是有难度的，距离就是一个很好的度量，

距离越长，连接的困难越大，这就是距离的作用。

 

建立长的连接难，建立短的连接易

运用这个特点，我们几乎可以分析或预测所有有关网络的事情。

 

比如说一个国家的产业升级，

如果大量的连接分布在原材料出口，橡胶，石油....，则这个国家很难进入到现代化社会，

产业链难以进行较大的转移，很大概率会在相近的领域不断徘徊，给再长的时间也非常困难，

除非有外力破坏原有连接，从而使连接重组，产生新的连接。

这也证实了为什么人需要不断面对挑战来提升自己，就是接受外力的破坏，从而使思想达到连接的重组。

同时也说明了起点很重要，有些事一旦规划好在想转型就非常困难。