深度學習（32）隨機梯度下降十: 手寫數字識別問題（層）

• 1. 數據集
• 2. 網絡層
• 3. 網絡模型
• 4. 網絡訓練

本節將利用前面介紹的多層全連接網絡的梯度推導結果，直接利用Python循環計算每一層的梯度，并按著梯度下降算法手動更新。由于TensorFlow具有自動求導功能，我們選擇沒有自動求導功能的Numpy實現網絡，并利用Numpy手動計算梯度并手動更新網絡參數。
需要注意的是，本章推導的梯度傳播公式是針對于多層全連接層，只有Sigmoid一種激活函數，并且損失函數為均方誤差函數的網絡類型。對于其它類型的網絡，比如激活函數采用ReLU，損失函數采用交叉熵的網絡，需要重新推導梯度傳播表達式，但是方法是一樣。正是因為手動推導梯度的方法局限性較大，在實踐中采用極少，更多的是利用自動求導工具計算。
我們將實現一個4層的全連接網絡，來完成二分類任務。網絡輸入節點數為2，隱藏層的節點數設計為: 25、50和25，輸出層兩個節點，分別表示屬于類別1的概率和屬于類別2的概率，如下圖所示:

這里并沒有采用Softmax函數將網絡輸出概率值之和進行約束，而是直接利用均方誤差函數計算與One-hot編碼的真實標簽之間的誤差，所有的網絡激活函數全部采用Sigmoid函數，這些設計都是為了能直接利用我們的梯度傳播公式。

1. 數據集

這里通過scikit-learn庫提供的邊界工具生成2000個線性不可分的2分類數據集，數據的特征長度為2，采樣出的數據分布如下圖所示。

所有的紅色點為一類，所有的藍色點為一類，可以看到每個類別數據的分布呈月牙狀，并且是線性不可分的，無法用線性網絡獲得較好效果。為了測試網絡的性能，我們按著$7:3$比例切分訓練集和測試集，其中$2000?0.3=600$個樣本用于測試，不參與訓練，剩下的$1400$個點用于網絡的訓練。
數據集的采用直接使用scikit-learn提供的make_moons[1]函數生成。設置采樣點數和切割比率，代碼如下:

N_SAMPLES = 2000 # 采樣點數 TEST_SIZE = 0.3 # 測試數量比率 # 利用工具函數直接生成數據集 X, y = make_moons(n_samples = N_SAMPLES, noise=0.2, random_state=100) # 將2000 個點按著7:3 分割為訓練集和測試集 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=42) print(X.shape, y.shape)

可以通過如下可視化代碼繪制數據集的分布:

# 繪制數據集的分布，X 為2D 坐標，y 為數據點的標簽 def make_plot(X, y, plot_name, file_name=None, XX=None, YY=None, preds=None, dark=False): if (dark): plt.style.use('dark_background') else: sns.set_style("whitegrid") plt.figure(figsize=(16,12)) axes = plt.gca() axes.set(xlabel="$x_1$", ylabel="$x_2$") plt.title(plot_name, fontsize=30) plt.subplots_adjust(left=0.20) plt.subplots_adjust(right=0.80) if(XX is not None and YY is not None and preds is not None): plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha = 1, cmap=cm.Spectral) plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5], cmap="Greys", vmin=0, vmax=.6) # 繪制散點圖，根據標簽區分顏色 plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='none') plt.savefig('dataset.svg') plt.close() # 調用make_plot 函數繪制數據的分布，其中X 為2D 坐標，y 為標簽 make_plot(X, y, "Classification Dataset Visualization ") plt.show()

2. 網絡層

通過新建類Layer實現一個網絡層，需要傳入網絡層的輸入節點數、輸出節點數、激活函數類型等參數，權值weights和偏置張量bias在初始化時根據輸入、輸出節點數自動生成并初始化。代碼如下:

