編者按：和Piotr Skalski一起，基于NumPy手寫神經網絡，通過親自動手實踐，加深對神經網絡內部機制的理解。

Keras、TensorFlow、PyTorch等高層框架讓我們可以快速搭建復雜模型。然而，花一點時間了解下底層概念是值得的。前不久我發過一篇文章，以簡單的方式解釋了神經網絡是如何工作的。但這是一篇高度理論性的文章，主要以數學為主（數學是神經網絡超能力的來源）。我打算以實踐的方式繼續這一主題，在這篇文章中，我們將嘗試僅僅基于NumPy創建一個可以工作的神經網絡。最后，我們將測試一下創建的模型——用它來解決簡單的分類問題，并和基于Keras搭建的神經網絡比較一下。

顯然，今天的文章會包含很多Python代碼，我希望你不會因此覺得枯燥。我同時也把文中所有的代碼發在GitHub上：SkalskiP/ILearnDeepLearning.py

概覽

在開始編程之前，先讓我們準備一份基本的路線圖。我們的目標是創建一個特定架構（層數、層大小、激活函數）的密集連接神經網絡。然后訓練這一神經網絡并做出預測。

上面的示意圖展示了訓練網絡時進行的操作，以及單次迭代不同階段需要更新和讀取的參數。

初始化神經網絡層

讓我們從初始化每一層的權重矩陣W和偏置向量b開始。下圖展示了網絡層l的權重矩陣和偏置向量，其中，上標[l]表示當前層的索引，n表示給定層中的神經元數量。

我們的程序也將以類似的列表形式描述神經網絡架構。列表的每一項是一個字典，描述單個網絡層的基本參數：input_dim是網絡層輸入的信號向量的大小，output_dim是網絡層輸出的激活向量的大小，activation是網絡層所用的激活函數。

nn_architecture = [

{"input_dim": 2, "output_dim": 4, "activation": "relu"},

{"input_dim": 4, "output_dim": 6, "activation": "relu"},

{"input_dim": 6, "output_dim": 6, "activation": "relu"},

{"input_dim": 6, "output_dim": 4, "activation": "relu"},

{"input_dim": 4, "output_dim": 1, "activation": "sigmoid"},

]

如果你熟悉這一主題，你的腦海中大概已經回蕩起焦急的聲音：“喂喂！搞錯了！這里有些是不必要的……”這一次，你內心的聲音是對的，一個網絡層的輸出向量同時也是下一層的輸入，所以其實只用列出兩者之一就夠了。不過，我故意使用這樣的表示法，使每一層的格式保持一致，也讓初次接觸這一主題的人更容易理解代碼。

def init_layers(nn_architecture, seed = 99):

np.random.seed(seed)

number_of_layers = len(nn_architecture)

params_values = {}

for idx, layer in enumerate(nn_architecture):

layer_idx = idx + 1

layer_input_size = layer["input_dim"]

layer_output_size = layer["output_dim"]

params_values['W' + str(layer_idx)] = np.random.randn(

layer_output_size, layer_input_size) * 0.1

params_values['b' + str(layer_idx)] = np.random.randn(

layer_output_size, 1) * 0.1

return params_values

上面的代碼初始化了網絡層的參數。注意我們用隨機的小數字填充矩陣W和向量b。這并不是偶然的。權重值無法使用相同的數字初始化，否則會造成破壞性的對稱問題。基本上，如果權重都一樣，不管輸入X是什么，隱藏層的所有單元也都一樣。這樣，我們就會陷入初始狀態，不管訓練多久，網絡多深，都無望擺脫。線性代數不會原諒我們。

小數值增加了算法的效率。我們可以看看下面的sigmoid函數圖像，大數值處的函數圖像幾乎是扁平的，這會對神經網絡的學習速度造成顯著影響。所有參數使用小隨機數是一個簡單的方法，但它保證了算法有一個足夠好的開始。

激活函數

激活函數只需一行代碼就可以定義，但它們給神經網絡帶來了非線性和所需的表達力?！皼]有它們，神經網絡將變成線性函數的組合，也就是單個線性函數?！奔せ詈瘮涤泻芏喾N，但在這個項目中，我決定使用其中兩種——sigmoid和ReLU。為了同時支持前向傳播和反向傳播，我們還需要準備好它們的導數。

def sigmoid(Z):

return1/(1+np.exp(-Z))

def relu(Z):

return np.maximum(0,Z)

def sigmoid_backward(dA, Z):

