Tensorflow笔记（4）：神经网络的优化

4.1
√ 神经元模型： 用数学公式表示为：

f  为激活函数。 神经网络 是 以神经元为基本单元构成 的。
√ 激活函数： 引入 非线性 激 活因素， 提高模型的表达力 。
常用的激活 函数有  relu 、 sigmoid 、h tanh  等。
①  激活函数  relu: 在 Tw ensorflow  中，用  tf.nn.relu()

relu() 数学表达式                         r elu() 数学图形

②  激活函数  sigmoid ：在 w Tensorflow  中，用 用  tf.nn.sigmoid() 表示

sigmoid () 数学表达式                        r elu() 数学图形

②  激活函数  sigmoid ：在  Tensorflow  中，用tf.nn.tanh() 表示

tanh()数学表达式                               tanh()数学图形

√ 神经网络的复杂度：可用神经网络的层数和神经网络中待优化参数个数表示
√ 神经网路的 层数：一般不计入输入层，层数 = = n n  个隐藏层 1 + 1 

√ 神经网路待优化的 参数：神经网络中所有参数 w w  的个数 +  所有参数 b b  的个数
例如：

输入层           隐藏层          输出层

在该神经网络中，包含 1 个输入层、1 个隐藏层和 1 个输出层，该神经网络的层数为 2 层。
在该神经网络中，参数的个数是所有参数 w 的个数加上所有参数 b 的总数，第一层参数用三行四列的二阶张量表示（即 12 个线上的权重 w）再加上 4 个偏置 b；第二层参数是四行两列的二阶张量（）即8 个线上的权重 w）再加上 2 个偏置 b。总参数 = 3*4+4 + 4*2+2 = 26。

√损失函数（ loss）： 用来表示预测值（y y）与已知答案（ y_）的差距。 在训练神经网络时，通过不断
改变神经网络中所有参数，使损失函数不断减小，从而训练出更高准确率的神经网络模型。
√ 常用的 损失函数有均方误差、自定义和交叉熵 等。
√ 均方误差  mse ：n n  个样本的 预测值 y y 与已知 答案  y_之差的 平方和，再求平均值。

 在 w Tensorflow  中用  loss_mse = tf.reduce_mean(tf.square(y_ - y))

例如：
        预测酸奶日销量 y，x1 和 x2 是影响日销量的两个因素。
        应提前采集的数据有：一段时间内，每日的 x1 因素、x2 因素和销量 y_。采集的数据尽量多。
        在本例中用销量预测产量，最优的产量应该等于销量。由于目前没有数据集，所以拟造了一套数
据集。利用 Tensorflow 中函数随机生成 x1、 x2，制造标准答案  y_ = = x1 + x2，为了更真实，求和后
还加了正负 0.05 的随机噪声。

        我们把这套自制的数据集喂入神经网络，构建一个一层的神经网络，拟合预测酸奶日销量的函数。

代码如下：

运行结果如下：

 

由上述代码可知，本例中神经网络预测模型为 y = w1*x1 + w2*x2，损失函数采用均方误差。通过使损失函数值（loss）不断降低，神经网络模型得到最终参数 w1=0.98，w2=1.02，销量预测结果为 y =0.98*x1 + 1.02*x2。由于在生成数据集时，标准答案为 y = x1 + x2，因此，销量预测结果和标准答案已非常接近，说明该神经网络预测酸奶日销量正确。

√ 自定义损失函数：根据 问题的实际情况，定制 合理的损失函数 。

例如：
对于预测酸奶日销量问题，如果预测销量大于实际销量则会损失成本；如果预测销量小于实际销量则会损失利润。在实际生活中，往往制造一盒酸奶的成本和销售一盒酸奶的利润是不等价的。因此，需要使用符合该问题的自定义损失函数。

自定义损失函数为：

其中，损失定义成分段函数：

损失函数表示，若预测结果 y 小于标准答案 y_，损失函数为利润乘以预测结果 y 与标准答案 y_之差；
若预测结果 y 大于标准答案 y_，损失函数为成本乘以预测结果 y 与标准答案 y_之差。

