全連線神經網路

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中設定了這些計算單元，規定了它們的組合方式，就好像把一個個閘電路串起來那樣

TensorFLow Session

Session用來執行Graph裡規定的計算，就好像給一個個閘電路通上電，我們在Session裡，給計算單元衝上資料，That’s Flow.
- 重複計算單元反覆訓練800次，提高其準確度
- 為了快速檢視訓練效果，每輪訓練只給10000個訓練資料(subset)，恩，每次都是相同的訓練資料
- 將計算單元graph傳給session
- 初始化引數
- 傳給session優化器 - train_loss的梯度optimizer，訓練損失 - train_loss，每次的預測結果，迴圈執行訓練
python
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次迴圈後，會用驗證集進行驗證一次，驗證也同時修正了一部分引數
python
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%，而且準確率隨訓練次數增加而提高的速度變快了

神經網路

• 上面SGD的模型只有一層WX+b，現在使用一個RELU作為中間的隱藏層，連線兩個WX+b
  
  • 仍然只需要修改Graph計算單元為
    python
Y = W2 * RELU(W1*X + b1) + b2

  • 為了在數學上滿足矩陣運算，我們需要這樣的矩陣運算：
    
[n * 10] = RELU([n * 784] · [784 * N] + [n * N]) · [N * 10] + [n * 10]

  • 這裡N取1024，即1024個隱藏結點
  • 於是四個引數被修改
    python
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]))

  • 預測值計算方法改為
    python
ys = tf.matmul(tf_train_dataset, weights1) + biases1
hidden = tf.nn.relu(ys)
logits = tf.matmul(hidden, weights2) + biases2

  • 計算3000次，可以發現準確率一開始提高得很快，後面提高速度變緩，最終測試準確率提高到88.8%

深度神經網路實踐

優化

Regularization

在前面實現的RELU連線的兩層神經網路中，加Regularization進行約束，採用加l2 norm的方法，進行調節：

程式碼實現上，只需要對tf_sgd_relu_nn中train_loss做修改即可：
- 可以用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使之降到同一個量級
    python
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方式強迫神經網路學習更多知識

• 我們需要丟掉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可好？