TensorFlow之深层神经网络 学习总结

作者：jliang
https://blog.csdn.net/jliang3

TensorFlow实战Google深度学习框架学习笔记

说明：以下所有代码使用版本TensorFlow1.4.0或1.12.0版本

import tensorflow as tf
print(tf.__version__)

1.12.0

4. 深层神经网络

4.1 深度学习与深层神经网络

• 维基百科对深度学习的精确定义为”一类通过多层非线性变换对高复杂性数据建模算法的集合“，两个非常重要的特性：
  • 多层
  • 非线性
• 线性模型的最大特点是任意线性模型的组合任然还是线性模型，能够解决的问题是有限的。
• 将每个神经元的输出通过一个非线性函数，那么整个神经网络也就不再是线性的了，这个非线性函数就是激活函数。
• 偏置项可以表达为一个输出永远为1的结点。
• TensorFlow提供了7种不同的非线性激活函数，最常见的3种是：
  • tf.nn.relu
  • tf.sigmoid
  • tf.tanh

4.2 损失函数定义

分类

• 交叉熵（cross entropy）是常用的评判多分类问题的方法之一。
  • 刻画两个概率分布之间的距离
  • 交叉熵函数是不对称的：H(p,q)!=H(q,p)，它刻画的是通过概率分布q来表达概率分布p的困难程度，p代表正确答案，q代表预测值。

cross_entropy = -tf.reduce_mean(
    y_ * tf.log(tf.clip_by_value(y, 1e-10, 1.0)) + (1-y_)*tf.log(tf.clip_by_value((1-y), 1e-10, 1.0))
)

tf.clip_by_value(A, min, max)：输入张量A，把A中的每个元素的值都压缩在min和max之间，小于min的让它等于min，大于max的元素的值等于max。
通过tf.clip_by_value(A, min, max)就可以保证log运算时，不会出现log0这样的错误或者大于1的概率。

关于乘法：

• 通过“*”操作是元素之间直接相乘
• 使用tf.matmul()实施矩阵乘法

v1 = tf.constant([[1.0, 2.0], [3.0, 4.0]])
v2 = tf.constant([[5.0, 6.0], [7.0, 8.0]])

with tf.Session() as sess:
    print('元素相乘：\n{}\n'.format((v1*v2).eval()))

    print('矩阵相乘：\n{}'.format(tf.matmul(v1, v2).eval()))

元素相乘：
[[ 5. 12.]
 [21. 32.]]

矩阵相乘：
[[19. 22.]
 [43. 50.]]

交叉熵一般会与softmax回归一起使用，TensorFlow对两个功能进行了封装tf.nn.softmax_cross_entropy_with_logits(labels,logits)

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y)

回归

回归问题最常用的损失函数时均方误差（MSE, mean squared error）

mse = tf.reduce_mean(tf.square(y_, y))

自定义损失函数

TensorFlow不仅支持经典的损失函数，还可以优化任意的自定义损失函数。

例子：预测商品销量时，如果预测多了损失成本1元，预测少了就少挣10元。

• 如果使用均方误差，那么很有可能就无法最大化预测的利润，为了最大化利润，需要将损失函数和利润直接联系起来。
  • Loss(y_, y)=sum(f(y_, y))
    • f(y_, y) = 10*(y_ - y), if y_ > y
    • f(y_, y) = 1*(y - y_), if y_ <= y

loss = tf.reduce_sum(tf.where(tf.greater(v1, v2), (v1 - v2) * a, (v2 - v1) * b))

tf.greater()输入两个张量，这函数会比较两个张量中每个元素的大小，并返回比较的结果。输入维度不一样时，将会进行类似Numpy广播操作处理。

v1 = tf.constant([[1.0, 2.0, 3.0, 4.0]])
v2 = tf.constant([[5.0, 6.0, 2.0, 1.0]])

with tf.Session() as sess:
    print(tf.greater(v1, v2).eval())
    

[[False False  True  True]]

4.3 神经网络优化算法

• 梯度下降算法主要用于优化单个参数的取值，而反向传播算法给出了一个高效的方式在所有参数上使用梯度下降算法，从而使神经网络模型在训练数据上损失函数尽可能小。
• 目前没有一个通用的方法可以对任意损失函数直接求解最佳的参数取值。
• 实践中，梯度下降算法是最常用的神经网络优化方法。

神经网络优化过程分为两个阶段：

• 通过前向传播算法计算得到预测值，并将预测值和真实值做对比得出两者之间的差距。
• 通过反向传播算法计算损失函数对每一个参数的梯度，再根据梯度和学习率使用梯度下降算法更新每一个参数。

4.4 神经网络进一步优化

学习率设置

• 学习率决定了参数每次更新的幅度。如果幅度过大，那么可能导致参数在最优值的两侧来回移动。如果幅度过小，虽然能保证收敛性，但是会大大降低优化速度。
• 指数衰减法：tf.train.exponential_decay()实现了指数衰减学习率，先用较大学习率快速得到一个比较优的解，然后随着迭代继续逐步减少学习率，使模型更加稳定。
  • 通过参数staircase选择不同的衰减方式：False时为连续衰减学习率，True时为阶梯状衰减学习率。

损失函数下降的速度和迭代结束之后总损失的大小没有必然的联系，所以并不能通过前几轮损失函数下降的速度来比较不同神经网络的效果。

global_step = tf.Variable(0)

learning_rate = tf.train.exponential_decay(0.1, global_step, 100, 0.96, staircase=True)