用 Tensorflow 函数表示为：

loss = tf.reduce_sum(tf.where(tf.greater(y,y_),COST(y-y_),PROFIT(y_-y)))
① 若酸奶成本为 1 元，酸奶销售利润为 9 元，则制造成本小于酸奶利润，因此希望预测的结果 y 多一些。采用上述的自定义损失函数，训练神经网络模型。
代码如下：

运行结果如下：

由代码执行结果可知，神经网络最终参数为 w1=1.03， w2=1.05，销量预测结果为 y =1.03*x1 +1.05*x2。由此可见，采用自定义损失函数预测的结果大于采用均方误差预测的结果，更符合实际需求。
②若酸奶成本为 9 元，酸奶销售利润为 1 元，则制造成本大于酸奶利润，因此希望预测结果 y 小一些。采用上述的自定义损失函数，训练神经网络模型。
代码如下：

运行结果如下：

由执行结果可知，神经网络最终参数为 w1=0.96，w2=0.97，销量预测结果为 y =0.96*x1 + 0.97*x2。
因此，采用自定义损失函数预测的结果小于采用均方误差预测的结果，更符合实际需求。

√ 交叉熵(Cross Entropy)： ： 表示 两个概率分布之间的距离。交叉熵越大，两个概率分布 距离 越远， 两个概率分布越 相异 ； 交叉熵越小，两个概率分布 距离 越近 ，两个概率分布越相似 。
交叉熵计算公式：

用 Tensorflow  函数表示 为

ce= - tf.reduce_mean(y_* tf.log(tf.clip_by_value(y, 1e- 12, 1.0)))例如：
两个神经网络模型解决二分类问题中，已知标准答案为 y_ = (1, 0)，第一个神经网络模型预测结果为y1=(0.6, 0.4)，第二个神经网络模型预测结果为 y2=(0.8, 0.2)，判断哪个神经网络模型预测的结果更接近标准答案。

根据交叉熵的计算公式得：

H1((1,0),(0.6,0.4)) = -(1*log0.6 + 0*log0.4) ≈ -(-0.222 + 0) = 0.222
H2((1,0),(0.8,0.2)) = -(1*log0.8 + 0*log0.2) ≈ -(-0.097 + 0) = 0.097

由于 0.222>0.097，所以预测结果 y2 与标准答案 y_更接近，y2 预测更准确。
√ softmax  函数 ：将  n  分类的 n  个输出（ （y1,y2…yn） ） 变 为 满足以下概率分布要求的函数

softmax 函数表示为： 函数表示为

softmax 函数应用：在 n 分类中，模型会有 n 个输出，即 y1,y2…yn，其中 yi 表示第 i 种情况出现的可
能性大小。将 n 个输出经过 softmax 函数，可得到符合概率分布的分类结果。

√在 在 Tensorflow  中，一般让 模型 的过 输出经过 sofemax  函数 ， 以 获得输出分类的 概率分布，再与标准
答案 对比， 求 出 交叉熵 ， 得到损失函数，用如下函数 实现 ：
ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
cem = tf.reduce_mean(ce)

4.2 2
√ 学习率 learning_rate ： 表示了 每次参数更新的幅度大小 。 学习率过大， 会 导致 待优化的参数 在最
小值附近波动 ，不收敛 ；学习率过小， 会导致 待优化的参数收敛缓慢 。
在训练过程中， 参数的更新向着损失函数梯度下降的方向 。
参数的更新公式 为：

假设损失函数为 loss =(w + 1)^2。梯度是损失函数 loss 的导数为 ∇=2w+2。如参数初值为 5，学习
率为 0.2，则参数和损失函数更新如下

1 次                       参数 w：5              5 - 0.2 * (2 * 5 + 2) = 2.6
2 次                       参数 w：2.6           2.6 - 0.2 * (2 * 2.6 + 2) = 1.16
3 次                       参数 w：1.16         1.16 – 0.2 * (2 * 1.16 + 2) = 0.296
4 次                       参数 w：0.296

 

损失函数 loss = (w + 1)^2的图像为：

