深层网络识别猫(吴恩达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) 
posted @ 2018-07-18 11:51  天字三号房  阅读(1199)  评论(0编辑  收藏  举报