題目
- 要建立一個神經網絡，它有一個隱藏層。該模型可以對圖中的散點（二分類）繪制出決策邊界。
- 這個模型和上一個邏輯回歸實現的模型有很大的區別。testCases.py和planar_utils.py的完整代碼也在最底部。
- 在這篇文章中有如下知識：
- 構建具有單隱藏層的2類分類神經網絡。
- 使用具有非線性激活功能激活函數，例如tanh。
- 計算交叉熵損失（損失函數）。
- 實現向前和向后傳播。
編程實現
1. 准備軟件包
- 我們需要准備一些軟件包：
- numpy：是用Python進行科學計算的基本軟件包。
- matplotlib ：是一個用於在Python中繪制圖表的庫。
- sklearn：為數據挖掘和數據分析提供的簡單高效的工具。
- testCases：提供了一些測試示例來評估函數的正確性，參見底部的代碼。
- planar_utils ：提供了在這個任務中使用的各種有用的功能函數，參見底部的代碼。
import numpy as np
import matplotlib.pyplot as plt
from testCases import *
import sklearn
import sklearn.datasets
import sklearn.linear_model
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
#%matplotlib inline #如果你使用用的是Jupyter Notebook的話請取消注釋。
np.random.seed(1) #設置一個固定的隨機種子，以保證接下來的步驟中我們的結果是一致的。
2. 加載和查看數據集
首先，我們來看看我們將要使用的數據集，下面的代碼會將一個花的圖案的2類數據集加載到變量X和Y中
X, Y = load_planar_dataset()
把數據集加載完成了，然后使用matplotlib可視化數據集，代碼如下：
plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y),s=40,cmap=plt.cm.Spectral) #繪制散點圖
數據看起來像一朵紅色（y = 0）和一些藍色（y = 1）的數據點的花朵的圖案。 我們的目標是建立一個模型來適應這些數據。現在，我們已經有了以下的東西：
- X：一個numpy的矩陣，包含了這些數據點的數值
- Y：一個numpy的向量，對應着的是X的標簽【0 | 1】（紅色:0 ， 藍色 :1）
shape_X = X.shape
shape_Y = Y.shape
m = Y.shape[1] # 訓練集里面的數量
print ("X的維度為: " + str(shape_X))
print ("Y的維度為: " + str(shape_Y))
print ("數據集里面的數據有：" + str(m) + " 個")
3. 查看簡單的Logistic回歸的分類效果
在構建完整的神經網絡之前，先讓我們看看邏輯回歸在這個問題上的表現如何，我們可以使用sklearn的內置函數來做到這一點，運行下面的代碼來訓練數據集上的邏輯回歸分類器。
clf = sklearn.linear_model.LogisticRegressionCV()
clf.fit(X.T,Y.T)
把邏輯回歸分類器的分類繪制出來：
plot_decision_boundary(lambda x: clf.predict(x), X, np.squeeze(Y)) #繪制決策邊界
plt.title("Logistic Regression") #圖標題
LR_predictions = clf.predict(X.T) #預測結果
print ("邏輯回歸的准確性： %d " % float((np.dot(Y, LR_predictions) + np.dot(1 - Y,1 - LR_predictions)) / float(Y.size) * 100) + "% " + "(正確標記的數據點所占的百分比)")
這里遇到了一點問題參考這個博客得以解決。
准確性只有47%的原因是數據集不是線性可分的，所以邏輯回歸表現不佳，現在我們正式開始構建神經網絡。
4. 搭建神經網絡
要搭建的神經網絡模型如下圖：
對於 \(x^{(i)}\)（第i個訓練樣本）而言:
注： \(a^{[2](i)}\) ，其中[2]指第二層，(i)指第i個訓練樣本。其他符號同理。
\[z^{[1](i)}=w^{[1](i)} x^{(i)} + b^{[1](i)} \tag{1} \]
\[a^{[1](i)}=tanh(z^{[1](i)}) \tag{2} \]
\[z^{[2](i)}=w^{[2](i)} a^{[1](i)} + b^{[2](i)} \tag{3} \]
\[a^{[2](i)}=\sigma(z^{[2](i)}) \tag{4} \]
向量化實現：
\[Z^{[1]}=W^{[1]} X + b^{[1]} \tag{6} \]
\[A^{[1] }=tanh(Z^{[1]}) \tag{7} \]
\[Z^{[2] }=W^{[2] } A^{[1] } + b^{[2] } \tag{8} \]
\[A^{[2] }=\sigma(Z^{[2]}) \tag{9} \]
可以按如下方式計算成本J：
\[J=-\frac1m \sum_{i=1}^m \left( y^{(i)} log(a^{[2](i)}) +(1-y^{(i)}) log(1-a^{[2](i)}) \right) \tag{5} \]
- 構建神經網絡的一般方法是：
- 定義神經網絡結構（輸入單元的數量，隱藏單元的數量等）
- 初始化模型的參數
- 循環：
- 實施前向傳播
- 計算損失
- 實現向后傳播
- 更新參數（梯度下降）
- 最后把它們合並到一個nn_model()函數中，當構建好了nn_model（）並學習了正確的參數，就可以預測新的數據。
4.1 定義神經網絡結構
- 在構建之前，我們要先把神經網絡的結構給定義好：
- n_x: 輸入層的數量
- n_h: 隱藏層的數量（這里設置為4）
- n_y: 輸出層的數量
def layer_sizes(X , Y):
"""
參數：
X - 輸入數據集,維度為（輸入的數量，訓練/測試的數量）
Y - 標簽，維度為（輸出的數量，訓練/測試數量）
返回：
n_x - 輸入層的數量
n_h - 隱藏層的數量
n_y - 輸出層的數量
"""
n_x = X.shape[0] #輸入層
n_h = 4 #隱藏層，硬編碼為4
n_y = Y.shape[0] #輸出層
return (n_x,n_h,n_y)
來測試一下：
#測試layer_sizes
print("=========================測試layer_sizes=========================")
# 這里的測試數據 X.shape=(5,3),Y.shape=(2,3)
X_asses , Y_asses = layer_sizes_test_case()
(n_x,n_h,n_y) = layer_sizes(X_asses,Y_asses)
print("輸入層的節點數量為: n_x = " + str(n_x))
print("隱藏層的節點數量為: n_h = " + str(n_h))
print("輸出層的節點數量為: n_y = " + str(n_y))
4.2 初始化模型的參數
要實現函數initialize_parameters()。要確保參數的大小合適，參考上面的神經網絡圖。
- 隨機值初始化權重矩陣。
np.random.randn(a，b)* 0.01來隨機初始化一個維度為(a，b)的矩陣。
- 將偏向量初始化為零。
np.zeros((a，b))用零初始化矩陣（a，b）。
def initialize_parameters( n_x , n_h ,n_y):
"""
參數：
n_x - 輸入層節點的數量
n_h - 隱藏層節點的數量
n_y - 輸出層節點的數量
返回：
parameters - 包含參數的字典：
W1 - 權重矩陣,維度為（n_h，n_x）
b1 - 偏向量，維度為（n_h，1）
W2 - 權重矩陣，維度為（n_y，n_h）
b2 - 偏向量，維度為（n_y，1）
"""
np.random.seed(2) #指定一個隨機種子，以便你的輸出與我們的一樣。
W1 = np.random.randn(n_h,n_x) * 0.01
b1 = np.zeros(shape=(n_h, 1))
W2 = np.random.randn(n_y,n_h) * 0.01
b2 = np.zeros(shape=(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
測試一下代碼：
#測試initialize_parameters
print("=========================測試initialize_parameters=========================")
n_x , n_h , n_y = initialize_parameters_test_case()
parameters = initialize_parameters(n_x , n_h , n_y)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
4.3 前向傳播
- 現在要實現前向傳播函數forward_propagation()。可以使用sigmoid()函數，也可以使用np.tanh()函數。
- 步驟如下：
- 使用字典類型的 parameters（它是initialize_parameters() 的輸出）檢索每個參數。
- 實現向前傳播, 計算 \(Z^{[1]}, A^{[1]}, Z^{[2]}\) 和 \(A^{[2]}\) （訓練集里面所有例子的預測向量）。
- 反向傳播所需的值存儲在“cache”中，cache將作為反向傳播函數的輸入。
def forward_propagation( X , parameters ):
"""
參數：
X - 維度為（n_x，m）的輸入數據。
parameters - 初始化函數（initialize_parameters）的輸出
返回：
A2 - 使用sigmoid()函數計算的第二次激活后的數值
cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典類型變量
"""
W1 = parameters["W1"]
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
#前向傳播計算A2
Z1 = np.dot(W1 , X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2 , A1) + b2
A2 = sigmoid(Z2)
#使用斷言確保我的數據格式是正確的
assert(A2.shape == (1,X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return (A2, cache)
測試一下代碼：
#測試forward_propagation
print("=========================測試forward_propagation=========================")
X_assess, parameters = forward_propagation_test_case()
A2, cache = forward_propagation(X_assess, parameters)
print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"]))
4.4 計算損失
計算成本的公式如下：
\[J=-\frac1m \sum_{i=1}^m \left( y^{(i)} log(a^{[2](i)}) +(1-y^{(i)}) log(1-a^{[2](i)}) \right) \tag{5} \]
開始構建計算成本的函數：
def compute_cost(A2,Y,parameters):
"""
計算公式（5）中給出的交叉熵成本，
參數：
A2 - 使用sigmoid()函數計算的第二次激活后的數值
Y - "True"標簽向量,維度為（1，數量）
parameters - 一個包含W1，B1，W2和B2的字典類型的變量
返回：
成本 - 交叉熵成本給出方程（13）
"""
m = Y.shape[1]
W1 = parameters["W1"]
W2 = parameters["W2"]
#計算成本
logprobs = logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))
cost = - np.sum(logprobs) / m
cost = float(np.squeeze(cost))
assert(isinstance(cost,float))
return cost
測試一下成本函數：
#測試compute_cost
print("=========================測試compute_cost=========================")
A2 , Y_assess , parameters = compute_cost_test_case()
print("cost = " + str(compute_cost(A2,Y_assess,parameters)))
4.5 反向傳播
反向傳播通常是深度學習中最難（數學意義）部分，這里有反向傳播講座的幻燈片， 由於我們正在構建向量化實現，因此我們將需要使用這下面的六個方程：
為了計算 \(dZ^{[1]}\) ，里需要計算 \(g^{[1]'}(Z^{[1]})\) ，$ g^{[1]}(...)$ 是tanh激活函數，如果 \(a = g^{[1]}(Z)\) 那么 $ g^{[1]'}(Z) = 1-a^2$ 。所以我們需要使用 (1 - np.power(A1, 2)) 來計算 \(g^{[1]'}(Z^{[1]})\)
def backward_propagation(parameters,cache,X,Y):
"""
使用上述說明搭建反向傳播函數。
參數：
parameters - 包含我們的參數的一個字典類型的變量。
cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典類型的變量。
X - 輸入數據，維度為（2，數量）
Y - “True”標簽，維度為（1，數量）
返回：
grads - 包含W和b的導數一個字典類型的變量。
"""
m = X.shape[1]
W1 = parameters["W1"]
W2 = parameters["W2"]
A1 = cache["A1"]
A2 = cache["A2"]
dZ2= A2 - Y
dW2 = (1 / m) * np.dot(dZ2, A1.T)
db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
dZ1 = np.multiply(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 = {"dW1": dW1,
"db1": db1,
"dW2": dW2,
"db2": db2 }
return grads
測試一下反向傳播函數：
#測試backward_propagation
print("=========================測試backward_propagation=========================")
parameters, cache, X_assess, Y_assess = backward_propagation_test_case()
grads = backward_propagation(parameters, cache, X_assess, Y_assess)
print ("dW1 = "+ str(grads["dW1"]))
print ("db1 = "+ str(grads["db1"]))
print ("dW2 = "+ str(grads["dW2"]))
print ("db2 = "+ str(grads["db2"]))
4.6 更新參數
我們需要使用 (dW1, db1, dW2, db2) 來更新 (W1, b1, W2, b2) 。
更新算法如下：
\[\theta = \theta - \alpha \frac{\partial J }{ \partial \theta } \]
- $ \alpha$：學習速率
- \(\theta\)：參數
需要選擇一個良好的學習速率，
def update_parameters(parameters,grads,learning_rate=1.2):
"""
使用上面給出的梯度下降更新規則更新參數
參數：
parameters - 包含參數的字典類型的變量。
grads - 包含導數值的字典類型的變量。
learning_rate - 學習速率
返回：
parameters - 包含更新參數的字典類型的變量。
"""
W1,W2 = parameters["W1"],parameters["W2"]
b1,b2 = parameters["b1"],parameters["b2"]
dW1,dW2 = grads["dW1"],grads["dW2"]
db1,db2 = grads["db1"],grads["db2"]
W1 = W1 - learning_rate * dW1
b1 = b1 - learning_rate * db1
W2 = W2 - learning_rate * dW2
b2 = b2 - learning_rate * db2
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
測試一下update_parameters()：
#測試update_parameters
print("=========================測試update_parameters=========================")
parameters, grads = update_parameters_test_case()
parameters = update_parameters(parameters, grads)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
4.7 整合成一個函數
現在把上面的東西整合到nn_model()中，神經網絡模型必須以正確的順序使用先前的功能。
def nn_model(X,Y,n_h,num_iterations,print_cost=False):
"""
參數：
X - 數據集,維度為（2，示例數）
Y - 標簽，維度為（1，示例數）
n_h - 隱藏層的數量
num_iterations - 梯度下降循環中的迭代次數
print_cost - 如果為True，則每1000次迭代打印一次成本數值
返回：
parameters - 模型學習的參數，它們可以用來進行預測。
"""
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(num_iterations):
A2 , cache = forward_propagation(X,parameters)
cost = compute_cost(A2,Y,parameters)
grads = backward_propagation(parameters,cache,X,Y)
parameters = update_parameters(parameters,grads,learning_rate = 1.2)
if print_cost:
if i%1000 == 0:
print("第 ",i," 次循環，成本為："+str(cost))
return parameters
測試nn_model()：
#測試nn_model
print("=========================測試nn_model=========================")
X_assess, Y_assess = nn_model_test_case()
parameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, print_cost=False)
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
4.8 模型預測
構建predict()來使用模型進行預測， 使用向前傳播來預測結果。
def predict(parameters,X):
"""
使用學習的參數，為X中的每個示例預測一個類
參數：
parameters - 包含參數的字典類型的變量。
X - 輸入數據（n_x，m）
返回
predictions - 我們模型預測的向量（紅色：0 /藍色：1）
"""
A2 , cache = forward_propagation(X,parameters)
# 返回浮點數A2的四舍五入的值
predictions = np.round(A2)
return predictions
進行測試：
#測試predict
print("=========================測試predict=========================")
parameters, X_assess = predict_test_case()
predictions = predict(parameters, X_assess)
print("預測的平均值 = " + str(np.mean(predictions)))
5. 正式運行
parameters = nn_model(X, Y, n_h = 4, num_iterations=10000, print_cost=True)
#繪制邊界
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
plt.title("Decision Boundary for hidden layer size " + str(4))
predictions = predict(parameters, X)
print ('准確率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')
6. 更改隱藏層節點數量
上面的實驗把隱藏層定為4個節點，現在更改隱藏層里面的節點數量，看一看節點數量是否會對結果造成影響。
plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] #隱藏層數量
for i, n_h in enumerate(hidden_layer_sizes):
plt.subplot(5, 2, i + 1)
plt.title('Hidden Layer of size %d' % n_h)
parameters = nn_model(X, Y, n_h, num_iterations=5000)
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
predictions = predict(parameters, X)
accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)
print ("隱藏層的節點數量： {} ，准確率: {} %".format(n_h, accuracy))
- 可以看到，較大的模型（具有更多隱藏單元）能夠更好地適應訓練集，直到最終的最大模型過度擬合數據。
- 最好的隱藏層大小似乎在n_h=5附近。實際上，這里的值似乎很適合數據，而且不會引起過度擬合。
- 之后會學習有關正則化的知識，它允許我們使用非常大的模型（如n_h = 50），而不會出現太多過度擬合。
7. 如果改變數據集
# 數據集
noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()
datasets = {"noisy_circles": noisy_circles,
"noisy_moons": noisy_moons,
"blobs": blobs,
"gaussian_quantiles": gaussian_quantiles}
dataset = "noisy_moons"
X, Y = datasets[dataset]
X, Y = X.T, Y.reshape(1, Y.shape[0])
if dataset == "blobs":
Y = Y % 2
plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)
parameters = nn_model(X, Y, n_h = 4, num_iterations=10000, print_cost=True)
#繪制邊界
plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
plt.title("Decision Boundary for hidden layer size " + str(4))
predictions = predict(parameters, X)
print ('准確率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')
可以看到該模型也可以很好的擬合新的數據包。
知識點匯總
- 構建神經網絡的一般方法是：
- 定義神經網絡結構（輸入單元的數量，隱藏單元的數量等）
- 初始化模型的參數
- 循環：
- 實施前向傳播
- 計算損失
- 實現向后傳播
- 更新參數（梯度下降）
- 最后把它們合並到一個nn_model()函數中，當構建好了nn_model（）並學習了正確的參數，就可以預測新的數據。
- 正向傳播的過程：
對於 \(x^{(i)}\)（第i個訓練樣本）而言:
注：\(a^{[2](i)}\) ，其中[2]指第二層，(i)指第i個訓練樣本。其他符號同理。
\[z^{[1](i)}=w^{[1](i)} x^{(i)} + b^{[1](i)} \tag{1} \]
\[a^{[1](i)}=tanh(z^{[1](i)}) \tag{2} \]
\[z^{[2](i)}=w^{[2](i)} a^{[1](i)} + b^{[2](i)} \tag{3} \]
\[a^{[2](i)}=\sigma(z^{[2](i)}) \tag{4} \]
向量化實現：
\[Z^{[1]}=W^{[1]} X + b^{[1]} \tag{6} \]
\[A^{[1] }=tanh(Z^{[1]}) \tag{7} \]
\[Z^{[2] }=W^{[2] } A^{[1] } + b^{[2] } \tag{8} \]
\[A^{[2] }=\sigma(Z^{[2]}) \tag{9} \]
可以按如下方式計算成本J：
\[J=-\frac1m \sum_{i=1}^m \left( y^{(i)} log(a^{[2](i)}) +(1-y^{(i)}) log(1-a^{[2](i)}) \right) \tag{5} \]
- 因為該題目是一個二分類任務，所以在計算
$A^{[2]}$的時候使用的激活函數是sigma函數，這個函數除了應用在輸出層是一個二分類問題的情況下基本不會使用，原因是tanh函數幾乎在所有的場合更加優越。 - tanh函數的原型是：
\[a = g^{[1]}(Z)=\frac{e^z-e^{-z}}{e^z+e^{-z}} \]
\[a '={g^{[1]}}'(Z) = 1-a^2 \]
- 反向傳播的過程：
軟件包的代碼
因為不知道老師提供的軟件包中都有什么樣的函數，提供哪些功能，讓我在理解程序的過程中有些困難，所以把提供的兩個軟件包的代碼放在這：
planar_utils.py中的代碼：
import matplotlib.pyplot as plt
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.linear_model
def plot_decision_boundary(model, X, y):
# Set min and max values and give it some padding
x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1
y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1
h = 0.01
# Generate a grid of points with distance h between them
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
# Predict the function value for the whole grid
Z = model(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
# Plot the contour and training examples
plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)
plt.ylabel('x2')
plt.xlabel('x1')
plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral)
def sigmoid(x):
s = 1/(1+np.exp(-x))
return s
def load_planar_dataset():
np.random.seed(1)
m = 400 # number of examples
N = int(m/2) # number of points per class
D = 2 # dimensionality
X = np.zeros((m,D)) # data matrix where each row is a single example
Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue)
a = 4 # maximum ray of the flower
for j in range(2):
ix = range(N*j,N*(j+1))
t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta
r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius
X[ix] = np.c_[r*np.sin(t), r*np.cos(t)]
Y[ix] = j
X = X.T
Y = Y.T
return X, Y
def load_extra_datasets():
N = 200
noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3)
noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2)
blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6)
gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None)
no_structure = np.random.rand(N, 2), np.random.rand(N, 2)
return noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure
testCases.py中的代碼
#-*- coding: UTF-8 -*-
"""
# WANGZHE12
"""
import numpy as np
# 用於測試神經網絡結構的數據
def layer_sizes_test_case():
np.random.seed(1)
X_assess = np.random.randn(5, 3)
Y_assess = np.random.randn(2, 3)
return X_assess, Y_assess
# 初始化模型參數的測試數據
def initialize_parameters_test_case():
n_x, n_h, n_y = 2, 4, 1
return n_x, n_h, n_y
# 向前傳播的測試數據
def forward_propagation_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[ 0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[ 0.],
[ 0.],
[ 0.],
[ 0.]]),
'b2': np.array([[ 0.]])}
return X_assess, parameters
# 代價函數的測試數據
def compute_cost_test_case():
np.random.seed(1)
Y_assess = np.random.randn(1, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[ 0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[ 0.],
[ 0.],
[ 0.],
[ 0.]]),
'b2': np.array([[ 0.]])}
a2 = (np.array([[ 0.5002307 , 0.49985831, 0.50023963]]))
return a2, Y_assess, parameters
# 反向傳播的測試數據
def backward_propagation_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
Y_assess = np.random.randn(1, 3)
parameters = {'W1': np.array([[-0.00416758, -0.00056267],
[-0.02136196, 0.01640271],
[-0.01793436, -0.00841747],
[ 0.00502881, -0.01245288]]),
'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]),
'b1': np.array([[ 0.],
[ 0.],
[ 0.],
[ 0.]]),
'b2': np.array([[ 0.]])}
cache = {'A1': np.array([[-0.00616578, 0.0020626 , 0.00349619],
[-0.05225116, 0.02725659, -0.02646251],
[-0.02009721, 0.0036869 , 0.02883756],
[ 0.02152675, -0.01385234, 0.02599885]]),
'A2': np.array([[ 0.5002307 , 0.49985831, 0.50023963]]),
'Z1': np.array([[-0.00616586, 0.0020626 , 0.0034962 ],
[-0.05229879, 0.02726335, -0.02646869],
[-0.02009991, 0.00368692, 0.02884556],
[ 0.02153007, -0.01385322, 0.02600471]]),
'Z2': np.array([[ 0.00092281, -0.00056678, 0.00095853]])}
return parameters, cache, X_assess, Y_assess
# 更新參數的測試數據
def update_parameters_test_case():
parameters = {'W1': np.array([[-0.00615039, 0.0169021 ],
[-0.02311792, 0.03137121],
[-0.0169217 , -0.01752545],
[ 0.00935436, -0.05018221]]),
'W2': np.array([[-0.0104319 , -0.04019007, 0.01607211, 0.04440255]]),
'b1': np.array([[ -8.97523455e-07],
[ 8.15562092e-06],
[ 6.04810633e-07],
[ -2.54560700e-06]]),
'b2': np.array([[ 9.14954378e-05]])}
grads = {'dW1': np.array([[ 0.00023322, -0.00205423],
[ 0.00082222, -0.00700776],
[-0.00031831, 0.0028636 ],
[-0.00092857, 0.00809933]]),
'dW2': np.array([[ -1.75740039e-05, 3.70231337e-03, -1.25683095e-03,
-2.55715317e-03]]),
'db1': np.array([[ 1.05570087e-07],
[ -3.81814487e-06],
[ -1.90155145e-07],
[ 5.46467802e-07]]),
'db2': np.array([[ -1.08923140e-05]])}
return parameters, grads
# 整合成nn_model函數的測試數據
def nn_model_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
Y_assess = np.random.randn(1, 3)
return X_assess, Y_assess
# 預測函數的測試數據
def predict_test_case():
np.random.seed(1)
X_assess = np.random.randn(2, 3)
parameters = {'W1': np.array([[-0.00615039, 0.0169021 ],
[-0.02311792, 0.03137121],
[-0.0169217 , -0.01752545],
[ 0.00935436, -0.05018221]]),
'W2': np.array([[-0.0104319 , -0.04019007, 0.01607211, 0.04440255]]),
'b1': np.array([[ -8.97523455e-07],
[ 8.15562092e-06],
[ 6.04810633e-07],
[ -2.54560700e-06]]),
'b2': np.array([[ 9.14954378e-05]])}
return parameters, X_assess
學習感悟
- 不太懂的點：數據的生成；該例子中的Logistic回歸的分類的實現；繪制決策邊界函數的實現。