由图可知，损失函数 loss 的最小值会在(-1,0)处得到，此时损失函数的导数为 0,得到最终参数 w =
-1。代码如下：

运行结果如下：

由结果可知，随着损失函数值的减小，w 无限趋近于-1，模型计算推测出最优参数 w = -1。
√ 学习率 的 设置
学习率过大，会导致 待优化的参数 在最小值附近波动，不收敛；学习率过小， 会导致 待优化的参数收敛缓慢。

例如：
① 对于上例的损失函数 loss = (w + 1)^2 。则将上述代码中学习率修改为 1，其余内容不变。
实验结果如下：

由运行结果可知，损失函数 loss 值并没有收敛，而是在 5 和-7 之间波动。
② 对于上例的损失函数 loss = (w + 1)^2 。则将上述代码中学习率修改为 0.0001，其余内容不变。
实验结果如下：

由运行结果可知，损失函数 loss 值缓慢下降，w 值也在小幅度变化，收敛缓慢。
√ 指数衰减学习率 ： 学习率随着 训练轮数变化而动态更新
学习率计算公式如下：

用 用 Tensorflow 的 的 函数表示 为 ：
global_step = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
LEARNING_RATE_STEP, LEARNING_RATE_DECAY,
staircase=True/False)

其中，LEARNING_RATE_BASE 为学习率初始值，LEARNING_RATE_DECAY 为学习率衰减率,global_step 记
录了当前训练轮数，为不可训练型参数。学习率 learning_rate 更新频率为输入数据集总样本数除以每
次喂入样本数。若 staircase 设置为 True 时，表示 global_step/learning rate step 取整数，学习
率阶梯型衰减；若 staircase 设置为 false 时，学习率会是一条平滑下降的曲线。

 

例如：

在本例中，模型训练过程不设定固定的学习率，使用指数衰减学习率进行训练。其中，学习率初值设
置为 0.1，学习率衰减率设置为 0.99，BATCH_SIZE 设置为 1。

代码如下：

运行结果如下：

由结果可以看出，随着训练轮数增加学习率在不断减小。

4.3
√ 滑动平均 ： 记录了 一段时间内模型中所有参数 w w 和 和 b b  各自 的平均 值 。利用滑动平均值可以增强模
型的泛化能力。
√ 滑动平均值 （影子） 计算公式：

影子 = 衰减率 *  影子 + （1  - 衰减率） *  参数

√用 用 T Tw esnsorflow  函数表示为：
√ ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY ， global_step)

其中，MOVING_AVERAGE_DECAY 表示滑动平均衰减率，一般会赋接近 1 的值，global_step 表示当前
训练了多少轮。

√ema_op = ema.apply(tf.trainable_variables())

其中，ema.apply()函数实现对括号内参数求滑动平均，tf.trainable_variables()函数实现把所有
待训练参数汇总为列表。

√ with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name='train')

其中，该函数实现将滑动平均和训练过程同步运行。
查看模型中参数的平均值，可以用 ema.average()函数。
例如：
在神经网络模型中，将 MOVING_AVERAGE_DECAY 设置为 0.99，参数 w1 设置为 0，w1 的滑动平均值设
置为 0。

