python实现基于SVM的手写数字识别器

立即下载用AI写一个

发布时间：2019-12-26

46人 | 浏览：10170次 | 收藏 |

技术：SVM算法

运行环境：python3.6 + scikit-learn0.19.1 + numpy1.11 +PIL1.17.4 +wxPython4.0

概述

带GUI界面的(界面用wxPython开发），用python实现的基于SVM(支持向量机)算法的手写数字识别器，可用于识别手写数字，训练数据集为mnist。 ( 代码在 python2.7 或 python3.6 下均能正常运行, 已在以下环境中进行过测试 python2.7 + scikit-learn0.18.1 + numpy1.11 +PIL1.1.7 +wxPython2.8; python3.6 + scikit-learn0.19.1 + numpy1.11 +PIL1.17.4 +wxPython4.0)

详细

## 详细说明：

支持向量机（support vector machine，SVM）算法是一种基本的分类与回归方法.
在卷积神经网络（Convolutional Neural Networks, CNN）变得流行之前的一段相当长的时间里，SVM都是分类领域的王者.
那么，SVM是怎么样的呢？通俗点来说，额。。。，其实要解释清楚SVM，根本通俗不了，有大量的文章甚至书籍整本整本地介绍SVM，相关的优化算法涉及大量的数学知识。相比于线性回归、感知机等，SVM在解决非线性、高维特征的问题时十分高效；相比于神经网络等，SVM只需小量的样本就可以训练出不错的模型。

python 不少的第三方库，如scikit-learn(sklearn)，OpenCV等都提供了SVM的分类算法。

MNIST手写数字数据库（Mixed National Institute of Standards and Technology database）包含
70000张手写数字图片。这些数字是通过美国国家统计局的员工和美国高校的学生收集的。每张图片
都是28x28的灰度图。
![数据集](/contentImages/image/20191224/jYimMuqoPClXfPMov4s.jpg "数据集")
 ![](数据集.jpg)

先用mnist训练集训练出一个SVM分类器，再对新输入的手写数字进行识别。

## 准备工作：
1.安装必要的第三方库：

pip install scikit-learn 
     pip install numpy
     pip install wxPython

安装PIL,在以下地址下载PIL库进行安装:
 http://effbot.org/media/downloads/PIL-1.1.7.win32-py2.7.exe
 （或在http://effbot.org/downloads/ 中找到与你操作系统及python版本相对应
 版本的PIL)
 当然，如果你使用是的Anaconda等的集成开发环境，scikit-learn,numpy,PIl/Pillow等均无需另行安装，这些都已经被集成到其中，只需要安装wxPython即可。

2.下载mnist数据集并从中提取图片：
 可以从以下地址下载mnist数据集。
 http://yann.lecun.com/exdb/mnist/
如下：
![mnist下载页面](/contentImages/image/20191224/vxvrSedOFeBKa5k8jLc.png "mnist下载页面")
![](mnist下载页面.png)
强烈建议从此处下载原始的压缩文档。
虽然不少的机器学习库或深度学习框架中都提供了下载以及使用mnist数据集的相关函数，如sklearn中的：
```
from sklearn.datasets import fetch_mldata
from sklearn.preprocessing import scale

## 下载数据
data = fetch_mldata('MNIST original', data_home='data\mnist')

X, y = data.data, data.target
```

在chainer中:
```
import chainer

train, test = chainer.datasets.get_mnist()
```
都是寥寥数行就完成了下载、样本与样本标签的提取、训练集与测试集的划分等，
但是如果你不看相应函数的源码，根本不知道背后进行了什么样的操作。当需要在自己的图片数据集上训练出自己的模型时，就无从下手了。
所以本例子将演示如何从压缩文档中提取出图片数据，如何将图像加载为符合模型要求的数据类型，了解了这样一个数据预处理的流程，才能做到触类旁通。

将下载的原始压缩文档进行解压后，将得到以下的文件：
![压缩文件](/contentImages/image/20191224/wRC0ohZI15ISIdqMeIs.png "压缩文件")
![](待解析的文件.png)
对于我们来说，这依然是一个压缩文件。
另外，由文件名可知，train-images,train-labels,t10k-images,t10k-labels分别是训练集图像文件，训练集标签文件，测试集图像文件，测试集标签文件。

