神经网络优化

最新推荐文章于 2023-08-16 10:43:52 发布

vitalchuan

最新推荐文章于 2023-08-16 10:43:52 发布

阅读量191

点赞数 1

分类专栏：神经网络

本文链接：https://blog.csdn.net/qq_35154223/article/details/95375775

版权

神经网络专栏收录该内容

4 篇文章 0 订阅

订阅专栏

神经网络优化

一
二
三
四
总结

一

神经元模型：用数学公式表示为: $f(\sum_{i}x_{i}w_{i}+b)$ ，f为激活函数。
激活函数：引入非线性激活因素，提高模型的表达力
常用的激活函数有relu、sigmoid、tanh等

激活函数relu：在TensorFlow中，用tf.nn.relu()表示。
$f(x)=max(x,0)\\ =\begin{cases} 0, & \text{x<=0} \\ x, & \text{x>=0} \end{cases}$
激活函数sigmoid：在TensorFlow中，用tf.nn.sigmoid()表示。 $f(x)=\frac{1}{1+e^{-x}}$
激活函数tanh：在TensorFlow中，用tf.nn.tanh()表示。
$f(x)=\frac{1-e^{-2x}}{1+e^{-2x}}$

神经网络复杂度：可用神经网络层数和待优化参数表示。
神经网络层数：层数=n个隐藏层+1个输出层
神经网络待优化参数：所有参数w的个数+所有参数b的个数

损失函数(loss)：用来表示预测值(y)与已知答案(y_)的差距。在训练神经网络时，通过不断改变神经网络中所有参数，使损失函数不断减小，从而训练出更高准确率的神经网络模型。常用的损失函数有均方误差、自定义和交叉熵等。
均方误差：n个样本的预测值与已知答案y_之差的平方和，再求平均值。
$MSE(y_{\_},y)=\frac{\sum_{i=1}^{n}{(y-y_{\_})^2}}{n}$
在TensorFlow中表示为

loss_mse=tf.reduce_mean(tf.square(y-y_))

交叉熵(cross entropy)：表示两个概率分布之间的距离。交叉熵越大，两个概率分布距离越远，两个概率分布越相异；交叉熵越小，两个概率分布距离越近，两个概率分布越相似。
计算公式： $H(y_{\_},y)=-\sum{y_{\_}\times\log{y}}$
在TensorFlow中表示为

ce=-tf.reduce_mean(y*tf.log(tf.clip_by_value(y,1e-12,1.0)))

例如：用两个神经网络解决二分类问题，已知标准答案为y_=(1,0)，第一个神经网络预测结果y₁=(0.6,0.4)，第二个神经网络预测结果为y₂=(0.8,0.2)，判断哪一个神经网络预测结构更接近标准答案（直观上可以看出第二个预测结果更加正确）
根据交叉熵计算公式得：
$H_1((1,0),(0.6,0.4))=-(1\times\log0.6+0\times\log0.4)\approx0.222$ $H_2((1,0),(0.8,0.2))=-(1\times\log0.8+0\times\log0.2)\approx0.097$ 由于0.222>0.0097，所以预测结果2与标准答案更接近，y₂预测更准确。
softmax函数：将n分类的n个输出(y1,y2…yn)变为满足以下概率分布的函数。
$\forall{x}\in(y_1,y_2...y_n)\quad P(X=x)\in[0,1]且\sum{P(X=x)=1}$ softmax函数数学意义： $softmax(y_i)=\frac{e^{y_i}}{\sum_{j=1}^{n}{e^{y_j}}}$
在TensorFlow中，一般让模型的输出经过softmax函数，以获得输出分类的概率分布，再与标准答案对比，求出交叉熵，得到损失函数，用如下函数实现。

ce=tf.nn.square_softmax_cross_entropy_with_logits(logits=y,labels=tf.agrmax(y_,1))
cem=tf.reduce_mean(ce)

二

学习率learning_rate：表示了每次参数更新的幅度大小。学习率过大，会导致待优化参数在最小值附近波动，不收敛；学习率过小，会导致待优化参数收敛缓慢。在训练过程中，参数更新向着损失函数梯度下降的方向。
指数衰减学习率： 学习率随着训练轮数变化而动态更新。
$learning_{\_}rate=LEARNING_{\_}RATE_{\_}BASE*LEARNING_{\_}RATE_{\_}DECAY*\frac{global_{\_}step}{LEARNING_{\_}RATE_{\_}BATCH_{\_}SIZE}$ 在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。

