[ MOOC课程学习 ] 人工智能实践:Tensorflow笔记_CH4_5 模块化搭建神经网络

模块化搭建神经网络

  1. 前向传播:由输入到输出,搭建完整的网络结构,描述前向传播的过程需要定义三个函数:

    (1) 第一个函数 forward()完成网络结构的设计,从输入到输出搭建完整的网络结构,实现前向传播过程。
    该函数中,参数 x 为输入,regularizer 为正则化权重,返回值为预测或分类结果 y。

    def forward(x, regularizer):
        w=
        b=
        y=
        return y

    (2) 第二个函数 get_weight()对参数 w 设定。
    该函数中,参数 shape 表示参数 w 的形状,regularizer表示正则化权重,返回值为参数 w。
    其中,tf.variable()给 w 赋初值,tf.add_to_collection()表示将参数 w 正则化损失加到总损失 losses 中。

    def get_weight(shape, regularizer):
        w = tf.Variable()
        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
        return w

    (3) 第三个函数 get_bias()对参数 b 进行设定。
    该函数中,参数 shape 表示参数 b 的形状,返回值为参数b。
    其中,tf.variable()表示给 b 赋初值。

    def get_bias(shape):
        b = tf.Variable()
        return b
  2. 反向传播:训练网络,优化网络参数,提高模型准确性。
    函数 backward()中, placeholder()实现对数据集 x 和标准答案 y_占位, forward.forward()实现前向传播的网络结构,参数 global_step 表示训练轮数,设置为不可训练型参数。

    def backward( ):
        x = tf.placeholder()
        y_ = tf.placeholder()
        y = forward.forward(x, REGULARIZER)
        global_step = tf.Variable(0, trainable=False)
        loss =

    注意:在训练网络模型时,常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。其中,滑动平均和指数衰减学习率中的 global_step 为同一个参数。

  3. 例如:在前一篇文章的例子中,我们加入指数衰减学习率优化效率,加入正则化提高泛化性,并使用模块化设计方法,把红色点和蓝色点分开。
    代码总共分为三个模块 : 生成数据集(generateds.py) 、 前向传播 (forward.py) 、 反向传播(backward.py)。
    (1) generateds.py

    
    #coding:utf-8
    
    import numpy as np
    
    SEED = 2
    
    def generateds():
        rdm = np.random.RandomState(SEED)
        X = rdm.randn(300, 2)
        Y_ = [int(xi[0]*xi[0] + xi[1]*xi[1] < 2) for xi in X]
        Y_c = [['red' if yi else 'blue'] for yi in Y_]
    
        X = np.vstack(X).reshape(-1, 2)
        Y_ = np.vstack(Y_).reshape(-1, 1)
    
        return X, Y_, Y_c

    (2) forward.py

    
    #coding:utf-8
    
    import tensorflow as tf
    
    def get_weight(shape, regularizer):
        w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
        return w
    
    def get_bias(shape):
        b = tf.Variable(tf.constant(0.01, shape=shape))
        return b
    
    def forward(x, regularizer):
        w1 = get_weight([2, 11], regularizer)
        b1 = get_bias([11])
        y1 = tf.nn.relu(tf.matmul(x, w1) + b1)
    
        w2 = get_weight([11, 1], regularizer)
        b2 = get_bias([1])
        y = tf.matmul(y1, w2) + b2
    
        return y

    (3) backward.py

    
    #coding:utf-8
    
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import generateds
    import forward
    
    DATA_NUM = 300
    BATCH_SIZE = 30
    REGULARIZER = 0.01
    LR = 0.001
    LR_DECAY_STEPS = DATA_NUM // BATCH_SIZE
    LR_DECAY_RATE = 0.999
    
    STEPS = 40000
    
    def backward():
        x = tf.placeholder(tf.float32, [None, 2])
        y_ = tf.placeholder(tf.float32, [None, 1])
    
        global_step = tf.Variable(0, trainable=False)
    
        X, Y_, Y_c = generateds.generateds()
        y = forward.forward(x, REGULARIZER)
    
        lr = tf.train.exponential_decay(
            learning_rate = LR,
            global_step = global_step,
            decay_steps = LR_DECAY_STEPS,
            decay_rate = LR_DECAY_RATE,
            staircase = True
        )
    
        loss_mse = tf.reduce_mean(tf.square(y-y_))
        loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))
        train_step = tf.train.AdamOptimizer(lr).minimize(loss_total, global_step)
    
    
    
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            for i in range(STEPS):
                start = (i*BATCH_SIZE) % 300
                end = min(start+BATCH_SIZE, 300)
                sess.run(train_step, feed_dict={x:X[start:end], y_:Y_[start:end]})
                if i % 2000 == 0:
                    loss_v = sess.run(loss_total, feed_dict={x:X, y_:Y_})
                    print('After %d stpes, loss is: %f' % (i, loss_v))
    
            xx, yy = np.mgrid[-3:3:0.01, -3:3:0.01]
            grid = np.c_[xx.ravel(), yy.ravel()]
            probs = sess.run(y, feed_dict={x: grid})
            probs = probs.reshape(xx.shape)
    
        plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c))
        plt.contour(xx, yy, probs, levels=[.5])
        plt.show()
    
    if __name__ == '__main__':
        backward()
    

    运行结果图:
    [ MOOC课程学习 ] 人工智能实践:Tensorflow笔记_CH4_5 模块化搭建神经网络_第1张图片

你可能感兴趣的:(tensorflow,tensorflow)