神经网络优化（一）
1. 相关概念介绍
1.1 神经元模型
- 定义：用数学公式表示为：?(∑????? + ?)，f 为激活函数。神经网络是以神经元为基本单元构成的。
1.2 激活函数
- 定义：引入非线性激活因素，提高模型的表达力。
| 常用的激活函数 | Tensorflow表示 | 数学表达式 | 数学图形 |
|---|---|---|---|
| relu | tf.nn.relu() |  |  |
| sigmoid | tf.nn.sigmoid() |  |  |
| tanh | tf.nn.tanh() |  |  |
1.3 神经网络的复杂度
可用神经网络的层数和神经网络中待优化参数个数表示
1.4 神经网路的层数
一般不计入输入层，层数 = n 个隐藏层 + 1 个输出层
1.5 神经网路待优化的参数
神经网络中所有参数 w 的个数和所有参数 b 的个数的所有组合
| 神经网络 | 神经网路的层数 | 神经网路待优化的参数 |
|---|---|---|
 | 1 个输入层、1 个隐藏层和 1 个输出层，该神经网络的层数为 2 层 | 第一层参数用三行四列的二阶张量表示（即 12 个线上的权重 w）再加上 4 个偏置 b；第二层参数是四行两列的二阶张量（即8 个线上的权重 w）再加上 2 个偏置 b，总参数 = 3 ∗ 4 + 4 + 4 ∗ 2 + 2 = 26 3*4+4 + 4*2+2 = 26 3∗4+4+4∗2+2=26 |
