精华内容
下载资源
问答
  • 基于复杂网络结构熵的聚散节点演化问题的研究,郝军军,郝五零,本文通过构造一个通用的蜘蛛网网络模型,并通过调节相应的参数使复杂网络拓扑结构不断地演化,使用网络结构熵定量地显示了这些演
  • 摘要: Python复杂网络结构可视化——matplotlib+networkx 什么是networkx? networkx在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化...

    原文链接

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

    什么是networkx?

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

    我们可以用networkx做什么?

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

    1.画图

     

    image

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

     

    image

    3.总之各种图

     

    image

     

    image

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

    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()
    

     

    image

    生成了标号为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') 如果你想保存图片,去除这句的注释
    

     

    image

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

    画个圈圈

    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()
    

     

    image

    画个五角星

    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()
    

     

    image

    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()
    

     

    image

    加入权重

    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()
    

     

    image

    有向图

    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()
    

     

    image

    颜色渐变的节点

    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()
    

     

    image

    颜色渐变的边

    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()
    

     

    image

    如何画一个多层感知机?

    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()
    

     

    image

    差不多就是这个效果了。

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

    上面你也可以改变layer_sizes

    比如改为233333

     

    image

    调皮了

     

    image

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

    完。

    原文发布时间为:2018-08-06
    本文作者:DeepWeaver
    本文来自云栖社区合作伙伴“ Python爱好者社区”,了解相关信息可以关注“ Python爱好者社区

    展开全文
  • (7)session,有上述placeholder,variable,reshape,loss,optimizer,train,还有神经网络结构,程序还是不能运行,因为还没有执行session。  把一个tensorflow程序比作一堆管道部件的话,只能说有上述的...

    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.总结

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

    1. 创建一个新文件夹,放入函数所在程序;
    2. 在其中创建一个setup.py文件,内容包含着有关发布的数据;
    3. 然后执行python3 setup.py sdist,以构建一个发布文件;
    4. 再将发布安装到本地,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在02年5月产生,是用python语言编写的软件包,便于用户对复杂网络进行创建、操作和学习。利用networkx可以以标准化和非标准化的数据格式存储网络、生成多种随机网络和经典网络、分析网络结构、建立网络模型...

    什么是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, ] 贼丑了

    完。

    展开全文
  • 复杂网络拓扑结构的研究复杂网络拓扑结构的研究复杂网络拓扑结构的研究复杂网络拓扑结构的研究复杂网络拓扑结构的研究
  • 基于股票价格波动序列的相关特性,通过阈值化处理得到金融网络的连接矩阵,并用复杂网络的特征参量表征其网络性质。节点累积度分布的胖尾特征表明存在少数中心节点的股票,而聚类系数和最紧邻平均度表征金融网络具有...
  • 复杂网络研究学者提供一些基础性代码,主要是说明在复杂网络中社团结构的形成与识别。
  • 简单结构复杂网络

    2019-08-18 23:48:26
    简单结构通过连接形成复杂网络 简单结构 单一个体,遵循相同的连接规律,拥有相同的功能 比如 单个的蜜蜂,路由器,人... 复杂网络 由简单结构形成的整体, 复杂网络形成的条件,机理往往是相同的, 所以...

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

    简单结构

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

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

     

    复杂网络

    由简单结构形成的整体,

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

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

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

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

     

    连接规则

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

     

    复杂网络的特性

    上图,

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

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

     

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

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

     

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

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

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

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

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

     

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

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

     

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

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

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

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

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

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

     

     

     

     

     

    展开全文
  • 复杂网络结构的复杂性以及节点行为的多样性等因素,使得分数阶复杂网络的同步与控制研究得到了国内外研究者的广泛关注。讨论了异结构分数阶复杂网络的同步问题。应用自适应控制方法设计出一类非常简单的控制器。基于...
  • nbspJava复杂网络的社区结构.pdf14页本文档一共被下载:次,您可全文免费在线阅读后下载本文档。 下载提示1.本站不保证该用户上传的文档完整性,不预览、不比对内容而直接下载产生的反悔问题本站不予受理。2.该文档...
  • 复杂网络的社区结构

    2013-04-15 12:34:28
    社区结构作为真实复杂网络所普遍具有的一个重要拓扑特性,在最近10年 内得到了广泛而深入的研究。回顾了近几年国内外社区结构研究的主要进展,重 点介绍社区发现的研究历程和研究成果,并结合社会计算的背景展望了社区...
  • 基于边密度的复杂网络社区结构划分方法
  • 发现网络中的社团结构有助于更好地理解网络结构和分析网络属性。通过定义边的聚类系数和基于局部信息的方法,提出了一种寻找复杂网络中社团结构的算法。该算法首先在网络的剩余节点中寻找度最大的节点,然后利用该...
  • 复杂网络拓扑结构中特定属性的计算和评估进行了研究。层次分析法和熵权法被用来计算复杂网络拓扑结构的权重,这样既可以防止在主观赋权法上因专家经验不足使得对方案的排序造成很大的随意性,又可以避免客观赋权法...
  • 06 社团结构 6.1社团结构研究的意义 6.2社团结构的定义 6.3检验划分算法的网络及划分结果比较 6.4社团划分探测算法 6.5Q函数及其优化算法 6.6重叠社团的划分算法 ...社团结构是中观尺度网络性质的体
  • 具有随机拓扑结构复杂网络的随机稳定
  • 我们研究了基于不同边缘攻击的复杂网络结构脆弱性。 根据引入的四种加权方法策略,通过去除一定比例的边缘来引发攻击,这些策略也可以描述链接的特征。 测量了两个指标(网络中巨型组件的相对大小,最短路径的平均...
  • 复杂网络中反社区结构的定量测量和方法
  • 论文研究-复杂网络结构功能性质及其应用.pdf,
  • 复杂网络社区结构划分方法

    千次阅读 2009-11-02 17:46:00
    复杂网络社区结构划分方法 随着对网络性质的物理意义和数学特性的深入研究,人们发现许多实际网络都具有一个共同性质,即社区结构。也就是说,整个网络是由若干个“社区”或“组”构成的。每个社区内部的结点间的...
  • 基于复杂网络社区划分的网络拓扑结构可视化布局算法
  • 研究采用脉冲方法实现复杂网络的混沌同步问题,考察了脉冲信号作用下复杂网络的稳定性,推导出稳定性判定定理,以判断能否用脉冲信号实现复杂网络的脉冲同步.研究得到:脉冲信号作用下复杂网络稳定性判定定理,并通过4个...
  • 网络簇结构复杂网络最普遍和最重要的拓扑属性之一,网络聚类问题就是要找出给定网络中的所有类簇.有很多实际应用问题可被建模成网络聚类问题.尽管目前已有许多网络聚类方法被提出,但如何进一步提高聚类精度,特别是...
  • 论文研究-基于共邻矩阵的复杂网络社区结构划分方法.pdf, 提出了一种基于共邻矩阵和增益函数的划分算法来发现复杂网络中的社区结构.共邻矩阵中元素的含义为结点对之间...
  • 复杂网络一般具有随机、小世界、无标度、超小世界、社区结构、分形结构等。依据这些特征将复杂网络分为随机网络、小世界网络、无标度网络、超小世界网络、社区网络、分形网络等。 1.2.1 随机网络 1959年Erdos和...
  • 基于社区结构复杂网络双曲映射,晋凤东,王祖喜,网络隐藏的双曲几何为复杂网络研究提供了一个新的视角。如何将网络映射至双曲空间是网络双曲几何研究的重要问题。现有的双曲映射
  • 许多标准图算法 网络结构与分析措施 经典图,随机图和合成网络的生成器 节点可以是“任何东西”(例如,文本,图像,XML记录) 边可以保存任意数据(例如权重,时间序列) 开源3条款BSD许可证 经过良好测试,代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,960
精华内容 3,184
关键字:

复杂网络结构