深层网络识别猫（吴恩达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) 

深层网络识别猫（吴恩达1课4周编程实例）

原文：https://www.cnblogs.com/sytt3/p/9328372.html