class Layer: # 全連接網絡層 def __init__(self, n_input, n_neurons, activation=None, weights=None, bias=None): """ :param int n_input: 輸入節點數 :param int n_neurons: 輸出節點數 :param str activation: 激活函數類型 :param weights: 權值張量，默認類內部生成 :param bias: 偏置，默認類內部生成 """ # 通過正態分布初始化網絡權值，初始化非常重要，不合適的初始化將導致網絡不收斂 self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons) self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1 self.activation = activation # 激活函數類型，如’sigmoid’ self.last_activation = None # 激活函數的輸出值o self.error = None # 用于計算當前層的delta 變量的中間變量 self.delta = None # 記錄當前層的delta 變量，用于計算梯度

網絡層的向前傳播函數實現如下，其中last_activation變量用于保存當前層的輸出值:

def activate(self, x): # 前向傳播函數 r = np.dot(x, self.weights) + self.bias # X@W+b # 通過激活函數，得到全連接層的輸出o self.last_activation = self._apply_activation(r) return self.last_activation

注:
(1) np.dot為矩陣的乘法[2];
上述代碼中的self._apply_activation函數實現了不同類型的激活函數的向前計算的過程，盡管此處我們只使用Sigmoid激活函數一種。代碼如下:

def _apply_activation(self, r): # 計算激活函數的輸出 if self.activation is None: return r # 無激活函數，直接返回 # ReLU 激活函數 elif self.activation == 'relu': return np.maximum(r, 0) # tanh 激活函數 elif self.activation == 'tanh': return np.tanh(r) # sigmoid 激活函數 elif self.activation == 'sigmoid': return 1 / (1 + np.exp(-r)) return r

針對不同類型的激活函數，它們的導數計算實現如下:

def apply_activation_derivative(self, r): # 計算激活函數的導數 # 無激活函數，導數為1 if self.activation is None: return np.ones_like(r) # ReLU 函數的導數實現 elif self.activation == 'relu': grad = np.array(r, copy=True) grad[r > 0] = 1. grad[r <= 0] = 0. return grad # tanh 函數的導數實現 elif self.activation == 'tanh': return 1 - r ** 2 # Sigmoid 函數的導數實現 elif self.activation == 'sigmoid': return r * (1 - r) return r

可以看到，Sigmoid函數的導數實現為r(1-r)，其中r即為σ(z)[3]。

3. 網絡模型

創建單層網絡類后，我們實現網絡模型的NeuralNetwork類，它內部維護各層的網絡層Layer類對象，可以通過add_layer函數追加網絡層，實現創建不同結構的網絡模型目的。代碼如下:

class NeuralNetwork: # 神經網絡模型大類 def __init__(self): self._layers = [] # 網絡層對象列表 def add_layer(self, layer): # 追加網絡層 self._layers.append(layer) 網絡的前向傳播只需要循環調各個網絡層對象的前向計算函數即可[4]，代碼如下： def feed_forward(self, X): # 前向傳播 for layer in self._layers: # 依次通過各個網絡層 X = layer.activate(X) return X

根據網絡結構圖的配置，利用NeuralNetwork類創建網絡對象，并添加4層全連接層，代碼如下:

nn = NeuralNetwork() # 實例化網絡類 nn.add_layer(Layer(2, 25, 'sigmoid')) # 隱藏層1, 2=>25 nn.add_layer(Layer(25, 50, 'sigmoid')) # 隱藏層2, 25=>50 nn.add_layer(Layer(50, 25, 'sigmoid')) # 隱藏層3, 50=>25 nn.add_layer(Layer(25, 2, 'sigmoid')) # 輸出層, 25=>2

網絡模型的反向傳播實現稍復雜，需要從最末層開始，計算每層的δ變量，然后根據推導出的梯度公式，將計算出的δ變量存儲在Layer類的delta變量中。代碼如下:

def backpropagation(self, X, y, learning_rate): # 反向傳播算法實現 # 前向計算，得到輸出值 output = self.feed_forward(X) for i in reversed(range(len(self._layers))): # 反向循環 layer = self._layers[i] # 得到當前層對象 # 如果是輸出層 if layer == self._layers[-1]: # 對于輸出層 layer.error = y - output # 計算2 分類任務的均方差的導數 # 關鍵步驟：計算最后一層的delta，參考輸出層的梯度公式 layer.delta = layer.error * layer.apply_activation_derivative(output) else: # 如果是隱藏層 next_layer = self._layers[i + 1] # 得到下一層對象 layer.error = np.dot(next_layer.weights, next_layer.delta) # 關鍵步驟：計算隱藏層的delta，參考隱藏層的梯度公式 layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation) …# 代碼接下面

