基于BP神经网络的手写数字识别

Halcom

基于BP神经网络的手写数字识别
运行结果视频：https://pan.baidu.com/s/1x2wGGBZ8iBIEYU2IZRv0OQ

1. """
   
2. Created on Sun May 20 21:38:45 2018
   
3. 
   
4. @author: ysw
   
5. """
   
6. #-*- coding: utf-8 -*-
   
7. #from PIL import Image
   
8. import numpy as np
   
9. from scipy import io as spio
   
10. from scipy import optimize
    
11. from matplotlib import pyplot as plt
    
12. #from sklearn import datasets
    
13. #from sklearn.preprocessing import StandardScaler
    
14. import time
    
15.                
    
16. # BP
    
17. def BPneuralNetwork(X, y, input_layer_size,hidden_layer_size,out_put_layer):
    
18.     m,n = X.shape
    
19.     ##　随机显示几行数据
    
20.     rand_indices = [t for t in [np.random.randint(x-x, m) for x in range(100)]]  # 生成100个0-m的随机数
    
21.     display_data(X[rand_indices,:])     # 显示100个数字   
    
22.    
    
23.     Lambda = 1
    
24.     initial_Theta1 = randInitializeWeights(input_layer_size,hidden_layer_size);
    
25.     initial_Theta2 = randInitializeWeights(hidden_layer_size,out_put_layer)
    
26.     initial_nn_params = np.vstack((initial_Theta1.reshape(-1,1),initial_Theta2.reshape(-1,1)))  #展开theta   
    
27.     result = optimize.fmin_cg(nnCostFunction, initial_nn_params, fprime=nnGradient, args=(input_layer_size,hidden_layer_size,out_put_layer,X,y,Lambda), maxiter=100)
    
28.     '''可视化 Theta1'''
    
29.     length = result.shape[0]
    
30.     Theta1 = result[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
    
31.     Theta2 = result[hidden_layer_size*(input_layer_size+1):length].reshape(out_put_layer,hidden_layer_size+1)   
    
32.     return Theta1, Theta2
    
33. 
    
34. # 显示100个数字
    
35. def display_data(imgData):
    
36.     sum = 0
    
37.     '''
    
38.     显示100个数（若是一个一个绘制将会非常慢，可以将要画的数字整理好，放到一个矩阵中，显示这个矩阵即可）
    
39.     - 初始化一个二维数组
    
40.     - 将每行的数据调整成图像的矩阵，放进二维数组
    
41.     - 显示即可
    
42.     '''
    
43.     m,n = imgData.shape
    
44.     width = np.int32(np.round(np.sqrt(n)))
    
45.     height = np.int32(n/width);
    
46.     rows_count = np.int32(np.floor(np.sqrt(m)))
    
47.     cols_count = np.int32(np.ceil(m/rows_count))
    
48.     pad = 1
    
49.     display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad)))
    
50.     for i in range(rows_count):
    
51.         for j in range(cols_count):
    
52.             if sum >= m: #超过了行数，退出当前循环
    
53.                 break;
    
54.             display_array[pad+i*(height+pad):pad+i*(height+pad)+height,pad+j*(width+pad):pad+j*(width+pad)+width] = imgData[sum,:].reshape(height,width,order="F")    # order=F指定以列优先，在matlab中是这样的，python中需要指定，默认以行
    
55.             sum += 1
    
56.         if sum >= m:  #超过了行数，退出当前循环
    
57.             break;
    
58.             
    
59. #    plt.imshow(np.transpose(display_array),cmap='gray')   #显示灰度图像
    
60.     plt.imshow(display_array, cmap='gray')   #显示灰度图像
    
61.     plt.axis('off')
    
62.     plt.show()
    
63. 
    
64. # 代价函数
    
65. def nnCostFunction(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
    
66.     length = nn_params.shape[0] # theta的中长度
    
67.     # 还原theta1和theta2
    
68.     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1)
    
69.     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1)
    
70.    
    
71.     m = X.shape[0]
    
72.     class_y = np.zeros((m,num_labels))      # 数据的y对应0-9，需要映射为0/1的关系
    
73.     # 映射y
    
74.     for i in range(num_labels):
    
75.         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以赋值
    
76.      
    
77.     '''去掉theta1和theta2的第一列，因为正则化时从1开始'''   
    
