純用NumPy實現(xiàn)神經(jīng)網(wǎng)絡的示例代碼

更新時間：2018年10月24日 13:39:30 作者：阿里云云棲社區(qū)

這篇文章主要介紹了純用NumPy實現(xiàn)神經(jīng)網(wǎng)絡的示例代碼，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

摘要：純NumPy代碼從頭實現(xiàn)簡單的神經(jīng)網(wǎng)絡。

Keras、TensorFlow以及PyTorch都是高級別的深度學習框架，可用于快速構(gòu)建復雜模型。前不久，我曾寫過一篇文章，對神經(jīng)網(wǎng)絡是如何工作的進行了簡單的講解。該文章側(cè)重于對神經(jīng)網(wǎng)絡中運用到的數(shù)學理論知識進行詳解。本文將利用NumPy實現(xiàn)簡單的神經(jīng)網(wǎng)絡，在實戰(zhàn)中對其進行深層次剖析。最后，我們會利用分類問題對模型進行測試，并與Keras所構(gòu)建的神經(jīng)網(wǎng)絡模型進行性能的比較。

Note：源碼可在我的GitHub中查看。

在正式開始之前，需要先對所做實驗進行構(gòu)思。我們想要編寫一個程序，使其能夠創(chuàng)建一個具有指定架構(gòu)（層的數(shù)量、大小以及激活函數(shù)）的神經(jīng)網(wǎng)絡，如圖一所示?？傊覀冃枰A先對網(wǎng)絡進行訓練，然后利用它進行預測。

上圖展示了神經(jīng)網(wǎng)絡在被訓練時的工作流程。從中我們可以清楚的需要更新的參數(shù)數(shù)量以及單次迭代的不同狀態(tài)。構(gòu)建并管理正確的數(shù)據(jù)架構(gòu)是其中最困難的一環(huán)。由于時間限制，圖中所示的參數(shù)不會一一詳解，有興趣可點擊此處進行了解。

神經(jīng)網(wǎng)絡層的初始化

首先，對每一層的權(quán)重矩陣W及偏置向量b進行初始化。在上圖中，上標[l]表示目前是第幾層（從1開始），n的值表示一層中的神經(jīng)元數(shù)量。描述神經(jīng)網(wǎng)絡架構(gòu)的信息類似于Snippet 1中所列內(nèi)容。每一項都描述了單層神經(jīng)網(wǎng)絡的基本參數(shù)：input_dim，即輸入層神經(jīng)元維度；output_dim，即輸出層神經(jīng)元維度；activation，即使用的激活函數(shù)。

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.

從Snippet 1可看出，每一層輸出神經(jīng)元的維度等于下一層的輸入維度。對權(quán)重矩陣W及偏置向量b進行初始化的代碼如下：

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.

在本節(jié)中，我們利用NumPy將權(quán)重矩陣W及偏置向量b初始化為小的隨機數(shù)。特別注意的是，初始化權(quán)重值不能相同，否則網(wǎng)絡會變?yōu)閷ΨQ的。也就是說，如果權(quán)重初始化為同一值，則對于任何輸入X，每個隱藏層對應的每個神經(jīng)元的輸出都是相同的，這樣即使梯度下降訓練，無論訓練多少次，這些神經(jīng)元都是對稱的，無論隱藏層內(nèi)有多少個結(jié)點，都相當于在訓練同一個函數(shù)。

初始化的值較小能夠使得算法第一次迭代的時候效率更高。Sigmoid函數(shù)圖像如下圖所示，它對中央?yún)^(qū)的信號增益較大，對兩側(cè)區(qū)的信號增益小。

激活函數(shù)（Activation functions）

激活函數(shù)在神經(jīng)網(wǎng)絡中至關(guān)重要，其原理簡單但功能強大，給神經(jīng)元引入了非線性因素，使得神經(jīng)網(wǎng)絡可以任意逼近任何非線性函數(shù)，從而應用于眾多的非線性模型?！叭绻麤]有激活函數(shù)，每一層輸出都是上層輸入的線性函數(shù)，無論神經(jīng)網(wǎng)絡有多少層，輸出都是輸入的線性組合?！奔せ詈瘮?shù)種類眾多，本文選取了最常用的兩種——ReLU及Sigmoid函數(shù)，代碼如下：

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.

