基于极限学习机的手写数字识别

Halcom

基于极限学习机的手写数字识别
运行结果视频：https://pan.baidu.com/s/1x2wGGBZ8iBIEYU2IZRv0OQ

1. # -*- coding: utf-8 -*-
   
2. """
   
3. Created on Sun May 20 22:43:31 2018
   
4. 
   
5. @author: ysw
   
6. """
   
7. '''https://blog.csdn.net/zxl55/article/details/79507110'''
   
8. #from PIL import Image
   
9. import numpy as np
   
10. from scipy import io as spio
    
11. from scipy import optimize
    
12. from matplotlib import pyplot as plt
    
13. #from sklearn import datasets
    
14. #from sklearn.preprocessing import StandardScaler
    
15. import time
    
16. 
    
17. #引入包含数据验证方法的包
    
18. from sklearn import metrics
    
19. 
    
20. class Extreme_Learning_Machine(object):
    
21. 
    
22.     def __init__(self,X,y,num_hidden):
    
23.         self.data_x = np.atleast_2d(X)       #判断输入训练集是否大于等于二维; 把x_train()取下来
    
24.         self.data_y = np.array(y).flatten()  #a.flatten()把a放在一维数组中，不写参数默认是“C”，也就是先行后列的方式，也有“F”先列后行的方式； 把 y_train取下来
    
25.         self.num_data = len(self.data_x)     #训练数据个数
    
26.         self.num_feature = self.data_x.shape[1];  #shape[] 读取矩阵的长度，比如shape[0]就是读取矩阵第一维度的长度 (120行，4列，所以shape[0]==120,shapep[1]==4)
    
27.         self.num_hidden = num_hidden;  #隐藏层节点个数
    
28. 
    
29.         #随机生产权重（从-1，到1，生成（num_feature行,num_hidden列））
    
30.         self.w = np.random.uniform(-1, 1, (self.num_feature, self.num_hidden))
    
31. 
    
32.         #随机生成偏置，一个隐藏层节点对应一个偏置
    
33.         for i in range(self.num_hidden):
    
34.             b = np.random.uniform(-0.6, 0.6, (1, self.num_hidden))
    
35.             self.first_b = b
    
36. 
    
37.         #生成偏置矩阵，以隐藏层节点个数4为行，样本数120为列
    
38.         for i in range(self.num_data-1):
    
39.             b = np.row_stack((b, self.first_b))  #row_stack 以叠加行的方式填充数组
    
40.         self.b = b
    
41.         
    
42.     #定义sigmoid函数  
    
43.     def sigmoid(self,x):
    
44.         return 1.0 / (1 + np.exp(-x))
    
45. 
    
46.     def train(self,x_train,y_train,classes):
    
47.         mul = np.dot(self.data_x, self.w)    #输入乘以权重
    
48.         add = mul + self.b                        #加偏置
    
49.         H = self.sigmoid(add)                #激活函数
    
50. 
    
51.         H_ = np.linalg.pinv(H)               #求广义逆矩阵
    
52.         #print(type(H_.shape))
    
53. 
    
54.         #将只有一列的Label矩阵转换，例如，iris的label中共有三个值，则转换为3列，以行为单位，label值对应位置标记为1，其它位置标记为0
    
55.         self.train_y = np.zeros((self.num_data,classes))  #初始化一个120行，3列的全0矩阵
    
56.         for i in range(0,self.num_data):
    
57.             self.train_y[i,y_train[i]] = 1   #对应位置标记为1
    
58. 
    
59.         self.out_w = np.dot(H_,self.train_y)  #求输出权重
    
60. 
    
61.     def predict(self,x_test):
    
62.         self.t_data = np.atleast_2d(x_test)    #测试数据集
    
63.         self.num_tdata = len(self.t_data)      #测试集的样本数
    
64.         self.pred_Y = np.zeros((x_test.shape[0]))  #初始化
    
65. 
    
66.         b = self.first_b
    
67. 
    
68.         #扩充偏置矩阵，以隐藏层节点个数4为行，样本数30为列
    
69.         for i in range(self.num_tdata-1):
    
70.             b = np.row_stack((b, self.first_b))  #以叠加行的方式填充数组
    