78.     Theta1_colCount = Theta1.shape[1]   
    
79.     Theta1_x = Theta1[:,1:Theta1_colCount]
    
80.     Theta2_colCount = Theta2.shape[1]   
    
81.     Theta2_x = Theta2[:,1:Theta2_colCount]
    
82.     # 正则化向theta^2
    
83.     term = np.dot(np.transpose(np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1)))),np.vstack((Theta1_x.reshape(-1,1),Theta2_x.reshape(-1,1))))
    
84.    
    
85.     '''正向传播,每次需要补上一列1的偏置bias'''
    
86.     a1 = np.hstack((np.ones((m,1)),X))      
    
87.     z2 = np.dot(a1,np.transpose(Theta1))   
    
88.     a2 = sigmoid(z2)
    
89.     a2 = np.hstack((np.ones((m,1)),a2))
    
90.     z3 = np.dot(a2,np.transpose(Theta2))
    
91.     h  = sigmoid(z3)   
    
92.     '''代价'''   
    
93.     J = -(np.dot(np.transpose(class_y.reshape(-1,1)),np.log(h.reshape(-1,1)))+np.dot(np.transpose(1-class_y.reshape(-1,1)),np.log(1-h.reshape(-1,1)))-Lambda*term/2)/m   
    
94.     #temp1 = (h.reshape(-1,1)-class_y.reshape(-1,1))
    
95.     #temp2 = (temp1**2).sum()
    
96.     #J = 1/(2*m)*temp2
    
97.     return np.ravel(J)
    
98. 
    
99. # 梯度
    
100. def nnGradient(nn_params,input_layer_size,hidden_layer_size,num_labels,X,y,Lambda):
     
101.     length = nn_params.shape[0]
     
102.     Theta1 = nn_params[0:hidden_layer_size*(input_layer_size+1)].reshape(hidden_layer_size,input_layer_size+1).copy()   # 这里使用copy函数，否则下面修改Theta的值，nn_params也会一起修改
     
103.     Theta2 = nn_params[hidden_layer_size*(input_layer_size+1):length].reshape(num_labels,hidden_layer_size+1).copy()
     
104.     m = X.shape[0]
     
105.     class_y = np.zeros((m,num_labels))      # 数据的y对应0-9，需要映射为0/1的关系   
     
106.     # 映射y
     
107.     for i in range(num_labels):
     
108.         class_y[:,i] = np.int32(y==i).reshape(1,-1) # 注意reshape(1,-1)才可以赋值
     
109.      
     
110.     '''去掉theta1和theta2的第一列，因为正则化时从1开始'''
     
111.     Theta1_colCount = Theta1.shape[1]   
     
112.     Theta1_x = Theta1[:,1:Theta1_colCount]
     
113.     Theta2_colCount = Theta2.shape[1]   
     
114.     Theta2_x = Theta2[:,1:Theta2_colCount]
     
115.    
     
116.     Theta1_grad = np.zeros((Theta1.shape))  #第一层到第二层的权重
     
117.     Theta2_grad = np.zeros((Theta2.shape))  #第二层到第三层的权重
     
118.       
     
119.     '''正向传播，每次需要补上一列1的偏置bias'''
     
120.     a1 = np.hstack((np.ones((m,1)),X))
     
121.     z2 = np.dot(a1,np.transpose(Theta1))
     
122.     a2 = sigmoid(z2)
     
123.     a2 = np.hstack((np.ones((m,1)),a2))
     
124.     z3 = np.dot(a2,np.transpose(Theta2))
     
125.     h  = sigmoid(z3)
     
126.    
     
127.     '''反向传播，delta为误差，'''
     
128.     delta3 = np.zeros((m,num_labels))
     
129.     delta2 = np.zeros((m,hidden_layer_size))
     
130.     for i in range(m):
     
131.         #delta3[i,:] = (h[i,:]-class_y[i,:])*sigmoidGradient(z3[i,:])  # 均方误差的误差率
     
132.         delta3[i,:] = h[i,:]-class_y[i,:]                              # 交叉熵误差率
     
133.         Theta2_grad = Theta2_grad+np.dot(np.transpose(delta3[i,:].reshape(1,-1)),a2[i,:].reshape(1,-1))
     