sig = sigmoid(Z)

return dA * sig * (1 - sig)

def relu_backward(dA, Z):

dZ = np.array(dA, copy = True)

dZ[Z <= 0] = 0;

return dZ;

前向傳播

我們設計的神經網絡有一個簡單的架構。輸入矩陣X傳入網絡，沿著隱藏單元傳播，最終得到預測向量Y_hat。為了讓代碼更易讀，我將前向傳播拆分成兩個函數——單層前向傳播，和整個神經網絡前向傳播。

def single_layer_forward_propagation(A_prev, W_curr, b_curr, activation="relu"):

Z_curr = np.dot(W_curr, A_prev) + b_curr

if activation is"relu":

activation_func = relu

elif activation is"sigmoid":

activation_func = sigmoid

else:

raiseException('Non-supported activation function')

return activation_func(Z_curr), Z_curr

這部分代碼大概是最直接，最容易理解的。給定來自上一層的輸入信號，我們計算仿射變換Z，接著應用選中的激活函數?；贜umPy，我們可以對整個網絡層和整批樣本一下子進行矩陣操作，無需迭代，這大大加速了計算。除了計算結果外，函數還返回了一個反向傳播時需要用到的中間值Z。

基于單層前向傳播函數，編寫整個前向傳播步驟很容易。這是一個略微復雜一點的函數，它的角色不僅是進行預測，還包括組織中間值。

def full_forward_propagation(X, params_values, nn_architecture):

memory = {}

A_curr = X

for idx, layer in enumerate(nn_architecture):

layer_idx = idx + 1

A_prev = A_curr

activ_function_curr = layer["activation"]

W_curr = params_values["W" + str(layer_idx)]

b_curr = params_values["b" + str(layer_idx)]

A_curr, Z_curr = single_layer_forward_propagation(A_prev, W_curr, b_curr, activ_function_curr)

memory["A" + str(idx)] = A_prev

memory["Z" + str(layer_idx)] = Z_curr

return A_curr, memory

損失函數

損失函數可以監測進展，確保我們向著正確的方向移動。“一般來說，損失函數是為了顯示我們離‘理想’解答還有多遠?！睋p失函數根據我們計劃解決的問題而選用，Keras之類的框架提供了很多選項。因為我計劃將神經網絡用于二元分類問題，我決定使用交叉熵：

為了取得更多關于學習過程的信息，我決定另外實現一個計算精確度的函數。

def get_cost_value(Y_hat, Y):

m = Y_hat.shape[1]

cost = -1 / m * (np.dot(Y, np.log(Y_hat).T) + np.dot(1 - Y, np.log(1 - Y_hat).T))

return np.squeeze(cost)

def get_accuracy_value(Y_hat, Y):

Y_hat_ = convert_prob_into_class(Y_hat)

return (Y_hat_ == Y).all(axis=0).mean()

反向傳播

不幸的是，很多缺乏經驗的深度學習愛好者都覺得反向傳播很嚇人，難以理解。微積分和線性代數的組合經常會嚇退那些沒有經過扎實的數學訓練的人。所以不要過于擔心你現在還不能理解這一切。相信我，我們都經歷過這個過程。

def single_layer_backward_propagation(dA_curr, W_curr, b_curr, Z_curr, A_prev, activation="relu"):

m = A_prev.shape[1]

if activation is"relu":

backward_activation_func = relu_backward

elif activation is"sigmoid":

backward_activation_func = sigmoid_backward

else:

raiseException('Non-supported activation function')

dZ_curr = backward_activation_func(dA_curr, Z_curr)

dW_curr = np.dot(dZ_curr, A_prev.T) / m

db_curr = np.sum(dZ_curr, axis=1, keepdims=True) / m

dA_prev = np.dot(W_curr.T, dZ_curr)

return dA_prev, dW_curr, db_curr

人們經常搞混反向傳播和梯度下降，但事實上它們不一樣。前者是為了高效地計算梯度，后者則是為了基于計算出的梯度進行優化。在神經網絡中，我們計算損失函數在參數上的梯度，但反向傳播可以用來計算任何函數的導數。反向傳播算法的精髓在于遞歸地使用求導的鏈式法則，通過組合導數已知的函數，計算函數的導數。下面的公式描述了單個網絡層上的反向傳播過程。由于本文的重點在實際實現，所以我將省略求導過程。從公式上我們可以很明顯地看到，為什么我們需要在前向傳播時記住中間層的A、Z矩陣的值。

