精华内容
下载资源
问答
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • knn手写数字识别(代码和数据)
  • 机器学习入门KNN算法实现的手写数字识别 基本上照搬了http://lib.csdn.net/article/opencv/30167的代码,只是改了一点bug和增加了一点功能 输入就是直接在一个512*512大小的白色画布上画黑线,然后转化为01矩阵,用...
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • KNN实现手写数字识别Python

    千次阅读 2017-01-06 09:44:43
    本文章总结了KNN算法字手写数字识别的应用,比较系统的对传统KNN和各种改进的KNN算法进行实现,由于完整的代码量较大(部分代码参考了机器学习实战),不适合全部贴出,但是博主乐于分享,有需要的话可以直接联系我...

    本文章总结了KNN算法字手写数字识别的应用,比较系统的对传统KNN和各种改进的KNN算法进行实现,由于完整的代码量较大(部分代码参考了机器学习实战),不适合全部贴出,但是博主乐于分享,有需要的话可以直接联系我,我会很乐意共享的,一希望大家能帮我校准文章的错误啦~~~


    首先用1500张手写数据进行训练,然后利用500张数字做测试,数据集大家可以搜手写数字识别数据集,网上很多,我过几天也会贴到我的资源库里面,欢迎打家下载,可以用notepad++查看每个数字。

    KNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别,则该样本也属于这个类别,并具有这个类别上样本的特性。算法步骤如下:

    输入:训练数据集T={(x1,y1),(x2,y2),…,(xn,yn)}

    输出:实例x所属的类y

    (1)根据给定距离度量,在训练集T中找出与x最近邻的k个点,涵盖这k个点的x的领域记作Nk(x)

    (2)在Nk(x)中根据分类决策规则(多数表决)决定x的类别y


    4.12 核心代码

    首先构造一个分类起,该分类器接收训练数据集合待测实例,返回待测实例的分类。


    然后从分别从数据文本中获取训练数据集和测试数据集,并调用classifyEU方法,输出结果


    结果如下:



    二、改进距离

            欧氏距离虽然很有用,但也有明显的缺点。它将样品的不同属性(即各指标或各变量)之间的差别等同看待,这一点有时不能满足实际要求。例如,在教育研究中,经常遇到对人的分析和判别,个体的不同属性对于区分个体有着不同的重要性。因此,有时需要采用不同的距离函数。这里采用马氏距离。

    结果如下:


           出乎意料,使用马氏距离后,分类器的效果奇差,错误率达到56%,这显然是不能令人满意的。可能原因是由于马氏距离是把各个特征维度的相关性考虑进去,但是手写数字系统各个维度并没有很大的相关性,并且由于各个维度的取值都只是0和1两种,因此效果非常差,这也说明各个距离都有自己的适用场合,我们需要根据数据的实际意义和特征,选取恰当的距离度量,才能去得良好地效果。


    三、SAHIBSINGH A. DUDANI 等在The Distance-Weighted k-Nearest-Neighbor Rule 中提出一种改进权重的KNN方        法,这里用Python实现看看效果是不是真有那么好,哈哈。

          论文大家可以自己下载:核心思想是距离测试点更近的点应该赋予更大的权值,二距离远的点应该赋予更小的权值。权值公式为


    核心代码:


    运行结果:


    可以看到WKNN算法的错误个数是10,错误率约1.06%,准确率约98.94%,所用时间约49.408秒,准确率相对KNN有所提高,SAHIBSINGH A. DUDANI诚不欺我也~~~


    另外P. Viswanath and T. Hitendra Sarma等在An Improvement to k-Nearest Neighbor Classifier中提出另一种改进KNN方法,经博主实验证明改算法在手写数字识别数据集的准确率可以达到99%+,几乎可以赶上神经网络的正确率了,看来经过捣鼓捣鼓得KNN果然是良心算法呀,简单实用,哈哈。但是该改进算法运算量相对比较大,因为需要对每一个类求K个近邻。


    四、kd-Tree

           实现k近邻法时,主要考虑的问题是如何对训练数据进行快速k近邻搜索,这点在特征空间的维数大以及训练数据容量大时尤其重要。为了提高k近邻搜索的效率,考虑使用特殊的结构存储训练数据,以减少计算距离的次数。通过构造kd_Tree来实现。

            Kd-Tree是一个二叉树,每个节点表示的是一个空间范围。下表表示的是Kd-树中每个节点中主要包含的数据结构。Range域表示的是节点包含的空间范围。Node-data域就是数据集中的某一个n维数据点。分割超面是通过数据点Node-Data并垂直于轴split的平面,分割超面将整个空间分割成两个子空间。令split域的值为i,如果空间Range中某个数据点的第i维数据小于Node-Data[i],那么,它就属于该节点空间的左子空间,否则就属于右子空间。Left,Right域分别表示由左子空间和右子空间空的数据点构成的Kd-Tree。

    核心代码:

    首先创建一个树节点




    运行结果:



           看到这个结果博主心里是蓝瘦香菇的,这哪里改进了运行效率嘛,运行时间分明比不用KD-Tree还长很多,不过博主还是耐心的分析了原因,果然还是有所发现,在运行效率方面,根据经验,kd-Tree只在:特征维数远小于样本数的情况下才是比较平衡的,而该训练数据集特征维数为1024和训练样本数接近,并且每一个维度都只有0和1两个值,因此构造出来的是一个极度不平衡的树,当树完全不平衡的时候其效率和逐个遍历没有什么区别,因此并没有使运行时间效率提升,反而因为需要构造kd-Tree、比较等操作使得运行效率相对较低,由此得到的教训是并不是一个好的算法思路就能拿来用呀,关键还得看场景!场景!场景!





    展开全文
  • KNN手写数字识别,knn手写数字识别mnist,Python源码.zip
  • 基于Python3.7实现手写识别功能,调用KNN算法。包括源程序、训练数据、测试数据和测试结果。
  • 使用kNN算法对0-9的手写数据集进行识别,包括python代码和数据,数据为txt格式。
  • 需要下载MNIST数据集,将路径修改为本地MNIST数据集的地址。需要OpenCV与Tensorflow环境
  • 测试算法:使用 K 近邻算法识别手写数字 已经将数据处理成分类器可以识别的格式。接下来,将这些数据输入到分类器,检测分类器的执行效果。在写入这些代码之前,必须确保将 from os import listdir 写入文件的起始...

    一家懂得用细节留住客户的3年潮牌老店我必须支持!➕🛰:luyao1931

    在这里插入图片描述

    实验知识点:

    1、K 近邻分类算法
    2、从文本文件中解析和导入数据
    3、使用 Matplotlib 创建扩散图
    4、归一化数值

    首先介绍下监督学习和无监督学习:

    监督学习:(数据有输入有输出),通过已有的一部分数据和输出数据之间的相应关系,生成一个函数,将输入映射到合适的输出,在准确的说有监督学习就是训练样本中必须有标签或者标记;
    无监督学习:(数据只有输入),给定的训练样本中难以标注类别或者标注成本过高,这类没有类别标注(未被标记)的训练集建模模式称为无监督学习
    半监督学习:一部分数据有标签一部分数据没标签称为半监督学习

    监督学习常用算法:

    分为 分类(classification)和回归(regression)俩大类
    分类:
    K近邻、支持向量机、朴素贝叶斯、决策树、随机森林、人工神经网络等;
    回归:
    线性回归、神经网络等

    无监督学习常用算法:

    无监督学习算法主要为 聚类:
    K-Means聚类,高斯混合模型等;
    监督学习—KNN(k最近邻分类算法)

    KNN算法思想:

    K最近邻算法,顾名思义就是搜寻最近的K个已知类别样本用于未知类别样本的预测。
    "最近"的度量就是应用点之间的距离或相似性,距离越小或相似度越高,说明他们之间越近
    “预测”,对于离散型的因变量来说,从k个最近的已知类别样本中挑选出频率最好的类别用
    于未知样本的判断;对于连续性的因变量来说,则是将K个最近的已知样本均值用作未知样
    本的预测。

    最佳K值的选择:

    为了在模型中防止出现过拟合或欠拟合状态,也为了获得最佳的k值,可以考虑俩种解决方
    案:一种是设置k近邻样本投票权重,假设读者在使用KNN算法进行分类或预测时设置的
    k值比较大,担心模型发生欠拟合的现象,一个简单有效的方法就是设置近邻样本的投票权
    重,如果一直样本距离未知样本比较远,则对应的权重就设置的低一些,否则权重高一些
    通常可以将权重设置为距离的倒数,另一种是采用多重交叉验证,最后选出平均误差最小的
    k值,当然还可以将俩种方法的有点相结合,选出理想的k值。

    K近邻算法概述:

    简单地说,K 近邻算法采用测量不同特征值之间的距离方法进行分类。它具有的优缺点如下:
    优点:精度高、对异常值不敏感、无数据输入假定。
    缺点:计算复杂度高、空间复杂度高。
    K 近邻算法适用数据范围为:数值型和标称型。
    K 近邻算法的工作原理是:存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一数据与所属分类的对应关系。

    输入没有标签的新数据后,将新数据的每个特征与样本集中数据对应的特征进行比较,然后算法提取样本集中特征最相似数据(最近邻)的分类标签。一般来说,我们只选择样本数据集中前 kk 个最相似的数据,这就是 K 近邻算法中 kk 的出处,通常 kk 是不大于 20 的整数。最后,选择 kk 个最相似数据中出现次数最多的分类,作为新数据的分类。

    K近邻算法的一般流程:

    1、收集数据:可以使用任何方法。
    2、准备数据:距离计算所需要的数值,最好是结构化的数据格式。
    3、分析数据:可以使用任何方法。
    4、训练算法:此步骤不适用于 K 近邻算法。
    5、测试算法:计算错误率。
    6、使用算法:首先需要输入样本数据和结构化的输出结果,然后运行K 近邻算法判定输入数据分别属于哪个分类,最后应用对计算出的分类执行后续的处理。

    开发准备:

    为了简单起见,这里构造的系统只能识别数字 0 到 9,参见图 2-6。需要识别的数字已经使用图形处理软件,处理成具有相同的色彩和大小 1:宽高是 32 像素 x 32 像素的黑白图像。

    尽管采用文本格式存储图像不能有效地利用内存空间,但是为了方便理解,还是将图像转换为文本格式。

    在这里插入图片描述

    实验步骤:

    准备数据:将图像转换为测试向量

    为了使用前面两个例子的分类器,我们必须将图像格式化处理为一个向量。我们将把一个 32x32 的二进制图像矩阵转换为 1x1024 的向量,这样前两节使用的分类器就可以处理数字图像信息了。

    首先编写一段函数 img2vector,将图像转换为向量:该函数创建 1x1024 的 NumPy 数组,然后打开给定的文件,循环读出文件的前 32 行,并将每行的头 32 个字符值存储在 NumPy 数组中,最后返回数组。
    代码

    def img2vector(filename):
        # 创建向量
        returnVect = np.zeros((1, 1024))
        # 打开数据文件,读取每行内容
        fr = open(filename)
        for i in range(32):
            # 读取每一行
            lineStr = fr.readline()
            # 将每行前 32 字符转成 int 存入向量
            for j in range(32):
                returnVect[0, 32*i+j] = int(lineStr[j])
    
    return returnVect
    
    

    分析数据:

    实现这个算法的核心部分:计算「距离」。
    当有一定的样本数据和这些数据所属的分类后,输入一个测试数据,就可以根据算法得出该测试数据属于哪个类别,此处的类别为 0-9 十个数字,就是十个类别。

    算法实现过程:

    1、计算已知类别数据集中的点与当前点之间的距离;
    2、按照距离递增次序排序;
    3、选取与当前点距离最小的 k 个点;
    4、确定前 k 个点所在类别的出现频率;
    5、返回前 k 个点出现频率最高的类别作为当前点的预测分类。

    实现代码:

    import operator
    def classify0(inX, dataSet, labels, k):
    
        """
        参数: 
        - inX: 用于分类的输入向量
        - dataSet: 输入的训练样本集
        - labels: 样本数据的类标签向量
        - k: 用于选择最近邻居的数目
        """
    
        # 获取样本数据数量
        dataSetSize = dataSet.shape[0]
    
        # 矩阵运算,计算测试数据与每个样本数据对应数据项的差值
        diffMat = np.tile(inX, (dataSetSize, 1)) - dataSet
    
        # sqDistances 上一步骤结果平方和
        sqDiffMat = diffMat**2
        sqDistances = sqDiffMat.sum(axis=1)
    
        # 取平方根,得到距离向量
        distances = sqDistances**0.5
    
        # 按照距离从低到高排序
        sortedDistIndicies = distances.argsort()
        classCount = {}
    
        # 依次取出最近的样本数据
        for i in range(k):
            # 记录该样本数据所属的类别
            voteIlabel = labels[sortedDistIndicies[i]]
            classCount[voteIlabel] = classCount.get(voteIlabel, 0) + 1
    
        # 对类别出现的频次进行排序,从高到低
        sortedClassCount = sorted(
            classCount.items(), key=operator.itemgetter(1), reverse=True)
    
        # 返回出现频次最高的类别
    return sortedClassCount[0][0]
    
    

    在这里插入图片描述
    计算完所有点之间的距离后,可以对数据按照从小到大的次序排序。然后,确定前 kk 个距离最小元素所在的主要分类,输入 kk 总是正整数;最后,将 classCount 字典分解为元组列表,然后使用程序第二行导入运算符模块的 itemgetter 方法,按照第二个元素的次序对元组进行排序。

    此处的排序为逆序,即按照从最大到最小次序排序,最后返回发生频率最高的元素标签。

    测试算法:使用 K 近邻算法识别手写数字

    已经将数据处理成分类器可以识别的格式。接下来,将这些数据输入到分类器,检测分类器的执行效果。在写入这些代码之前,必须确保将 from os import listdir 写入文件的起始部分,这段代码的主要功能是从 os 模块中导入函数 listdir,它可以列出给定目录的文件名。

    测试的步骤:

    1、读取训练数据到向量(手写图片数据),从数据文件名中提取类别标签列表(每个向量对应的真实的数字)
    2、读取测试数据到向量,从数据文件名中提取类别标签
    3、执行K 近邻算法对测试数据进行测试,得到分类结果
    4、与实际的类别标签进行对比,记录分类错误率
    5、打印每个数据文件的分类数据及错误率作为最终的结果

    测试代码:

    from os import listdir
    def handwritingClassTest():
        # 样本数据的类标签列表
        hwLabels = []
    
        # 样本数据文件列表
        trainingFileList = listdir('digits/trainingDigits')
        m = len(trainingFileList)
    
        # 初始化样本数据矩阵(M*1024)
        trainingMat = np.zeros((m, 1024))
    
        # 依次读取所有样本数据到数据矩阵
        for i in range(m):
            # 提取文件名中的数字
            fileNameStr = trainingFileList[i]
            fileStr = fileNameStr.split('.')[0]
            classNumStr = int(fileStr.split('_')[0])
            hwLabels.append(classNumStr)
    
            # 将样本数据存入矩阵
            trainingMat[i, :] = img2vector(
                'digits/trainingDigits/%s' % fileNameStr)
    
        # 循环读取测试数据
        testFileList = listdir('digits/testDigits')
    
        # 初始化错误率
        errorCount = 0.0
        mTest = len(testFileList)
    
        # 循环测试每个测试数据文件
        for i in range(mTest):
            # 提取文件名中的数字
            fileNameStr = testFileList[i]
            fileStr = fileNameStr.split('.')[0]
            classNumStr = int(fileStr.split('_')[0])
    
            # 提取数据向量
            vectorUnderTest = img2vector('digits/testDigits/%s' % fileNameStr)
    
            # 对数据文件进行分类
            classifierResult = classify0(vectorUnderTest, trainingMat, hwLabels, 3)
    
            # 打印 K 近邻算法分类结果和真实的分类
            print("测试样本 %d, 分类器预测: %d, 真实类别: %d" %
                  (i+1, classifierResult, classNumStr))
    
            # 判断K 近邻算法结果是否准确
            if (classifierResult != classNumStr):
                errorCount += 1.0
    
        # 打印错误率
        print("\n错误分类计数: %d" % errorCount)
        print("\n错误分类比例: %f" % (errorCount/float(mTest)))
    
    

    上面的代码中,将 trainingDigits 目录中的文件内容存储在列表中,然后可以得到目录中有多少文件,并将其存储在变量 m 中。接着,代码创建一个 m 行 1024 列的训练矩阵,该矩阵的每行数据存储一个图像。

    可以从文件名中解析出分类数字。该目录下的文件按照规则命名,如文件 9_45.txt 的分类是 9,它是数字 9 的第 45 个实例。然后可以将类代码存储在 hwLabels 向量中,使用前面讨论的 img2vector 函数载入图像。

    在下一步中,我们对 testDigits 目录中的文件执行相似的操作,不同之处是并不将这个目录下的文件载入矩阵中,而是使用 classify0() 函数测试该目录下的每个文件。
    最后,输入 handwritingClassTest(),测试该函数的输出结果。
    K 近邻算法识别手写数字数据集,错误率为 1.05%。改变变量 k 的值、修改函数 handwritingClassTest 随机选取训练样本、改变训练样本的数目,都会对 K 近邻算法的错误率产生影响。

    测试结果:
    在这里插入图片描述

    【实验体会】

    K 近邻算法是分类数据最简单有效的算法。K 近邻算法是基于实例的学习,使用算法时我们必须有接近实际数据的训练样本数据。K 近邻算法必须保存全部数据集,如果训练数据集很大,必须使用大量的存储空间。此外,由于必须对数据集中的每个数据计算距离值实际使用是可能非常耗时。是否存在一种算法减少存储空间和计算时间的开销呢?K 决策树就是 K 近邻算法的优化版,可以节省大量的计算开销。

    实验数据关注上面公众号私聊小编!

    展开全文
  • KNN实现手写数字识别,包含图片数据,已经实现图片数据与文本数据的转换
  • 主要为大家详细介绍了python使用KNN算法识别手写数字,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 手写数字识别 python

    2018-06-27 11:11:32
    基于knn手写数字识别,利用python实现, 能够运行,测试集和训练集都有
  • Python实现KNN算法手写识别数字

    千次阅读 2017-04-01 16:53:01
    本文实现用KNN算法实现手写识别数字功能。 语言:Python 训练材料:手写数字素材32*32像素from numpy import * import os from os import listdir import operator #将文件32*32转成1*1024 def img2vector...

    本文实现用KNN算法实现手写识别数字功能。
    语言:Python
    训练材料:手写数字素材32*32像素

    from numpy import *
    import os
    from os import listdir
    import operator
    #将文件32*32转成1*1024
    def img2vector(filename):
        vect=zeros((1,1024))
        f=open(filename)
        for i in range(32):
            line=f.readline()
            for j in range(32):
                vect[0,32*i+j]=int(line[j])
        return vect
    
    def dict2list(dic:dict):
        #''' 将字典转化为列表 '''
        keys = dic.keys()
        vals = dic.values()
        lst = [(key, val) for key, val in zip(keys, vals)]#zip是一个可迭代对象
        return lst
    #inputvector:输入的用于测试的向量
    #trainDataSet:训练的样本集
    #labels:标签
    #k:k邻近的个数
    def knntest(inputvector,trainDataSet,labels,k):
        datasetsize=trainDataSet.shape[0]
        #tile(a,[2,3]) ([a a a],[a,a,a])用第一个参数来构造
        #这里用输入向量来构造一个1024行 1列的矩阵,刚好和训练矩阵同样大小
        diffmat=tile(inputvector,(datasetsize,1))-trainDataSet
    
        #求平方和
        #每个元素都平方
        sqdiffmat=diffmat**2
        #按行求和
        sqdistance=sqdiffmat.sum(axis=1)
        #平方根,得到的是一个一维的矩阵
        distance=sqdistance**0.5
    
        #按照从低到高排序
        #argsort函数排列后得到的是按下标进行排列的矩阵,
        #在原先distance中的下标按距离最近排列 argsort函数返回的是数组值从小到大的索引值
        sortdistance=distance.argsort()
        classcout={}#用来存储key(标签)value(标签出现的次数,选取次数最大的前几个数,找到其标签)
    
        #依次取出最近的样本数据
        for i in range(k):
            #记样本的类别
            votelabel=labels[sortdistance[i]]
            #统计每个标签的次数
            classcout[votelabel]=classcout.get(votelabel,0)+1#获取votelabel键对应的值,无返回默认
        #print("*************")
        #print(classcout)
        #classcout.iteritems()在Python3中取消了,key=lambda x:x[0](按第0个元素排序)字典排序,按照value来排序,返回键
        sortclasscount=sorted(dict2list(classcout),key=operator.itemgetter(1),reverse=True)
        #返回出现频次最高的类别
        return sortclasscount[0][0]
    
    
    
    #手写识别
    def handwritingClassTest():
        print(os.getcwd())
        #将训练数据存储到一个矩阵中1024维,并存储对应的标签
        handlabel=[]
        trainName=listdir(r'digits\trainingDigits')
        trainNum=len(trainName)
        trainNumpy = zeros((trainNum,1024))
        #print("trainNum=%d"%trainNum)
        #对文件名进行分析,训练文本对应的标签
        for i in range(trainNum):
            filename=trainName[i]#文件名
            filestr=filename.split('.')[0]#不带后缀的文件名
            filelabel=int(filestr.split('_')[0])#文件的标签
            #将标签添加至handlabel中
            handlabel.append(filelabel)
            trainNumpy[i,:]=img2vector(r'digits\trainingDigits\%s'%filename)#转成1024
        #print(handlabel[:20])
        testfilelist=listdir(r'digits\testDigits')
        errornum=0
        testnum=len(testfilelist)
        errfile=[]
        #将每一个测试样本放入训练集中使用KNN进行测试
        for i in range(testnum):
            testfilename=testfilelist[i]
            testfilestr=testfilename.split('.')[0]
            testfilelabel=int(testfilestr.split('_')[0])#实际的数字标签
            #将测试样本1024
            testvector=img2vector(r'digits\testDigits\%s'%testfilename)
            #进行测试
            #print("-----------")
            result=knntest(testvector,trainNumpy,handlabel,3)
            print("test value is %d, real value is %d"%(result,testfilelabel))
            if(result!=testfilelabel):
                errornum+=1
                errfile.append(testfilename)
        print("the num of error is %d"%errornum)
        print("the right rate of test is %f "%(1-errornum/float(testnum)))
        print("the error of file are ")
        count=0
        for i in range(len(errfile)):
            if(count==9):
                print()
            print(errfile[i]+' ',end="")
            count+=1
    
    def main():
        #path=os.getcwd()
        handwritingClassTest()
    
    
    if __name__=='__main__':
        main();
    
    

    转载自k-近邻算法实现手写数字识别系统
    并自身进行了测试。

    展开全文
  • 基于KNN实现的手写数字识别C++代码,输出结果有混淆矩阵、召回率、训练准确率、预测数据输出等。
  • 1.knn算法 knn算法的英文全称是k-...2.利用python实现knn算法的手写数字识别 (1)准备训练数据 利用windows自带的绘图软件或其它软件写出若干手写体的数字,保存为图片格式并分好类别。接着利用以下代码将图...

    1.knn算法
    knn算法的英文全称是k-NearestNeighbor翻译成中文为邻近算法。k代表的意思为k个最近的意思,意思是每个样本都可以用离它最近的k个值来表示,若k个值不统一则取出现频率最高的那个值来表示。

    2.利用python实现knn算法的手写体数字识别

    (1)准备训练数据

    利用windows自带的绘图软件或其它软件写出若干手写体的数字,保存为图片格式并分好类别。接着利用以下代码将图片转化为01矩阵的样式保存到另一个文件夹中。
    
    for i in range(1, 5):
        for j in range(1, 11):
            im = Image.open("E:/traindata-pic/"+str(i)+".train-"+str(j)+".png")
            fh = open("E:/traindata-txt/"+str(i)+".train-"+str(j)+".txt", "a")
            w = im.size[0]
            h = im.size[1]
            for m in range(0, h):
                for n in range(0, w):
                    cl = im.getpixel((n ,m))
                    cla = cl[0]+cl[1]+cl[2]
                    if(cla==765):
                        fh.write("1")
                    else:
                        fh.write("0")
                fh.write("\n")
            fh.close()
    
    接着利用如下代码将上述矩阵转化为向量。
    
    def datatoarray(fname):
        arr=[]
        fh=open(fname)
        for i in range(0, 564):
            thisline=fh.readline()
            for j in range(0, 696):
             arr.append(int(thisline[j]))
        return arr
    
    利用以下代码根据命名方式得到每个向量代表的数字,本文的命名方式为:4.train-4。
    
    def seplabel(fname):
        filestr=fname.split(".")[0]
        label=int(filestr.split("train-")[0])
        return label
    
    最终利用如下代码处理训练数据。
    
    def traindata():
        labels=[]
        trainfile = listdir("E:/traindata-txt")
        num = len(trainfile)
        trainarr=zeros((num, 696*564))
        for i in range(0, num):
            thisfname=trainfile[i]
            thislabel=seplabel(thisfname)
            labels.append(thislabel)
            trainarr[i, :]=datatoarray("E:/traindata-txt/"+thisfname)
        return trainarr, labels
    

    (2)knn算法的实现

    knn算法的本质就是在训练数据中筛选出离样本点最近的k个数据,然后利用这k个数据来确定样本点的值。利用如下代码可以实现。
    
    def knn(k, testdata, traindata, labels):
        traindatasize = traindata.shape[0]
        dif = tile(testdata, (traindatasize , 1))-traindata
        sqdif = dif**2
        sumsqdif = sqdif.sum(axis=1)
        distance = sumsqdif**0.5
        sortdistance = distance.argsort()
        count={}
        for i in range(0, k):
            vote = labels[sortdistance[i]]
            count[vote]=count.get(vote, 0)+1
            sortcount = sorted(count.items(), key=operator.itemgetter(1), reverse=True)
            return sortcount[0][0]
    

    (3)识别手写体数字

    其中添加了根据命名方式获取实际数字的步骤,本文命名方式为:3.test-1,代码如下。
    
    def seplabelt(fname):
        filestr=fname.split(".")[0]
        labelt=int(filestr.split("test-")[0])
        return labelt
    
    最终识别代码如下:
    
     def datatest():
        trainarr, labels=traindata()
        testlist = listdir("E:/testdata-txt")
        tnum=len(testlist)
        for i in range(0, tnum):
            thistestfile=testlist[i]
            labelt = seplabelt(thistestfile)
            testarr=datatoarray("E:/testdata-txt/"+thistestfile)
            rknn=knn(3, testarr, trainarr, labels)
            print("识别数字为:"+str(rknn)+" 正确数字为:"+str(labelt))
    
    最终得到识别结果对比,本文实际利用的数据量较小,但从结果来看12个数据只识别错了一个。
    运行结果如下:
    
    datatest()
    识别数字为:1 正确数字为:1
    识别数字为:1 正确数字为:1
    识别数字为:1 正确数字为:1
    识别数字为:2 正确数字为:2
    识别数字为:2 正确数字为:2
    识别数字为:2 正确数字为:2
    识别数字为:3 正确数字为:3
    识别数字为:3 正确数字为:3
    识别数字为:3 正确数字为:3
    识别数字为:1 正确数字为:4
    识别数字为:4 正确数字为:4
    识别数字为:4 正确数字为:4
    
    展开全文
  • 代码及数据集:KNN分类算法--手写数字识别任务
  • faaron-KNN手写数字识别

    2016-03-23 09:41:55
    python开发的手写数字识别。 详情参考:http://blog.csdn.net/faaronzheng/article/details/50908961
  • KNN手写数字识别实战 大纲 1.算法背景 2.sklearn接口API 3.手写数字识别实战 算法背景 KNN(K-Nearest Neighbor):算法核心为:“近朱者赤,近墨者黑”。 工作原理: 1.计算待分类样本与训练样本的距离 2.对距离升序...
  • ↑ 点击上方【计算机视觉联盟】关注我们本节使用KNN算法实现手写数字识别KNN算法基本原理前边文章已经详细叙述,盟友们可以参考哦!数据集介绍有两个文件:(1)trainingDigit...
  • 基于KNN模型实现手写数字识别
  • # 利用sklearn KNN实现手写数字识别 import numpy as np import pandas as pd from PIL import Image import matplotlib.pyplot as plt from sklearn.preprocessing import MinMaxScaler from sklearn....
  • 主要介绍了python实现kNN算法识别手写数字的示例代码,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 通过最近邻域法(KNN)实现手写数字识别,并且计算识别的准确率
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • 选修了模式识别这门课,完成一个简单的基于KNN的分类项目:手写体分类任务。 首先从网站上下载数据,格式为.idx3-ubyte和.idx1-ubyte,分别对应的是图片和标签的数据格式。首先需要对其进行解码,即转化成可以进行...
  • 一:KNN算法理论基础 1) K近邻法(k-nearest neighbor, kNN)的本质是将指定对象根据已知特征值分类。 2) K近邻法是一种基本分类与回归方法,其基本做法是:给定测试实例,基于某种距离度量找出训练集中与其最靠近...
  • python实现K进邻算法对手写数字识别的一个小Demo,含代码和数据集。适合刚入门的小白。棒棒棒棒棒棒棒棒棒棒棒棒
  • Python做的KNN车牌识别程序,可以根据图片识别数字手写数字0123456789就可以识别出来。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,165
精华内容 1,266
关键字:

knn手写数字识别python

python 订阅