深層網絡識別貓（吳恩達1課4周編程實例）

第四周編程

目標：建立一個深層的神經網絡識別貓

核心思想：

1. 正向傳播
2. 反向傳播

需要注意的事正反向傳播的初始值， ， ，

數據集：與第一個編程作業的數據集一樣

 

代碼流程：

1. 根據神經網絡結構初始化參數（W,b）
2. 將單元函數寫出來（linear，sigmoid，relu，sigmoid_backward,relu_backward）
3. 正反向傳播，輸出梯度
4. 單步梯度下降更新參數
5. 預測函數
6. 建立整合函數

    

代碼，穿插詳解與思路

 

第16行：隨機初始化，將W1=（n1,n0）的矩陣存入字典parameters['W1']中

注意：隨機初始化時時* np.sqrt(2/layers_dims[l-1]),並不是吳恩達所說的*0.01

這是因為，這是一個多隱藏層的網絡，當*0.01時，反向傳播幾次之后會使得后面的深層網絡參數值變成0

詳細原因可看這四篇文章：

https://blog.csdn.net/shwan_ma/article/details/76257967

https://www.cnblogs.com/makefile/p/init-weight.html?utm_source=itdadao&utm_medium=referral

https://blog.csdn.net/marsggbo/article/details/77771497

https://blog.csdn.net/u013082989/article/details/53770851

（被吳恩達給坑了，一開始*0.01，cost一直不變。搞了好長時間）

 

21-38行：將單元函數列在這里，是因為我想將這個model標准化，你可以在這里添加你想添加的單元函數， 比如tanh函數，記得添加了一個tanh函數時，還要添加一個對應的tanh_backward函數。有正向傳播，就要有反向傳播

 

41-71行：propagate傳播函數。這里代碼看起來復雜，實際上很容易理解。正向傳播就是一條路走到成本函數。第l層，正向傳播先計算出Z[l],再根據選擇的激活函數計算A[l]

反向傳播，先看一下核心思想中反向傳播。先根據激活函數，將dAl,和dZl傳入反向傳播計算的單元函數中。然后再一步一步計算出dW,db。假設L=5，那么左后一層的A的激活函數是dA4,從dA[L-l]開始反向傳播計算

propagate函數傳出Y_p，是因為不想在預測函數中再寫一次正向傳播，所以添加了一個Y_p

 

122,123行：兩個超參數輸入。122行輸入的是layers_dims 即你想建立的神經網絡結構。

如：你想建立幾個隱藏層，每一層的隱藏層有幾個神經節點。通過一個列表組裝

123行輸入的是每一層的激活函數。由於我的單元函數只有relu和sigmoid函數，所以只有這兩個關鍵字可選進去

ps：通過列表組裝數據很不穩，一不小心就會傳錯參數。最好的方法是傳一個字典進去如

當然，中間調用layers_dims,activations的代碼也要發生點變化，人懶，不想改了

最后的分析步驟也就是，將識別錯誤的圖片打印出來而已

