深度學(xué)習(xí)筆記3：手動搭建深度神經(jīng)網(wǎng)絡(luò)（DNN）

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

再次回顧一下之前我們在搭建神經(jīng)網(wǎng)絡(luò)時所秉持的思路和步驟：

• 定義網(wǎng)絡(luò)結(jié)構(gòu)

• 初始化模型參數(shù)

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

神經(jīng)網(wǎng)絡(luò)的計算流程

初始化模型參數(shù)

對于一個包含L層的隱藏層深度神經(jīng)網(wǎng)絡(luò)，我們在初始化其模型參數(shù)的時候需要更靈活一點。我們可以將網(wǎng)絡(luò)結(jié)構(gòu)作為參數(shù)傳入初始化函數(shù)里面：

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

以上代碼中，我們將參數(shù) layer_dims 定義為一個包含網(wǎng)絡(luò)各層維數(shù)的 list ，使用隨機(jī)數(shù)和歸零操作來初始化權(quán)重 W 和偏置 b 。

比如說我們指定一個輸入層大小為 5 ，隱藏層大小為 4 ，輸出層大小為 3 的神經(jīng)網(wǎng)絡(luò)，調(diào)用上述參數(shù)初始化函數(shù)效果如下：

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í)行加權(quán)線性計算和對線性計算的結(jié)果進(jìn)行激活函數(shù)處理的過程。除了此前常用的 sigmoid 激活函數(shù)，這里我們引入另一種激活函數(shù) ReLU ，那么這個 ReLU 又是個什么樣的激活函數(shù)呢？

ReLU

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

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

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

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

定義L層神經(jīng)網(wǎng)絡(luò)的前向計算函數(shù)為：

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

計算當(dāng)前損失

有了前向傳播的計算結(jié)果之后，就可以根據(jù)結(jié)果值計算當(dāng)前的損失大小。定義計算損失函數(shù)為：

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í)行反向傳播的關(guān)鍵在于正確的寫出關(guān)于權(quán)重 W 和 偏置b 的鏈?zhǔn)角髮?dǎo)公式，對于第 l層而言，其線性計算可表示為：

響應(yīng)的第l層的W 和 b 的梯度計算如下：

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

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

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

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

反向傳播涉及大量的復(fù)合函數(shù)求導(dǎo)計算，所以這一塊需要一定的微積分基礎(chǔ)。這也是為什么數(shù)學(xué)是深度學(xué)習(xí)人工智能的基石所在。

權(quán)值更新

反向傳播計算完成后，即可根據(jù)反向計算結(jié)果對權(quán)值參數(shù)進(jìn)行更新，定義參數(shù)更新函數(shù)如下：

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

封裝搭建過程

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

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

這樣一個深度神經(jīng)網(wǎng)絡(luò)計算完整的搭建完畢了。從兩層網(wǎng)絡(luò)推到$$層網(wǎng)絡(luò)從原理上是一樣的，幾個難點在于激活函數(shù)的選擇和處理、反向傳播中的多層復(fù)雜鏈?zhǔn)角髮?dǎo)等。多推導(dǎo)原理，多動手實踐，相信你會自己搭建深度神經(jīng)網(wǎng)絡(luò)。