下面写一个脚本从中提取出图片并保存到本地。
parse_mnist_data.py
```
import numpy as np 
import struct 
from PIL import Image 
import os

def make_img(fn_img = "t10k-images.idx3-ubyte", 
             fn_label = "t10k-labels.idx1-ubyte", 
             size1 = 7840016, size2 = 10008, root = "test"):
    fmt_img1 = ">IIII"
    offset_img1 = offset_label1= 0
    fmt_label1 = ">II"
    
    data_file_size = str(size1 - 16) + "B"
    labels_file_size = str(size2 - 8) + "B"
    
    fmt_img2 = ">" + data_file_size
    offset_img2 = struct.calcsize(fmt_img1)
    
    fmt_label2 = ">" + labels_file_size
    offset_label2 = struct.calcsize(fmt_label1)
    
    with open(fn_img, 'rb') as f:
        data_buf = f.read()
        
    with open(fn_label, 'rb') as f:
        label_buf = f.read()
        
    magic_img, numImages, numRows, numColumns = struct.unpack_from(fmt_img1, data_buf, offset_img1) 
    datas = struct.unpack_from(fmt_img2, data_buf, offset_img2)
    datas = np.array(datas).astype(np.uint8).reshape(numImages, 1, numRows, numColumns)
    
    magic_label, numLabels = struct.unpack_from(fmt_label1, label_buf, offset_label1)
    labels = struct.unpack_from(fmt_label2, label_buf, offset_label2)
    labels = np.array(labels).astype(np.int64)
    
    if not os.path.exists(root): 
        os.mkdir(root) 
    
    for i in range(10): 
        file_name = root + os.sep + str(i) 
        if not os.path.exists(file_name): 
            os.mkdir(file_name) 
        
    for ii in range(numLabels): 
        img = Image.fromarray(datas[ii, 0, 0:28, 0:28]) 
        label = labels[ii] 
        
        file_name = root + os.sep + str(label) + os.sep + str(ii).zfill(5) + '.png' 
        img.save(file_name)

```
分别针对训练集文件和测试集文件执行该函数,将提取出相应的图片文件并保存到本地。
本函数稍加修改即可用于提取目前另一个流行的数据集fashion-mnist。

## 项目结构图：
整体的项目结构十分简单，一共四个文件，一个是GUI界面脚本（digit_gui.py)，
一个是分类器脚本(model_svm.py),还有一个就是上述提取图片的脚本(parse_mnist_data.py)，而mnist_svm.m则是训练好的模型。
如下：
![项目结构](/contentImages/image/20191224/hv4B5G3oC66HIagXzIl.png "项目结构")
![](文件结构.png)

## 实现过程的部分代码展示
1. 在model_svm.py中导入相关的库：
```
import numpy as np
import os
from PIL import Image
from sklearn.svm import SVC
from sklearn.externals import joblib
from sklearn.metrics import confusion_matrix, classification_report
import glob
import time
```

2. 在model_svm.py中的编写一个加载数据以及保存数据的类DataLoader，
编写类中的函数,将图片转为向量：

```
    def get_data_labels(self, fpath = "train"):
        paths = glob.glob(fpath + os.sep + "*")
        X = []
        y = []
        for fpath in paths:
            fs = self.get_files(fpath)
            for fn in fs:
                X.append(self.img2vec(fn))
            label = np.repeat(int(os.path.basename(fpath)), len(fs))
            y.append(label)
        labels = y[0]
        for i in range(len(y) - 1):
            labels = np.append(labels, y[i + 1])
        return np.array(X), labels

def img2vec(self, fn):
        """将jpg等格式的图片转为向量"""
        im = Image.open(fn).convert('L')
        im = im.resize((28,28))
        tmp = np.array(im)
        vec = tmp.ravel()
        return vec

```

编写训练器相关的类Trainer:
```
class Trainer(object):
    '''训练器;'''

def svc(self, x_train, y_train):
        '''构建分类器'''
        model = SVC(kernel = 'poly',degree = 4,probability= True)
        model.fit(x_train, y_train)
        return model

```