2. 损失函数（loss）
| 损失函数定义 | 常用的损失函数 |
|---|---|
| 用来表示预测值（y）与已知答案（y_）的差距。在训练神经网络时，通过不断 改变神经网络中所有参数，使损失函数不断减小，从而训练出更高准确率的神经网络模型 | 均方误差、自定义、交叉熵等。 |
2.1 均方误差 mse
| 均方误差 MSE | 解释 |
|---|---|
| 定义 | 求前向传播计算结果与已知答案之差的平方再求平均 |
| 公式 |  |
| tensorflow 函数表示 | loss_mse = tf.reduce_mean(tf.square(y_ - y)) |
- 例：预测酸奶日销量 y，x1 和 x2 是影响日销量的两个因素。
- 分析：应提前采集的数据有：一段时间内，每日的 x1 因素、x2 因素和销量 y_。采集的数据尽量多。在本例中用销量预测产量，最优的产量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 #一次喂入神经网络8组数据
SEED = 23455 #只要随机种子的数值相同，生成的随机数就相同，实际应用中，SEED可以不用写
rdm = np.random.RandomState(SEED) #生成随机噪声
X = rdm.rand(32, 2) #随机生成32行2列的数据集X，32：32组0到1之间的随机数x1和x2，2：每组数据包含2种特征（x1和x2两个因素）,
Y_ = [[x1 + x2 + (rdm.rand()/10.0-0.05)] for (x1, x2) in X] #取出每组随机数求和，再加上随机噪声（(rdm.rand()/10.0-0.05)），rdm.rand()：生成0到1之间的随机数，左闭右开，rdm.rand()/10.0-0.05：生成-0.05~+0.05的随机数
#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_mse = tf.reduce_mean(tf.square(y_ - y)) #定义损失函数为MSE
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse) #反向传播方法为梯度下降
#3.生成会话，训练STEP轮
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]}) #每轮从X的数据集中和Y_种抽取从start到end个特征和标签喂入神经网络，对train_step过程进行运算，用sess.run()计算第一层神经网络参数w1
if i % 500 == 0:
print('After', i, 'training steps,w1 is :')
print(sess.run(w1), '\n')
print('Final w1 is :\n',sess.run(w1))
- 运行结果
- 由上述代码可知，本例中神经网络预测模型为 y = w 1 ∗ x 1 + w 2 ∗ x 2 y = w1*x1 + w2*x2 y=w1∗x1+w2∗x2，损失函数采用均方误差。通过使损失函数值（loss）不断降低，神经网络模型得到最终参数 w1=0.98，w2=1.02，销量预测结果为 y = 0.98x1 + 1.02x2。由于在生成数据集时，标准答案为 y = x1 + x2，因此，销量预测结果和标准答案已非常接近，说明该神经网络预测酸奶日销量正确
2.2 自定义损失函数
| 自定义损失函数 | 解释 |
|---|---|
| 定义 | 根据问题的实际情况，定制合理的损失函数 |
| 公式 | loss = ∑??(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 多一些。采用上述的自定义损失函数，训练神经网络模型
-
#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.生成会话，训练STEP轮
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]}) #每轮从X的数据集中和Y_种抽取从start到end个特征和标签喂入神经网络，对train_step过程进行运算，用sess.run()计算第一层神经网络参数w1
if i % 500 == 0:
print('After', i, 'training steps,w1 is :')
print(sess.run(w1), '\n')
print('Final w1 is :\n',sess.run(w1))
- 运行结果
- 例2：若酸奶成本为 9 元，酸奶销售利润为 1 元，则制造成本大于酸奶利润，因此希望预测结果 y 小一些。采用上述的自定义损失函数，训练神经网络模型
#coding:utf-8
#酸奶成本9元，酸奶利润1元
#预测多了损失大，故不要预测多，故生成的模型会比预测少一些
#0.导入模块，生成数据集
import tensorflow as tf
import numpy as np
BATCH_SIZE = 8
SEED = 23455
COST = 9
PROFIT = 1
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.生成会话，训练STEP轮
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]}) #每轮从X的
if i % 500 == 0:
print('After', i, 'training steps,w1 is :')
print(sess.run(w1), '\n')
print('Final w1 is :\n',sess.run(w1))
- 运行结果
- 由执行结果可知，神经网络最终参数为 w1=0.96，w2=0.97，销量预测结果为 y = 0.96 ∗ x 1 + 0.97 ∗ x 2 y =0.96*x1 + 0.97*x2 y=0.96∗x1+0.97∗x2。因此，采用自定义损失函数预测的结果小于采用均方误差预测的结果，更符合实际需求。
2.3 交叉熵(Cross Entropy)
| 交叉熵(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)) = -(1log0.6 + 0log0.4) ≈ -(-0.222 + 0) = 0.222
H2((1,0),(0.8,0.2)) = -(1log0.8 + 0log0.2) ≈ -(-0.097 + 0) = 0.097
由于 0.222>0.097，所以预测结果 y2 与标准答案 y_更接近，y2 预测更准确。
- 根据交叉熵的计算公式得：
3. softmax 函数
| softmax 函数 | 解释 |
|---|---|
| 定义 | 将 n 分类的 n 个输出（y1,y2…yn）变为满足以下概率分布要求的函数。 |
| 表示 |  |
| 应用 | 在 n 分类中，模型会有 n 个输出，即 y1,y2…yn，其中 yi 表示第 i 种情况出现的可能性大小。将 n 个输出经过 softmax 函数，可得到符合概率分布的分类结果。 |
| 在 Tensorflow 中 | 一般让模型的输出经过 softmax 函数，以获得输出分类的概率分布，再与标准答案对比，求出交叉熵，得到损失函数，用如下函数实现： |
ce = tf.nn.sparse_softmax_cross_entropy_with_logits(logits = y, labels = tf.argmax(y_, 1)))
cem = tf.reduce_mean(ce)
loss = cem + tf.add_n(tf.get_collection('losses')) #最终的损失函数
4. 学习率（ learning_rate）
| 学习率 | 解释 |
|---|---|
| 定义 | 表示了每次参数更新的幅度大小（用于控制在训练期间我们改变网络参数的速度）。 |
| 影响 | 学习率过大，会导致待优化的参数在最小值附近波动，不收敛；学习率过小，会导致待优化的参数收敛缓慢。 |
| 应用 | 用于参数的更新：训练过程中，参数的更新向着损失函数梯度下降的方向。参数的更新公式为：W?+? = W? − ????????_????? |
- 例如：假设损失函数为 l o s s = ( w + 1 ) 2 loss = (w + 1)^2 loss=(w+1)2。梯度是损失函数 loss 的导数为 ∇=2w+2。如参数初值为 5，学习率为 0.2，则参数和损失函数更新如下：
| 第n次 | 参数w | 损失函数 |
|---|---|---|
| 1 次 | 5 | 5 - 0.2 * (2 * 5 + 2) = 2.6 |
| 2 次 | 2.6 | 2.6 - 0.2 * (2 * 2.6 + 2) = 1.16 |
| 3 次 | 1.16 | 1.16 – 0.2 * (2 * 1.16 + 2) = 0.296 |
| 4 次 | 0.296 |
| 损失函数 l o s s = ( w + 1 ) 2 loss = (w + 1)^2 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', i, 'steps:w is:', w_val, 'loss is:', loss_val)
- 运行结果
由结果可知，随着损失函数值的减小，w 无限趋近于-1，模型计算推测出最优参数 w = -1
4.1 指数衰减学习率
| 指数衰减学习率 | 解释 |
|---|---|
| 定义 | 学习率随着训练轮数变化而动态更新 |
| 学习率计算公式 |  |
- 用 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_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， 反向传播就是求最优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', i, 'steps:global_step is', global_step_val, 'w is', w_val, 'learning_rate is', learning_rate_val, 'loss is ', loss_val )
- 运行结果
- 随着训练轮数增加学习率在不断减小
- 随着训练轮数增加学习率在不断减小
5. 滑动平均(ema)
| 滑动平均(ema) | ema全写：Exponential Moving Average |
|---|---|
| 定义 | 记录了一段时间内模型中所有参数 w 和 b 各自的平均值。利用滑动平均值可以增强模型的泛化能力 |
| 滑动平均值（影子）计算公式 | 影子 = 衰减率 * 影子 +（1 - 衰减率）* 参数，其中，衰减率 = ??? {??????????????????,（?+轮数）/（??+轮数）}，影子初值 = 参数初值 |
5.1 滑动平均值（影子）用 Tesnsorflow 函数表示
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')
- ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY，global_step)
- ema：滑动平均
- MOVING_AVERAGE_DECAY ：表示滑动平均衰减率，为超参数，一般会赋接近 1 的值
- global_step ：表示当前训练了多少轮
- ema_op = ema.apply(tf.trainable_variables())
- ema_op：滑动平均节点
- ema.apply()函数：实现对括号内参数求滑动平均
- tf.trainable_variables()函数：实现把所有待训练参数汇总为列表。
- with tf.control_dependencies([train_step, ema_op]):
train_op = tf.no_op(name=‘train’)- 该函数实现将滑动平均和训练过程同步运行
- ema.average()函数：查看模型中参数的平均值
5.2 举例
- 在神经网络模型中，将 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
- ①开始时，轮数 global_step 设置为 0，参数 w1 更新为 1，则 w1 的滑动平均值为：
- 代码实现
#coding:utf-8
import tensorflow as tf
#1.定义变量及滑动平均类
#定义一个32位浮点变量，初始值为0.0，这个代码就是不断更新w1参数，优化w1参数，滑动平均做了w1的影子
w1 = tf.Variable(0, dtype = tf.float32)
#定义num_updates(NN的迭代次数)，初始值为0，不可被优化（训练），这个参数不参加训练
global_step = tf.Variable(0, trainable = False)
#实例化滑动平均类，给删减率为0.99，当前论述global_step
MOVING_AVERAGE_DECAY = 0.99
ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
#ema.apply后的括号里是更新列表，每次运行sess.run(ema_op)时，对更新列表中的元素求滑动平均值
#再实际应用中会使用tf.trainable_variables()自动将所有待训练的参数汇总为列表
#ema_op = ema.apply([w1])
ema_op = ema.apply(tf.trainable_variables())
#2.查看不同迭代中变量取值的变化
with tf.Session() as sess:
#初始化
init_op = tf.global_variables_initializer()
sess.run(init_op)
#用ema.average(w1)获取w1滑动平均值（要运行多个节点，作为列表中是元素列出，写在sess.run()中）
#打印当前参数w1和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
#将global_step的值重赋值为100
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会更新一次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)]))
- 运行结果
- 从运行结果可知：
- 最初参数 w1 和滑动平均值都是 0；
- 参数 w1 设定为1后，滑动平均值变为0.9；
- 当迭代轮数更新为 100 轮时，参数 w1 更新为 10 后，滑动平均值变为 1.644。
- 随后每执行一次，参数w1 的滑动平均值都向参数 w1 靠近。可见，滑动平均追随参数的变化而变化
6. 正则化
6.1 过拟合
定义：神经网络模型在训练数据集上的准确率较高，在新的数据进行预测或分类时准确率较低，说明模型的泛化能力差
6.2 正则化缓解过拟合
| 正则化 | 解释 |
|---|---|
| 定义 | 在损失函数中给每个参数 w 加上权重，引入模型复杂度指标，从而抑制模型噪声，减小过拟合。 |
| 影响 | 使用正则化后，损失函数 loss 变为两项之和：loss = loss(y 与 y_) + REGULARIZER*loss(w) |
| 正则化计算方法 | L1 正则化： L2 正则化： |
| L1 正则化用 Tesnsorflow 函数表示 | 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在交叉熵里面提到过） |
-
loss = loss(y 与 y_) + REGULARIZER*loss(w)
- loss(y 与 y_) ：模型中所有参数的损失函数，如：交叉熵、均方误差
- REGULARIZER：为超参数，给出参数w在总loss中的比例，即正则化的权重
- loss(w)：这里的w表示需要正则化的参数，包含两种正则化方法：L1正则化、L2正则化
-
tf.add_to_collection(‘losses’, tf.contrib.layers.l2_regularizer(regularizer)(w)
loss = cem + tf.add_n(tf.get_collection(‘losses’))- tf.add_to_collection(‘losses’, tf.contrib.layers.l2_regularizer(regularizer)(w) ：表示通过tf.add_to_collection（）函数将所有计算好的参数w正则化加到losses中
- loss = cem + tf.add_n(tf.get_collection(‘losses’)) ：tf.add_n(）表示把所有losses值相加，cem：交叉熵，loss：总损失函数
-
例如：
用 300 个符合正态分布的点 X[x0, x1]作为数据集，根据点 X[x0, x1]计算生成标注 Y_，将数据集标注为红色点和蓝色点。- 标注规则：当 x 0 2 + x 1 2 < 2 x0^2+ x1^2< 2 x02+x12<2时，y_=1，标注为红色；当 x 0 2 + x 1 2 ≥ 2 x0^2+ x1^2≥2 x02+x12≥2，y_=0，标注为蓝色。
- 我们分别用无正则化和有正则化两种方法，拟合曲线，把红色点和蓝色点分开。
- 在实际分类时，如果前向传播输出的预测值 y 接近 1 则为红色点概率越大，接近 0 则为蓝色点概率越大，输出的预测值 y 为 0.5 是红蓝点概率分界线
- 需要使用的模块与函数
-
matplotlib 模块：Python 中的可视化工具模块，实现函数可视化
-
plt.scatter（）函数：利用指定颜色实现指定点(x,y)的可视化
plt.scatter (x 坐标, y 坐标, c=”颜色”) plt.show() #将图像散点化 -
收集规定区域内所有的网格坐标点：
xx, yy = np.mgrid[起:止:步长, 起:止:步长] #找到规定区域以步长为分辨率的行列网格坐标点 grid = np.c_[xx.ravel(), yy.ravel()] #收集规定区域内所有的网格坐标点 。ravel()：把xx和yy的坐标拉直，即降低xx和yy的维度，变成1行n列，np.c_[]：将xx和yy对应位置配对，组成矩阵，这样就收集到了这个区域内的所有网格坐标点 ``` -
plt.contour()函数：告知 x、y 坐标和各点高度，用 levels 指定高度的点描上颜色
-
plt.contour (x 轴坐标值, y 轴坐标值, 该点的高度, levels=[等高线的高度]) plt.show()- 代码实现
#coding:utf-8
#0导入模块，生成模拟数据集，并可视化数据集散点
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
BATCH_SIZE = 30
seed = 2
#基于seed产生随机数
rdm = np.random.RandomState(seed)
#随机数返回300行2列的矩阵，表示300组坐标点（x0, x1）作为输入数据集
X = rdm.randn(300, 2)
#从X这个300行2列的矩阵中取出一行，判断如果两个坐标的平方和小于2，则给Y赋值1，否则赋值0
#作为输入数据集的标签（正确答案）
Y_ = [int(x0*x0 + x1*x1 <2) for (x0, x1) in X]
#遍历Y中的每个元素，1赋值'red'其余赋值'blue',这样可视化显示时人眼可直观区分
Y_c = [['red' if y else 'blue'] for y in Y_]
#对数据集X和标签Y进行shape整理，第一个元素为-1表示，随第二个参数计算得到，第二个元素表示多少列，把X整理为n行2列，把Y整理为n行1列
X = np.vstack(X).reshape(-1, 2)
Y_ = np.vstack(Y_).reshape(-1, 1)
print(X)
print(Y_)
print(Y_c)
#用plt.scatter画出数据集X各行中第0列元素和第1列元素的点即各行的（x0, x1），用各行Y_c对应的值表示颜色
plt.scatter(X[:, 0], X[:, 1], c = np.squeeze(Y_c))
plt.show()
#1.定义神经网络的输入、参数、输出、前向传播过程
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) #[2, 11]：shape，都是以列表的形式给出的，0.01：正则化权重为0.01
b1 = get_bias([11]) #11：每层中b的个数为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 #输出层不过激活
#2.定义损失函数、定义反向传播方法（不含正则化`）
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)
#3.会话
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, y_:Y_})
if i % 2000 == 0:
loss_mse_v = sess.run(loss_mse, feed_dict = {x:X, y_:Y_})
print('After', i, 'steps,loss is :', loss_mse_v )
#xx在-3到3之间以步长为0.01，yy在-3到3之间以步长为0.01,生成二维网格坐标点
xx, yy = np.mgrid[-3:3:0.01, -3:3:0.01]
#将xx,yy拉直，并合并成一个2列的矩阵，得到一个网络坐标点的集合
grid = np.c_[xx.ravel(), yy.ravel()]
#将网络坐标点喂入神经网络，probs：区域中所有坐标点是偏蓝还是偏红的变化值
probs = sess.run(y, feed_dict = {x:grid})
#对probs整形，让它调整成xx的样子
probs = probs.reshape(xx.shape)
print('w1:\n',sess.run(w1))
print('b1:\n',sess.run(b1))
print('w2:\n',sess.run(w2))
plt.scatter(X[:, 0], X[:, 1],) c = np.squeeze(Y_c)
plt.contour(xx, yy, probs, levels = [0.5]) #0.5：给probs值为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', i, 'steps,loss is :', loss_v )
#xx在-3到3之间以步长为0.01，yy在-3到3之间以步长为0.01,生成二位网格坐标点
xx, yy = np.mgrid[-3:3:0.01, -3:3:0.01]
#将xx,yy拉直，并合并成一个2列的矩阵，得到一个网络坐标点的集合
grid = np.c_[xx.ravel(), yy.ravel()]
#将网络坐标点喂入神经网络，probs为输出
probs = sess.run(y, feed_dict = {x:grid})
#probs的shape调整成xx的样子
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()
- 运行结果
-
未经正则化的结果
-
经过正则化的结果
-
对比无正则化与有正则化模型的训练结果，可看出有正则化模型的拟合曲线平滑，模型具有更好的泛化能力
扫一扫
1204
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
