精华内容
下载资源
问答
  • 可支持手写数字识别,r和python两种语言编写,生成画板鼠标手写输入,也支持上传图片
  • KNN编写的书写数字识别MNIST手写数字库。用到tf函数下载MNIST库,需要安装TensorFlow。如果没有安装,需要手动导入数据。
  • KNN手写数字识别,knn手写数字识别mnist,Python源码.zip
  • 需要下载MNIST数据集,将路径修改为本地MNIST数据集的地址。需要OpenCV与Tensorflow环境
  • K近邻分类器(KNN)手写数字(MNIST)识别

    千次阅读 2017-01-21 19:46:48
    KNN(K-Nearest-Neighbor) 是分类算法中比较简单的一个算法。算法思想非常简单:对于一个未知类别的样例,我们在很多... 在这里我将用KNN算法做手写识别,用的数据集是MNIST,最后准确率为94%左右。附带数据集与源码

    KNN(K-Nearest-Neighbor) 是分类算法中比较简单的一个算法。算法思想非常简单:对于一个未知类别的样例,我们在很多已知类别的样本中找出跟它最相近的K个样本,赋予该样例这K个样本中占多数的类别。
    KNN决策示例
    如图中所示,如果我们选取K值为3,则将样本分类为三角形的类别。而如果K为5,则将样本分类为正方形的类别。这里也可以看出K值的选取很关键。

    这里呢,我将用KNN做手写体数字的识别。另人惊异的是,用如此简单的算法也可以获得超过94%的识别准确率。
    首先我先介绍一下我用的数据集MNIST,我有的是10500条已经标好类别的样本,我用其中500条做测试样例,用剩下10000条做训练集。其中每一个样本784 位0、1 加上一位类别组成,784位0/1 可以组成28*28的二值图。
    训练样本示例
    二值图含义

    下面是计算两个样例之间距离的公式,这也是最基本的欧式距离。
    欧式距离公式

    public static double calDistance(int[] a, int[] b) {
            double temp = 0;
            for (int x = 0; x < a.length; x++) {
                temp += (a[x] - b[x]) * (a[x] - b[x]);
            }
            return temp = Math.sqrt(temp);
        }

    下面给出分类代码,这里我的程序是读入测试样例,然后逐条计算它与训练样本的距离,找出K个最接近的样本,统计K个中出现最多的类标赋予给测试样例。如果要用这个代码的话需要稍微改一改,用的编程语言都是Java

    public static int classify(String filename, int[] a) throws IOException {
            FileReader fr = new FileReader(filename);
            BufferedReader bufr = new BufferedReader(fr);
    
            double[] d = new double[K];//存放K近邻的距离
    
            for (int x = 0; x < K; x++) {//先将所有K近邻的距离初始化为最大距离28
                d[x] = 28;
            }
            double temp = 0;
            int lable = 0;
            int[] num = new int[K];//记录对应距离的类标
            String str = null;
            int t = 0;
            while ((str = bufr.readLine()) != null && t++ < 10000) {
                int[] b = str2int(str.substring(0, str.length() - 1).split(","));
                temp = calDistance(a, b);
                lable = Integer.parseInt(str.substring(str.length() - 1));
                for (int x = 0; x < K; x++) {//找到K近邻的样本
                    if (temp < d[x]) {
                        d[x] = temp;
                        num[x] = lable;
                        break;
                    }
                }
            }
            bufr.close();
            int[] count = new int[10];
            for (int x = 0; x < K; x++) {//统计各数字出现次数
                count[num[x]]++;
            }
            int result = 0;
            for (int x = 1; x < 10; x++) {//找出出现次数最多的
                if (count[x] > count[result])
                    result = x;
            }
            return result;
        }

    进一步的改进
    关于KNN的改进有以下几个方面:

    1. 加权重,这里的原理是距离测试样本最近的训练样本有比较高的权重。一般权重公式可以为距离的倒数。
    2. 换距离公式,可以换成cos距离
    3. 去除不重要的特征减少计算量;采用特殊的数据结构排序训练样本如kd-tree,减少计算距离次数。

    数据集与整个项目的源码我都已经上传,点击下载。值得注意的是,在我的项目里面已经实现了汉明距离与cos距离两种不同距离衡量方法。有任何问题欢迎讨教

    展开全文
  • 本篇文章主要介绍了PyTorch CNN实战之MNIST手写数字识别示例,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 使用kNN算法对0-9的手写数据集进行识别,包括python代码和数据,数据为txt格式。
  • 手写数字识别Mnist的Pytorch实现

    千次阅读 2020-07-02 23:20:09
    手写数字识别Mnist的Pytorch实现 注:该内容为校内课程实验,仅供参考,请勿抄袭! 源码地址: 一、引言(Introduction)   手写数字识别时经典的图像分类任务,也是经典的有监督学习任务,经常被用于测试图像的...

    手写数字识别Mnist的Pytorch实现

    注:该内容为校内课程实验,仅供参考,请勿抄袭!
    源码地址:Gray-scale-Hand-Written-Digits-Pytorch

    一、引言(Introduction)

      手写数字识别时经典的图像分类任务,也是经典的有监督学习任务,经常被用于测试图像的特征提取效果、分类器性能度量等方面,本文将通过应用机器学习和深度学习算法实现手写数字识别。
      图像分类任务是指给定一张图像来对其进行分类,常见的图像分类任务有手写数字识别、猫狗分类、物品识别等,图像分类也是计算机视觉基本的分类任务。而对于手写数字识别任务来说,可以当做图像分类问题,也可以当做目标检测与分类。其中图像分类即输入整个图像并预测其类别,例如含有6的数字的图像我们希望最大化预测为6的概率;另外也可以视为目标检测任务,即提取图像中的目标并将目标提取出后进行预测,例如OCR对字符进行识别。因为手写数字是被预处理后的图像,且一张图像中只包含一个数字,因此本文则将手写数字识别视为整个图像的分类。

    二、任务分析

    2.1 形式化描述
      给定一个图像数据集,其中图像记做,是一个宽为,高为,通道数为的图像,是图像对应的类标,任务的目标是寻找一个由图像数据到类别的映射。
    2.2 任务分析
      传统的方法是对图像进行序列化,即使用一组向量来对图像进行表示。例如本文处理的手写数字识别是灰度图像,即通道数为1,宽高均为28像素的图像,因此可以直接将图像的每个像素使用0-255整型数进行表示,并形成784维度的向量,然后使用包括SVM(支持向量机)、LR(逻辑回归)、DT(决策树)等机器学习学习多个超平面将假设空间中的样本正确的分类。另外也可以使用聚类算法,例如KNN、K-means、DBSCAN等算法自动将样本聚到10个类别上。
      另外由于手写数字相同类别之间会存在相关性,因此也有基于图像压缩方法进行特征提取工作。通常使用PCA等降维技术将784维度的图像降维到较低空间,形成潜在的特征向量,且这些向量每一个维度之间是不相关;其次对压缩后的特征向量在使用机器学习算法进行分类,这种方法可以大大提高对重要特征的学习,忽略噪声对分类的影响。
      随着深度学习的发展,基于深度学习神经网络可以自动地对特征进行提取以及分类成为图像分类的主流方法。常规有直接将图像对应的矩阵(或张量)进行展开后直接喂入一个前馈神经网络,或使用卷积神经网络或胶囊网络对特征进行提取,并使用一层前馈神经网络进行分类。基于深度学习的方法通常可以有效的提升分类的性能和精度。
    本文主要进行了简单的对比实验,对比方案包括机器学习算法(KNN算法和决策树算法)以及深度学习算法(神经网络、CNN),并进行可视化展示。机器学习算法在实验1和2中有所介绍,因此本节主要介绍CNN网络:
      CNN为两层卷积层以及池化层。第一层卷积层为32个大小为33的卷积核,第二层卷积层为64个22的卷积核,两个池化层均为2值最大池化,卷积网络则为3136维度的向量,输出层为两层神经网络,网络中使用正则化防止过拟合,输出部分为softmax。

    三、数据描述

      本次实验使用MNIST数据集进行实验,其中我们用6000张图像作为训练集,1000张图像作为测试集,图像的示例如图所示:

    在这里插入图片描述
      由于数据集已经集成于一些深度学习框架中,因此我们直接使用pytorch的torchvision中的datasets库下载相应数据集。数据集包括如下几个文件,如下所示:

    train-images-idx3-ubyte 训练集图像数据二进制文件
    train-labels-idx1-ubyte 训练集对应类标二进制文件
    t10k-images-idx3-ubyte 测试集10K图像数据二进制文件
    t10k-labels-idx1-ubyte 测试集10K对应类标二进制文件

      数据集是二进制文件,因此我们使用Pytorch读取数据集,并直接转换为张量,其次将每张图像与类标存入JSON数据中,保存为“{‘img’: img, ‘label’: label}”格式。另外我们使用min_batch方法进行训练,因此使用Pytorch提供的DataLoader方法自动生成batch。

    四、实验

      实验中,首先使用Sklearn调用了包括KNN(K近邻)和DT(决策树)两个算法并对训练集进行训练,其次在测试集上进行实验:。其次使用Pytorch实现只有一层隐层的神经网络以及含有多层卷积核池化层的CNN网络进行实验,程序划分为基于机器学习的训练入口函数(ml_main.py),机器学习算法类为Classifier.py;基于深度学习的训练入口函数(dl_main.py)以及模型为Network.py。使用机器学习的算法实验结果如表所示:

    算法精确度
    KNN97.50%
    DT75.96%
    SVM97.92%

      在使用深度学习训练时,相关超参数如表2所示:

    超参数取值
    Epoch20
    Batch_size30
    Learn_rate0.01
    Hidden_size196

    基于深度学习的实验结果如表4所示:

    算法精确度
    单隐层神经网络93.86%
    CNN98.86%

      下图展示了在CNN模型下训练和测试过程中的损失与精度的变化曲线,以展示最优的CNN的收敛情况。
    在这里插入图片描述

      其中横坐标表示统计的次数,训练集的loss和acc则是每训练20个batch统计一次,测试集的loss和test则是每1000个batch记录一次。

    五、总结

      通过使用几个简单的机器学习和深度学习算法实现了对手写数字识别数据集MNIST的分类,可以发现机器学习算法中SVM模型表现最优,在深度学习模型中CNN分类效果最优。另外通过对模型训练过程中的收敛情况可知,当训练第3轮时模型以及基本达到收敛,因此可知模型的收敛速度和收敛性得以保证。在今后的拓展实验中,我们还将会对彩色图像以及场景图像进行识别,以提升模型的鲁棒性。

    参考文献
    [1]Simonyan K, Zisserman A. VERY DEEP CONVOLUTIONAL NETWORKS FOR LARGE-SCALE IMAGE RECOGNITION[C]. computer vision and pattern recognition, 2014.
    [2]He K, Zhang X, Ren S, et al. Deep Residual Learning for Image Recognition[C]. computer vision and pattern recognition, 2016: 770-778.
    [3]张黎;刘争鸣;唐军;;基于BP神经网络的手写数字识别方法的实现[J];自动化与仪器仪表;2015年06期

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

    万次阅读 多人点赞 2016-07-03 00:17:06
    mnist数据集,包含42000张28*28的图片,可以从网盘下载http://pan.baidu.com/s/1kVi1nc7,下载完解压后如下图所示: 三. 处理方法 1. 把图片读取到一个28*28的矩阵里,然后对图片进行一个简单的二值化,

    一. KNN的原理

    KNN的主要思想是找到与待测样本最接近的k个样本,然后把这k个样本出现次数最多的类别作为待测样本的类别。

    二. 数据源

    mnist数据集,包含42000张28*28的图片,可以从网盘下载http://pan.baidu.com/s/1kVi1nc7,下载完解压后如下图所示:

    三. 处理方法

    1. 把图片读取到一个28*28的矩阵里,然后对图片进行一个简单的二值化,这里选择127为一个界限,大于127的像素点为1,小于等于127的像素点为0,二值化之后的手写数字如下图所示:

    2. 把28*28的矩阵直接转成一个784维的向量,直接去欧氏距离作为度量进行KNN算法,代码如下:

    import os
    import Image
    import numpy as np
    
    def binaryzation(data):
    	row = data.shape[1]
    	col = data.shape[2]
    	ret = np.empty(row * col)
    	for i in range(row):
    		for j in range(col):
    			ret[i * col + j] = 0
    			if(data[0][i][j] > 127):
    				ret[i * col + j] = 1
    	return ret
    
    def load_data(data_path, split):
    	files = os.listdir(data_path)
    	file_num = len(files)
    	idx = np.random.permutation(file_num)
    	selected_file_num = 42000
    	selected_files = []
    	for i in range(selected_file_num):
    		selected_files.append(files[idx[i]])
    
    	img_mat = np.empty((selected_file_num, 1, 28, 28), dtype = "float32")
    
    	data = np.empty((selected_file_num, 28 * 28), dtype = "float32")
    	label = np.empty((selected_file_num), dtype = "uint8")
    
    	print "loading data..."
    	for i in range(selected_file_num):
    		print i,"/",selected_file_num,"\r",
    		file_name = selected_files[i]
    		file_path = os.path.join(data_path, file_name)
    		img_mat[i] = Image.open(file_path)
    		data[i] = binaryzation(img_mat[i])
    		label[i] = int(file_name.split('.')[0])
    	print ""
    
    	div_line = (int)(split * selected_file_num)
    	idx = np.random.permutation(selected_file_num)
    	train_idx, test_idx = idx[:div_line], idx[div_line:]
    	train_data, test_data = data[train_idx], data[test_idx]
    	train_label, test_label = label[train_idx], label[test_idx]
    	
    	return train_data, train_label, test_data, test_label
    
    def KNN(test_vec, train_data, train_label, k):
    	train_data_size = train_data.shape[0]
    	dif_mat = np.tile(test_vec, (train_data_size, 1)) - train_data
    	sqr_dif_mat = dif_mat ** 2
    	sqr_dis = sqr_dif_mat.sum(axis = 1)
    
    	sorted_idx = sqr_dis.argsort()
    
    	class_cnt = {}
    	maxx = 0
    	best_class = 0
    	for i in range(k):
    		tmp_class = train_label[sorted_idx[i]]
    		tmp_cnt = class_cnt.get(tmp_class, 0) + 1
    		class_cnt[tmp_class] = tmp_cnt
    		if(tmp_cnt > maxx):
    			maxx = tmp_cnt
    			best_class = tmp_class
    	return best_class
    
    if __name__=="__main__":
    	np.random.seed(123456)
    	train_data, train_label, test_data, test_label = load_data("mnist_data", 0.7)
    	tot = test_data.shape[0]
    	err = 0
    	print "testing..."
    	for i in range(tot):
    		print i,"/",tot,"\r",
    		best_class = KNN(test_data[i], train_data, train_label, 3)
    		if(best_class != test_label[i]):
    			err = err + 1.0
    	print ""
    	print "accuracy"
    	print 1 - err / tot
    

    四. 实验结果

    实验取70%的数据作为训练,30%的数据作为测试,准确率为95%,结果截图如下:

    如有错误,请指正
    展开全文
  • 机器学习之knn算法----手写数字识别mnist knn介绍 KNeighborsClassifier(n_neighbors=5, weights=‘uniform’, algorithm=‘auto’, leaf_size=30, p=2, metric=‘minkowski’, metric_params=None, n_jobs=1, **...

    机器学习之knn算法----手写数字识别mnist

    knn介绍

    KNeighborsClassifier(n_neighbors=5, weights=‘uniform’, algorithm=‘auto’, leaf_size=30, p=2, metric=‘minkowski’, metric_params=None, n_jobs=1, **kwargs)
    Parameters

    n_neighbors : int, (default = 5)—k的值

    weights : str or callable, optional (default = ‘uniform’)

    - 'uniform' : 默认投票是权重一致
    - 'distance' : 距离越近权重越高
    

    algorithm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional

    - 'ball_tree' 球树,创建球树,减少计算次数
    - 'kd_tree' `KDTree`,创建二叉树,减少计算次数
    - 'brute' 暴力法
    - 'auto' 自动选择。当然数量比较少时,还是使用暴力法
    

    leaf_size :

    -int, optional (default = 30)
    -当使用 BallTree or KDTree.  这个是跟节点的数量,默认是30,当数据量很大时,可以加深节点
    

    p : integer, optional (default = 2)

    - p=1曼哈顿距离。p=2欧氏距离
    - 应该都知道,没什么介绍的。一般都用欧氏距离
    - 
    

    metric : string or callable, default ‘minkowski’

    - 闵可夫斯基,这就是一个公式,不同的p值对应不同的距离。p=2就是欧式
    

    n_jobs : int, optional (default = 1)

    -  让几个人去计算,-1就是你电脑有几个核就用几个。默认就是一个
    

    进入正题

    这些参数到底怎么影响knn的正确率呢?我们来看看。。。。

    这里使用的是.mat的二进制文件。网上有下载,我后面也会上传

    导入模块

    import scipy.io as spio
    
    import numpy as np
    
    import pandas as pd
    
    import matplotlib.pyplot as plt
    %matplotlib inline
    
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.model_selection import train_test_split
    

    因为是mat文件,所以用scipy来获取:

    mnist = spio.loadmat("./data/mnist.mat")
    display(mnist)
    

    输出:

    {'__header__': b'MATLAB 5.0 MAT-file Platform: posix, Created on: Sun Mar 30 03:19:02 2014',
     '__version__': '1.0',
     '__globals__': [],
     'mldata_descr_ordering': array([[array(['label'], dtype='<U5'), array(['data'], dtype='<U4')]],
           dtype=object),
     'data': array([[0, 0, 0, ..., 0, 0, 0],
            [0, 0, 0, ..., 0, 0, 0],
            [0, 0, 0, ..., 0, 0, 0],
            ...,
            [0, 0, 0, ..., 0, 0, 0],
            [0, 0, 0, ..., 0, 0, 0],
            [0, 0, 0, ..., 0, 0, 0]], dtype=uint8),
     'label': array([[0., 0., 0., ..., 9., 9., 9.]])}
    

    这是一种MATLAB的格式文件,有兴趣的可以自行百度,在这不做重点
    可以看出数据都是在data里,目标值在label中。
    获取数据:

    #因为直接获取到的数据shape为(784,70000),所以要进行转置
    #每一个图片的格式都是28*28
    data = mnist["data"].T
    taget = mnist["label"].T
    taget = taget.reshape(70000,)
    

    数据我处理成了一份图片格式的保存在本地,一共七万张图片。后面我也会上传。
    代码就不上了,比较简单。需要的也可以私信我。

    数据切分和加载算法:

    X_train,x_test,Y_train,y_test = train_test_split(data,taget,test_size=0.2)
    #使用默认参数
    knn = KNeighborsClassifier()
    knn.fit(X_train,Y_train)
    

    计算得分

    knn.score(x_test,y_test)
    

    输出:0.9715714285714285

    这是默认参数的准确率。那么他到底预测了哪些是错的哪些的对的呢?我怎么能看到?
    先接收一下他预测出来的数据

    y_ = knn.predict(x_test)
    

    好,我们来画个图:

    plt.figure(figsize=(10*3,10*4))
    #因为测试样本有一万四千个,我们取100个,每隔100个取一个
    for i in range(100):
        plt.subplot(10,10,i+1)
        a = x_test[i*100].reshape(28,28)
        plt.imshow(a,cmap="gray")
        c="b"
        if(y_test[i*100]!=y_[i*100]):c="r"
        plt.title("real:{}predict:{}".format(y_test[i*100],y_[i*100]),color=c)
    

    来一起研究一下。红色的是预测错误的
    在这里插入图片描述
    现在我就想看看预测错的错误数据。

    result = y_==y_test
    
    x_c=x_test[~result]
    y_real = y_test[~result]
    y_c = y_[~result]
    plt.figure(figsize=(10*3,40*4))
    for i in range(y_test[~result].size):
    
        plt.subplot(40,10,i+1)
        plt.imshow(x_c[i].reshape(28,28),cmap="gray")
        
        plt.title("real:{},predict:{}".format(y_real[i],y_c[i]))
        
    

    这个结果有398张,太大太长。我就不显示了。


    现在我更改一下算法

    #kd树来构建knn
    knn = KNeighborsClassifier(algorithm='kd_tree')
    knn.fit(X_train,Y_train)
    knn.score(x_test,y_test)
    

    输出:0.9715714285714285

    我再更改一下算法

    #选择用球树来构建
    knn = KNeighborsClassifier(algorithm='ball_tree')
    knn.fit(X_train,Y_train)
    knn.score(x_test,y_test)
    

    输出:0.9715714285714285

    最终不会因为算法的改变而改变准确率。
    经过画图也看出,他们的准确率和计算错误的样本都是一样的,错都错在那几张图

    kdtree和球树只是检索计算的时候用到,可能会比暴力计算法(全部计算一遍)要快那么一点点。当然对于这个案例来说,我喜欢用kdtree。还是会快一点的。另外大家运算的时候,最少要让n_jobs=2.不然真的太慢了。可能是我电脑的原因吧。

    那么K的值到底取多少好?我还能不能在通过其他参数来提升一点正确率呢?
    我们来试一试,先改变一下K值看看

    这段代码真的很费时间!!!可以看出knn的时间空间复杂度真的很大

    #用于放置准确率的列表,后期画图用
    socre_list = []
    for k in range(3,14):
        t1 = time.time()
        knn = KNeighborsClassifier(n_neighbors=k,n_jobs=2,algorithm='kd_tree')
        knn.fit(x_train,y_train)
        y_ = knn.predict(x_test)
        result = y_==y_test
        score = y_test[result].size/14000
        socre_list.append(score)
        t2 = time.time()
        print("k的值为:{},用时{:.2f}秒,此时的正确率为:{:.10f}".format(k,t2-t1,score))
    

    我的电脑运行内部一次循环用时500到560秒左右
    一共循环十几次,可想而知
    。。。。。。。

    dispaly(socre_list)
    

    输出:

    socre_list =[0.9719285714,0.9717857143,0.9715714286,0.9722857143,0.9715000000,0.9701428571,0.9702857143,0.9698571429,0.9694285714,0.9684285714,0.9677857143]
    

    以上就是最后的到的准确率

    #画图展示
    plt.figure(figsize=(12,9))
    plt.plot(list1,color="b",marker='o',lw=2,ls='-',label="正确率")
    plt.title("近邻算法K值所影响的手写数字识别正确率:")
    plt.legend(loc="best")
    plt.xticks(range(10),np.arange(4,14))
    plt.xlabel("k值")
    plt.ylabel("正确率")
    plt.grid(True)
    plt.show()
    

    在这里插入图片描述
    图中可以知道:当k取6时,准确率是最高的。


    准确率就是这样慢慢试出来的,你也不知道怎么样他就会蹦高。但对于手写字体,经过我的实验,加了权重以后,准确率会高不少
    当然如果没有一台好电脑,你也会像我一样崩溃的。。。。。
    重构代码,增加distance权重

    socre_list1 = []
    for k in range(3,14):
        t1 = time.time()
        knn = KNeighborsClassifier(n_neighbors=k,n_jobs=2,algorithm='kd_tree',weights='distance')
        knn.fit(x_train,y_train)
        y_ = knn.predict(x_test)
        result = y_==y_test
        score = y_test[result].size/14000
        socre_list1.append(score)
        t2 = time.time()
        print("k的值为:{},用时{:.2f}秒,此时的正确率为:{:.10f}".format(k,t2-t1,score))
    

    输出:

    k的值为:3,用时528.99秒,此时的正确率为:0.9730000000
    k的值为:4,用时560.37秒,此时的正确率为:0.9741428571
    k的值为:5,用时560.62秒,此时的正确率为:0.9730714286
    k的值为:6,用时519.32秒,此时的正确率为:0.9735000000
    k的值为:7,用时522.16秒,此时的正确率为:0.9722857143
    k的值为:8,用时520.83秒,此时的正确率为:0.9726428571
    k的值为:9,用时521.36秒,此时的正确率为:0.9710714286
    k的值为:10,用时518.88秒,此时的正确率为:0.9717142857
    k的值为:11,用时521.65秒,此时的正确率为:0.9704285714
    k的值为:12,用时520.72秒,此时的正确率为:0.9702142857
    k的值为:13,用时521.22秒,此时的正确率为:0.9689285714
    

    画图:

    plt.figure(figsize=(12,9))
    plt.plot(socre_list1,color="b",marker='o',lw=2,ls='-',label="正确率")
    plt.title("近邻算法K值所影响的手写数字识别正确率:")
    plt.legend(loc="best")
    plt.xticks(range(11),np.arange(3,14))
    plt.xlabel("k值")
    plt.ylabel("正确率")
    plt.grid(True)
    plt.show()
    

    在这里插入图片描述

    这样可能看不出来两种有啥不同。我们画在一张图上

    plt.figure(figsize=(9,6))
    plt.plot(socre_list1,color="r",marker='o',lw=2,ls='-',label="加了权重distance的正确率")
    # plt.xticks(range(11),np.arange(3,14))
    
    plt.plot(list1,color="b",marker='o',lw=2,ls='-',label="默认权重的正确率")
    plt.xticks(range(11),np.arange(3,14))
    plt.grid(True)
    plt.legend(loc="best")
    plt.title("近邻算法K值所影响的手写数字识别正确率:")
    
    plt.show()
    

    在这里插入图片描述
    当然每一次运行结果可能都会不一样,因为train_test_split分割每一个的数据也是不一样的。这里只是相对而言比不加权重高一点。
    但是对于机器学习建模来说,测试样本的准确率只是一方面。也许这个样本准确度高,换一个样本集,就不行了呢。。。所以要多试试吧。今天就先这么多。希望大家一起学习交流。这个算法还是很简单的!

    展开全文
  • 图像识别:利用KNN实现手写数字识别mnist数据集) 步骤: 1、数据的加载(trainSize和testSize不要设置的太大) 2、k值的设定(不宜过大) 3、KNN的核心:距离的计算 4、k个最近的图片-->根据下标寻找...
  • KNN算法使用MNIST数据集、0-1二值图集、自写的数字图片集,做手写数字识别的代码,文件夹分类明确。
  • 本文实例为大家分享了基于TensorFlow的CNN实现Mnist手写数字识别的具体代码,供大家参考,具体内容如下 一、CNN模型结构 输入层:Mnist数据集(28*28) 第一层卷积:感受视野5*5,步长为1,卷积核:32个 第一层...
  • 选修了模式识别这门课,完成一个简单的基于KNN的分类项目:手写体分类任务。 首先从网站上下载数据,格式为.idx3-ubyte和.idx1-ubyte,分别对应的是图片和标签的数据格式。首先需要对其进行解码,即转化成可以进行...
  • https://blog.csdn.net/askmeaskyou/article/details/108674860 文章全套代码。 mnist手写数字识别tensorflow2全连接层实现和卷积层实现(包含代码,模型,调用接口)
  • MNIST | 基于k-means和KNN的0-9数字手写识别-附件资源
  • 代码及数据集:KNN分类算法--手写数字识别任务
  • 代码使用matlab编写,压缩包中包含MNIST数据集及其读取函数、KNN算法实现和ReadMe.txt。 KNN算法中使用了PCA降维处理数据减少运行时间,正确率可达95%,有部分注释。请结合ReadMe文件使用。
  • 点击查看:Tensorflow2.0的手写数字识别系统(Mnist数据集) 项目编号:C60 文件大小:986M 操作系统:Windows10旗舰版 开发工具:Python、Tensorflow2.0, 开发语言:.py 简要概述: 基于Tensorflow2.0的手写数字识别...
  • 关于手写数字的解析在我的另外一篇博客了作了讲解,这篇文章我们将利用OpenCV的机器学习算法knn实现对手写数字识别。使用knn进行手写数字的准确率高达97%。 环境准备: vs2015 OpenCV4.5.0 下面为模型训练代码: #...
  • 使用knnMNIST分类

    2019-01-13 12:23:15
    有不少同学看到我的《Python代码实现简单的MNIST手写数字识别(适合初学者看)》博客,跟我要源代码和数据,还得邮箱一个一个回复,我直接放在资源里吧。另外还有根据knn原理写的代码,没有使用sklearn库,也上传在...
  • MNIST数据集,原下载地址(http://yann.lecun.com/exdb/mnist/);对于数据读取以及KNN测试的代码可见https://blog.csdn.net/z1433768804/article/details/104780971
  • 本文介绍了KNN原理,利用KNN对手写体进行了识别,并给出了主要的函数及其用法。
  • scikit-learn/KNN手写数字识别

    千次阅读 2017-07-10 09:15:56
    环境:python 3, scikit-learn 0.18KNN可以看成:有一堆已经知道分类的数据,当一个新数据进入的时候,就开始跟训练数据里的每个点求距离,然后挑离这个训练数据最近的K个点看看这几个点属于什么类型,然后利用少数...
  • mnist手写字体识别KNN,用的python代码,本科课程作业,内含MNIST手写字体数据集,含代码等等
  • k-NN分类器将应用于图像数据集,以便从MNIST子集中识别手写数字。 理解 数据集的75%将接受培训,其余的将进行测试; 培训数据的10%将分配给验证,其余90%将作为培训数据保留 精度将显示要使用的最有效的k。 对...
  • 用K近邻(KNN)做手写识别MNIST),准确率可以达到94%。关于具体原理可以看我的博客
  • KNN项目实战——手写数字识别 1、数据集介绍 2、准备数据:将图像转换为测试向量 3、代码实现 KNN项目实战——手写数字识别 1、数据集介绍 需要识别数字已经使用图形处理软件,处理成具有相同的色彩和大小:...
  • 数据集:MINST 数据预处理参考了...处理出来有用的信息也就是28×2828 \times 2828×28的矩阵和Label信息。 关于KNN的信息参考了:《机器学习实战》和《机器学习》(周志华)两本书 KNN大致实现: ...
  • KNN实现手写数字识别

    2018-02-10 23:55:46
    对于KNN算法的一个简单python实现 少于100行+++++++++

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 882
精华内容 352
关键字:

knn手写数字识别mnist