【2.2】tensorflow神经网络优化

一、基本概念

神经元模型

用数学公式表示为:

$$f(\sum_{i}x_{i}w_{i} + b)$$

f 为激活函数。神经网络是以神经元为基本单元构成的。

激活函数

引入非线性激活因素,提高模型的表达力。

常用的激活函数有 relu、sigmoid、tanh 等。

1.激活函数 relu: 在 Tensorflow 中,用 tf.nn.relu()表示

2.激活函数 sigmoid:在 Tensorflow 中,用 tf.nn.sigmoid()表示

3.激活函数 tanh:在 Tensorflow 中,用 tf.nn.tanh()表示

复杂度

神经网络的复杂度:可用神经网络的层数和神经网络中待优化参数个数表示

神经网路的层数:一般不计入输入层,层数 = n 个隐藏层 + 1 个输出层

神经网路待优化的参数:神经网络中所有参数 w 的个数 + 所有参数 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_)的差距。在训练神经网络时,通过不断 改变神经网络中所有参数,使损失函数不断减小,从而训练出更高准确率的神经网络模型。

常用的损失函数有: 均方误差、自定义和交叉熵等。

均方误差 mse:n 个样本的预测值 y 与已知答案 y_之差的平方和,再求平均值。

$$MSE(y\_,y)= \frac{\sum_{i=1}^{n}(y-y\_ )^{2}}{n}$$

在 Tensorflow 中用 loss_mse = tf.reducemean(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,因此,销量预测结果和标准 答案已非常接近,说明该神经网络预测酸奶日销量正确。

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

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

自定义损失函数为:

$$loss =\sum_{n}f(y\_,y)$$

其中,损失定义成分段函数:

损失函数表示,若预测结果 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.若酸奶成本为 1 元,酸奶销售利润为 9 元,则制造成本小于酸奶利润,因此希望预测的结果 y 多一些。采用上述的自定义损失函数,训练神经网络模型。

代码如下:

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

2.若酸奶成本为 9 元,酸奶销售利润为 1 元,则制造成本大于酸奶利润,因此希望预测结果 y 小一 些。采用上述的自定义损失函数,训练神经网络模型。

代码如下:

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

交叉熵(Cross Entropy)

表示两个概率分布之间的距离。交叉熵越大,两个概率分布距离越远,两 个概率分布越相异;交叉熵越小,两个概率分布距离越近,两个概率分布越相似。

交叉熵计算公式:

$$ H(y\_,y) = -\sum y\_ * log y $$

用 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 函数应用:在 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)

学习率 learning_rate:

表示了每次参数更新的幅度大小。学习率过大,会导致待优化的参数在最 小值附近波动,不收敛;学习率过小,会导致待优化的参数收敛缓慢。

在训练过程中,参数的更新向着损失函数梯度下降的方向。

参数的更新公式为:

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

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

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

由结果可知,随着损失函数值的减小,w 无限趋近于-1,模型计算推测出最优参数 w = -1。

学习率的设置

学习率过大,会导致待优化的参数在最小值附近波动,不收敛;学习率过小,会导致待优化的参数收 敛缓慢。 例如:

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

由运行结果可知,损失函数 loss 值并没有收敛,而是在 5 和-7 之间波动。

2.对于上例的损失函数 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。

代码如下:

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

滑动平均

记录了一段时间内模型中所有参数 w 和 b 各自的平均值。利用滑动平均值可以增强模 型的泛化能力。

滑动平均值(影子)计算公式:

影子 = 衰减率 * 影子 +(1 - 衰减率)* 参数

用 Tesnsorflow 函数表示为:

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。

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

代码如下:

运行程序,结果如下:

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

过拟合

神经网络模型在训练数据集上的准确率较高,在新的数据进行预测或分类时准确率较 低,说明模型的泛化能力差。

正则化

在损失函数中给每个参数 w 加上权重,引入模型复杂度指标,从而抑制模型噪声,减小 过拟合。

使用正则化后,损失函数 loss 变为两项之和:

loss = loss(y 与 y_) + REGULARIZER*loss(w) 

其中,第一项是预测结果与标准答案之间的差距,如之前讲过的交叉熵、均方误差等;第二项是正则化计算结果。

正则化计算方法:

  1. L1 正则化: 𝒍𝒐𝒔𝒔𝑳𝟏 = ∑𝒊|𝒘𝒊|

用 Tesnsorflow 函数表示:loss(w) = tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

  1. 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 的计算已在前面给出。

例如:

用 300 个符合正态分布的点 X[x0, x1]作为数据集,根据点 X[x0, x1]计算生成标注 Y_,将数据集标注为红色点和蓝色点。

标注规则为:当 x02 + x12 < 2 时,y=1,标注为红色;当 x02 + x12 ≥2 时,y=0,标注为蓝色。

我们分别用无正则化和有正则化两种方法,拟合曲线,把红色点和蓝色点分开。在实际分类时, 如果前向传播输出的预测值 y 接近 1 则为红色点概率越大,接近 0 则为蓝色点概率越大,输出的预 测值 y 为 0.5 是红蓝点概率分界线。

在本例子中,我们使用了之前未用过的模块与函数:

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 指定高度的点描上颜色 
plt.contour (x 轴坐标值, y 轴坐标值, 该点的高度, levels=[等高线的高度])
plt.show()

本例代码如下:

执行代码,效果如下: 首先,数据集实现可视化,x02 + x12 < 2 的点显示红色,x02 + x12 ≥2 的点显示蓝色,如图所示:

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

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

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

二、搭建模块化神经网络八股

前向传播:由输入到输出,搭建完整的网络结构

描述前向传播的过程需要定义三个函数:

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 表示训练轮数,设置为不可训练型参数。

在训练网络模型时,常将正则化、指数衰减学习率和滑动平均这三个方法作为模型优化方法。

在 Tensorflow 中,正则化表示为:

首先,计算预测结果与标准答案的损失值

  1. MSE: y 与 y_的差距(loss_mse) = tf.reducemean(tf.square(y-y))
  2. 交叉熵:ce = tf.nn.sparse_softmax_cross_entropy_withlogits(logits=y, labels=tf.argmax(y, 1)) y 与 y_的差距(cem) = tf.reduce_mean(ce)
  3. 自定义:y 与 y_的差距

其次,总损失值为预测结果与标准答案的损失值加上正则化项

loss = y 与 y_的差距 + tf.add_n(tf.get_collection(‘losses’))

在 Tensorflow 中,指数衰减学习率表示为:

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)

在 Tensorflow 中,滑动平均表示为:

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

其中,滑动平均和指数衰减学习率中的 global_step 为同一个参数。

用 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:
            if i % 轮数 == 0:
                print

其中,with 结构用于初始化所有参数信息以及实现调用训练过程,并打印出 loss 值。

判断 python 运行文件是否为主文件

if __name__=='__main__':
    backward()

该部分用来判断 python 运行的文件是否为主文件。若是主文件,则执行 backword()函数。

例如:

用 300 个符合正态分布的点 X[x0, x1]作为数据集,根据点 X[x0, x1]的不同进行标注 Y,将数据集标 注为红色和蓝色。标注规则为:当 x02 + x12 < 2 时,y=1,点 X 标注为红色;当 x02 + x12 ≥2 时, y_=0,点 X 标注为蓝色。我们加入指数衰减学习率优化效率,加入正则化提高泛化性,并使用模块化 设计方法,把红色点和蓝色点分开。

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

  1. 生成数据集的模块(generateds.py)
  2. 前向传播模块(forward.py)

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

运行代码,结果如下:

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

参考资料:

北京大学 曹建老师 《人工智能实践:Tensorflow学习笔记》

个人公众号,比较懒,很少更新,可以在上面提问题,如果回复不及时,可发邮件给我: tiehan@sina.cn

Sam avatar
About Sam
专注生物信息 专注转化医学