Tensorflow笔记—4—神经网络搭建之反向传播

一. 回顾与扩充

搭建神经网络的八股

• 先回顾神经网络的实现过程，可以总结出神经网络的搭建分4步：
  • 1.准备数据集
  • 2.前向传播
  • 3.反向传播
  • 4.迭代更新

回顾一下神经网络的实现过程

• 1.准备数据，提取特征，作为输入喂给神经网络
• 2.搭建神经网络结构，从输入到输出（先搭建计算图，再用会话执行）
  （NN前向传播算法===>计算输出）
• 3.大量特征数据喂给NN，迭代优化NN参数
  （NN反向传播算法===>优化参数训练模型）
• 4.使用训练好的模型，预测和分类

二. 反向传播

2.1 反向传播概念：

• 训练模型参数，在所有参数上用梯度下降，使用神经网络模型在训练数据上的损失函数loss最小

2.2 损失函数：（loss）

• 计算得到的预测值 y 与已知答案 y_ 差距
• 损失函数的计算有很多方法，均方误差MSE是比较常用的方法之一

2.3 均方误差：

• 求前向传播计算结果与已知答案之差的平方再求平均
  
• 用 Tensorflow 函数表示：
  • loss = tf.reduce_mean(tf.square(y-y_))

2.4 反向传播训练方法：

• 以减小 loss 值为优化目标，有梯度下降，moment 优化器，adm 优化器等优化方法
• 这三种优化方法分别是：

train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)    #minimize() 函数处理了梯度计算和参数更新两个操作
#train_step = tf.train.MomentumOptimizer(0.001, 0.9).minimize(loss)     #在更新参数时，利用了超参数
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss)         #是利用自适应学习率的优化算法，Adam 算法和随机梯度下降算法不同

2.5具体代码演示：

随机产生 32 组生产出的零件的体积和重量，训练 3000 轮，每 500 轮输出一次损失函数loss

import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
seed = 23455

#基于seed产生随机数
rng = np.random.RandomState(seed)
#随机数返回32行2列的矩阵  表示32组   体积和重量   作为输入数据集
X = rng.rand(32, 2)
#从X这个32行2列的矩阵中 取出一行 判断如果和小于1 给Y赋值1 如果和不小于1 给Y赋值0
#作为输入数据集的标签（正确答案）
Y = [[int(x0 + x1 < 1)] for (x0, x1) in X]
print("X:", X)
print("Y:", Y)

#定义神经网络的输入、参数和输出，定义前向传播过程
x = tf.placeholder(tf.float32, shape=(None, 2))     #N*2
y_ = tf.placeholder(tf.float32, shape=(None, 1))    #N*1,正确答案

w1 = tf.Variable(tf.random_normal([2, 3], stddev=1, seed=1))    #2*3，随机生成
w2 = tf.Variable(tf.random_normal([3, 1], stddev=1, seed=1))    #3*1，随机生成

a = tf.matmul(x, w1)    #N*3
y = tf.matmul(a, w2)    #N*1，预测答案

#定义损失函数（优化函数）以及反向传播方法
# 定义损失函数为MSE(均方误差)，反向传播方法为梯度下降，使参数沿着梯度的反方向，即总损失减小的方向移动，实现更新参数
loss = tf.reduce_mean(tf.square(y-y_))  #预测答案-正确答案
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)    #minimize() 函数处理了梯度计算和参数更新两个操作
#train_step = tf.train.MomentumOptimizer(0.001, 0.9).minimize(loss)     #在更新参数时，利用了超参数
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss)         #是利用自适应学习率的优化算法，Adam 算法和随机梯度下降算法不同

#生成会话，训练STEPS轮
with tf.Session()as sess:
    #初始化参数
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    #输出目前（未经训练）的参数取值，随机生成
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))
    
    #训练模型，最关键步骤
    STEPS = 6000   #迭代次数
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = start + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})     #喂数据，不断更新参数
        if i % 500 == 0:    #每迭代500次输出一次结果  损失函数loss在所有训练集上的损失值
            total_loss = sess.run(loss, feed_dict={x: X, y_: Y})    
            print("After %d training step(s), loss on all data is %g" % (i, total_loss))
    #输出训练后的参数取值
    print("\n")
    print("w1:\n", sess.run(w1))
    print("w2:\n", sess.run(w2))

运行结果：

X: [[0.83494319 0.11482951]
 [0.66899751 0.46594987]
 [0.60181666 0.58838408]
 [0.31836656 0.20502072]
 [0.87043944 0.02679395]
 [0.41539811 0.43938369]
 [0.68635684 0.24833404]
 [0.97315228 0.68541849]
 [0.03081617 0.89479913]
 [0.24665715 0.28584862]
 [0.31375667 0.47718349]
 [0.56689254 0.77079148]
 [0.7321604  0.35828963]
 [0.15724842 0.94294584]
 [0.34933722 0.84634483]
 [0.50304053 0.81299619]
 [0.23869886 0.9895604 ]
 [0.4636501  0.32531094]
 [0.36510487 0.97365522]
 [0.73350238 0.83833013]
 [0.61810158 0.12580353]
 [0.59274817 0.18779828]
 [0.87150299 0.34679501]
 [0.25883219 0.50002932]
 [0.75690948 0.83429824]
 [0.29316649 0.05646578]
 [0.10409134 0.88235166]
 [0.06727785 0.57784761]
 [0.38492705 0.48384792]
 [0.69234428 0.19687348]
 [0.42783492 0.73416985]
 [0.09696069 0.04883936]]
Y: [[1], [0], [0], [1], [1], [1], [1], [0], [1], [1], [1], [0], [0], [0], [0], [0], [0], [1], [0], [0], [1], [1], [0], [1], [0], [1], [1], [1], [1], [1], [0], [1]]
w1:
 [[-0.8113182   1.4845988   0.06532937]
 [-2.4427042   0.0992484   0.5912243 ]]
w2:
 [[-0.8113182 ]
 [ 1.4845988 ]
 [ 0.06532937]]

#随着训练次数的增加，损失函数loss在不断减小
After 0 training step(s), loss on all data is 5.13118
After 500 training step(s), loss on all data is 0.429111
After 1000 training step(s), loss on all data is 0.409789
After 1500 training step(s), loss on all data is 0.399923
After 2000 training step(s), loss on all data is 0.394146
After 2500 training step(s), loss on all data is 0.390597
After 3000 training step(s), loss on all data is 0.388336
After 3500 training step(s), loss on all data is 0.386855
After 4000 training step(s), loss on all data is 0.385863
After 4500 training step(s), loss on all data is 0.385187
After 5000 training step(s), loss on all data is 0.384719
After 5500 training step(s), loss on all data is 0.384391


w1:
 [[-0.69458205  0.844646    0.09441539]
 [-2.3423436  -0.11862345  0.5862369 ]]
w2:
 [[-0.07946703]
 [ 0.8466813 ]
 [-0.05690445]]