在反向計算完每層的δ變量后，只需按著公式?L/(?w_ij )=o_i δ_j^((J))計算每層參數的梯度，并更新網絡參數即可。由于代碼中的delta計算的其實是-δ，因此更新時使用了加號。代碼如下:

def backpropagation(self, X, y, learning_rate): … # 代碼接上面 # 循環更新權值 for i in range(len(self._layers)): layer = self._layers[i] # o_i 為上一網絡層的輸出 o_i = np.atleast_2d(X if i == 0 else self._layers[i - 1].last_activation) # 梯度下降算法，delta 是公式中的負數，故這里用加號 layer.weights += layer.delta * o_i.T * learning_rate

因此，在backpropagation函數中，反向計算每層的δ變量，并根據梯度公式計算每層參數的梯度值，按著梯度下降算法完成一次參數的更新。

4. 網絡訓練

這里的二分類任務網絡設計為兩個輸出節點，因此需要將真實標簽$y$進行One-hot編碼，代碼如下:

def train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs): # 網絡訓練函數 # one-hot 編碼 y_onehot = np.zeros((y_train.shape[0], 2)) y_onehot[np.arange(y_train.shape[0]), y_train] = 1

將One-hot編碼后的真實標簽與網絡的輸出計算均方誤差，并調用反向傳播函數更新網絡參數，循環迭代訓練集1000遍即可。代碼如下:

mses = [] for i in range(max_epochs): # 訓練1000 個epoch for j in range(len(X_train)): # 一次訓練一個樣本 self.backpropagation(X_train[j], y_onehot[j], learning_rate) if i % 10 == 0: # 打印出MSE Loss mse = np.mean(np.square(y_onehot - self.feed_forward(X_train))) mses.append(mse) print('Epoch: #%s, MSE: %f' % (i, float(mse))) # 統計并打印準確率 print('Accuracy: %.2f%%' % (self.accuracy(self.predict(X_test), y_test.flatten()) * 100)) return mses

網絡性能
我們將每個Epoch的訓練損失值記錄如下，并繪制為曲線，如圖所示，為訓練誤差曲線:

在訓練完1000個Epoch后，在測試集600個樣本上得到的準確率為:

Epoch: #990, MSE: 0.024335 Accuracy: 97.67%

可以看到，通過手動計算梯度公式并手動更新網絡參數的方式，我們在簡單的二分類任務上也能獲得了較低的錯誤率。通過精調網絡超參數等技巧，還可以獲得更好的網絡性能。
在每個Epoch中，我們在測試集上完成一次準確度測試，并繪制成曲線，如下圖所示:

可以看到，隨著Epoch的進行，模型的準確率穩步提升，開始階段提升較快，后續提升較為平緩。
通過這個基于Numpy手動計算梯度而實現的二分類全連接網絡，我們能夠更加深刻地體會到深度學習框架在算法實現中的角色。沒有諸如TensorFlow這些框架，我們同樣能夠實現復雜的神經網絡，但是靈活性、穩定性、開發效率和計算效率都較差，基于這些深度學習框架進行算法設計與訓練，將大大提升算法開發人員的工作效率。同時我們也能意識到，框架只是一個工具，更重要的是我們對算大本身的理解，這才是算法開發者最重要的能力。
6. 完整代碼

