摘要：看過上的代碼并對有一定經驗的人會發現，矩陣和向量被小的隨機數填充。一般來說，損失函數用來表征我們與理想解決方案的距離。損失函數和準確率計算反向傳播許多缺乏經驗的深度學習愛好者認為反向傳播是一種難以理解的算法。

BP（Back Propagation）神經網絡是1986年由Rumelhart和McCelland為首的科學家小組提出，是一種==按誤差逆傳播算法訓練的多層前饋網絡==，是目前應用最廣泛的神經網絡模型之一。BP網絡能學習和存貯大量的==輸入-輸出模式映射關系==，而無需事前揭示描述這種映射關系的數學方程。它的學習規則是使用梯度下降法，通過反向傳播來不斷調整網絡的權值和閾值，使==網絡的誤差平方和最小==。BP神經網絡模型拓撲結構包括輸入層（input）、隱層(hidden layer)和輸出層(output layer)。

注：本文將包含大量用 Python 編寫的代碼片段。希望讀起來不會太無聊。

Keras、TensorFlow、PyTorch 等高級框架可以幫助我們快速構建復雜模型。深入研究并理解其中的理念很有價值。下面嘗試只使用 NumPy 構建一個全運算的神經網絡，通過解決簡單的分類問題來測試模型，并將其與 Keras 構建的神經網絡進行性能比較。

密集神經網絡架構

在開始編程之前，需要先整理一個基本的路線圖。我們的目標是創建一個程序，該程序能創建一個擁有特定架構（層的數量和大小以及激活函數都是確定的）的密集連接神經網絡。圖 1 給出了網絡的示例。最重要的是，網絡必須可訓練且能進行預測。

神經網絡框圖
上圖顯示了在訓練神經網絡時需要執行的操作。它還顯示了在單次迭代的不同階段，需要更新和讀取多少參數。構建正確的數據結構并熟練地管理其狀態是任務中最困難的部分之一。

l 層的權值矩陣 W 和偏置向量 b 的維數。

首先初始化每一層的權值矩陣 W 和偏置向量 b。在圖 3 中。先準備一個為系數分配適當維數的清單。上標 [l] 表示當前層的索引 (從 1 數起)，值 n 表示給定層中的單位數。假設描述 NN 架構的信息將以類似 Snippet 1 的列表形式傳遞到程序中，列表的每一項是一個描述單個網絡層基本參數的字典：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"},
]

Snippet 1：包含描述特定神經網絡參數的列表。該列表對應圖 1 所示的 NN。

如果你對這個話題很熟悉，你可能已經在腦海中聽到一個焦慮的聲音：「嘿，嘿！這里有問題！有些領域是不必要的……」是的，這次你內心的聲音是對的。前一層輸出的向量是下一層的輸入，所以實際上只知道一個向量的大小就足夠了。但我特意使用以下符號來保持所有層之間目標的一致性，使那些剛接觸這一課題的人更容易理解代碼。

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

Snippet 2：初始化權值矩陣和偏置向量值的函數。

最后是這一部分最主要的任務——層參數初始化。看過 Snippet 2 上的代碼并對 NumPy 有一定經驗的人會發現，矩陣 W 和向量 b 被小的隨機數填充。這種做法并非偶然。權值不能用相同的數字初始化，不然會出現「對稱問題」。如果所有權值一樣，不管輸入 X 是多少，隱藏層中的所有單位都相同。在某種程度上，我們在初始階段就會陷入死循環，無論訓練模型時間多長、網絡多深都無法逃脫。線性代數是不會被抵消的。

在第一次迭代中，使用較小的數值可以提高算法效率。通過圖 4 所示的 sigmoid 函數圖可以看到，對于較大數值，它幾乎是平的，這十分影響 NN 的學習速度。總之，使用小隨機數進行參數初始化是一種簡單的方法，能保證我們的算法有足夠好的起點。準備好的參數值存儲在帶有唯一標定其父層的 python 字典中。字典在函數末尾返回，因此算法的下一步是訪問它的內容。

算法中使用的激活函數
我們將使用的函數中，有幾個函數非常簡單但功能強大。激活函數可以寫在一行代碼中，但卻能使神經網絡表現出自身所需的非線性性能和可表達性。「沒有它們，我們的神經網絡就會變成由多個線性函數組合而成的線性函數。」可選激活函數很多，但在這個項目中，我決定使用這兩種——sigmoid 和 ReLU。為了能夠得到完整循環并同時進行前向和反向傳播，我們還需要求導。