编写测试相关的类Tester:
```
class Tester(object):
    '''测试器;'''
    def __init__(self, model_path):
        trainer = Trainer()      
        self.clf = trainer.load_model(model_path)
        
    def clf_metrics(self,X_test,y_test):
        """评估分类器效果"""
        pred = self.clf.predict(X_test)
        cnf_matrix = confusion_matrix(y_test, pred)
        score = self.clf.score(X_test, y_test)
        clf_repo = classification_report(y_test, pred)
        return cnf_matrix, score, clf_repo
```
3. 接下来就可以加载数据、训练模型、评估训练效果了：
```
    loader = DataLoader()
    trainer = Trainer()
    
    X, y = loader.get_data_labels()
    clf = trainer.svc(X, y)
    
    trainer.save_model(clf, "mnist_svm.m")
    
    X_test, y_test = loader.get_data_labels("test")
    
    tester = Tester("mnist_svm.m")
    mt, score, repo = tester.clf_metrics(X_test, y_test)
```
4. 在digit_gui.py中编写用户界面：
导入相关的库：
```
import wx
from collections import namedtuple
from PIL import Image
import os
from model_svm import Tester
```
编写界面：
```
class MainWindow(wx.Frame):
    def __init__(self,parent,title):
        wx.Frame.__init__(self,parent,title=title,size=(600,-1))
        static_font = wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL)
        
        Size = namedtuple("Size",['x','y'])
        s = Size(100,50)
        model_path = os.path.join(origin_path,'mnist_svm.m')

self.fileName = None
        self.model = Tester(model_path)
        
        b_labels = [u'open',u'run']

TipString = [u'选择图片', u'识别数字']
        
        funcs = [self.choose_file,self.run]
        
        '''create input area'''
        self.in1 = wx.TextCtrl(self,-1,size = (2*s.x,3*s.y))
        self.out1 = wx.TextCtrl(self,-1,size = (s.x,3*s.y))

'''create button'''
        self.sizer0 = wx.FlexGridSizer(cols=4, hgap=4, vgap=2) 
        self.sizer0.Add(self.in1)
        
        buttons = []
        for i,label in enumerate(b_labels):
            b = wx.Button(self, id = i,label = label,size = (1.5*s.x,s.y))
            buttons.append(b)
            self.sizer0.Add(b)

self.sizer0.Add(self.out1)

'''set the color and size of labels and buttons'''  
        for i,button in enumerate(buttons):
            button.SetForegroundColour('red')
            button.SetFont(static_font)
#            button.SetToolTipString(TipString[i]) #wx2.8
            button.SetToolTip(TipString[i])   #wx4.0
            button.Bind(wx.EVT_BUTTON,funcs[i])

'''layout'''
        self.SetSizer(self.sizer0)
        self.SetAutoLayout(1)
        self.sizer0.Fit(self)
        
        self.CreateStatusBar()
        self.Show(True)
```
界面如下：
![界面](/contentImages/image/20191224/CQoYbOfWtix2qmTVPXs.jpg "界面")
![](界面.jpg)

编写控件的回调函数：
```
    def run(self,evt):
        if self.fileName is None:
            self.raise_msg(u'请选择一幅图片')
            return None
        else:
            ans = self.model.predict(self.fileName)
            self.out1.Clear()
            self.out1.write(str(ans))

def choose_file(self,evt):
        '''choose img'''
        dlg = wx.FileDialog(
            self, message="Choose a file",
            defaultDir=os.getcwd(), 
            defaultFile="",
            wildcard=wildcard,
#            style=wx.OPEN | wx.MULTIPLE | wx.CHANGE_DIR #wx2.8
            style = wx.FD_OPEN | wx.FD_MULTIPLE |     #wx4.0
                    wx.FD_CHANGE_DIR | wx.FD_FILE_MUST_EXIST |
                    wx.FD_PREVIEW
            )
        if dlg.ShowModal() == wx.ID_OK:
            paths = dlg.GetPaths()
            dlg.Destroy()
            self.in1.Clear()
            self.in1.write(paths[0])
            self.fileName = paths[0]
            im = Image.open(self.fileName)
            im.show()
        else:
            return None
```

运行效果如下：
![运行效果](/contentImages/image/20191224/UNTgPkVQCrV9QZagB8E.gif "运行效果")
![](digit_svm.gif)

#### 其他
我们可以针对测试数据集用混淆矩阵来评估模型的分类效果。
![mnist svm混淆矩阵](/contentImages/image/20191224/4aax4HOoveUzdjyN8Pp.jpg "mnist svm混淆矩阵")
![](mnist_svm_混淆矩阵.jpg)
混淆矩阵中对角线上的数值是该类别被正确分类的数量，可见分类效果相当不错。
另外，在训练时间方面，训练完整个训练集需要一点耐心，训练时间因硬件设备而有所差异，不过会比[knn算法实现的模型](http://www.demodashi.com/demo/13039.html)要稍快。
如果需要快速训练，可以考虑用OpenCv中的SVM算法，针对这个数据集，在我的机器上用sklearn训练完需要20来分钟，而用OpenCV中的SVM，只需要70多秒，模型的准确率都是差不多的。

本实例支付的费用只是购买源码的费用，如有疑问欢迎在文末留言交流，如需作者在线代码指导、定制等，在作者开启付费服务后，可以点击“购买服务”进行实时联系，请知悉，谢谢

感谢

手机上随时阅读、收藏该文章？请扫下方二维码

python实现基于SVM的手写数字识别器

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子