import matplotlib.pyplot as plt import numpy as np import seaborn as sns from sklearn.datasets import make_moons from sklearn.model_selection import train_test_splitplt.rcParams['font.size'] = 16 plt.rcParams['font.family'] = ['STKaiti'] plt.rcParams['axes.unicode_minus'] = Falsedef load_dataset():# 采樣點數N_SAMPLES = 2000# 測試數量比率TEST_SIZE = 0.3# 利用工具函數直接生成數據集X, y = make_moons(n_samples=N_SAMPLES, noise=0.2, random_state=100)# 將 2000 個點按著 7:3 分割為訓練集和測試集X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=TEST_SIZE, random_state=42)return X, y, X_train, X_test, y_train, y_testdef make_plot(X, y, plot_name, XX=None, YY=None, preds=None, dark=False):# 繪制數據集的分布， X 為 2D 坐標， y 為數據點的標簽if (dark):plt.style.use('dark_background')else:sns.set_style("whitegrid")plt.figure(figsize=(16, 12))axes = plt.gca()axes.set(xlabel="$x_1$", ylabel="$x_2$")plt.title(plot_name, fontsize=30)plt.subplots_adjust(left=0.20)plt.subplots_adjust(right=0.80)if XX is not None and YY is not None and preds is not None:plt.contourf(XX, YY, preds.reshape(XX.shape), 25, alpha=1, cmap=plt.cm.Spectral)plt.contour(XX, YY, preds.reshape(XX.shape), levels=[.5], cmap="Greys", vmin=0, vmax=.6)# 繪制散點圖，根據標簽區分顏色plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), s=40, cmap=plt.cm.Spectral, edgecolors='none')plt.savefig('數據集分布.svg')plt.close()class Layer:# 全連接網絡層def __init__(self, n_input, n_neurons, activation=None, weights=None,bias=None):""":param int n_input: 輸入節點數:param int n_neurons: 輸出節點數:param str activation: 激活函數類型:param weights: 權值張量，默認類內部生成:param bias: 偏置，默認類內部生成"""# 通過正態分布初始化網絡權值，初始化非常重要，不合適的初始化將導致網絡不收斂self.weights = weights if weights is not None else np.random.randn(n_input, n_neurons) * np.sqrt(1 / n_neurons)self.bias = bias if bias is not None else np.random.rand(n_neurons) * 0.1self.activation = activation # 激活函數類型，如’sigmoid’self.last_activation = None # 激活函數的輸出值oself.error = None # 用于計算當前層的delta 變量的中間變量self.delta = None # 記錄當前層的delta 變量，用于計算梯度# 網絡層的前向傳播函數實現如下，其中last_activation 變量用于保存當前層的輸出值：def activate(self, x):# 前向傳播函數r = np.dot(x, self.weights) + self.bias # X@W+b# 通過激活函數，得到全連接層的輸出oself.last_activation = self._apply_activation(r)return self.last_activation# 上述代碼中的self._apply_activation 函數實現了不同類型的激活函數的前向計算過程，# 盡管此處我們只使用Sigmoid 激活函數一種。代碼如下：def _apply_activation(self, r):# 計算激活函數的輸出if self.activation is None:return r # 無激活函數，直接返回# ReLU 激活函數elif self.activation == 'relu':return np.maximum(r, 0)# tanh 激活函數elif self.activation == 'tanh':return np.tanh(r)# sigmoid 激活函數elif self.activation == 'sigmoid':return 1 / (1 + np.exp(-r))return r# 針對于不同類型的激活函數，它們的導數計算實現如下：def apply_activation_derivative(self, r):# 計算激活函數的導數# 無激活函數，導數為1if self.activation is None:return np.ones_like(r)# ReLU 函數的導數實現elif self.activation == 'relu':grad = np.array(r, copy=True)grad[r > 0] = 1.grad[r <= 0] = 0.return grad# tanh 函數的導數實現elif self.activation == 'tanh':return 1 - r ** 2# Sigmoid 函數的導數實現elif self.activation == 'sigmoid':return r * (1 - r)return r# 神經網絡模型 class NeuralNetwork:def __init__(self):self._layers = [] # 網絡層對象列表def add_layer(self, layer):# 追加網絡層self._layers.append(layer)# 網絡的前向傳播只需要循環調各個網絡層對象的前向計算函數即可，代碼如下：# 前向傳播def feed_forward(self, X):for layer in self._layers:# 依次通過各個網絡層X = layer.activate(X)return Xdef backpropagation(self, X, y, learning_rate):# 反向傳播算法實現# 前向計算，得到輸出值output = self.feed_forward(X)for i in reversed(range(len(self._layers))): # 反向循環layer = self._layers[i] # 得到當前層對象# 如果是輸出層if layer == self._layers[-1]: # 對于輸出層layer.error = y - output # 計算2 分類任務的均方差的導數# 關鍵步驟：計算最后一層的delta，參考輸出層的梯度公式layer.delta = layer.error * layer.apply_activation_derivative(output)else: # 如果是隱藏層next_layer = self._layers[i + 1] # 得到下一層對象layer.error = np.dot(next_layer.weights, next_layer.delta)# 關鍵步驟：計算隱藏層的delta，參考隱藏層的梯度公式layer.delta = layer.error * layer.apply_activation_derivative(layer.last_activation)# 循環更新權值for i in range(len(self._layers)):layer = self._layers[i]# o_i 為上一網絡層的輸出o_i = np.atleast_2d(X if i == 0 else self._layers[i - 1].last_activation)# 梯度下降算法，delta 是公式中的負數，故這里用加號layer.weights += layer.delta * o_i.T * learning_ratedef train(self, X_train, X_test, y_train, y_test, learning_rate, max_epochs):# 網絡訓練函數# one-hot 編碼y_onehot = np.zeros((y_train.shape[0], 2))y_onehot[np.arange(y_train.shape[0]), y_train] = 1# 將One-hot 編碼后的真實標簽與網絡的輸出計算均方誤差，并調用反向傳播函數更新網絡參數，循環迭代訓練集1000 遍即可mses = []accuracys = []for i in range(max_epochs + 1): # 訓練1000 個epochfor j in range(len(X_train)): # 一次訓練一個樣本self.backpropagation(X_train[j], y_onehot[j], learning_rate)if i % 10 == 0:# 打印出MSE Lossmse = np.mean(np.square(y_onehot - self.feed_forward(X_train)))mses.append(mse)accuracy = self.accuracy(self.predict(X_test), y_test.flatten())accuracys.append(accuracy)print('Epoch: #%s, MSE: %f' % (i, float(mse)))# 統計并打印準確率print('Accuracy: %.2f%%' % (accuracy * 100))return mses, accuracysdef predict(self, X):return self.feed_forward(X)def accuracy(self, X, y):return np.sum(np.equal(np.argmax(X, axis=1), y)) / y.shape[0]def main():X, y, X_train, X_test, y_train, y_test = load_dataset()# 調用 make_plot 函數繪制數據的分布，其中 X 為 2D 坐標， y 為標簽make_plot(X, y, "Classification Dataset Visualization ")plt.show()nn = NeuralNetwork() # 實例化網絡類nn.add_layer(Layer(2, 25, 'sigmoid')) # 隱藏層 1, 2=>25nn.add_layer(Layer(25, 50, 'sigmoid')) # 隱藏層 2, 25=>50nn.add_layer(Layer(50, 25, 'sigmoid')) # 隱藏層 3, 50=>25nn.add_layer(Layer(25, 2, 'sigmoid')) # 輸出層, 25=>2mses, accuracys = nn.train(X_train, X_test, y_train, y_test, 0.01, 1000)x = [i for i in range(0, 101, 10)]# 繪制MES曲線plt.title("MES Loss")plt.plot(x, mses[:11], color='blue')plt.xlabel('Epoch')plt.ylabel('MSE')plt.savefig('訓練誤差曲線.svg')plt.close()# 繪制Accuracy曲線plt.title("Accuracy")plt.plot(x, accuracys[:11], color='blue')plt.xlabel('Epoch')plt.ylabel('Accuracy')plt.savefig('網絡測試準確率.svg')plt.close()if __name__ == '__main__':main()

參考文獻:
[1] https://blog.csdn.net/woai8339/article/details/88628509
[2] https://blog.csdn.net/Liang_xj/article/details/85003467
[3] https://blog.csdn.net/weixin_43360025/article/details/119832866?spm=1001.2014.3001.5501
[4] https://blog.csdn.net/weixin_43360025/article/details/119607666?spm=1001.2014.3001.5501
[5] D. E. Rumelhart, G. E. Hinton 和 R. J. Williams, “{Learning Representations by Backpropagating
Errors},” Nature, 卷 323, 編號 6088, pp. 533-536, 1986.
[6] 尼克, 人工智能簡史, 圖靈教育, 2017.

創作挑戰賽新人創作獎勵來咯，堅持創作打卡瓜分現金大獎

總結

以上是生活随笔為你收集整理的深度学习（32）随机梯度下降十: 手写数字识别问题（层）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。