TensorFlow 深度学习笔记 TensorFlow实现与优化深度神经网络

时间 2019-11-18

标签 tensorflow 深度学习笔记实现优化神经网络繁體版

原文原文链接

转载请注明做者：梦里风林
Github工程地址：https://github.com/ahangchen/GDLnotes
欢迎star，有问题能够到Issue区讨论
官方教程地址
 视频/字幕下载html

全链接神经网络

辅助阅读：TensorFlow中文社区教程 - 英文官方教程node

代码见：full_connect.pypython

Linear Model

加载lesson 1中的数据集
将Data降维成一维，将label映射为one-hot encoding

def reformat(dataset, labels):
    dataset = dataset.reshape((-1, image_size * image_size)).astype(np.float32)
    # Map 0 to [1.0, 0.0, 0.0 ...], 1 to [0.0, 1.0, 0.0 ...]
    labels = (np.arange(num_labels) == labels[:, None]).astype(np.float32)
    return dataset, labels

TensorFlow Graph

使用梯度计算train_loss，用tf.Graph()建立一个计算单元
- 用tf.constant将dataset和label转为tensorflow可用的训练格式（训练中不可修改）
- 用tf.truncated_normal生成正太分布的数据，做为W的初始值，初始化b为可变的0矩阵
- 用tf.variable将上面的矩阵转为tensorflow可用的训练格式（训练中能够修改）
- 用tf.matmul实现矩阵相乘，计算WX+b，这里实际上logit只是一个变量，而非结果
- 用tf.nn.softmax_cross_entropy_with_logits计算WX+b的结果相较于原来的label的train_loss，并求均值
- 使用梯度找到最小train_loss
```
optimizer = tf.train.GradientDescentOptimizer(0.5).minimize(loss)
```
- 计算相对valid_dataset和test_dataset对应的label的train_loss
上面这些变量都是一种Tensor的概念，它们是一个个的计算单元，咱们在Graph中设置了这些计算单元，规定了它们的组合方式，就好像把一个个门电路串起来那样git

TensorFLow Session

Session用来执行Graph里规定的计算，就好像给一个个门电路通上电，咱们在Session里，给计算单元冲上数据，That’s Flow.github

重复计算单元反复训练800次，提升其准确度
- 为了快速查看训练效果，每轮训练只给10000个训练数据(subset)，恩，每次都是相同的训练数据
- 将计算单元graph传给session
- 初始化参数
- 传给session优化器 - train_loss的梯度optimizer，训练损失 - train_loss，每次的预测结果，循环执行训练

with tf.Session(graph=graph) as session:
        tf.initialize_all_variables().run()
        for step in range(num_steps):
            _, l, predictions = session.run([optimizer, loss, train_prediction])

在循环过程当中，W和b会保留，并不断获得修正
在每100次循环后，会用验证集进行验证一次，验证也同时修正了一部分参数

valid_prediction.eval()

最后用测试集进行测试
注意若是lesson 1中没有对数据进行乱序化，可能训练集预测准确度很高，验证集和测试集准确度会很低

这样训练的准确度为83.2%算法

SGD

每次只取一小部分数据作训练，计算loss时，也只取一小部分数据计算loss
- 对应到程序中，即修改计算单元中的训练数据，
  - 每次输入的训练数据只有128个，随机取起点，取连续128个数据：
```
offset = (step * batch_size) % (train_labels.shape[0] - batch_size)
batch_data = train_dataset[offset:(offset + batch_size), :]
batch_labels = train_labels[offset:(offset + batch_size), :]
```
- 因为这里的数据是会变化的，所以用tf.placeholder来存放这块空间
```
tf_train_dataset = tf.placeholder(tf.float32,
                                        shape=(batch_size, image_size * image_size))
tf_train_labels = tf.placeholder(tf.float32, shape=(batch_size, num_labels))
```
- 计算3000次，训练总数据量为384000，比以前8000000少
准确率提升到86.5%，并且准确率随训练次数增长而提升的速度变快了api

神经网络

上面SGD的模型只有一层WX+b，如今使用一个RELU做为中间的隐藏层，链接两个WX+b

仍然只须要修改Graph计算单元为

Y = W2 * RELU(W1*X + b1) + b2

为了在数学上知足矩阵运算，咱们须要这样的矩阵运算：

[n * 10] = RELU([n * 784] · [784 * N] + [n * N]) · [N * 10] + [n * 10]

这里N取1024，即1024个隐藏结点
因而四个参数被修改

weights1 = tf.Variable(
          tf.truncated_normal([image_size * image_size, hidden_node_count]))
biases1 = tf.Variable(tf.zeros([hidden_node_count]))
weights2 = tf.Variable(
          tf.truncated_normal([hidden_node_count, num_labels]))
biases2 = tf.Variable(tf.zeros([num_labels]))

预测值计算方法改成

ys = tf.matmul(tf_train_dataset, weights1) + biases1
hidden = tf.nn.relu(ys)
logits = tf.matmul(hidden, weights2) + biases2

计算3000次，能够发现准确率一开始提升得很快，后面提升速度变缓，最终测试准确率提升到88.8%

深度神经网络实践

代码见nn_overfit.py网络

优化

Regularization

在前面实现的RELU链接的两层神经网络中，加Regularization进行约束，采用加l2 norm的方法，进行调节：session

代码实现上，只须要对tf_sgd_relu_nn中train_loss作修改便可：app