和前向傳播一樣，我決定將計算拆分成兩個函數。之前給出的是單個網絡層的反向傳播函數，基本上就是以NumPy方式重寫上面的數學公式。而定義完整反向傳播過程的函數，主要是讀取、更新三個字典中的值。

def full_backward_propagation(Y_hat, Y, memory, params_values, nn_architecture):

grads_values = {}

m = Y.shape[1]

Y = Y.reshape(Y_hat.shape)

dA_prev = - (np.divide(Y, Y_hat) - np.divide(1 - Y, 1 - Y_hat));

for layer_idx_prev, layer in reversed(list(enumerate(nn_architecture))):

layer_idx_curr = layer_idx_prev + 1

activ_function_curr = layer["activation"]

dA_curr = dA_prev

A_prev = memory["A" + str(layer_idx_prev)]

Z_curr = memory["Z" + str(layer_idx_curr)]

W_curr = params_values["W" + str(layer_idx_curr)]

b_curr = params_values["b" + str(layer_idx_curr)]

dA_prev, dW_curr, db_curr = single_layer_backward_propagation(

dA_curr, W_curr, b_curr, Z_curr, A_prev, activ_function_curr)

grads_values["dW" + str(layer_idx_curr)] = dW_curr

grads_values["db" + str(layer_idx_curr)] = db_curr

return grads_values

基于單個網絡層的反向傳播函數，我們從最后一層開始迭代計算所有參數上的導數，并最終返回包含所需梯度的python字典。

更新參數值

反向傳播是為了計算梯度，以根據梯度進行優化，更新網絡的參數值。為了完成這一任務，我們將使用兩個字典作為函數參數：params_values，其中保存了當前參數值；grads_values，其中保存了用于更新參數值所需的梯度信息。現在我們只需在每個網絡層上應用以下等式即可。這是一個非常簡單的優化算法，但我決定使用它作為更高級的優化算法的起點（大概會是我下一篇文章的主題）。

def update(params_values, grads_values, nn_architecture, learning_rate):

for idx, layer in enumerate(nn_architecture):

layer_idx = idx + 1

params_values["W" + str(layer_idx)] -= learning_rate * grads_values["dW" + str(layer_idx)]

params_values["b" + str(layer_idx)] -= learning_rate * grads_values["db" + str(layer_idx)]

return params_values;

整合一切

萬事俱備只欠東風。最困難的部分已經完成了——我們已經準備好了所需的函數，現在只需以正確的順序把它們放到一起。

def train(X, Y, nn_architecture, epochs, learning_rate):

params_values = init_layers(nn_architecture, 2)

cost_history = []

accuracy_history = []

for i in range(epochs):

Y_hat, cashe = full_forward_propagation(X, params_values, nn_architecture)

cost = get_cost_value(Y_hat, Y)

cost_history.append(cost)

accuracy = get_accuracy_value(Y_hat, Y)

accuracy_history.append(accuracy)

grads_values = full_backward_propagation(Y_hat, Y, cashe, params_values, nn_architecture)

params_values = update(params_values, grads_values, nn_architecture, learning_rate)

return params_values, cost_history, accuracy_history

大衛對戰歌利亞

該是看看我們的模型能不能解決一個簡單的分類問題的時候了。我生成了一個包含兩個分類的數據點的數據集，如下圖所示。

作為對比，我用高層框架Keras搭建了一個模型。兩個模型采用相同的架構和學習率。不過這仍然是一場不公平的較量，因為我們的模型用的都是最簡單的方案。最終，基于NumPy和Keras的模型在測試集上都取得了類似的精確度（95%）。不過，我們的模型收斂的速度要慢很多倍。在我看來，這主要是因為我們的模型缺乏恰當的優化算法。

再見

希望我的文章拓展了你的視野，增加了你對神經網絡內部運作機制的理解——這將是對我投入精力撰寫本文的最好回報。我在編寫代碼和說明的時候也學到了很多東西，親自動手實踐能讓你學到很多東西。

如你有任何疑問，或者找到了代碼中的錯誤，請留言告知。如果你喜歡這篇文章，可以在Twitter（PiotrSkalski92）和Medium（piotr.skalski92）上關注我，也可以上GitHub（SkalskiP）和Kaggle（skalskip）查看我的其他項目。本文是“神經網絡的奧秘”系列的第三篇，如果你還沒有讀過前兩篇，可以看一下https://towardsdatascience.com/preventing-deep-neural-network-from-overfitting-953458db800a

保持好奇心！