1. import numpy as np  
2. import h5py  
3. import matplotlib.pyplot as plt  
4. import lr_utils  
5. import testCases_v2  
6. plt.rcParams['figure.figsize']=(5.0,4.0)  
7. plt.rcParams['image.interpolation']='nearest'  
8. plt.rcParams['image.cmap']='gray' 
9. #上面三句是設置圖形的默認格式
10. np.random.seed(1)  
11. 產生可預測#隨機值 
12. def initialize_parameters(layers_dims):  
13.     np.random.seed(3)  
14.     parameters={}  
15.     for l in range(1,len(layers_dims)):  
16.         parameters['W'+str(l)]=np.random.randn(layers_dims[l],layers_dims[l-1])*np.sqrt(2/layers_dims[l-1])  
17.         parameters['b'+str(l)]=np.zeros(shape=(layers_dims[l],1))  
18.     return parameters  
19.     
20. # 單元函數  
21. def linear(A,W,b):  
22.     Z=np.dot(W,A)+b  
23.     return Z  
24. def sigmoid(Z):  
25.     A=1/(1+np.exp(-Z))  
26.     return A  
27. def relu(Z):  
28.     A=np.maximum(0,Z)  
29.     return A  
30.     
31. def sigmoid_backword(dA,Z):  
32.     s=1/(1+np.exp(-Z))  
33.     dZ=dA*s*(1-s)  
34.     return dZ  
35. def relu_backword(dA,Z):  
36.     dZ=dA.copy()  
37.     dZ[Z<=0]=0  
38.     return dZ  
39.         
40. #正反向傳播  
41. def propagate(X,Y,parameters,layers_dims,activations):  
42.     m=X.shape[1]  
43.     L=len(layers_dims)  
44.         
45.     #正向傳播  
46.     caches,grads={'A0':X},{}  
47.     for l in range(1,L):  
48.         caches['Z'+str(l)]=linear(caches['A'+str(l-1)],parameters['W'+str(l)],parameters['b'+str(l)])  
49.         if activations[l-1]=='sigmoid':  
50.             caches['A'+str(l)]=sigmoid(caches['Z'+str(l)])  
51.         if activations[l-1]=='relu':  
52.             caches['A'+str(l)]=relu(caches['Z'+str(l)])  
53.     Y_p=caches['A'+str(L-1)]  
54.         
55.     #成本函數  
56.     cost=-np.sum(Y*np.log(Y_p)+(1-Y)*np.log(1-Y_p))/m  
57.     cost=np.squeeze(cost)  
58.         
59.         
60.     #反向傳播  
61.     grads['dA'+str(L-1)]=-(Y/Y_p)+(1-Y)/(1-Y_p)  
62.     for l in range(1,L):  
63.         if activations[-l]=='sigmoid':  
64.             grads['dZ'+str(L-l)]=sigmoid_backword(grads['dA'+str(L-l)],caches['Z'+str(L-l)])  
65.         if activations[-l]=='relu':  
66.             grads['dZ'+str(L-l)]=relu_backword(grads['dA'+str(L-l)],caches['Z'+str(L-l)])  
67.         grads['dW'+str(L-l)]=np.dot(grads['dZ'+str(L-l)],(caches['A'+str(L-l-1)]).T)/m  
68.         grads['db'+str(L-l)]=np.sum(grads['dZ'+str(L-l)],axis=1,keepdims=True)/m  
69.         grads['dA'+str(L-l-1)]=np.dot((parameters['W'+str(L-l)]).T,grads['dZ'+str(L-l)])  
70.         
71.     return grads,Y_p,cost  
72.     
73. #更新參數  
74. def update_parameters(parameters,grads,learning_rate,layers_dims):  
75.     L=len(layers_dims)  
76.     for l in range(1,L):  
77.         parameters['W'+str(l)]=parameters['W'+str(l)]-learning_rate*grads['dW'+str(l)]  
78.         parameters['b'+str(l)]=parameters['b'+str(l)]-learning_rate*grads['db'+str(l)]  
79.     return parameters  
80.     
81.     
82.     
83.     
84. #預測函數  
85. def predict(X,Y,parameters,layers_dims,activations):  
86.     m=X.shape[1]  
87.     grads,Y_p,cost=propagate(X,Y,parameters,layers_dims,activations)  
88.     Y_p = np.round(Y_p)  
89.     print('准確度:'+str(float(np.sum((Y_p == Y))/m)))  
90.     return Y_p  
91.     
92. #模型組合  
93. def model3(X,Y,num_iterations,learning_rate,layers_dims,activations,print_cost=False,isplot=True):  
94.     np.random.seed(1)  
95.     parameters=initialize_parameters(layers_dims)  
96.     L=len(layers_dims)  
97.     costs=[]  
98.     for i in range(num_iterations):  
99.         grads,Y_p,cost=propagate(X,Y,parameters,layers_dims,activations)  
100.         parameters=update_parameters(parameters,grads,learning_rate,layers_dims)  
101.         if i%100 == 0:  
102.             costs.append(cost)  
103.             if print_cost:  
104.                 print('after iteration of %d cost:%f'%(i,cost))  
105.     if isplot:  
106.         plt.plot(np.squeeze(costs))  
107.         plt.ylabel('cost')  
108.         plt.title('Learning rate ='+str(learning_rate))  
109.         plt.show()  
110.     return parameters  
111.     
112.     
113. train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = lr_utils.load_dataset()  
114.     
115. train_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T   
116. test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T  
117.     
118. train_x = train_x_flatten / 255  
119. train_y = train_set_y  
120. test_x = test_x_flatten / 255  
121. test_y = test_set_y  
122. layers_dims = [12288,20,7,5,1]  
123. activations=['relu','relu','relu','sigmoid']  
124. parameters=model3(train_x,train_y,num_iterations=2500,learning_rate=0.0075,layers_dims=layers_dims,activations=activations,print_cost=True,isplot=False)  
125. Y_p=predict(test_x,test_y,parameters,layers_dims,activations)  
126.     
127. #分析  
128. def print_mislabeled_images(classes,X,y,p):  
129.     a=p+y  
130.     mislabeled_indices=np.asarray(np.where(a==1))  
131.     plt.rcParams['figure.figsize'] = (40.0, 40.0)  
132.     num_images = len(mislabeled_indices[0])  
133.     for i in range(num_images):  
134.         index = mislabeled_indices[1][i]  
135.     
136.         plt.subplot(2, num_images, i + 1)  
137.         plt.imshow(X[:,index].reshape(64,64,3), interpolation='nearest')  
138.         plt.axis('off')  
139.         plt.title("Prediction: " + classes[int(p[0,index])].decode("utf-8") + " \n Class: " + classes[y[0,index]].decode("utf-8"))  
140. print_mislabeled_images(classes,test_x,test_y,Y_p)