【北京大学】7 TensorFlow1.x的神经网络模块设计思想举例及实现

╰半橙微兮° 2022-12-29 04:37 150阅读 0赞

### 目录 ###

*  1 第一个文件forward.py
 *  2 第二个文件backward.py
 *  3 模块化设计网络举例
 *   *  （1）生成数据集generateds.by
     *  （2）前向传播 forward.py，设计了神经网络结构
     *  （3）反向传播 backward.py
 *  相关笔记

# 1 第一个文件forward.py #

放前向传播的函数，前向传播就是搭建网络结构，设计网络结构。一般需要包含三个函数

#定义前向传播过程
    def forward(x,regularizer):
        w = 
        b = 
        y = 
        return y
    #给权重赋初值
    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

# 2 第二个文件backward.py #

反向传播就是训练网络，优化网络参数，该文件可以包含损失函数、指数衰减学习率、滑动平均

def backard():
        x = tf.placeholder()
        y = tf.placeholder()
        y = forward.forward(x,REGULARIZER)
        global_step = tf.Variable(0,trainable =False)
        loss = 
    ## 损失函数
    #loss第一种是一般求差值的loss，一种是交叉熵的loss，另一种是正则化的loss
    #loss_mse = tf.reduce_mean(tf.square(y-y_))# 一般loss
    #loss_ce = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y,labels = tf.argmax(y_,1)))# 交叉熵
    #loss_total = loss_mse + tf.add_n(tf.get_collection('losses'))# 正则化的loss
    ## 指数衰减学习率
    learning_rate = tf.train.exponential_decay(
            LEARNING_RATE_BASE,
        global_step,
        #数据集总样本数/Batch_size
        LEARNING_RATE_DECAY,
        staircase =True
    )
    #定义反向传播方法
    train_step = tf.train.AdamOptimizer(0.0001).minimize(loss，global_step =global_step)
    ## 滑动平均
    ema = tf.train.ExponentialMovingAverage(衰减率MOVING_AVERAGE_DECAY, 当前轮数global_step)#滑动平均
    ema_op = ema.apply(tf.trainable_variables())#每运行此句，所有待优化的参数求滑动平均
    # 通常我们把滑动平均与训练过程绑定在一起，使它们合成一个训练节点。如下所示
    with tf.control_dependencies([train_step,ema_op]):
        train_op = tf.no_op(name='train')
        
    with tf.Session() as sess:
        init_op = tf.global_variables_initializer()#初始化
        sess.run(init_op)#初始化
        STEPS = 3000 # 定义轮数
        for i in range(STEPS):#三千轮
            start = (i*BATCH_SIZE) % 32  #8个数据 为一个数据块输出
            end = (i*BATCH_SIZE) % 32 + BATCH_SIZE  #[i:i+8]
            sess.run(train_step, feed_dict={ x: X[start:end], y_: Y[start:end]})#训练
    if __name__ = '__main__':
        backward()

# 3 模块化设计网络举例 #

数据X\[x0,x1\]为正态分布随机点，标注Y\_当时y\_= 1(标记为红色)，其余y\_=0(标记未蓝色)。代码按照模块分为三个文件。

## （1）生成数据集generateds.by ##

#coding:utf-8
    #生成模拟数据集
    import numpy as np
    import matplotlib.pyplot as plt
    seed = 2 
    def generateds():
        #基于seed产生随机数
        rdm = np.random.RandomState(seed)
        #随机数返回300行2列的矩阵，表示300组坐标点（x0,x1）作为输入数据集
        X = rdm.randn(300,2)
        #从X这个300行2列的矩阵中取出一行,判断如果两个坐标的平方和小于2，给Y赋值1，其余赋值0
        #作为输入数据集的标签（正确答案）
        Y_ = [int(x0*x0 + x1*x1 <2) for (x0,x1) in X]
        #遍历Y中的每个元素，1赋值'red'其余赋值'blue'，这样可视化显示时人可以直观区分
        Y_c = [['red' if y else 'blue'] for y in Y_]#对应颜色Y_c
        #对数据集X和标签Y进行形状整理，第一个元素为-1表示跟随第二列计算，第二个元素表示多少列，可见X为两列，Y为1列
        X = np.vstack(X).reshape(-1,2)#整理形状
        Y_ = np.vstack(Y_).reshape(-1,1)#整理形状
        
        return X, Y_, Y_c
        
    #print X
    #print Y_
    #print Y_c
    #用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0，x1），用各行Y_c对应的值表示颜色（c是color的缩写） 
    #plt.scatter(X[:,0], X[:,1], c=np.squeeze(Y_c)) 
    #plt.show()

## （2）前向传播 forward.py，设计了神经网络结构 ##