#coding:utf-8
#设损失函数 loss=(w+1)^2,设w初值为10
import tensorflow as tf
LEARNING_RATE_BASE=0.1		#最初学习率
LEARNING_RATE_DECAY=0.99	#学习率衰减率
LEARNING_RATE_STEP=1			#喂入多少轮BATCH_SIZE后，更新一次学习率，一般设为：总样本率/BATCH_SIZE

#运行轮数计数器，设为不可被训练
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)
#定义待优化参数，初值给10
w=tf.Variable(tf.constant(10,dtype=tf.float32))
loss=tf.square(w+1)
#定义反向传播方法
train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss,global_step=global_step)

#生成会话，训练40轮
with tf.Session() as sess:
	init_op=tf.global_variables_initializer()
	sess.run(init_op)
	for i in range(40):
		sess.run(train_step)
		learning_rate_val=sess.run(learning_rate)
		global_step_val=sess.run(global_step)
		w_val=sess.run(w_val)
		loss_val=sess.run(loss)
		print("After %s steps: global step is %f, w is %f, learning rate is %f, loss is %f"%(i,global_step_val,w_val,learning_rate_val,loss_val))

部分运行结果如下：

After 35 steps: global step is 36.000000, w is -0.985877, learning rate is 0.069641, loss is 0.000199
After 36 steps: global step is 37.000000, w is -0.987844, learning rate is 0.068945, loss is 0.000148
After 37 steps: global step is 38.000000, w is -0.989520, learning rate is 0.068255, loss is 0.000110
After 38 steps: global step is 39.000000, w is -0.990951, learning rate is 0.067573, loss is 0.000082
After 39 steps: global step is 40.000000, w is -0.992174, learning rate is 0.066897, loss is 0.000061

三

滑动平均：记录了一段时间内模型中所有参数w和b的平均值。利用滑动平均可以增强模型的泛化能力。
滑动平均计算公式：
滑动平均值（影子）=衰减率 $\times$ 影子+（1-衰减率） $\times$ 参数
其中，衰减率=min{MOVING_AVERAGE_DECAY, $\frac{1+轮数}{10+轮数}$ }，影子初值等于参数初值
在TensorFlow中表示为

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_op,ema_op]):
	train_op=tf.no_op(name='train')

该函数实现将滑动平均与训练过程同步运行。查看模型中参数的滑动平均值，可以用ema.average()函数。
示例代码：

#coding:utf-8
import tensorflow as tf
#定义初始值为0的待优化参数w1，这个例子的目的就是不断更新w1参数，优化w1参数，并求w1的滑动平均值
w1=tf.Variable(0,dtype=tf.float32)
global_step=tf.Variable(0,trainable=False)
MOVING_AVERAGE_DECAY=0.99
#实例化滑动平均对象，衰减率为0.99，当前训练轮数为global_step
ema=tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY,global_step)
ema_op=ema.apply(tf.trainable_variables())

#查看迭代过程中变量取值的变化
with tf.Session() as sess:
	init_op=tf.global_variables_initializer()
	sess.run(init_op)
	#输出当前参数w1和滑动平均值
	print(sess.run([w1,ema.average(w1)]))
	
	#参数w1赋为1
	sess.run(tf.assign(w1,1))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))

	#更新step和w1的值，模拟出100轮迭代后，参数w1变为10
	sess.run(tf.assign(global_step,100)
	sess.run(tf.assign(w1,10))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))
	sess.run(ema_op)
	print(sess.run([w1,ema.average(w1)]))

运行结果是：

[0.0, 0.0]
[1.0, 0.89999998]
[10.0, 1.6445453]
[10.0, 2.3281732]
[10.0, 2.955868]
[10.0, 3.5322061]
[10.0, 4.061389]
[10.0, 4.5472751]

可见，滑动平均追随参数变化而变化。

四

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

L1正则化：
$loss_{L1}=\sum_{i}|w_i|$ 在TensorFlow中表示为：

loss(w)=tf.contrib.layers.l1_regularizer(REGULARIZER)(w)

L2正则化：
$loss_{L2}=\sum_{i}|w|^2$ 在TensorFlow中表示为：

loss(w)=tf.contrib.layers.l2_regularizer(REGULARIZER)(w)

