一
神经元模型:用数学公式表示为:
f
(
∑
i
x
i
w
i
+
b
)
f(\sum_{i}x_{i}w_{i}+b)
f(∑ixiwi+b),f为激活函数。
激活函数:引入非线性激活因素,提高模型的表达力
常用的激活函数有relu、sigmoid、tanh等
- 激活函数relu:在TensorFlow中,用tf.nn.relu()表示。
f ( x ) = m a x ( x , 0 ) = { 0 , x<=0 x , x>=0 f(x)=max(x,0)\\ =\begin{cases} 0, & \text{x<=0} \\ x, & \text{x>=0} \end{cases} f(x)=max(x,0)={0,x,x<=0x>=0
- 激活函数sigmoid:在TensorFlow中,用tf.nn.sigmoid()表示。
f
(
x
)
=
1
1
+
e
−
x
f(x)=\frac{1}{1+e^{-x}}
f(x)=1+e−x1
- 激活函数tanh:在TensorFlow中,用tf.nn.tanh()表示。
f ( x ) = 1 − e − 2 x 1 + e − 2 x f(x)=\frac{1-e^{-2x}}{1+e^{-2x}} f(x)=1+e−2x1−e−2x
神经网络复杂度:可用神经网络层数和待优化参数表示。
神经网络层数:层数=n个隐藏层+1个输出层
神经网络待优化参数:所有参数w的个数+所有参数b的个数
损失函数(loss):用来表示预测值(y)与已知答案(y_)的差距。在训练神经网络时,通过不断改变神经网络中所有参数,使损失函数不断减小,从而训练出更高准确率的神经网络模型。常用的损失函数有均方误差、自定义和交叉熵等。
均方误差:n个样本的预测值与已知答案y_之差的平方和,再求平均值。
M
S
E
(
y
_
,
y
)
=
∑
i
=
1
n
(
y
−
y
_
)
2
n
MSE(y_{\_},y)=\frac{\sum_{i=1}^{n}{(y-y_{\_})^2}}{n}
MSE(y_,y)=n∑i=1n(y−y_)2
在TensorFlow中表示为
loss_mse=tf.reduce_mean(tf.square(y-y_))
交叉熵(cross entropy):表示两个概率分布之间的距离。交叉熵越大,两个概率分布距离越远,两个概率分布越相异;交叉熵越小,两个概率分布距离越近,两个概率分布越相似。
计算公式:
H
(
y
_
,
y
)
=
−
∑
y
_
×
log
y
H(y_{\_},y)=-\sum{y_{\_}\times\log{y}}
H(y_,y)=−∑y_×logy
在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),判断哪一个神经网络预测结构更接近标准答案(直观上可以看出第二个预测结果更加正确)
根据交叉熵计算公式得:
H
1
(
(
1
,
0
)
,
(
0.6
,
0.4
)
)
=
−
(
1
×
log
0.6
+
0
×
log
0.4
)
≈
0.222
H_1((1,0),(0.6,0.4))=-(1\times\log0.6+0\times\log0.4)\approx0.222
H1((1,0),(0.6,0.4))=−(1×log0.6+0×log0.4)≈0.222
H
2
(
(
1
,
0
)
,
(
0.8
,
0.2
)
)
=
−
(
1
×
log
0.8
+
0
×
log
0.2
)
≈
0.097
H_2((1,0),(0.8,0.2))=-(1\times\log0.8+0\times\log0.2)\approx0.097
H2((1,0),(0.8,0.2))=−(1×log0.8+0×log0.2)≈0.097由于0.222>0.0097,所以预测结果2与标准答案更接近,y2预测更准确。
softmax函数:将n分类的n个输出(y1,y2…yn)变为满足以下概率分布的函数。
∀
x
∈
(
y
1
,
y
2
.
.
.
y
n
)
P
(
X
=
x
)
∈
[
0
,
1
]
且
∑
P
(
X
=
x
)
=
1
\forall{x}\in(y_1,y_2...y_n)\quad P(X=x)\in[0,1]且\sum{P(X=x)=1}
∀x∈(y1,y2...yn)P(X=x)∈[0,1]且∑P(X=x)=1softmax函数数学意义:
s
o
f
t
m
a
x
(
y
i
)
=
e
y
i
∑
j
=
1
n
e
y
j
softmax(y_i)=\frac{e^{y_i}}{\sum_{j=1}^{n}{e^{y_j}}}
softmax(yi)=∑j=1neyjeyi
在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:表示了每次参数更新的幅度大小。学习率过大,会导致待优化参数在最小值附近波动,不收敛;学习率过小,会导致待优化参数收敛缓慢。在训练过程中,参数更新向着损失函数梯度下降的方向。
指数衰减学习率: 学习率随着训练轮数变化而动态更新。
l
e
a
r
n
i
n
g
_
r
a
t
e
=
L
E
A
R
N
I
N
G
_
R
A
T
E
_
B
A
S
E
∗
L
E
A
R
N
I
N
G
_
R
A
T
E
_
D
E
C
A
Y
∗
g
l
o
b
a
l
_
s
t
e
p
L
E
A
R
N
I
N
G
_
R
A
T
E
_
B
A
T
C
H
_
S
I
Z
E
learning_{\_}rate=LEARNING_{\_}RATE_{\_}BASE*LEARNING_{\_}RATE_{\_}DECAY*\frac{global_{\_}step}{LEARNING_{\_}RATE_{\_}BATCH_{\_}SIZE}
learning_rate=LEARNING_RATE_BASE∗LEARNING_RATE_DECAY∗LEARNING_RATE_BATCH_SIZEglobal_step在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,
1
+
轮
数
10
+
轮
数
\frac{1+轮数}{10+轮数}
10+轮数1+轮数},影子初值等于参数初值
在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变为两项之和:
l
o
s
s
=
l
o
s
s
(
y
与
y
_
)
+
R
E
G
U
L
A
R
I
Z
E
R
∗
l
o
s
s
(
w
)
loss=loss(y与y_{\_})+REGULARIZER*loss(w)
loss=loss(y与y_)+REGULARIZER∗loss(w)其中第一项是预测结果与标准答案之间的差距,如之前讲过的交叉熵、均方误差等;第二项是正则化计算结果。
正则化计算方法:
- L1正则化:
l o s s L 1 = ∑ i ∣ w i ∣ loss_{L1}=\sum_{i}|w_i| lossL1=i∑∣wi∣在TensorFlow中表示为:
loss(w)=tf.contrib.layers.l1_regularizer(REGULARIZER)(w)
- L2正则化:
l o s s L 2 = ∑ i ∣ w ∣ 2 loss_{L2}=\sum_{i}|w|^2 lossL2=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
x02+x12<2的点显示红色,
x
0
2
+
x
1
2
>
2
x_0^2+x_1^2>2
x02+x12>2的点显示为蓝色,如图所示:

接着执行无正则化的训练过程,输出生成曲线:
最后,执行正则化的训练过程,输出生成曲线:
对比无正则化的生成曲线和正则化的生成曲线,可以看出正则化的拟合曲线更为平滑,模型具有更好的泛化能力。
总结
本文主要介绍了如何优化神经网络模型。主要优化方法有:
- 不同激活函数,优化神经元模型
- 不同损失函数,例如均方误差、交叉熵或自定义损失函数
- 指数衰减学习率
- 滑动平均
- 正则化
中国大学mooc《人工智能实践:Tensorflow笔记》