在筆記 1 和 2 里筆者使用 numpy 手動搭建了感知機單元與一個單隱層的神經網絡，理解了神經網絡的基本架構和傳播原理，掌握了如何從零開始手寫一個神經網絡。但以上僅是神經網絡和深度學習的基礎內容，深度學習的一大特征就在于隱藏層之深。因而，我們就這前面的思路，繼續(xù)利用 numpy 工具，手動搭建一個 DNN 深度神經網絡。

再次回顧一下之前我們在搭建神經網絡時所秉持的思路和步驟：

• 定義網絡結構

• 初始化模型參數

• 循環(huán)計算：前向傳播/計算當前損失/反向傳播/權值更新

神經網絡的計算流程

初始化模型參數

對于一個包含L層的隱藏層深度神經網絡，我們在初始化其模型參數的時候需要更靈活一點。我們可以將網絡結構作為參數傳入初始化函數里面：

def initialize_parameters_deep(layer_dims):
  np.random.seed(3)
  parameters = {}  
  # number of layers in the network
  L = len(layer_dims)      

  for l in range(1, L):
    parameters['W' + str(l)] = np.random.randn(layer_dims[l], layer_dims[l-1])*0.01
    parameters['b' + str(l)] = np.zeros((layer_dims[l], 1)) 
   
  assert(parameters['W' + str(l)].shape == (layer_dims[l], layer_dims[l-1]))    
  assert(parameters['b' + str(l)].shape == (layer_dims[l], 1))
  return parameters

以上代碼中，我們將參數 layer_dims 定義為一個包含網絡各層維數的 list ，使用隨機數和歸零操作來初始化權重 W 和偏置 b 。

比如說我們指定一個輸入層大小為 5 ，隱藏層大小為 4 ，輸出層大小為 3 的神經網絡，調用上述參數初始化函數效果如下：

parameters=initialize_parameters_deep([5,4,3])
print("W1="+str(parameters["W1"]))
print("b1="+str(parameters["b1"]))
print("W2="+str(parameters["W2"]))
print("b2="+str(parameters["b2"]))

W1 = [[ 0.01788628 0.0043651  0.00096497 -0.01863493 -0.00277388] [-0.00354759 -0.00082741 -0.00627001 -0.00043818 -0.00477218] [-0.01313865 0.00884622 0.00881318 0.01709573 0.00050034] [-0.00404677 -0.0054536 -0.01546477 0.00982367 -0.01101068]] 
b1 = [[0.] [0.] [0.] [0.]] 
W2 = [[-0.01185047 -0.0020565  0.01486148 0.00236716] [-0.01023785 -0.00712993 0.00625245 -0.00160513] [-0.00768836 -0.00230031 0.00745056 0.01976111]] 
b2 = [[0.] [0.] [0.]]

前向傳播

前向傳播的基本過程就是執(zhí)行加權線性計算和對線性計算的結果進行激活函數處理的過程。除了此前常用的 sigmoid 激活函數，這里我們引入另一種激活函數 ReLU ，那么這個 ReLU 又是個什么樣的激活函數呢？

ReLU

ReLU 全稱為線性修正單元，其函數形式表示為 y = max(0, x).
從統計學本質上講，ReLU 其實是一種斷線回歸函數，其主要功能在于能在計算反向傳播時緩解梯度消失的情形。相對書面一點就是，ReLU 具有稀疏激活性的優(yōu)點。關于ReLU的更多細節(jié)，這里暫且按下不表，我們繼續(xù)定義深度神經網絡的前向計算函數：

def linear_activation_forward(A_prev, W, b, activation):
  if activation == "sigmoid":
    Z, linear_cache = linear_forward(A_prev, W, b)
    A, activation_cache = sigmoid(Z)  
  elif activation == "relu":
    Z, linear_cache = linear_forward(A_prev, W, b)
    A, activation_cache = relu(Z)  
  
  assert (A.shape == (W.shape[0], A_prev.shape[1]))
  cache = (linear_cache, activation_cache)  
  return A, cache

在上述代碼中， 參數 A_prev 為前一步執(zhí)行前向計算的結果，中間使用了一個激活函數判斷，對兩種不同激活函數下的結果分別進行了討論。

對于一個包含L層采用 ReLU 作為激活函數，最后一層采用 sigmoid 激活函數，前向計算流程如下圖所示。

定義L層神經網絡的前向計算函數為：

def L_model_forward(X, parameters):
  caches = []
  A = X  
  # number of layers in the neural network
  L = len(parameters) // 2         

  # Implement [LINEAR -> RELU]*(L-1)
  for l in range(1, L):
    A_prev = A 
    A, cache = linear_activation_forward(A_prev, parameters["W"+str(l)], parameters["b"+str(l)], "relu")
    caches.append(cache)  
  # Implement LINEAR -> SIGMOID
  AL, cache = linear_activation_forward(A, parameters["W"+str(L)], parameters["b"+str(L)], "sigmoid")
  caches.append(cache)  
  
  assert(AL.shape == (1,X.shape[1]))  
  return AL, caches

計算當前損失

有了前向傳播的計算結果之后，就可以根據結果值計算當前的損失大小。定義計算損失函數為：