134.         delta2[i,:] = np.dot(delta3[i,:].reshape(1,-1),Theta2_x)*sigmoidGradient(z2[i,:])
     
135.         Theta1_grad = Theta1_grad+np.dot(np.transpose(delta2[i,:].reshape(1,-1)),a1[i,:].reshape(1,-1))
     
136.    
     
137.     Theta1[:,0] = 0
     
138.     Theta2[:,0] = 0         
     
139.     '''梯度'''
     
140.     grad = (np.vstack((Theta1_grad.reshape(-1,1),Theta2_grad.reshape(-1,1)))+Lambda*np.vstack((Theta1.reshape(-1,1),Theta2.reshape(-1,1))))/m
     
141.     return np.ravel(grad)
     
142. 
     
143. # S型函数   
     
144. def sigmoid(z):
     
145.     h = np.zeros((len(z),1))    # 初始化，与z的长度一致
     
146.     h = 1.0/(1.0+np.exp(-z))
     
147.     return h
     
148. 
     
149. # S型函数导数
     
150. def sigmoidGradient(z):
     
151.     g = sigmoid(z)*(1-sigmoid(z))
     
152.     return g
     
153. 
     
154. # 随机初始化权重theta
     
155. def randInitializeWeights(L_in,L_out):
     
156.     W = np.zeros((L_out,1+L_in))    # 对应theta的权重
     
157.     epsilon_init = (6.0/(L_out+L_in))**0.5
     
158.     W = np.random.rand(L_out,1+L_in)*2*epsilon_init-epsilon_init # np.random.rand(L_out,1+L_in)产生L_out*(1+L_in)大小的随机矩阵
     
159.     return W
     
160. 
     
161. # 预测
     
162. def predict(Theta1, Theta2, X):
     
163.     m = X.shape[0]
     
164.     num_labels = Theta2.shape[0]
     
165.     #p = np.zeros((m,1))
     
166.     '''正向传播，预测结果'''
     
167.     X = np.hstack((np.ones((m,1)),X))
     
168.     h1 = sigmoid(np.dot(X,np.transpose(Theta1)))
     
169.     h1 = np.hstack((np.ones((m,1)),h1))
     
170.     h2 = sigmoid(np.dot(h1,np.transpose(Theta2)))
     
171.    
     
172.     '''
     
173.     返回h中每一行最大值所在的列号
     
174.     - np.max(h, axis=1)返回h中每一行的最大值（是某个数字的最大概率）
     
175.     - 最后where找到的最大概率所在的列号（列号即是对应的数字）
     
176.     '''
     
177.     #np.savetxt("h2.csv",h2,delimiter=',')
     
178.     p = np.array(np.where(h2[0,:] == np.max(h2, axis=1)[0]))  
     
179.     for i in np.arange(1, m):
     
180.         t = np.array(np.where(h2[i,:] == np.max(h2, axis=1)[i]))
     
181.         p = np.vstack((p,t))
     
182.     return p   
     
183. 
     
184. # 加载mat文件
     
185. def loadmat_data(fileName):
     
186.     return spio.loadmat(fileName)
     
187. 
     
188. if __name__ == "__main__":
     
189.     # 加载数据
     
190.     data_img = loadmat_data("data_digits.mat")
     
191.     X = data_img['X']
     
192.     y = data_img['y']   
     
193.     input_layer_size = 400;
     
194.     hidden_layer_size = 25;
     
195.     out_put_layer = 10;
     
196.     start = time.time()
     
197.     Theta1, Theta2 = BPneuralNetwork(X, y, input_layer_size, hidden_layer_size, out_put_layer)
     
198.     print ('\n')
     
199.     print ('\n')
     
200.     print ( '执行时间：' )
     
201.     print ( time.time()-start )
     
202.     '''预测'''
     
203.     p = predict(Theta1,Theta2,X)
     
204.     print ('预测准确度为：')
     
205.     print ( np.mean(np.float64(p == y.reshape(-1,1))*100) )   
     
206.     res = np.hstack((p,y.reshape(-1,1)))
     
207.     np.savetxt("predict.csv", res, delimiter=',')
     

复制代码

百度网盘链接：链接：https://pan.baidu.com/s/1wyldRyUqMasP2uGfQ402Eg 密码：uidi