71. 
    
72.          #预测  
    
73.         self.pred_Y = np.dot(self.sigmoid(np.dot(self.t_data,self.w)+b),self.out_w)
    
74. 
    
75.         #取输出节点中值最大的类别作为预测值
    
76.         self.predy = []
    
77.         for i in self.pred_Y:
    
78.             L = i.tolist()
    
79.             self.predy.append(L.index(max(L)))  
    
80. 
    
81.     def score(self,y_test):
    
82.         print("准确率：")
    
83.         #使用准确率方法验证
    
84.         print(metrics.accuracy_score(y_true=y_test, y_pred=self.predy))
    
85. 
    
86. # 显示100个数字
    
87. def display_data(imgData):
    
88.     sum = 0
    
89.     '''
    
90.     显示100个数（若是一个一个绘制将会非常慢，可以将要画的数字整理好，放到一个矩阵中，显示这个矩阵即可）
    
91.     - 初始化一个二维数组
    
92.     - 将每行的数据调整成图像的矩阵，放进二维数组
    
93.     - 显示即可
    
94.     '''
    
95.     m,n = imgData.shape
    
96.     width = np.int32(np.round(np.sqrt(n)))
    
97.     height = np.int32(n/width);
    
98.     rows_count = np.int32(np.floor(np.sqrt(m)))
    
99.     cols_count = np.int32(np.ceil(m/rows_count))
    
100.     pad = 1
     
101.     display_array = -np.ones((pad+rows_count*(height+pad),pad+cols_count*(width+pad)))
     
102.     for i in range(rows_count):
     
103.         for j in range(cols_count):
     
104.             if sum >= m: #超过了行数，退出当前循环
     
105.                 break;
     
106.             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中需要指定，默认以行
     
107.             sum += 1
     
108.         if sum >= m:  #超过了行数，退出当前循环
     
109.             break;
     
110.             
     
111. #    plt.imshow(np.transpose(display_array),cmap='gray')   #显示灰度图像
     
112.     plt.imshow(display_array, cmap='gray')   #显示灰度图像
     
113.     plt.axis('off')
     
114.     plt.show()
     
115. 
     
116. # 加载mat文件
     
117. def loadmat_data(fileName):
     
118.     return spio.loadmat(fileName)
     
119. 
     
120. if __name__ == "__main__":
     
121.     # 加载数据
     
122.     data_img = loadmat_data("data_digits.mat")
     
123.     X = data_img['X']
     
124.     y = data_img['y']  
     
125.    
     
126.     m,n = X.shape
     
127.     ##　随机显示几行数据
     
128.     rand_indices = [t for t in [np.random.randint(x-x, m) for x in range(100)]]  # 生成100个0-m的随机数
     
129.     display_data(X[rand_indices,:])     # 显示100个数字   
     
130.      
     
131.     input_layer_size = 400;
     
132.     num_hidden = 25;
     
133.     classes = 10;
     
134.    
     
135.     start = time.time()
     
136.     ELM = Extreme_Learning_Machine(X, y, num_hidden)   #训练数据集，训练集的label，隐藏层节点个数
     
137.     ELM.train(X, y, classes)
     
138.     print ('\n')
     
139.     print ('\n')
     
140.     print ( '执行时间：' )
     
141.     print ( time.time()-start )
     
142.     '''预测'''
     
143.     ELM.predict(X)
     
144. #    ELM.score(y)
     
145.    
     
146.     # 计算得分
     
147.     p = ELM.predy;
     
148. #    print ('预测准确度为：')
     
149. #    print(metrics.accuracy_score(y_true=y, y_pred=p))
     
150.     p = np.array(p)
     
151.     p = np.reshape(p, [-1, 1] )
     
152.     print ('预测准确度为：')
     
153.     print ( np.mean(np.float64(p == y.reshape(-1,1))*100) )   
     
154.     res = np.hstack((p,y.reshape(-1,1)))
     
155.     np.savetxt("predict.csv", res, delimiter=',')
     
156. 
     

复制代码

百度网盘链接：链接：https://pan.baidu.com/s/15MPObcNGKfvoYTXE9woG8w 密码：u0na

asqbtzzt

谢谢楼主分享