用TensorFlow函数实现正则化：

tf.add_to_collection("losses",tf.contrib.layers.l2_regularizer(REGULARIZER)(w))
loss=cem+tf.add_n(tf.get_collection('losses'))

例如：
用300个符合正态分布的点X[x0,x1]作为数据集，并生成标签集Y_，将数据集标注为红色和蓝色。

# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

BATCH_SIZE=30
seed=2
rdm=np.random.RandomState(seed)
X=rdm.randn(300,2)
Y_=[int(x0*x0+x1*x1<2) for (x0,x1) in X]
Y_c=[['red' if y else 'blue'] for y in Y_]
X=np.vstack(X).reshape(-1,2)
Y_=np.vstack(Y_).reshape(-1,1)

plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.show()

#定义神经网络的输入、参数和输出，定义前向传播过程
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

x=tf.placeholder(tf.float32,shape=(None,2))
y_=tf.placeholder(tf.float32,shape=(None,1))

w1=get_weight([2,11],0.01)
b1=get_bias([11])
y1=tf.nn.relu(tf.matmul(x,w1)+b1)

w2=get_weight([11,1],0.01)
b2=get_bias([1])
y=tf.matmul(y1,w2)+b2

#定义损失函数
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(0.0001).minimize(loss_mse)

with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    STEPS=40000 #训练40000轮
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%300
        end=start+BATCH_SIZE
        sess.run(train_step,feed_dict={x:X[start:end],y_:Y_[start:end]})
        if i%2000 == 0:
            loss_mse_v=sess.run(loss_mse,feed_dict={x:X,y_:Y_})
            print("After %d steps, loss is:%f" % (i,loss_mse_v))
            
    #xx在-3到3之间以步长为0.01，yy在-3到3之间以步长为0.001，生成二维网格坐标点
    xx,yy=np.mgrid[-3:3:0.01,-3:3:0.01]
    grid=np.c_[xx.ravel(),yy.ravel()]
    #将网格坐标点喂入神经网络,probs为输出
    probs=sess.run(y,feed_dict={x:grid})
    #调整probs的形状
    probs=probs.reshape(xx.shape)
    print('w1:\n',sess.run(w1))
    print('b1:\n',sess.run(b1))
    print('w2:\n',sess.run(w2))
    print('b2:\n',sess.run(b2))
    
plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[0.5])
plt.show()

#定义反向传播方法，包含正则化
train_step=tf.train.AdamOptimizer(0.0001).minimize(loss_total)

with tf.Session() as sess:
    init_op=tf.global_variables_initializer()
    sess.run(init_op)
    STEPS=40000
    for i in range(STEPS):
        start=(i*BATCH_SIZE)%300
        end=start+BATCH_SIZE
        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: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)
    print("w1:\n",sess.run(w1))
    print("b1:\n",sess.run(b1))
    print("w2:\n",sess.run(w2))
    print("b2:\n",sess.run(b2))

plt.scatter(X[:,0],X[:,1],c=np.squeeze(Y_c))
plt.contour(xx,yy,probs,levels=[0.5])
plt.show()

运行代码，效果如下：
首先，将数据实现可视化， $x_0^2+x_1^2<2$ 的点显示红色， $x_0^2+x_1^2>2$ 的点显示为蓝色，如图所示：

接着执行无正则化的训练过程，输出生成曲线：
在这里插入图片描述
最后，执行正则化的训练过程，输出生成曲线：

对比无正则化的生成曲线和正则化的生成曲线，可以看出正则化的拟合曲线更为平滑，模型具有更好的泛化能力。

总结

本文主要介绍了如何优化神经网络模型。主要优化方法有：

不同激活函数，优化神经元模型
不同损失函数，例如均方误差、交叉熵或自定义损失函数
指数衰减学习率
滑动平均
正则化

中国大学mooc《人工智能实践：Tensorflow笔记》

vitalchuan

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
神经网络优化

神经网络优化一、神经元模型1.1 relu一、神经元模型神经元模型：用数学公式表示为:f(∑ixiwi+b)f(\sum_{i}x_{i}w_{i}+b)f(∑ixiwi+b)，f为激活函数。激活函数：引入非线性激活因素，提高模型的表达力常用的激活函数有relu、sigmoid、tanh等1.1 relu激活函数relu：在TensorFlow中，用tf.nn.relu()表示。...
复制链接

扫一扫

专栏目录