def sigmoid(Z):
    return 1/(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;

Snippet 3：ReLU 和 Sigmoid 激活函數及其導數。

設計好的神經網絡有一個簡單的架構。信息以 X 矩陣的形式沿一個方向傳遞，穿過隱藏的單元，從而得到預測向量 Y_hat。為了便于閱讀，我將前向傳播分解為兩個多帶帶的函數——對單個層進行前向傳播和對整個 NN 進行前向傳播。

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:
        raise Exception("Non-supported activation function")

    return activation_func(Z_curr), Z_curr

Snippet 4：單層前向傳播步驟

這部分代碼可能是最容易理解的。給定上一層的輸入信號，我們計算仿射變換 Z，然后應用選定的激活函數。通過使用 NumPy，我們可以利用向量化——一次性對整個層和整批示例執行矩陣運算。這減少了迭代次數，大大加快了計算速度。除了計算矩陣 A，我們的函數還返回一個中間值 Z。作用是什么呢？答案如圖 2 所示。我們需要在反向傳播中用到 Z。

在前向傳播中使用的單個矩陣的維數
使用預設好的一層前向函數后，就可以輕松地構建整個前向傳播。這個函數稍顯復雜，它的作用不僅是預測，還要管理中間值的集合。它返回 Python 字典，其中包含為特定層計算的 A 和 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

Snippnet 5：完整前向傳播步驟

為了觀察進度，保證正確方向，我們通常需要計算損失函數的值。「一般來說，損失函數用來表征我們與『理想』解決方案的距離。」我們根據要解決的問題來選擇損失函數，像 Keras 這樣的框架會有多種選擇。因為我計劃測試我們的 NN 在兩類點上的分類，所以選擇二進制交叉熵，它定義如下。為了獲得更多學習過程的信息，我決定引入一個計算準確率的函數。

Snippnet 6：損失函數和準確率計算

許多缺乏經驗的深度學習愛好者認為反向傳播是一種難以理解的算法。微積分和線性代數的結合常常使缺乏數學基礎的人望而卻步。所以如果你無法馬上理解，也不要擔心。相信我，我們都經歷過這個過程。

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:
        raise Exception("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

Snippnet 7：單層反向傳播步驟

人們常常混淆反向傳播與梯度下降，但實際上這是兩個獨立的問題。前者的目的是有效地計算梯度，而后者是利用計算得到的梯度進行優化。在 NN 中，我們計算關于參數的代價函數梯度（之前討論過），但是反向傳播可以用來計算任何函數的導數。這個算法的本質是在已知各個函數的導數后，利用微分學中的鏈式法則計算出結合成的函數的導數。對于一層網絡，這個過程可用下面的公式描述。本文主要關注的是實際實現，故省略推導過程。通過公式可以看出，預先記住中間層的 A 矩陣和 Z 矩陣的值是十分必要的。

一層中的前向和反向傳播
就像前向傳播一樣，我決定將計算分為兩個獨立的函數。第一個函數（Snippnet7）側重一個多帶帶的層，可以歸結為用 NumPy 重寫上面的公式。第二個表示完全反向傳播，主要在三個字典中讀取和更新值。然后計算預測向量（前向傳播結果）的代價函數導數。這很簡單，它只是重述了下面的公式。然后從末端開始遍歷網絡層，并根據圖 6 所示的圖計算所有參數的導數。最后，函數返回 python 字典，其中就有我們想求的梯度。

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

Snippnet 8：全反向傳播步驟

該方法的目標是利用梯度優化來更新網絡參數，以使目標函數更接近最小值。為了實現這項任務，我們使用兩個字典作為函數參數：params_values 存儲參數的當前值；grads_values 存儲根據參數計算出的代價函數導數。雖然該優化算法非常簡單，只需對每一層應用下面的方程即可，但它可以作為更高級優化器的一個良好起點，所以我決定使用它，這也可能是我下一篇文章的主題。

def update(params_values, grads_values, nn_architecture, learning_rate):
    for layer_idx, layer in enumerate(nn_architecture):
        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;

Snippnet 9：利用梯度下降更新參數值

任務中最困難的部分已經過去了，我們已經準備好了所有必要的函數，現在只需把它們按正確的順序組合即可。為了更好地理解操作順序，需要對照圖 2 的表。該函數經過訓練和期間的權值變化返回了最優權重。只需要使用接收到的權重矩陣和一組測試數據即可運行完整的前向傳播，從而進行預測。

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

Snippnet 10：訓練模型

如果對Python編程、網絡爬蟲、機器學習、數據挖掘、web開發、人工智能、面試經驗交流。感興趣可以519970686，群內會有不定期的發放免費的資料鏈接，這些資料都是從各個技術網站搜集、整理出來的，如果你有好的學習資料可以私聊發我，我會注明出處之后分享給大家。

現在可以檢驗我們的模型在簡單的分類問題上的表現了。我生成了一個由兩類點組成的數據集，如圖 7 所示。然后讓模型學習對兩類點分類。為了便于比較，我還在高級框架中編寫了 Keras 模型。兩種模型具有相同的架構和學習速率。盡管如此，這樣對比還是稍有不公，因為我們準備的測試太過于簡單。最終，NumPy 模型和 Keras 模型在測試集上的準確率都達到了 95%，但是我們的模型需要多花幾十倍的時間才能達到這樣的準確率。在我看來，這種狀態主要是由于缺乏適當的優化。

測試數據集

兩種模型實現的分類邊界可視化