python手写神经网络实现识别手写数字

矫情吗；* 2021-12-18 14:39 365阅读 0赞

--------------------

写在开头：这个实验和[matlab手写神经网络实现识别手写数字][matlab]一样。

--------------------

### 实验说明 ###

一直想自己写一个神经网络来实现手写数字的识别，而不是套用别人的框架。恰巧前几天，有幸从同学那拿到5000张已经贴好标签的手写数字图片，于是我就尝试用matlab写一个网络。

*  实验数据：5000张手写数字图片（.jpg)，图片命名为1.jpg,2.jpg…5000.jpg。还有一个放着标签的excel文件。
 *  数据处理：前4000张作为训练样本，后1000张作为测试样本。
 *  图片处理：用matlab的imread（）函数读取图片的灰度值矩阵（28，28），然后把每张图片的灰度值矩阵reshape为（28\*28，1），然后把前4000张图片的灰度值矩阵合并为x\_train，把后1000张图片的灰度值矩阵合并为x\_test。

![数字图片截图][70]  
![数字标签截图][70 1]

### 神经网络设计 ###

*  网络层设计：一层隐藏层，一层输出层
 *  输入层：一张图片的灰度值矩阵reshape后的784个数，也就是x\_train中的某一列
 *  输出层：（10，1）的列向量，其中列向量中最大的数所在的索引+1就是预测的数字
 *  激励函数：sigmoid函数（[公式][Link 1])
 *  更新法则：后向传播算法（[参考][Link 2]）
 *  测试：统计预测正确的个数

### 网络实现 ###

*  函数说明：读图片的函数（read\_photo() ）、读excel的函数（read\_excel(path) ）、修正函数（layerout(w,b,x) ）、训练函数（mytrain(x\_train,y\_train) ）、测试函数（mytest(x\_test,y\_test,w,b,w\_h,b\_h) ）、主函数（main() ）

具体代码如下：

