本章將利用numpy搭建一個單隱層的神經網絡，選擇2個輸入單元，4個隱藏單元和2個輸出單元。
神經網絡的搭建由以下六個步驟完成：
1、定義神經網絡結構
2、初始化模型參數（w和b）
3、前向傳播算法結構設計
4、損失函數定義
5、反向傳播算法結構設計
6、權值迭代與更新算法結構設計
7、封裝代碼，整合模型便於直接調用
在進行神經網絡的構建之前，首先需要定義神經網絡的結構
網絡結構的定義
僞代碼
def 結構函數（樣本集，標籤集）
定義輸入層神經元個數
定義隱層神經元個數（這裏我們簡單設置單元數爲4）
定義輸出層神經元個數
return （輸入層神經元個數，隱層神經元個數，輸出層神經元個數）
程序實現
def layer_sizes(X, Y):
n_x = X.shape[0]
n_h = 4
n_y = Y.shape[0]
return (n_x, n_h, n_y)
接着，需要初始化我們的模型參數
【回顧】
權值w：連接層與層之間各神經元間的權重
偏置單元b：隱層、輸出層作爲輸出時加上的偏值
初始化模型參數
僞代碼如下：
def 初始化模型參數（輸入層神經元個數，隱層神經元個數，輸出層神經元個數）
權值1 = <輸入層單元→隱層>間的權值參數（用於計算w*x）
偏值1 = <隱層偏置單元>加上的偏值(b，用於計算w*x + b)
權值2 = <隱層→輸出層>間的權值參數（用於計算w*hid_x）
偏值2 = <輸出層偏置單元>加上的偏值（b2, 用於計算w*hid_x + b）
將初始化的參數放入數據字典pararameters{}
return parameters
程序實現
def initialize_parameters(n_x, n_h, n_y):
#這裏之所以n_h在前，n_x在後，因爲w是根據隱層單元個數決定了行數，列數由輸入層單元決定
#這裏在w的初始化中用到了random隨機數生成方法
#在b的初始化中用到了zeros方法
W1 = np.random.randn(n_h, n_x)*0.01
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h)*0.01
b2 = np.zeros((n_y, 1))
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
以上就是前期的準備工作，當準備工作完成後，就可以開始神經網絡算法核心部分——前向傳播，損失計算與反向傳播的構建了
前向傳播函數構建
【回顧】
隱層原始數據：接收輸入層的數據X，對其作加權w1處理，並加上偏值b1
隱層激活函數：選擇tanh雙曲正切函數
隱層輸出數據：Z1 = tanh（隱層原始數據）
輸出層原始數據：接收隱層傳出的數據Z1，對其作加權w2處理，並加上偏值b2
輸出層激活函數：Sigmoid函數（可調用numpy的，也可使用自定義的）
輸出層預測結果：Z2 = sigmoid（輸出層原始數據）
僞代碼如下：
def 前向傳播算法（樣本集X，初始化的字典parameters{}）
輸入→隱層權值W1 = 參數字典["W1"]
隱層偏值b1 = 參數字典["b1"]
隱層→輸出層權值W2 = 參數字典["W2"]
輸出層偏值b2 = 參數字典["b2"]
隱層原始數據Z1 = W1 * X + b1
隱層輸出數據A1 = tanh(Z1)
輸出層原始數據Z2 = W2 * A1 + b2
輸出層預測結果A2 = sigmoid（Z1）
將計算後的Z1, A1, Z2, A2保存到數據字典cache裏
return cache
程序清單
def forward_propagation(X, parameters):
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, Z1) + b2
A2 = sigmoid(Z2)
assert(A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
損失函數計算（無正則化約束）
這裏的損失函數採用交叉熵損失
僞代碼如下
def 定義損失函數（預測輸出A2，標籤值Y，參數集合parameters）
m = 樣本個數
logprobs = 計算Y*log(A2) + （1-Y）*log(1-A2)
損失函數 = -1/m * sum(logprobs)
return 損失函數
程序清單
def compute_cost(A2, Y, parameters):
m = Y.shape[1] # number of example
#計算交叉熵
logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1-A2), 1-Y)
cost = -1/m * np.sum(logprobs)
#對cost的結果進行處理，squeeze用於刪除多餘的維度
cost = np.squeeze(cost)
assert(isinstance(cost, float))
return cost
反向傳播算法的實現
當前向傳播和當前損失確定之後，就需要繼續執行反向傳播過程來調整權值和偏值了。這裏涉及到了梯度下降算法，具體的公式步驟如下：
僞代碼如下：
def 反向傳播算法（參數字典parameters, 隱、輸出層輸出集合cache, 樣本集X, 標籤集Y）
m = 樣本個數
W1 = 參數字典parameters['W1']——輸入層→隱層權值W1
W2 = 參數字典parameters['W2']——隱層→輸出層權值W2
A1 = 輸出字典cache['A1']——隱層輸出結果A1
A2 = 輸出字典cache['A2']——輸出層預測結果A2
#執行梯度下降
Z2偏導 = A2 - Y
W2偏導 = 1/m * (Z2偏導 * A1)
b2偏導 = 1/m * sum(Z2偏導)
Z1偏導 = W2*Z2偏導*(1-(A1^2))
W1偏導 = 1/m * (Z1偏導 * X)
b1偏導 = 1/m * sum(Z1偏導)
將結果W2偏導、W1偏導、b2偏導、b1偏導存入梯度字典grads
return grads
程序清單
def backward_propagation(parameters, cache, X, Y):
m = X.shape[1]
# 首先從參數字典parameters中提取W1和W2的權值
W1 = parameters['W1']
W2 = parameters['W2']
# 再從輸出字典cache中提取隱層輸出和輸出層輸出的輸出值A1和A2
A1 = cache['A1']
A2 = cache['A2']
#反向傳播（梯度下降）求解：dW1, db1, dW2, db2.
dZ2 = A2-Y
dW2 = 1/m * np.dot(dZ2, A1.T)
db2 = 1/m * np.sum(dZ2, axis=1, keepdims=True)
dZ1 = np.dot(W2.T, dZ2)*(1-np.power(A1, 2))
dW1 = 1/m * np.dot(dZ1, X.T)
db1 = 1/m * np.sum(dZ1, axis=1, keepdims=True)
#存儲進梯度字典grads
grads = {"dW1": dW1,
"db1": db1,
"dW2": dW2,
"db2": db2}
return grads
將梯度下降處理後的權值更新
我們需要將已經進行梯度下降處理的新梯度反饋給隱層、輸出層各神經元計算
程序清單：
def update_parameters(parameters, grads, learning_rate = 1.2):
#通過parameters字典傳參給對應的權值、偏值
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
#通過grads字典傳參給對應變化求導後的權值、偏值
dW1 = grads['dW1']
db1 = grads['db1']
dW2 = grads['dW2']
db2 = grads['db2']
#更新權值，步長爲learning_rate=1.2
W1 -= dW1 * learning_rate
b1 -= db1 * learning_rate
W2 -= dW2 * learning_rate
b2 -= db2 * learning_rate
#將更新後的權值和偏值重新存入數據字典parameters（覆蓋原來的）
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
整合模型便於調用
def nn_model(X, Y, n_h, num_iterations = 10000, print_cost=False):
np.random.seed(3)
n_x = layer_sizes(X, Y)[0]
n_y = layer_sizes(X, Y)[2]
parameters = initialize_parameters(n_x, n_h, n_y)
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
#開始循環迭代使用梯度下降算法，計算最優權值和偏值
for i in range(0, num_iterations):
#調用前向傳播：輸入樣本集X和參數字典parameters，輸出A2和輸出數據字典cache
A2, cache = forward_propagation(X, parameters)
# 調用損失函數：輸入A2，Y和parameters，輸出損失cost
cost = compute_cost(A2, Y, parameters)
#調用反向傳播：輸入parameters, cache, X和Y，輸出梯度字典grads
grads = backward_propagation(parameters, cache, X, Y)
#梯度（參數）更新： 輸入parameters, grads，輸出更新後的參數字典parameters
parameters = update_parameters(parameters, grads, learning_rate=1.2)
#該過程迭代1000次
if print_cost and i % 1000 == 0:
print ("Cost after iteration %i: %f" %(i, cost))
return parameters
以上就是一套完整的利用numpy搭建單隱層神經網絡的實現過程。參考於公衆號：數據科學家養成記