第四周編程

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

核心思想：

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
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
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
40. #正反向傳播
41. def propagate(X,Y,parameters,layers_dims,activations):
42. m=X.shape[1]
43. L=len(layers_dims)
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)]
55. #成本函數
56. cost=-np.sum(Y*np.log(Y_p)+(1-Y)*np.log(1-Y_p))/m
57. cost=np.squeeze(cost)
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)])
71. return grads,Y_p,cost
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
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
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
113. train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = lr_utils.load_dataset()
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
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)
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]
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)

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