神经网络优化--人工智能实践

由之前的知识我们知道，前向传播主要负责搭建网络结构，反向传播负责训练网络参数。

我们之前的基本神经元模型都是输入X和权重W相乘所得到的Sigma(XiWi)，而在1943年心理学家McCulloch和数学家Pitts的神经元模型中是f（(Sigma(XiWi))+bias），其中()为激活函数，bias为偏置项。而神经网络的基本单元就是神经元。

常用激活函数如下：

激活函数：引入非线性激活因素，提高模型的表达力。

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

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

          

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

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

        

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

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

                   

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

NN复杂度：NN层数和NN参数个数

层数：隐藏计算层+一个输出层，总参数：总W和总b的所有个数,W和b的层次个数是一样的

然后我们来看看神经网络的优化，我们从损失函数loss、学习率、滑动平均ema和正则化regularization来看看。

首先看看损失函数loss：前向传播计算出的预测值（y）与已知答案（y_）的差距

NN优化的目标：loss最小，而loss可以由均方误差MSE、交叉商ce（Cross Entropy）或自定义给出。

均方误差我们已经了解了，语句是loss_mse=tf.reduce_mean(tf.square(y-y_))

举个例子，预测酸奶日销量y。X1、x2是影响日销量的因素。在建立模型前，应该预先采集数据：一段时间内，每日x1、x2和已知销量y_。拟造数据集X，Y_：y_=x1+x2,为了更真实，再加一个随机噪声-0.05~+0.05，来拟合可以预测销量的函数。

示例代码：

#coding:utf-8
#预测多或预测少的影响一样
#0导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
 
rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y_ = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]
 
#1定义神经网络的输入、参数和输出，定义前向传播过程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)
 
#2定义损失函数及反向传播方法。
#定义损失函数为MSE,反向传播方法为梯度下降。
loss_mse = tf.reduce_mean(tf.square(y_ - y))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
#train_step = tf.train.MomentumOptimizer(0.001,0.9).minimize(loss_mse)  
#train_step = tf.train.AdamOptimizer(0.001).minimize(loss_mse)
 
#3生成会话，训练STEPS轮
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 20000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y_[start:end]})
        if i % 500 == 0:
            print "After %d training steps, w1 is: " % (i)
            print sess.run(w1), "\n"
    print "Final w1 is: \n", sess.run(w1)
#在本代码#2中尝试其他反向传播方法，看对收敛速度的影响

 

 最后我们得到最后的w1参数大小是0.980和1.015。

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

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

在我们上个例子中，认为销量预测多了和销量预测少了，损失是一样的。然而其实，预测多了损失了成本，预测少了，损失了利润。利润和成本是不一样的，则mse产生的loss无法使得利益最大化。

例如：

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

自定义损失函数为：

loss=Sigma  f(y,y_)

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

f（y，y_）=PROFIT*(y_ -y),  when y<y_

           COST*(y-y_),     when 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))) 

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

 

我们给出源代码：

#coding:utf-8
#酸奶成本1元， 酸奶利润9元
#预测少了损失大，故不要预测少，故生成的模型会多预测一些
#0导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 1
PROFIT = 9
 
rdm = np.random.RandomState(SEED)
X = rdm.rand(32,2)
Y = [[x1+x2+(rdm.rand()/10.0-0.05)] for (x1, x2) in X]
 
#1定义神经网络的输入、参数和输出，定义前向传播过程。
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
w1= tf.Variable(tf.random_normal([2, 1], stddev=1, seed=1))
y = tf.matmul(x, w1)
 
#2定义损失函数及反向传播方法。
# 定义损失函数使得预测少了的损失大，于是模型应该偏向多的方向预测。
loss = tf.reduce_sum(tf.where(tf.greater(y, y_), (y - y_)*COST, (y_ - y)*PROFIT))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss)
 
#3生成会话，训练STEPS轮。
with tf.Session() as sess:
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    STEPS = 3000
    for i in range(STEPS):
        start = (i*BATCH_SIZE) % 32
        end = (i*BATCH_SIZE) % 32 + BATCH_SIZE
        sess.run(train_step, feed_dict={x: X[start:end], y_: Y[start:end]})
        if i % 500 == 0:
            print "After %d training steps, w1 is: " % (i)
            print sess.run(w1), "\n"
    print "Final w1 is: \n", sess.run(w1)

 

三、交叉熵计算公式：

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

四、学习率 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。

示例代码： 

#coding:utf-8

#设损失函数 loss=(w+1)^2, 令w初值是常数5。反向传播就是求最优w，即求最小loss对应的w值

import tensorflow as tf

#定义待优化参数w初值赋5

w = tf.Variable(tf.constant(5, dtype=tf.float32))

#定义损失函数loss

loss = tf.square(w+1)

#定义反向传播方法

train_step = tf.train.GradientDescentOptimizer(0.2).minimize(loss)

#生成会话，训练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)

w_val = sess.run(w)

loss_val = sess.run(loss)

print "After %s steps: w is %f, loss is %f." % (i, w_val,loss_val)

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

   ②对于上例的损失函数loss = (w + 1)2。则将上述代码中学习率修改为0.0001，其余内容不变。 

   实验结果如下：  

   

   由运行结果可知，损失函数 loss 值缓慢下降，w值也在小幅度变化，收敛缓慢。

2. 指数衰减学习率：学习率随着训练轮数变化而动态更新 学习率计算公式如下：

   Learning_rate=LEARNING_RATE_BASE*LEARNING_RATE_DECAY* 

   用 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。 示例代码：

3. #coding:utf-8
   
   #设损失函数 loss=(w+1)^2, 令w初值是常数10。反向传播就是求最优w，即求最小loss对应的w值
   
   #使用指数衰减的学习率，在迭代初期得到较高的下降速度，可以在较小的训练轮数下取得更有收敛度。
   
   import tensorflow as tf
   
   
   LEARNING_RATE_BASE = 0.1 #最初学习率
   
   LEARNING_RATE_DECAY = 0.99 #学习率衰减率
   
   LEARNING_RATE_STEP = 1 #喂入多少轮BATCH_SIZE后，更新一次学习率，一般设为：总样本数/BATCH_SIZE
   
   
   #运行了几轮BATCH_SIZE的计数器，初值给0, 设为不被训练
   
   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(5, dtype=tf.float32))
   
   #定义损失函数loss
   
   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)
   
   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)

4. 

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

   运行结果如下：

   

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

   学习率的设置 学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。

   例如：

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

   实验结果如下：