# -*- coding: utf-8 -*-
    
    from PIL import Image
    
    from pylab import *
    
    import numpy as np
    
    import xlrd
    
    
    
    #读取图片的灰度值矩阵
    def read_photo():
        for i in range(5000):
            j = i+1
            j = str(j)
            st = '.jpg'
            j = j+st
            im1 = array(Image.open(j))
            #（28，28）-->(28*28,1)
            im1 = im1.reshape((784,1))
            #把所有的图片灰度值放到一个矩阵中
            #一列代表一张图片的信息
            if i == 0:
                im = im1
            else:
                im = np.hstack((im,im1))
        return im
    
    
    #读取excel文件内容（path为文件路径）
    def read_excel(path):
        # 获取所有sheet
        workbook = xlrd.open_workbook(path)
        sheet_names = workbook.sheet_names()
    
        # 根据sheet索引或者名称获取sheet内容
        for sheet_name in sheet_names:
            isheet = workbook.sheet_by_name(sheet_name)
    
            #获取该sheet的列数
            ncols = isheet.ncols
            #获取每一列的内容
            for i in range(ncols):
                if i == 0:
                    xl1 = isheet.col_values(i)
                    xl1 = np.array(xl1)
                    xl1 = xl1.reshape((10,1))
                    xl = xl1
                else:
                    xl1 = isheet.col_values(i)
                    xl1 = np.array(xl1)
                    xl1 = xl1.reshape((10,1))
                    xl = np.hstack((xl,xl1))
        return xl
    
    #layerout函数
    def layerout(w,b,x):
        y = np.dot(w,x) + b
        t = -1.0*y
        # n = len(y)
        # for i in range(n):
            # y[i]=1.0/(1+exp(-y[i]))
        y = 1.0/(1+exp(t))
        return y
    
    
    #训练函数
    def mytrain(x_train,y_train):
        ''' 设置一个隐藏层，784-->隐藏层神经元个数-->10 '''
    
        step=int(input('mytrain迭代步数：')) 
        a=double(input('学习因子：')) 
        inn = 784  #输入神经元个数
        hid = int(input('隐藏层神经元个数：'))#隐藏层神经元个数
        out = 10  #输出层神经元个数
    
        w = np.random.randn(out,hid)
        w = np.mat(w)
        b = np.mat(np.random.randn(out,1)) 
        w_h = np.random.randn(hid,inn)
        w_h = np.mat(w_h)
        b_h = np.mat(np.random.randn(hid,1)) 
    
        for i in range(step):
            #打乱训练样本
            r=np.random.permutation(4000)
            x_train = x_train[:,r]
            y_train = y_train[:,r]
            #mini_batch
            for j in range(400):
                #取batch为10 更新取10次的平均值
                x = np.mat(x_train[:,j]) 
                x = x.reshape((784,1))
                y = np.mat(y_train[:,j]) 
                y = y.reshape((10,1))
                hid_put = layerout(w_h,b_h,x) 
                out_put = layerout(w,b,hid_put) 
    
                #更新公式的实现
                o_update = np.multiply(np.multiply((y-out_put),out_put),(1-out_put)) 
                h_update = np.multiply(np.multiply(np.dot((w.T),np.mat(o_update)),hid_put),(1-hid_put)) 
    
                outw_update = a*np.dot(o_update,(hid_put.T)) 
                outb_update = a*o_update 
                hidw_update = a*np.dot(h_update,(x.T)) 
                hidb_update = a*h_update 
    
                w = w + outw_update 
                b = b+ outb_update 
                w_h = w_h +hidw_update 
                b_h =b_h +hidb_update 
    
        return w,b,w_h,b_h
    
    #test函数
    def mytest(x_test,y_test,w,b,w_h,b_h):
        ''' 统计1000个测试样本中有多少个预测正确了 预测结果表示：10*1的列向量中最大的那个数的索引+1就是预测结果了 '''
        sum = 0
        for k in range(1000):
            x = np.mat(x_test[:,k])
            x = x.reshape((784,1))
    
            y = np.mat(y_test[:,k])
            y = y.reshape((10,1))
    
            yn = np.where(y ==(np.max(y)))
            # print(yn)
            # print(y)
            hid = layerout(w_h,b_h,x);
            pre = layerout(w,b,hid);
            #print(pre)
            pre = np.mat(pre)
            pre = pre.reshape((10,1))
            pren = np.where(pre ==(np.max(pre)))
            # print(pren)
            # print(pre)
            if yn == pren:
                sum += 1
    
        print('1000个样本，正确的有:',sum)
    
    def main():
        #获取图片信息
        im = read_photo()
        immin = im.min()
        immax = im.max()
    
        im = (im-immin)/(immax-immin)
    
        #前4000张图片作为训练样本
        x_train = im[:,0:4000]
        #后1000张图片作为测试样本
        x_test = im[:,4000:5000]
    
        #获取label信息
        xl = read_excel('./label.xlsx')
    
        y_train = xl[:,0:4000]
        y_test = xl[:,4000:5000]
    
        print("---------------------------------------------------------------")
        w,b,w_h,b_h = mytrain(x_train,y_train)
        mytest(x_test,y_test,w,b,w_h,b_h)
        print("---------------------------------------------------------------")
    
    
    
    if __name__ == '__main__':
        main()

### 实验结果 ###

--------------------------------------------------------------- mytrain迭代步数：300 学习因子：0.3 隐藏层神经元个数：28 1000个样本，正确的有: 933 ---------------------------------------------------------------

迭代300步，正确率就有93.3%啦，还不错的正确率~

转载于:https://www.cnblogs.com/surecheun/p/9648954.html

[matlab]: https://blog.csdn.net/yunyunyx/article/details/80473532
[70]: /images/20211218/7b825e2e0e1044babd044a5217cd42d2.png
[70 1]: /images/20211218/6d2604ed57694004984ecea0d385c06e.png
[Link 1]: https://baike.baidu.com/item/Sigmoid%E5%87%BD%E6%95%B0
[Link 2]: http://www.cnblogs.com/ronny/p/ann_02.html