能够用tf.nn.l2_loss(t)对一个Tensor对象求l2 norm
须要对咱们使用的各个W都作这样的计算（参考tensorflow官方example）

l2_loss = tf.nn.l2_loss(weights1) + tf.nn.l2_loss(weights2)

添加到train_loss上
这里还有一个重要的点，Hyper Parameter: β
- 我以为这是一个拍脑壳参数，取什么值都行，但效果会不一样，我这里解释一下我取β=0.001的理由
- 若是直接将l2_loss加到train_loss上，每次的train_loss都特别大，几乎只取决于l2_loss
- 为了让本来的train_loss与l2_loss都能较好地对参数调整方向起做用，它们应当至少在同一个量级
- 观察不加l2_loss，step 0 时，train_loss在300左右
- 加l2_loss后， step 0 时，train_loss在300000左右
- 所以给l2_loss乘0.0001使之降到同一个量级
```
loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits, tf_train_labels)) + 0.001 * l2_loss
```
- 全部其余参数不变，训练3000次，准确率提升到92.7%
- 黑魔法之因此为黑魔法就在于，这个参数能够很容易地影响准确率，若是β = 0.002，准确率提升到93.5%

OverFit问题

在训练数据不多的时候，会出现训练结果准确率高，但测试结果准确率低的状况

缩小训练数据范围：将把batch数据的起点offset的可选范围变小（只能选择0-1128之间的数据）：

offset_range = 1000
offset = (step * batch_size) % offset_range

能够看到，在step500后，训练集就一直是100%，验证集一直是77.6%，准确度没法随训练次数上升，最后的测试准确度是85.4%

DropOut

采起Dropout方式强迫神经网络学习更多知识

参考aymericdamien/TensorFlow-Examples中dropout的使用

咱们须要丢掉RELU出来的部分结果
调用tf.nn.dropout达到咱们的目的：

keep_prob = tf.placeholder(tf.float32)
if drop_out:
    hidden_drop = tf.nn.dropout(hidden, keep_prob)
    h_fc = hidden_drop

这里的keep_prob是保留几率，即咱们要保留的RELU的结果所占比例，tensorflow建议的语法是，让它做为一个placeholder，在run时传入
固然咱们也能够不用placeholder，直接传一个0.5：

if drop_out:
    hidden_drop = tf.nn.dropout(hidden, 0.5)
    h_fc = hidden_drop

这种训练的结果就是，虽然在step 500对训练集预测没能达到100%（起步慢），但训练集预测率达到100%后，验证集的预测正确率仍然在上升
这就是Dropout的好处，每次丢掉随机的数据，让神经网络每次都学习到更多，但也须要知道，这种方式只在咱们有的训练数据比较少时颇有效
最后预测准确率为88.0%

Learning Rate Decay

随着训练次数增长，自动调整步长

在以前单纯两层神经网络基础上，添加Learning Rate Decay算法
使用tf.train.exponential_decay方法，指数降低调整步长，具体使用方法官方文档说的特别清楚
注意这里面的cur_step传给优化器，优化器在训练中对其作自增计数
与以前单纯两层神经网络对比，准确率直接提升到90.6%

Deep Network

增长神经网络层数，增长训练次数到20000

为了不修改网络层数须要重写代码，用循环实现中间层

# middle layer
for i in range(layer_cnt - 2):
     y1 = tf.matmul(hidden_drop, weights[i]) + biases[i]
     hidden_drop = tf.nn.relu(y1)
     if drop_out:
         keep_prob += 0.5 * i / (layer_cnt + 1)
         hidden_drop = tf.nn.dropout(hidden_drop, keep_prob)

初始化weight在迭代中使用

for i in range(layer_cnt - 2):
     if hidden_cur_cnt > 2:
         hidden_next_cnt = int(hidden_cur_cnt / 2)
     else:
         hidden_next_cnt = 2
     hidden_stddev = np.sqrt(2.0 / hidden_cur_cnt)
     weights.append(tf.Variable(tf.truncated_normal([hidden_cur_cnt, hidden_next_cnt], stddev=hidden_stddev)))
     biases.append(tf.Variable(tf.zeros([hidden_next_cnt])))
     hidden_cur_cnt = hidden_next_cnt

第一次测试时，用正太分布设置全部W的数值，将标准差设置为1，因为网络增长了一层，寻找step调整方向时具备更大的不肯定性，很容易致使loss变得很大
所以须要用stddev调整其标准差到一个较小的范围（怎么调整有许多研究，这里直接找了一个来用）

stddev = np.sqrt(2.0 / n)

启用regular时，也要适当调一下β，不要让它对本来的loss形成过大的影响
DropOut时，由于后面的layer获得的信息越重要，须要动态调整丢弃的比例，到后面的layer，丢弃的比例要减少

keep_prob += 0.5 * i / (layer_cnt + 1)

训练时，调节参数，你可能遇到消失（或爆炸）的梯度问题，
训练到必定程度后，梯度优化器没有什么做用，loss和准确率老是在必定范围内徘徊
官方教程表示最好的训练结果是，准确率97.5%，
个人nn_overfit.py开启六层神经网络，
启用Regularization、DropOut、Learning Rate Decay，
训练次数20000（应该还有再训练的但愿，在这里虽然loss降低很慢了，但仍然在降低），训练结果是，准确率95.2%

以为个人文章对您有帮助的话，给个star可好？

土豪能够打赏支持，一分也是爱：