# 使用指数衰减学习率时，在minimize函数中传入global_step将自动更新global_step参数
# 初始学习率为0.1，每训练100轮后学习率乘以0.96.
learnint_step = tr.train.GradientDescentOptimizer(learning_rate).minimize(loss_fun, global_step=global_step)

过拟合

指的是当一个模型过为复杂之后，它可以很好地“记忆”每一个训练数据中随机噪音的部分而忘记了要去学习训练数据中通用的趋势。

• 避免过拟合的一个非常常用的方法是正则化，正则化的思想就是在损失函数中加入刻画模型复杂程度的指标，优化时不只是优化损失函数，而是优化损失函数与模型复杂程度指标两者之和。
• 一般来说模型复杂度只由权重w决定，常用的刻画模型复杂度的函数由两者：L1和L2。
  • 基本思想都是希望通过限制权重的大小，使得模型不能任意拟合训练数据中的随机噪音。
  • L1正则化会使得参数变得稀疏。
  • L2正则化不会使得参数稀疏，因为当参数很小时，参数的平方基本上就可以忽略了，于是模型不会进一步将这个参数调整为0。
  • 实践中，可以同时使用L1和L2正则化。

w = tf.Variable(tf.random_normal([2, 1], stddev=1))
y = tf.matmul(x, w)
lambda_ = 0.5

loss = tf.reduce_mean(tf.square(y_ - y)) + tf.contrib.layers.l2_regularizer(lambda_)(w)

weights = tf.constant([[1.0, -2.0], [-3.0, 4.0]])

with tf.Session() as sess:
    # (|1.0| + |-2.0| + |-3.0| + |4.0|) * 0.5 = 5
    print(sess.run(tf.contrib.layers.l1_regularizer(0.5)(weights)))
    # (1^2 + (-2.0)^2 + (-3.0)^2 + 4^2)/2 * 0.5 = 7.5
    print(sess.run(tf.contrib.layers.l2_regularizer(0.5)(weights)))
    

5.0
7.5

由于需要把所有神经网络参数都输入到正则化函数中，神经网络中不同层的参数都要被放到正则化函数中，实施起来比较麻烦。
TensorFlow提供的集合（collection）可以在计算一个图中保存一组实体（如张量），通过集合可以比较方便对所有参数实施正则化。

import tensorflow as tf

def get_weight(shape, lambda_):
    var = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambda_)(var))
    return var
    
x = tf.placeholder(tf.float32, shape=(None, 2))
y_ = tf.placeholder(tf.float32, shape=(None, 1))
batch_size = 8
# 定义每一层网络中节点的个数
layer_dimension = [2, 10, 10, 10, 1]
# 神经网络层数
n_layers = len(layer_dimension)

cur_layer = x
# 当前节点的个数
in_dimension = layer_dimension[0]

# 循环生成多层神经网络
for i in range(1, n_layers):
    out_dimension = layer_dimension[i]
    
    weight = get_weight((in_dimension, out_dimension), 0.001)
    bias = tf.Variable(tf.constant(0.1, shape=[out_dimension]))
    
    cur_layer = tf.nn.relu(tf.matmul(cur_layer, weight) + bias)
    in_dimension = layer_dimension[i]
    
# 训练集的损失函数
mse_loss = tf.reduce_mean(tf.square(y_ - cur_layer))

# 将均方误差损失函数加入损失集合
tf.add_to_collection('losses', mse_loss)


# get_collection()返回一个列表，是所有这个集合中的元素。这些元素就是损失函数的不同部分，将它们加起来就可以得到最终的损失函数
print('{}'.format(tf.get_collection('losses')))

loss = tf.add_n(tf.get_collection('losses'))

[, , , , ]

滑动平均模型

可以使模型在测试数据上更健壮的方法。
在采用随机梯度下降算法训练神经网络时，使用滑动平均模型在很多应用中都可以在一定程度提高最终模型在测试数据上的表现。

• tf.train.ExponentialMovingAverage实现滑动平均模型
• 需要提供衰减率decay参数进行初始化，衰减率用于控制模型的更新速度
• ExponentialMovingAverage对每个变量会维护一个影子变量，初始值等于对应变量的初始值
• 每次运行变量更新时，影子变量的值就会按以下公式更新
  • shadow_variable = decay*shadow_vairable + (1-decay)*variable
  • variable为待更新的变量，decay为衰减率
  • decay决定了模型的更新速度，decay越大模型更新速度越慢，越趋于稳定
  • decay一般设成接近1的数（如0.999或0.9999）
  • 为了模型训练前期更快，还可以设置num_updates参数动态设置decay的大小：min(decay, 1+num_updates/(10_num_updates))

v1 = tf.Variable(0, dtype=tf.float32)
# step变量模拟神经网络中迭代的轮数，可以用于控制衰减率
step = tf.Variable(0, trainable=False)

ema = tf.train.ExponentialMovingAverage(0.99, step)
maintain_averages_op = ema.apply([v1]) 


with tf.Session() as sess:
    
    # 初始化
    init_op = tf.global_variables_initializer()
    sess.run(init_op)
    print(sess.run([v1, ema.average(v1)]))
    
    # 更新变量v1的取值
    sess.run(tf.assign(v1, 5))
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]))
    
    # 更新step和v1的取值
    sess.run(tf.assign(step, 10000))  
    sess.run(tf.assign(v1, 10))
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]))      
    
    # 更新一次v1的滑动平均值
    sess.run(maintain_averages_op)
    print(sess.run([v1, ema.average(v1)]))       

    

[0.0, 0.0]
[5.0, 4.5]
[10.0, 4.555]
[10.0, 4.60945]