前向傳播算法（Forward propagation）

本文所設計的神經(jīng)網(wǎng)絡結(jié)構(gòu)簡單，信息流只有一個方向：以X矩陣的形式傳遞，穿過所有隱藏層單元，最終輸出預測結(jié)構(gòu)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:
    raise Exception('Non-supported activation function')

  return activation_func(Z_curr), Z_curr

Snippet 4.

前向傳播就是上層處理完的數(shù)據(jù)作為下一層的輸入數(shù)據(jù)，然后進行處理(權(quán)重)，再傳給下一層，這樣逐層處理，最后輸出。給定上一層的輸入信號，計算仿射變換（affine transformation）Z，然后應用選定的激活函數(shù)。

前向傳播算法代碼如下，該函數(shù)不僅進行預測計算，還存儲中間層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

Snippet 5.

損失函數(shù)（Loss function）

損失函數(shù)是用來估量模型的預測值與真實值的不一致程度，它是一個非負實值函數(shù)。損失函數(shù)由我們想要解決的問題所決定。在本文中，我們想要測試神經(jīng)網(wǎng)絡模型區(qū)分兩個類別的能力，所以選擇了交叉熵損失函數(shù)（binary_crossentropy），其定義如下：

為了更加清楚的了解學習過程，我增添了一個用于計算精度的函數(shù)：

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()

Snippet 6.

反向傳播算法（Backward propagation）

許多缺乏經(jīng)驗的深度學習愛好者認為反向傳播是一種復雜且難以理解的算法。

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

Snippet 7.

其實，他們困惑的也就是反向傳播算法中的梯度下降問題，但二者并不可混為一談。前者旨在有效地計算梯度，而后者是利用計算得到的梯度進行優(yōu)化。梯度下降可以應對帶有明確求導函數(shù)的情況，我們可以把它看作沒有隱藏層的網(wǎng)絡；但對于多隱藏層的神經(jīng)網(wǎng)絡，應先將誤差反向傳播至隱藏層，然后再應用梯度下降，其中將誤差從最末層往前傳遞的過程需要鏈式法則，反向傳播算法可以說是梯度下降在鏈式法則中的應用。對于單層的神經(jīng)網(wǎng)絡，該過程如下所示：

本文省略的推導過程，但從上面的公式仍可看出A和Z矩陣值的重要性。

Snippet 7中所示代碼僅編寫了神經(jīng)網(wǎng)絡中某層的反向傳播算法，Snippet 8將展示神經(jīng)網(wǎng)絡中完整的反向傳播算法。

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

Snippet 8.

參數(shù)更新（Updating parameters values）

該部分旨在利用計算得到梯度更新網(wǎng)絡中的參數(shù)，同時最小化目標函數(shù)。我們會使用到params_values，它存放當前的參數(shù)值，以及grads_values，它存放存儲關(guān)于這些參數(shù)的損失函數(shù)的導數(shù)?，F(xiàn)在只需要在神經(jīng)網(wǎng)絡的每層應用如下公式即可：

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;

Snippet 9.

整合（Putting things together）

現(xiàn)在我們只需將準備好的函數(shù)按照正確的順序整合到一起，若對正確的順序有疑問請參見圖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

Snippet 10.

對比分析（David vs Goliath）

接下來，我們將利用所構(gòu)建的模型解決簡單的分類問題。如圖7所示，本次實驗使用的數(shù)據(jù)集包含兩個類別。我們將訓練模型對兩個不同的類別進行區(qū)分。此外，我們還準備了一個由Keras所構(gòu)建的神經(jīng)網(wǎng)絡模型以進行對比。兩個模型具有相同的架構(gòu)和學習速率。雖然我們的模型很簡單，但結(jié)果表明，NumPy和Keras模型在測試集上均達到了95%的準確率。只是我們的模型耗費了更多的時間，未來工作可通過加強優(yōu)化改善時間開銷問題。