精华内容
下载资源
问答
  • KNN手写数字识别,knn手写数字识别mnist,Python源码.zip
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • KNN手写数字识别源码.zip
  • KNN手写数字识别-源码.rar
  • KNN 手写数字识别

    2020-10-09 14:42:06
    数据集 ...提取码:jwsf 代码 from os import listdir import numpy as np def img2vector(filename): vector=np.zeros((1,1024)) fp=open(filename) for i in range(32): fstr=fp.readline() ...

    数据集
    链接:https://pan.baidu.com/s/1XCyuW3wbvWk8X28jvgS-WQ
    提取码:jwsf

    代码

    from os import listdir
    import numpy as np
    def img2vector(filename):
        vector=np.zeros((1,1024))
        fp=open(filename)
        for i in range(32):
            fstr=fp.readline()
            for j in range(32):
                vector[0,32*i+j]=int(fstr[j])
        return vector
    def getmat():
        labels=[]
        listname=listdir('数据绝对路径')
        m=len(listname)
        mat=[]
        for i in range(m):
            strname=listname[i].split('.')[0]
            str=strname.split('_')[0]
            labels.append(int(str))
            mat.extend(img2vector('数据绝对路径/%s'%listname[i]))
        testlist=listdir('数据绝对路径\\testDigits')
        n=len(testlist)
        rightnum=0
        for i in range(n):
            strname=testlist[i].split('.')[0]
            str=strname.split('_')[0]
            out=int(str)
            testmat=img2vector('数据绝对路径\\testDigits/%s'%testlist[i])
            classfyresult=classfy0(testmat,mat,labels)
            print("Classfy is",classfyresult,"Answer is",out)
            if classfyresult==out:
                rightnum=rightnum+1
        print('Right Rate=',rightnum/n)
    
    def classfy0(test,train,labels):
        diff1=train-np.tile(test,(np.size(train,0),1))
        diff2=diff1**2
        distance=diff2.sum(axis=1)**0.5
        sorteddis=distance.argsort()
        k=3
        labellist=np.zeros((1,10))
        for i in range(k):
            new_label=labels[sorteddis[i]]
            labellist[0,new_label]=labellist[0,new_label]+1
        finallabel=labellist.argsort()
        return finallabel[0,9]
    
        
    

    在这里插入图片描述

    展开全文
  • KNN手写数字识别

    2020-06-12 23:00:33
    预测时也要用二维数据 X_test = X_test.reshape(1000,784) 算法预测 %%time knn = KNeighborsClassifier(n_neighbors= 63) knn.fit(X_train,y_train) # 使用算法进行预测 # 保留了1000个数据,算法‘没见过‘这1000...

    目录

    导包

    读取数据

    将5000张图片全部加载进来

    画图显示

    加载数据,处理(灰度化)

    X,y划分成训练和验证数据

    算法训练和预测(验证)

    算法预测

    提升准确率,将邻居数降为5

    n-jobs提升

    二值化操作

    多次划分训练预测的平均准确率



    导包

    CV2比matplotlib加载速度快

    import numpy as np
    
    import cv2#加载图片
    
    import matplotlib.pyplot as plt
    
    #inline表示将图表嵌入到Notebook中
    
    %matplotlib inline
    
    from sklearn.neighbors import KNeighborsClassifier

    读取数据

    # bitmap 位图
    digit = cv2.imread('./data/0/0_101.bmp')
    plt.imshow(digit)
    #图为0
    
    

    一个小方块代表一个像素,数据是三维的。将digit转换为黑白的,数据即会减小。

    # 将彩色(三维的)图片转化成黑白的(图片灰度化处理):大大降低数据量
    digit = cv2.cvtColor(digit,code = cv2.COLOR_BGR2GRAY)
    
    # 原来的数据(28,28,3) [高度,宽度,像素]----------> (28,28)
    #  数据量大大减少了2/3,只有原来的1/3
    
    digit.shape

    # digit二维的,高度,宽度,像素(只有一个值)--------用什么颜色表示呢?
    # 选择黑白,图片show就是黑白,rainbow显示出来,彩虹效果
    
    plt.imshow(digit,cmap=plt.cm.gray)

     

    将5000张图片全部加载进来

    X = []
    for i in range(10):
        for j in range(1,501):#1-500
            digit = cv2.imread('./data/%d/%d_%d.bmp'%(i,i,j))
            X.append(digit[:,:,0])#切片
    # 数据X和目标值y是一一对应
    X = np.asarray(X) # 列表转换为numpy对象
    y = np.array([i for i in range(10)]*500)#500个是一类 列表乘以500
    y.sort()#排序
    

    画图显示

    # digit二维的,高度,宽度,像素(只有一个值)--------用什么颜色表示呢?
    # 选择黑白,图片show就是黑白,rainbow显示出来,彩虹效果
    
    index = np.random.randint(0,5000,size = 1)[0]
    
    digit = X[index]
    
    print('-----------------------',y[index])
    
    plt.imshow(digit,cmap = plt.cm.gray)

     

    加载数据,处理(灰度化)

    X,y划分成训练和验证数据

    # 模型选择,可以打乱顺序,按照比例进行划分
    from sklearn.model_selection import train_test_split
    
    # test_size = 0.2,train_size = 0.8 百分比 random_state:
    # 训练:测试= 4:1
    # 一一对应的 
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state = 100)

     

    算法训练和预测(验证)

    
    knn = KNeighborsClassifier(n_neighbors= 63)
    
    knn.fit(X_train,y_train)
    
    

    此时会发现报错了,

    数据是三维的,算法是预估,数据不符要求,应用reshape改变形状,变成二维的。

    # 数据不合要求,reshape形状改变
    # 数据不变
    # 三维的数据--------->变成2维
    X_train = X_train.reshape(4000,-1)
    X_train.shape

    再执行,就不报错了。

    预测时也要用二维数据

    X_test = X_test.reshape(1000,784)

    算法预测

    %%time
    knn = KNeighborsClassifier(n_neighbors= 63)
    
    knn.fit(X_train,y_train)
    
    # 使用算法进行预测
    # 保留了1000个数据,算法‘没见过‘这1000个数据
    X_test = X_test.reshape(1000,784)
    y_ = knn.predict(X_test)
    # 准确率
    # (y_ == y_test).sum()/1000
    print((y_ == y_test).mean())

    提升准确率,将邻居数降为5

    %%time
    # 参数n_neighbors = 5告诉计算机找到最近的5个邻居
    # 计算所有,找到最小的5个距离,最近的5个邻居
    knn = KNeighborsClassifier(n_neighbors= 5)
    knn.fit(X_train,y_train)
    # 使用算法进行预测
    # 保留了1000个数据,算法‘没见过‘这1000个数据
    X_test = X_test.reshape(1000,784)
    # 取出一个,找这一个5个邻居(4000个数据中)-----> 遍历------->d[:5]
    # 取出一个,找这一个63个邻居(4000个数据中)-----> 遍历------>d[:63]
    y_ = knn.predict(X_test)
    
    # 准确率
    # (y_ == y_test).sum()/1000
    print((y_ == y_test).mean())#

    由此可以看出kNN的缺点,时间和空间复杂度都比较大。

    设学习和预测的数据一样

    %%time
    # 参数n_neighbors = 5告诉计算机找到最近的5个邻居
    # 计算所有,找到最小的5个距离,最近的5个邻居
    knn = KNeighborsClassifier(n_neighbors= 5)
    # 算法是‘学习‘,不是死记硬背,存到数据库一样,进行一一对比
    knn.fit(X_train,y_train) #算法训练(学习)4000个数据
    # 使用算法进行预测
    # 保留了1000个数据,算法‘没见过‘这1000个数据
    X_test = X_test.reshape(1000,784)
    # 取出一个,找这一个5个邻居(4000个数据中)-----> 遍历------->d[:5]
    # 取出一个,找这一个63个邻居(4000个数据中)-----> 遍历------>d[:63]
    y_ = knn.predict(X_train) #算法预测4000个数据
    
    # 准确率是否可以100% ???
    # (y_ == y_test).sum()/1000
    print((y_ == y_train).mean())

    n-jobs提升

    knn = KNeighborsClassifier(n_neighbors= 5,n_jobs=-1)#n_jobs=-1便是使用全部的CPU

    算法是去学习,不是死记硬背,不是像数据库一样将数据一一对比,它是学习总结规律的过程,所以即使相同的数据去测试,准确率也不可能是100%。

    index = np.random.randint(0,5000,size = 1)[0]
    plt.imshow(X[index],cmap = 'gray')

    二值化操作

    # 二值化操作
    for i in range(5000):
        for y in range(28):#高
            for x in range(28):#宽
                if X[i][y,x] < 200:
                    X[i][y,x] = 0
                else:
                    X[i][y,x] = 255
    
    index = np.random.randint(0,5000,size = 1)[0]
    plt.imshow(X[index],cmap = 'gray')

    多次划分训练预测的平均准确率

    y = np.array([i for i in range(10)]*500)
    y.sort()
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2,random_state=100)#random_state标记状态
    
    %%time
    accuracy = 0
    for i in range(30):
        X_train,X_test,y_train,y_test = train_test_split(X,y,test_size = 0.2)
        # 参数n_neighbors = 5告诉计算机找到最近的5个邻居
        # 计算所有,找到最小的5个距离,最近的5个邻居
        knn = KNeighborsClassifier(n_neighbors= 5,n_jobs=-1)
        # 算法是‘学习‘,不是死记硬背,存到数据库一样,进行一一对比
        knn.fit(X_train.reshape(4000,-1),y_train) #算法训练(学习)4000个数据
        # 使用算法进行预测
        # 保留了1000个数据,算法‘没见过‘这1000个数据
        X_test = X_test.reshape(1000,784)
        # 取出一个,找这一个5个邻居(4000个数据中)-----> 遍历------->d[:5]
        # 取出一个,找这一个63个邻居(4000个数据中)-----> 遍历------>d[:63]
        y_ = knn.predict(X_test.reshape(1000,-1)) #算法预测4000个数据
    
        # 准确率是否可以100% ???
        # (y_ == y_test).sum()/1000
        accuracy += (y_ == y_test).mean()/30
    print('-----------------多次划分训练预测的平均准确率:%0.3f'%(accuracy))

     

     

     

    展开全文
  • knn手写数字识别

    千次阅读 2019-04-10 22:37:59
    import numpy as np ...def knn(k,testdata,traindata,labels): traindatasize=traindata.shape[0]####获取行数 dif=tile(testdata,(traindatasize,1))-traindata####将行数扩展和训练集一样,并...

    knn手写数字识别的原理其实特别简单,他先将手写的数字进行灰度化的处理,形成一个32 * 32像素的图片,然后将手写数字覆盖的地方用1表示,空白的地方用0表示,形成一个32 * 32的向量。大概出来的图像如下所示。在这里插入图片描述
    然后将需要识别的手写数字拿过来和已经有的一大群标注过得训练数据,进行欧式距离的计算,也就是每一对应位置相减在平方求和,找出和要识别数据欧式距离最近的前k个,这个k也就是knn里的k的含义。然后统计这k个里面出现次数最多的数字,将结果识别为这个数字。 当然在计算之前,无论是标注过的训练数据还是需要识别的测试数都需要将3232的向量转化为11024的向量这样方便计算。
    这基本就是knn手写数字识别的基本原理了,下面直接上代码。

    import numpy as np
    import os
    from numpy import *
    
    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(10):
            count[i]=0
        for i in range(0,k):
            vote=labels[sortdistance[i]]
            count[vote]+=1
    '''以下三种方法都是将前k个最匹配的出现频率最高的数字拿出来作为匹配结果'''
    #     sortcount=sorted(count.items(),key=operator.itemgetter(1),reverse=True)
        sortcount=sorted(count.items(),key=lambda x:x[1],reverse=True)
        return sortcount[0][0]
        
    #     max=0
    #     a=11
    
    #     for i in range(10):
    #         if count[i]>=max:
    #             max=count[i]
    #             a=i
    #     return a
    
    

    将一个32 * 32的0,1文件转化为数组1*1024的数组

    def datatoarray(fname):  ####将一个32*32的文件转化为数组1*1024的数组
        arr=[]
        fh=open(fname)
        for i in range(0,32):
            thisline=fh.readline()
            for j in range(0,32):
                arr.append(int(thisline[j]))
        return arr
    

    读取标签,即该特征代表的实际数字,文件名是0_0.txt这种格式。

    def seplabel(fname):###读取标签,即该特征代表的实际数字
        filestr=fname.split(".")[0]
        labels=int(filestr.split("_")[0])
        return labels
    

    训练数据,就是将训练数据进行处理,返回特征数组,和每个位置对应的真是数字。

    def traindata():
        labels=[]
        trainfile=os.listdir("C:/Users/ASUS/Desktop/data mining/traindata")
        num=len(trainfile)
        #像素32*32=1024
        #创建一个数组存放训练数据,行为文件总数,列为1024,为一个手写体的内容 zeros创建规定大小的数组
        trainarr=zeros((num,1024))
        for i in range(0,num):
            thisfname=trainfile[i]
            thislabel=seplabel(thisfname)
            labels.append(thislabel)
            trainarr[i]=datatoarray("C:/Users/ASUS/Desktop/data mining/traindata/"+thisfname)###第i行加入一个特征
        return trainarr,labels
        ‘’‘trainarr是一个多维的数组格式如[[1*1024],[1*1024]....],列表中每一个都是一个手写数字特征列表’‘’
    

    测试数据,主要就是一些数据处理方面和格式胡阿德输出的问题

    def datatest():
        trainarr,labels=traindata()
        testlist=os.listdir("C:/Users/ASUS/Desktop/data mining/testdata")
        tnum=len(testlist)
        right_count=0
        for i in range(tnum):
            thisname=testlist[i]
            test_arr=datatoarray("C:/Users/ASUS/Desktop/data mining/testdata/"+thisname)
            rknn=knn(k=1,testdata=test_arr,traindata=trainarr,labels=labels)
            lab=seplabel(str(thisname))
            if rknn==lab:
                right_count+=1
                print(str(thisname) + "  :  " + str(rknn)+'识别成功')
            else:
                print(str(thisname) + "  :  " + str(rknn) + '识别失败')
        print('正确率为:'+str(right_count/tnum))
    

    调用函数

    datatest()
    

    显示结果如下。
    在这里插入图片描述
    下面附上手写数字识别的训练集和测试集。
    链接:https://pan.baidu.com/s/1PGKuCk4eGZ3Z6YVcB575Rw
    提取码:l3s6

    展开全文
  • knn手写数字识别(代码和数据)
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • KNN实现手写数字识别博客上显示这个没有Jupyter的好看,想看Jupyter Notebook的请戳KNN实现手写数字识别.ipynb1 - 导入模块import numpy as npimport matplotlib.pyplot as pltfrom PIL import Imagefrom ld_mnist ...

    KNN实现手写数字识别

    博客上显示这个没有Jupyter的好看,想看Jupyter Notebook的请戳KNN实现手写数字识别.ipynb

    1 - 导入模块

    import numpy as np

    import matplotlib.pyplot as plt

    from PIL import Image

    from ld_mnist import load_digits

    %matplotlib inline

    2 - 导入数据及数据预处理

    import tensorflow as tf

    # Import MNIST data

    from tensorflow.examples.tutorials.mnist import input_data

    def load_digits():

    mnist = input_data.read_data_sets("path/", one_hot=True)

    return mnist

    mnist = load_digits()

    Extracting C:/Users/marsggbo/Documents/Code/ML/TF Tutorial/data/MNIST_data\train-images-idx3-ubyte.gz

    Extracting C:/Users/marsggbo/Documents/Code/ML/TF Tutorial/data/MNIST_data\train-labels-idx1-ubyte.gz

    Extracting C:/Users/marsggbo/Documents/Code/ML/TF Tutorial/data/MNIST_data\t10k-images-idx3-ubyte.gz

    Extracting C:/Users/marsggbo/Documents/Code/ML/TF Tutorial/data/MNIST_data\t10k-labels-idx1-ubyte.gz

    数据维度

    print("Train: "+ str(mnist.train.images.shape))

    print("Train: "+ str(mnist.train.labels.shape))

    print("Test: "+ str(mnist.test.images.shape))

    print("Test: "+ str(mnist.test.labels.shape))

    Train: (55000, 784)

    Train: (55000, 10)

    Test: (10000, 784)

    Test: (10000, 10)

    mnist数据采用的是TensorFlow的一个函数进行读取的,由上面的结果可以知道训练集数据X_train有55000个,每个X的数据长度是784(28*28)。

    x_train, y_train, x_test, y_test = mnist.train.images, mnist.train.labels, mnist.test.images, mnist.test.labels

    展示手写数字

    nums = 6

    for i in range(1,nums+1):

    plt.subplot(1,nums,i)

    plt.imshow(x_train[i].reshape(28,28), cmap="gray")

    1e637c5bac3d175fd8350cadf07937ad.png

    3 - 构建模型

    class Knn():

    def __init__(self,k):

    self.k = k

    self.distance = {}

    def topKDistance(self, x_train, x_test):

    '''

    计算距离,这里采用欧氏距离

    '''

    print("计算距离...")

    distance = {}

    for i in range(x_test.shape[0]):

    dis1 = x_train - x_test[i]

    dis2 = np.sqrt(np.sum(dis1*dis1, axis=1))

    distance[str(i)] = np.argsort(dis2)[:self.k]

    if i%1000==0:

    print(distance[str(i)])

    return distance

    def predict(self, x_train, y_train, x_test):

    '''

    预测

    '''

    self.distance = self.topKDistance(x_train, x_test)

    y_hat = []

    print("选出每项最佳预测结果")

    for i in range(x_test.shape[0]):

    classes = {}

    for j in range(self.k):

    num = np.argmax(y_train[self.distance[str(i)][j]])

    classes[num] = classes.get(num, 0) + 1

    sortClasses = sorted(classes.items(), key= lambda x:x[1], reverse=True)

    y_hat.append(sortClasses[0][0])

    y_hat = np.array(y_hat).reshape(-1,1)

    return y_hat

    def fit(self, x_train, y_train, x_test, y_test):

    '''

    计算准确率

    '''

    print("预测...")

    y_hat = self.predict(x_train, y_train, x_test)

    # index_hat =np.argmax(y_hat , axis=1)

    print("计算准确率...")

    index_test = np.argmax(y_test, axis=1).reshape(1,-1)

    accuracy = np.sum(y_hat.reshape(index_test.shape) == index_test)*1.0/y_test.shape[0]

    return accuracy, y_hat

    clf = Knn(10)

    accuracy, y_hat = clf.fit(x_train,y_train,x_test,y_test)

    print(accuracy)

    预测...

    计算距离...

    [48843 33620 11186 22059 42003 9563 39566 10260 35368 31395]

    [54214 4002 11005 15264 49069 8791 38147 47304 51494 11053]

    [46624 10708 22134 20108 48606 19774 7855 43740 51345 9308]

    [ 8758 47844 50994 45610 1930 3312 30140 17618 910 51918]

    [14953 1156 50024 26833 26006 38112 31080 9066 32112 41846]

    [45824 14234 48282 28432 50966 22786 40902 52264 38552 44080]

    [24878 4655 20258 36065 30755 15075 35584 12152 4683 43255]

    [48891 20744 47822 53511 54545 27392 10240 3970 25721 30357]

    [ 673 17747 33803 20960 25463 35723 969 50577 36714 35719]

    [ 8255 42067 53282 14383 14073 52083 7233 8199 8963 12617]

    选出每项最佳预测结果

    计算准确率...

    0.9672

    准确率略高。

    MARSGGBO原创

    2017-8-21

    展开全文
  • KNN手写数字识别.7z

    2020-04-15 11:19:06
    利用OpenCV中的KNN聚类方法来实现手写数字识别,可实时在创建的窗口画板上书写数字并进行识别。内含训练用的手写数字数据,如果缺失dll文件可以下载我的另一个资源“install文件”,其中包含了联合openVINO和CUDA...
  • # 1 重要# 2 KNN CNN 2种# 3 样本# 4 旧瓶装新酒 :数字识别的不同# 4.1 网络 4。2 每一级 4.3 先原理 后代码# 本质:knn test 样本 K个 max4 3个1 -》1# 1 load Data 1.1 随机数 1.2 4组 训练 测试 (图片 和 标签)#...
  • faaron-KNN手写数字识别

    2016-03-23 09:41:55
    python开发的手写数字识别。 详情参考:http://blog.csdn.net/faaronzheng/article/details/50908961
  • kNN手写数字识别实战

    2018-05-21 23:13:37
    本资源结合机器学习实战一书使用,包括手写数字图像和kNN.py代码,详细介绍可见博文:https://blog.csdn.net/louishao/article/details/80398834
  • KNN编写的书写数字识别。MNIST手写数字库。用到tf函数下载MNIST库,需要安装TensorFlow。如果没有安装,需要手动导入数据。
  • KNN手写数字识别实战 大纲 1.算法背景 2.sklearn接口API 3.手写数字识别实战 算法背景 KNN(K-Nearest Neighbor):算法核心为:“近朱者赤,近墨者黑”。 工作原理: 1.计算待分类样本与训练样本的距离 2.对距离升序...
  • 文件目录及样本数据: testDigits目录下为测试数据,trainingDigits目录下为训练数据,文件名形如[0-9]_[0-200].txt,即有0至9的各200个左右不同的样本,例如... 代码(knn.py):fromnumpyimport*importoperatorimport...
  • 10,knn手写数字识别

    2019-09-25 01:07:14
    img_arr = plt.imread('F:/数字.jpg') plt.imshow(img_arr) five_img = img_arr[95:150,85:130] plt.imshow(five_img) five_img.shape # 对目标照片进行降维 five_img = five_img.mean(axis=2) # 将照片的像素...
  • 机器学习--knn手写数字识别系统

    千次阅读 2017-05-07 20:04:05
    0. 刚接触java,并且在学习机器学习的相关算法,knn又... 功能2:可以对特定的区域进行截屏,因为要获取用户手写数字,保存为图像,然后使用算法进行分析  功能3:可以对图片进行缩放,要保证图片的大小(维度)要和
  • import numpy as np import os from os import listdir import operator def classify0(inX,dataSet,labels,k): dataSetSize = dataSet.shape[0] diffMat = np.tile(inX,(dataSetSize,1))-dataSet ...
  • 文章目录加载...本文采用PCA+KNN的方法进行kaggle手写数字识别,训练数据共有42000行,每行代表一幅数字图片,共有784列(一副数字图像是28*28像素,将一副图像展开为一行即784),更多关于Digit Recogniz...

空空如也

空空如也

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

knn手写数字识别