def compute_cost(AL, Y):
  m = Y.shape[1]  
  # Compute loss from aL and y.
  cost = -np.sum(np.multiply(Y,np.log(AL))+np.multiply(1-Y,np.log(1-AL)))/m

  cost = np.squeeze(cost) 
    
  assert(cost.shape == ())  
  return cost

執(zhí)行反向傳播

執(zhí)行反向傳播的關鍵在于正確的寫出關于權重 W 和 偏置b 的鏈式求導公式，對于第 l層而言，其線性計算可表示為：

響應的第l層的W 和 b 的梯度計算如下：

由上分析我們可定義線性反向傳播函數和線性激活反向傳播函數如下：

def linear_backward(dZ, cache):
  A_prev, W, b = cache
  m = A_prev.shape[1]

  dW = np.dot(dZ, A_prev.T)/m
  db = np.sum(dZ, axis=1, keepdims=True)/m
  dA_prev = np.dot(W.T, dZ)  

  assert (dA_prev.shape == A_prev.shape)  
  assert (dW.shape == W.shape)  
  assert (db.shape == b.shape)  
  
  return dA_prev, dW, db

def linear_activation_backward(dA, cache, activation):
  linear_cache, activation_cache = cache  
  if activation == "relu":
    dZ = relu_backward(dA, activation_cache)
    dA_prev, dW, db = linear_backward(dZ, linear_cache)  
  elif activation == "sigmoid":
    dZ = sigmoid_backward(dA, activation_cache)
    dA_prev, dW, db = linear_backward(dZ, linear_cache)  
  return dA_prev, dW, db

根據以上兩個反向傳播函數，我們可繼續(xù)定義L層網絡的反向傳播函數：

def L_model_backward(AL, Y, caches):
  grads = {}
  L = len(caches) 
  # the number of layers
  m = AL.shape[1]
  Y = Y.reshape(AL.shape) 
  # after this line, Y is the same shape as AL

  # Initializing the backpropagation
  dAL = - (np.divide(Y, AL) - np.divide(1 - Y, 1 - AL))  
  # Lth layer (SIGMOID -> LINEAR) gradients
  current_cache = caches[L-1]
  grads["dA" + str(L)], grads["dW" + str(L)], grads["db" + str(L)] = linear_activation_backward(dAL, current_cache, "sigmoid")  
  for l in reversed(range(L - 1)):
    current_cache = caches[l]
    dA_prev_temp, dW_temp, db_temp = linear_activation_backward(grads["dA" + str(l + 2)], current_cache, "relu")
    grads["dA" + str(l + 1)] = dA_prev_temp
    grads["dW" + str(l + 1)] = dW_temp
    grads["db" + str(l + 1)] = db_temp  
  return grads

反向傳播涉及大量的復合函數求導計算，所以這一塊需要一定的微積分基礎。這也是為什么數學是深度學習人工智能的基石所在。

權值更新

反向傳播計算完成后，即可根據反向計算結果對權值參數進行更新，定義參數更新函數如下：

def update_parameters(parameters, grads, learning_rate):
  # number of layers in the neural network
  L = len(parameters) // 2 
  # Update rule for each parameter. Use a for loop.
  for l in range(L):
    parameters["W" + str(l+1)] = parameters["W"+str(l+1)] - learning_rate*grads["dW"+str(l+1)]
    parameters["b" + str(l+1)] = parameters["b"+str(l+1)] - learning_rate*grads["db"+str(l+1)]  
  return parameters

封裝搭建過程

到此一個包含$$層隱藏層的深度神經網絡就搭建好了。當然了，跟前面保持統一，也需要 pythonic 的精神，我們繼續(xù)對全過程的各個函數進行統一封裝，定義一個封裝函數：

def L_layer_model(X, Y, layers_dims, learning_rate = 0.0075, num_iterations = 3000, print_cost=False):
  np.random.seed(1)
  costs = []  

  # Parameters initialization.
  parameters = initialize_parameters_deep(layers_dims)  
  # Loop (gradient descent)
  for i in range(0, num_iterations):    
    # Forward propagation: 
    # [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID
    AL, caches = L_model_forward(X, parameters)    
    # Compute cost.
    cost = compute_cost(AL, Y)    
    # Backward propagation.
    grads = L_model_backward(AL, Y, caches)    
    # Update parameters.
    parameters = update_parameters(parameters, grads, learning_rate)    
    # Print the cost every 100 training example
    if print_cost and i % 100 == 0:      
      print ("Cost after iteration %i: %f" %(i, cost))    if print_cost and i % 100 == 0:
      costs.append(cost)  
  # plot the cost
  plt.plot(np.squeeze(costs))
  plt.ylabel('cost')
  plt.xlabel('iterations (per tens)')
  plt.title("Learning rate =" + str(learning_rate))
  plt.show()  
  
  return parameters

這樣一個深度神經網絡計算完整的搭建完畢了。從兩層網絡推到$$層網絡從原理上是一樣的，幾個難點在于激活函數的選擇和處理、反向傳播中的多層復雜鏈式求導等。多推導原理，多動手實踐，相信你會自己搭建深度神經網絡。