①开始时，轮数 global_step 设置为 0，参数 w1 更新为 1，则 w1 的滑动平均值为：
w1 滑动平均值=min(0.99,1/10)*0+(1– min(0.99,1/10)*1 = 0.9
③ 当轮数 global_step 设置为 100 时，参数 w1 更新为 10，以下代码 global_step 保持为 100，每
次执行滑动平均操作影子值更新，则滑动平均值变为：
w1 滑动平均值=min(0.99,101/110)*0.9+(1– min(0.99,101/110)*10 = 0.826+0.818=1.644
③再次运行，参数 w1 更新为 1.644，则滑动平均值变为：
w1 滑动平均值=min(0.99,101/110)*1.644+(1– min(0.99,101/110)*10 = 2.328
④再次运行，参数 w1 更新为 2.328，则滑动平均值：
w1 滑动平均值=2.956

代码如下：

 

运行程序结果如下：

从运行结果可知，最初参数 w1 和滑动平均值都是 0；参数 w1 设定为 1 后，滑动平均值变为 0.9；
当迭代轮数更新为 100 轮时，参数 w1 更新为 10 后，滑动平均值变为 1.644。随后每执行一次，参数
w1 的滑动平均值都向参数 w1 靠近。可见，滑动平均追随参数的变化而变化。

4.4
√ 过拟合： 神经网络模型在训练数据集上的准确率较高，在新的数据进行预测或分类时准确率较
低， 说明模型的 泛化能力差。
√ 正则化： 在损失函数中给每个参数 w w  加上权重，引入模型复杂度指标，从而 抑制模型 噪声 ， 减小
过拟合。
使用正则化后，损失函数 loss 变为两项之和：
loss = loss(y 与 y_) + REGULARIZER*loss(w)
其中，第一项是预测结果与标准答案之间的差距，如之前讲过的交叉熵、均方误差等；第二项是正则
化计算结果。

√ 正则化 计算 方法：
① L 1  正则化：
用 用 T Tw esnsorflow  函数表示: : loss(w) = tf.contrib .layers.l1_regularizer(REGULARIZER)(w)
② L2 正则化： 正则化：
用Tesnsorflow  函数表示: : loss(w) = = tf.contrib.layers.l2_regularizer(REGULARIZER)(w)
√用Tesnsorflow  函数实现 正则化 ：
tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w)
loss = cem + tf.add_n(tf.get_collection('losses'))
cem  的计算已在 4.1 

例如：
用 300 个符合正态分布的点 X[x 0 , x 1 ]作为数据集，根据点 X[x 0 , x 1 ]计算生成标注 Y_，将数据集
标注为红色点和蓝色点。
标注规则为：当 x0^2+x1^2<2时，y_=1，标注为红色；当 x0^2+x1^2 ≥2 时，y_=0，标注为蓝色。
我们分别用无正则化和有正则化两种方法，拟合曲线，把红色点和蓝色点分开。在实际分类时，
如果前向传播输出的预测值 y 接近 1 则为红色点概率越大，接近 0 则为蓝色点概率越大，输出的预
测值 y 为 0.5 是红蓝点概率分界线。
在本例子中，我们使用了之前未用过的模块与函数：
b √matplotlib  模块：Python  中的可视化工具模块，实现函数可视化
终端安装指令： sudo pip install matplotlib
√ 函数  plt.scatter） （） ： 利用指定颜色实现点( ( x,y) 的可视化
plt.scatter (x  坐标 , y  坐标 , c= ” 颜色 ”)
plt.show()

√ 收集规定区域内所有的网格坐标点：
xx, yy = np.mgrid[ 起: : 止: : 步长 ,  起: : 止: : 步长 ] ## 找到规定区域以步长为分辨率的行列网格坐标点
grid = np.c_[xx.ravel(), yy.ravel()]  # 收集规定区域内所有的网格坐标点
√plt.contour() 函数：告知 x y  坐标和各点高度，用levels  指定高度的点描上颜色
x plt.contour (x  轴坐标值 , y  轴坐标值 ,  该点的高度 , levels=[ 等高线的高度 ])
plt.show()

本例代码如下：

执行代码，效果如下：
首先，数据集实现可视化，x0^2+x1^2 < 2 的点显示红色， x0^2+x1^2≥2 的点显示蓝色，如图所示：

接着，执行无正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：

最后，执行有正则化的训练过程，把红色的点和蓝色的点分开，生成曲线如下图所示：

对比无正则化与有正则化模型的训练结果，可看出有正则化模型的拟合曲线平滑，模型具有更好的泛
化能力。

4.5 5  搭建模块化神经网络八股
√ 前向传播： 由输入到输出，搭建完整的网络结构
描述前向传播的过程需要定义三个函数：
√ √def forward(x, regularizer):
w=
b=
y=
return y
第一个函数 forward()完成网络结构的设计，从输入到输出搭建完整的网络结构，实现前向传播过程。
该函数中，参数 x 为输入，regularizer 为正则化权重，返回值为预测或分类结果 y。
√ def get_weight(shape, regularizer): 
w = tf.Variable( )
tf.add_to_collection('losses',  tf.contrib.layers.l2_regularizer(regularizer)(w))
return w
第二个函数 get_weight()对参数 w 设定。该函数中，参数 shape 表示参数 w 的形状，regularizer
表示正则化权重，返回值为参数 w。其中，tf.variable()给 w 赋初值，tf.add_to_collection()表
示将参数 w 正则化损失加到总损失 losses 中。

√ def get_bias(shape):
b = tf.Variable( )
return b

第三个函数 get_bias()对参数 b 进行设定。该函数中，参数 shape 表示参数 b 的形状,返回值为参数
b。其中，tf.variable()表示给 b 赋初值。
√ 反向传播 ： 训练网络 ， 优化网络参数 ，提高模型准确性。
√ √def backward( ):
x = tf.placeholder( )
y_ = tf.placeholder( )
y = forward.forward(x, REGULARIZER)
global_step = tf.Variable(0, trainable=False)
loss =
函数 backward()中，placeholder()实现对数据集 x 和标准答案 y_占位，forward.forward()实现前向
传播的网络结构，参数 global_step 表示训练轮数，设置为不可训练型参数。

在训练网络模型时，常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。
√在 在 T Tw ensorflow  中， 正则化表示为：
首先，计算预测结果与标准答案的损失值
① MSE ： y 与 与 y_ 的差距 (loss_mse) = tf.reduce_mean(tf.square(y-y_))
②交叉熵：ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
y 与 与 y_ 的差距 (cem) = tf.reduce_mean(ce)
③自定义：y 与 与 y_ 的差距
其次，总损失值为预测结果与标准答案的损失值加上正则化项
loss = y 与 与 y_ 的差距 + tf.add_n(tf.get_collection('losses'))
√在 在 T Tw ensorflow  中，指数衰减学习率 表示为：
learning_rate = tf.train.exponential_decay(
LEARNING_RATE_BASE,
global_step,
数据集总样本数 / BATCH_SIZE,
LEARNING_RATE_DECAY,
staircase=True) 
train_step=tf.train .GradientDescentOptimizer(learning_rate).minimize(loss,
global_step=global_step)
√在 在 T Tw ensorflow  中， 滑动平均表示为：
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
ema_op = ema.apply(tf.trainable_variables())
with tf.control_dependen cies([train_step, ema_op]):
train_op = tf.no_op(name='train')
其中，滑动平均和指数衰减学习率中的 global_step 为同一个参数。
√用 用 h with  结构初始化所有参数
with tf.Session() as sess:
init_op = tf.global_variables_initializer()
sess.run(init_op)
for i in range(STEPS):
sess.run(train_step, feed_dict={x: , y_: })
if i %  轮数 == 0:

print

其中，with 结构用于初始化所有参数信息以及实现调用训练过程，并打印出 loss 值。
√ 判断 n python  运行文件是否为主文件
if __name__=='__main__':
backward()
该部分用来判断 python 运行的文件是否为主文件。若是主文件，则执行 backword()函数。
例如：
用 300 个符合正态分布的点 X[x 0 , x 1 ]作为数据集，根据点 X[x 0 , x 1 ]的不同进行标注 Y_，将数据集标
注为红色和蓝色。标注规则为：当 x0^2+x1^2< 2 时，y_=1，点 X 标注为红色；当 x0^2+x1^2≥2 时，
y_=0，点 X 标注为蓝色。我们加入指数衰减学习率优化效率，加入正则化提高泛化性，并使用模块化
设计方法，把红色点和蓝色点分开。

代码总共分为三个模块：生成数据集(generateds.py)、前向传播(forward.py)、反向传播
(backward.py)。
①生成数据集的模块(generateds.py) 
②前向传播模块(forward.py)

③反向传播模块(backward.py)

运行代码，结果如下：

由运行结果可见，程序使用模块化设计方法，加入指数衰减学习率，使用正则化后，红色点和蓝色点
的分割曲线相对平滑，效果变好。