中国大学MOOC-人工智能实践：Tensorflow笔记-课程笔记 Chapter4

本篇博客为学习中国大学MOOC-人工智能实践：Tensorflow笔记课程时的个人笔记记录。具体课程情况可以点击链接查看。（这里推一波中国大学MOOC，很好的学习平台，质量高，种类全，想要学习的话很有用的）
本篇是第四章的学习笔记,前三章的可以点击我阅读.

Chapter 4 神经网络的优化

4.1 损失函数

神经元模型

激活函数(activation function)

激活函数的作用: 有效避免仅适用线性组合,提高了模型的表达力,使模型有更好的区分力.

神经网络复杂度:多用NN层数和NN参数的个数表示.
层数 = 隐藏层的层数 + 1个输出层
总参数 = 总W + 总b

损失函数(loss):预测值(y)与已知答案(y_)的差距
NN优化目标: loss最小,常见的损失函数有均方误差(MSE),交叉熵损失函数(Cross Entropy)以及自定义损失函数:
MSE: MSE(y,y)=∑ni=1(y−y_)2n M S E ( y , y ) = ∑ i = 1 n ( y − y _ ) 2 n
TF中使用MSE损失函数:

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

课程中使用的代码opt4_1.py:

#coding:utf-8
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]

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)

loss_mse = tf.reduce_mean(tf.square(y_-y))
train_step = tf.train.GradientDescentOptimizer(0.001).minimize(loss_mse)
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 = start + 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))

其余所使用的代码可以参看我上传的文件.
Cross Entropy:表征两个概率分布之间的距离
H(y,y)=−∑y_∗log(y) H ( y , y ) = − ∑ y _ ∗ l o g ( y )
TF中使用交叉熵损失函数:

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

4.2 学习率

学习率(learning_rate):每次参数更新的幅度
wn+1=wn−learning_rateΔ w n + 1 = w n − l e a r n i n g _ r a t e Δ
学习率设置大了会震荡不收敛,学习率设置过小会收敛速度过慢.
解决方法:使用指数衰减学习率
learning_rate=LEARNING_RATE_BASE*LEARNING_RATE_DECAY^(global_step/LEARNING_RATE_STEP)

global_step=tf.Variable(0,trainable=False)
learning_rate=tf.train.exponential_decay(LEARNIN_RATE_BASE,global_step,LEARNING_RATE_STEP,LEARNING_RATE_DECAY,staircase = True)

4.3 滑动平均

滑动平均(影子值):记录了每个参数一段时间内过往值的平均,增加了模型的泛化性
针对所有参数:W和b
(像是给参数加了影子,参数变化,影子缓慢追随)
影子 = 衰减率影子+(1-衰减率)参数
影子初值=参数初值
衰减率=ming{MOVING_AVERAGE_DECAY,(1+轮数)/(10+轮数)}

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.average(参数名)->查看某参数的滑动平均值

4.4 正则化

正则化用于缓解过拟合
正则化在损失函数中引入模型复杂度指标,利用给W加权值,弱化了训练数据的噪声,(一般不会正则化b)
loss= loss(y与y_)+REGULARIZER*loss(w)
loss(y与y_):模型中所有参数的损失函数,如 交叉熵,均方误差
REGULARIZER: 用超参数REGULARIZER 给出参数w在总loss中的比例,即正则化的权重,
loss(w): w为需要正则化的参数

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

lossL1(w)=∑i|wi| l o s s L 1 ( w ) = ∑ i | w i |
lossL2(w)=∑i|w2i| l o s s L 2 ( w ) = ∑ i | w i 2 |

tf.add_to_collection('losses',tf.contrib.layers.l1_regularizer(REGULARIZER)(w))
# 把内容加到几何对应位置做加法
loss = cem + tf.add_n(tf.get_collection('losses'))

example:
安装 matplotlib
sudo pip install matplotlib

import matplotlib as plt
plt.scatter(x坐标,y坐标,c='颜色')
plt.show()
xx,yy = np.mgris[起:止:步长,起:止:步长]
grid = np.c_[xx.ravel(),yy.ravel()]
probs = sess.run(y,feed_dict={x:grid})
probs = probs.reshape(xx.shape)
plt.contour(x轴坐标值,y轴坐标值,该点的高度,levels=[等高线的高度])
plt.show()

opt4-7.py代码请查看我上传的附件.
这个代码运行的时候具有较大的随机性,因为w1是随机生成的,如果在生成的时候指定随机数种子以及标准差啥的,应该就能保证每次运行的结果一致.这个代码我在自己电脑上面跑了好多次,都完全没法得到像老师展示的那么好看的结果.

4.5 神经网络八股

搭建模块化的神经网络八股:
前线传播就是搭建网络,设计网络结构(forward.py)

def forward(x, regularizer):
    w = 
    b = 
    y =
    return y

def get_weight(shape, regularizer):
    w = tf.Variable()
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
    return w
def get_bias(shape):
    b = tf.Variable()
    return b

反向传播就是训练网络,优化网络参数(backward.py)

def backward():
    x = tf.placeholder()
    y_ = tf.placeholder()
    y = forward.forward(x, REGULARIZER)
    global_step = tf.Variable(0, trainable=False)
    loss = 
#关于loss
    loss 可以是:
    y与y_的差距(loss_mse)=tf.reduce_mean(tf.square(y-y_))
    也可以是:
    ce=tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_,1))
    y与y_的差距(cem)= tf.reduce_mean(ce)
    加入正则化后
    loss = y 与y_的差距+tf.add_n(tf.get_collection('losses'))

#关于指数衰减学习率
learning_rate=tf.train.exponential_decay(LEARNING_RATE_BASE,global_step,数据集总样本数/BATCH_SIZE,LEARNING_RATE_DECAY,staircase = True)

train_step = tf.train.GradientDenscentOptimizer(learning_rate).minimize(loss, global_step=global_step)
#关于滑动平均
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')

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:, y_:})
        if i % 轮数 == 0:
            print()
if __name__=='__main__'
    backward()