#coding:utf-8
    #前向传播就是搭建网络
    import tensorflow as tf
    #定义神经网络的输入、参数和输出，定义前向传播过程 
    def get_weight(shape, regularizer):#（shape：W的形状，regularizer正则化）
        w = tf.Variable(tf.random_normal(shape), dtype=tf.float32)#赋初值，正态分布权重
        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))#把正则化损失加到总损失losses中
        return w#返回w
    #tf.add_to_collection(‘list_name’, element)：将元素element添加到列表list_name中
    def get_bias(shape):  #偏执b
        b = tf.Variable(tf.constant(0.01, shape=shape)) #偏执b=0.01
        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
    #0导入模块 ，生成模拟数据集
    import tensorflow as tf
    import numpy as np
    import matplotlib.pyplot as plt
    import opt4_8_generateds
    import opt4_8_forward
    STEPS = 40000
    BATCH_SIZE = 30 
    LEARNING_RATE_BASE = 0.001
    LEARNING_RATE_DECAY = 0.999
    REGULARIZER = 0.01#正则化
    def backward():#反向传播
        x = tf.placeholder(tf.float32, shape=(None, 2))#占位
        y_ = tf.placeholder(tf.float32, shape=(None, 1))#占位
        #X：300行2列的矩阵。Y_:坐标的平方和小于2，给Y赋值1，其余赋值0
        X, Y_, Y_c = opt4_8_generateds.generateds()
        
        y = opt4_8_forward.forward(x, REGULARIZER)#前向传播计算后求得输出y
        
        global_step = tf.Variable(0,trainable=False)#轮数计数器 
        #指数衰减学习率
        learning_rate = tf.train.exponential_decay(
            LEARNING_RATE_BASE,#学习率
            global_step,#计数
            300/BATCH_SIZE,
            LEARNING_RATE_DECAY,#学习衰减lü
            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(learning_rate).minimize(loss_total)
        with tf.Session() as sess:
            init_op = tf.global_variables_initializer()#初始化
            sess.run(init_op)#初始化
            for i in range(STEPS):
                start = (i*BATCH_SIZE) % 300
                end = start + BATCH_SIZE#3000轮
                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 steps, loss is: %f" %(i, loss_v))
            xx, yy = np.mgrid[-3:3:.01, -3:3:.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()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTY5Ng_size_16_color_FFFFFF_t_70_pic_center]

# 相关笔记 #

以下所有源码以及更详细PDF笔记请在github下载  
[TensorFolwNotebook-from-Peking-University][]

1.  [【北京大学】1 TensorFlow1.x中Python基础知识][1 TensorFlow1.x_Python]
2.  [【北京大学】2 TensorFlow1.x的张量、计算图、会话][2 TensorFlow1.x]
3.  [【北京大学】3 TensorFlow1.x的前向传播推导与实现][3 TensorFlow1.x]
4.  [【北京大学】4 TensorFlow1.x的反向传播推导与实现][4 TensorFlow1.x]
5.  [【北京大学】5 TensorFlow1.x的损失函数和交叉熵举例讲解及实现][5 TensorFlow1.x]
6.  [【北京大学】6 TensorFlow1.x的学习率、滑动平均和正则化实例及实现][6 TensorFlow1.x]
7.  [【北京大学】7 TensorFlow1.x的神经网络模块设计思想举例及实现][7 TensorFlow1.x]
8.  [【北京大学】8 TensorFlow1.x的Mnist数据集实例实现][8 TensorFlow1.x_Mnist]
9.  [【北京大学】9 TensorFlow1.x的实现自定义Mnist数据集][9 TensorFlow1.x_Mnist]
10. [【北京大学】10 TensorFlow1.x的卷积神经网络(CNN)相关基础知识][10 TensorFlow1.x_CNN]
11. [【北京大学】11 TensorFlow1.x的卷积神经网络模型Lenet5实现][11 TensorFlow1.x_Lenet5]
12. [【北京大学】12 TensorFlow1.x的卷积神经网络模型VGGNet实现][12 TensorFlow1.x_VGGNet]
13. [【北京大学】13 TensorFlow1.x的项目实战之手写英文体识别OCR技术][13 TensorFlow1.x_OCR]
14. [【北京大学】14 TensorFlow1.x的二值神经网络实现MNIST数据集手写数字识别][14 TensorFlow1.x_MNIST]
15. [【北京大学】15 TensorFlow1.x的项目实战之人脸表情识别][15 TensorFlow1.x]
16. [【北京大学】16 TensorFlow1.x的项目实战之图像风格融合与快速迁移][16 TensorFlow1.x]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTY5Ng_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/40a7b4f6072c4d95a414b3a285189d23.png
[TensorFolwNotebook-from-Peking-University]: https://github.com/823316627bandeng/-TensorFolwNotebook-from-Peking-University
[1 TensorFlow1.x_Python]: https://betterbench.blog.csdn.net/article/details/111400935
[2 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111401620
[3 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111407104
[4 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111407700
[5 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111409255
[6 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111410367
[7 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111410935
[8 TensorFlow1.x_Mnist]: https://betterbench.blog.csdn.net/article/details/111414788
[9 TensorFlow1.x_Mnist]: https://betterbench.blog.csdn.net/article/details/111480327
[10 TensorFlow1.x_CNN]: https://betterbench.blog.csdn.net/article/details/111495960
[11 TensorFlow1.x_Lenet5]: https://betterbench.blog.csdn.net/article/details/111499496
[12 TensorFlow1.x_VGGNet]: https://betterbench.blog.csdn.net/article/details/111516848
[13 TensorFlow1.x_OCR]: https://betterbench.blog.csdn.net/article/details/111567501
[14 TensorFlow1.x_MNIST]: https://betterbench.blog.csdn.net/article/details/111590573
[15 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111594356
[16 TensorFlow1.x]: https://betterbench.blog.csdn.net/article/details/111641487