KNN算法实现手写体数字识别

已于 2024-04-15 23:07:27 修改
阅读量1.3k 收藏 19
点赞数 6
分类专栏： 机器学习 文章标签： 机器学习 深度学习
于 2024-04-02 18:36:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_74326343/article/details/137251204
版权

目录

一、算法概述

1.1算法介绍

1.2算法的一般流程

1.3 K的取值分析

二、算法实现

2.1数据集加载和预处理

2.2KNN算法实现

2.2.1手写KNN算法

2.2.2直接调库

三、实验结果分析 

1.分析KNN算法优劣

2.算法改进

四、模型性能评估

1、混淆矩阵：

2、ROC和PR曲线

1、ROC曲线

（1）概念

（2）绘制ROC曲线

2、PR曲线

（1）概念

（2）绘制PR曲线

一、算法概述

1.1算法介绍

K近邻算法：如果一个样本在特征空间中距离最近的K个样本点的所属类别比重最大的，则该样本也属于这个类别。

KNN算法的核心是样本间的距离和K的取值，主要应用于分类和回归。

1.2算法的一般流程

  1. 确定邻居数k：确定一个合适的k，是KNN算法中的一个超参数。

  2. 计算距离：对于待预测样本，计算它与训练集中每个样本的距离。常用的距离度量包括欧氏距离、曼哈顿距离、闵可夫斯基距离等。

  3. 找到最近的邻居：根据计算的距离，找到与待预测样本最近的k个训练样本。

  4. 投票决策：根据找到的k个最近邻样本的标签，采取多数投票或者加权投票的方式来决定待预测样本的类别。

  5. 输出预测结果：将投票决策的结果作为待预测样本的类别输出。

1.3 K的取值分析

（1）K的取值决定最后待测样本的类别，举个例子：

当K=3时，选取距离最近的3个样本，红圆=1<蓝三角=2，所以待测样本为蓝三角；

当K=5时，选取距离最近的5个样本，红圆=3>蓝三角=2，所以待测样本为红圆。

（2）K过大会导致，K太小会导致欠拟合。 

二、算法实现

2.1数据集加载和预处理

用torchvision直接调用手写体数据集MNIST下载；

可以print其中一个数据看效果（类似下图）：

2.2KNN算法实现

2.2.1手写KNN算法

（1）代码：

def knn(K):
    train_x, train_y, test_x, test_y = load_data()
    cnt = 0
    for i in range(len(test_x)):
        # print(i)
        x = test_x[i]
        y = test_y[i]
        vec = get_vec(K, x, train_x, train_y)
        weight = []  # 权重与序号
        sum_distance = 0.0
        for j in range(K):
            sum_distance += vec[j][0]  # 计算前K个距离的和
        for j in range(K):
            weight.append([1 - vec[j][0] / sum_distance, vec[j][1]])  # 权重+序号
        # 将相同序号的加起来
        num = []  # 统计有哪些序号
        for j in range(K):
            num.append(weight[j][1])
        num = list(set(num))  # 去重

        final_res = []
        for j in range(len(num)):
            res = 0.0
            for k in range(len(weight)):
                if weight[k][1] == num[j]:  # 前K个标签一样的样本权值加起来
                    res += weight[k][0]
            final_res.append([res, num[j]])

        final_res = sorted(final_res, key=(lambda e: e[0]), reverse=True)  # 按照权重从大到小排序

        if y == final_res[0][1]:
            cnt = cnt + 1
        print('预测结果：%d'%y, '正确结果：%d'%final_res[0][1])

    print('accuracy:', cnt / len(test_x))

（2）运行结果：

2.2.2直接调库

（1）代码：

if __name__ == '__main__':
    K = 10
    train_x, train_y, test_x, test_y = load_data()
    knn = KNeighborsClassifier(n_neighbors=K)
    knn.fit(train_x, train_y)
    acc = knn.score(test_x, test_y)
    print('accuracy:', acc)

（2）运行结果：

三、实验结果分析 

1.分析KNN算法优劣

KNN算法简单易懂，易于实现，但在处理大规模数据集时计算复杂度较高，手写体识别相比于用深度学习来说耗时长很多。此外，KNN算法对数据的特征缩放、数据维度等因素较为敏感。

2.算法改进

1、引入交叉验证

2、改用深度学习神经网络实现

（1）代码（pytorch实现）：

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.nn.functional as F
import torch.optim as optim

batch_size = 64
#dataset
transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307, ),(0.3081, ))])
train_data = datasets.MNIST(root='../data/minist',train=True,download=True,transform=transform)
train_loader = DataLoader(train_data,batch_size=batch_size,shuffle=True)

test_data = datasets.MNIST(root='../data/minist',train=True,download=True,transform=transform)
test_loader = DataLoader(test_data,batch_size=batch_size,shuffle=False)

#design modle
class InceptionA(torch.nn.Module):
    def __init__(self,in_channels) -> None:
        super(InceptionA,self).__init__()
        self.bratch1x1 = torch.nn.Conv2d(in_channels,16,kernel_size=1)

        self.bratch5x5_1 = torch.nn.Conv2d(in_channels,16,kernel_size=1)
        self.bratch5x5_2 = torch.nn.Conv2d(16,24,kernel_size=5,padding=2)

        self.bratch3x3_1 = torch.nn.Conv2d(in_channels,16,kernel_size=1)
        self.bratch3x3_2 = torch.nn.Conv2d(16,24,kernel_size=3,padding=1)
        self.bratch3x3_3 = torch.nn.Conv2d(24,24,kernel_size=3,padding=1)

        self.pooling = torch.nn.Conv2d(in_channels,24,kernel_size=1)

    def forward(self,x):
        bratch1x1 = self.bratch1x1(x)

        bratch5x5 = self.bratch5x5_1(x)
        bratch5x5 = self.bratch5x5_2(bratch5x5)

        bratch3x3 = self.bratch3x3_1(x)
        bratch3x3 = self.bratch3x3_2(bratch3x3)
        bratch3x3 = self.bratch3x3_3(bratch3x3)
        
        bratch_pool = F.avg_pool2d(x,kernel_size=3,stride=1,padding=1)
        bratch_pool = self.pooling(bratch_pool)

        outputs = [bratch1x1,bratch3x3,bratch5x5,bratch_pool]
        return torch.cat(outputs,dim=1) #沿着第一维度拼接
    
class Net(torch.nn.Module):
    def __init__(self) -> None:
        super(Net,self).__init__()
        self.conv1 = torch.nn.Conv2d(1,10,kernel_size=5)
        self.conv2 = torch.nn.Conv2d(88,20,kernel_size=5)

        self.incep1 = InceptionA(in_channels=10)
        self.incep2 = InceptionA(in_channels=20)

        self.mp = torch.nn.MaxPool2d(2)
        self.fc = torch.nn.Linear(1408,10)

    def forward(self,x):
        in_size = x.size(0)
        x = F.relu(self.mp(self.conv1(x)))  #1->10
        x = self.incep1(x)                  #10->88
        x = F.relu(self.mp(self.conv2(x)))  #88->20
        x = self.incep2(x)                  #20->1408
        x = x.view(in_size,-1)
        x = self.fc(x)
        return x
model = Net()

#optimizer & loss
criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),lr=0.01,momentum=0.5)

#train
def train(epoch):
    running_loss=0.0
    for batch_idx,data in enumerate(train_loader,0):    #这个batch_idx是？？？
        inputs, target = data
        optimizer.zero_grad()

        y_pred = model(inputs)
        loss = criterion(y_pred,target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch+1, batch_idx+1, running_loss/300))
            running_loss = 0.0

def test():
    correct,total=0,0
    with torch.no_grad():
        for data in test_loader:
            images,lables = data
            outputs = model(images)
            _,perdicted = torch.max(outputs.data,dim=1)
            total += lables.size(0)
            correct += (perdicted==lables).sum().item()
        print('accuracy on test set: %d %% ' % (100*correct/total))
 

if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

（2）运行结果(比起KNN算法，准确度更高)：

四、模型性能评估

1、混淆矩阵：

通过混淆矩阵算得下列值：

在这里简单举例一下关于recall和precision的计算：

（1）所有样本[这里以5个为例]

 （2）选取阈值：阈值设为0.6[即置信度大于0.6为预测正确的样本]，选出如下三个正样本

1）准确率：预测正确的样本有3个，但真正正确[上图红框]的只有2个，precision=2/3

2）召回率：正样本有5个[蓝框]，其中预测正确的正样本为2个，recall=2/5

2、ROC和PR曲线

1、ROC曲线

（1）概念

通常用于二分类问题的模型评估，以真正例率 (TPR，也叫recall) 和假正例率 (FPR) 作为纵、横轴，这两个指标计算如下：

曲线越靠近左上角说明模型的性能越佳。但是，当类别不平衡下，负类样本过多会导致FPR变化很小，曲线出现假乐观的情况。

（2）绘制ROC曲线

1）简单代码：

#TPR,FPR
fpr,tpr,threshold = roc_curve(data_labels,confidence_scores)
# print(fpr,fpr)
plt.figure()
plt.title('ROC Curve')
plt.xlabel('FPR')
plt.ylabel('TPR')
auc = auc(fpr,tpr)
plt.plot(fpr,tpr, label='Class 0 (AUC = %0.2f)' %  auc)
plt.legend('lower left')
plt.show()

2）可视化：

3）手写体识别的ROC曲线：

代码：

    #10个数字各自ROC曲线
    for i in range(10):
        y_pred = knn.predict_proba(test_x)
        fpr,tpr,threshold = roc_curve((test_y==i).astype(int),y_pred[:,i])
        roc_auc = auc(fpr,tpr)
        plt.plot(fpr, tpr, label='Class %d (AUC = %0.2f)' % (i, roc_auc))

    plt.xlabel('FPR')
    plt.ylabel('TPR')
    plt.title("10个类别的ROC曲线")
    plt.legend(loc="lower left")#放左下角
    plt.show()

可视化： 

2、PR曲线

（1）概念

PR曲线展示的是Precision vs Recall的曲线。（PR曲线与ROC曲线都采用了TPR (Recall),不同点是ROC曲线使用了FPR，而PR曲线使用了Precision，因此PR曲线的两个指标都聚焦于正例。类别不平衡问题中由于主要关心正例）

越往右上角效果越佳

（2）绘制PR曲线

1）简单代码【这里只是为了理解计算过程】：

#简单构造数据，因为事先初步理解计算过程，所以就没有用训练的数据集，而是直接给置信度和标签
confidence_scores = np.array([0.9,0.46,0.78,0.37,0.6,0.4,0.2,0.16])
confidence_scores = sorted(confidence_scores,reverse=True) #按大到小排序
print(f'置信度为：{confidence_scores}')

data_labels = np.array([1,1,0,1,0,0,1,0])

#精确率、召回率、阈值
precision,recall,threshold = precision_recall_curve(data_labels,confidence_scores)
print('准确率：',precision)
print('召回率：',recall)
print('阈值',threshold)
plt.figure()
plt.title('PR曲线')
plt.xlabel('recall')
plt.ylabel('precision')
plt.grid()  #添加网格线
plt.plot(recall,precision) #绘制pr曲线
plt.show()

2）可视化[由于只是自定义的一些离散数据，所以曲线不平滑]：

3）手写体识别的PR曲线

代码：

import numpy as np
import torchvision
import torchvision.transforms as transforms
from torchvision import datasets
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import precision_recall_curve,roc_curve,auc #计算PR和RPC
# from sklearn.metrics import plot_precision_recall_curve
import matplotlib.pyplot as plt


def load_data():
    transform = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.1307, ),(0.3081, ))])#传入元组，元组只有一个元素也必须在后面加逗号#01分布
    dataset_train = datasets.MNIST(root='../data/minist',train=True,download=True,transform=transform)
    dataset_test = datasets.MNIST(root='../data/minist', train=False, download=True,transform=transform)
    data_train = dataset_train.data
    X_train = data_train.numpy()
    X_test = dataset_test.data.numpy()
    X_train = np.reshape(X_train, (60000, 784))
    X_test = np.reshape(X_test, (10000, 784))
    Y_train = dataset_train.targets.numpy()
    Y_test = dataset_test.targets.numpy()

    return X_train, Y_train, X_test, Y_test



if __name__ == '__main__':
    K = 10
    # knn(K)
    train_x, train_y, test_x, test_y = load_data()
    knn = KNeighborsClassifier(n_neighbors=K)
    knn.fit(train_x, train_y)
    # y_pred = knn.predict(test_x)
    plt.figure()
    #10个数字各自的PR曲线
    for i in range(10):
        y_pred = knn.predict_proba(test_x)
        precision, recall, _ = precision_recall_curve((test_y == i).astype(int), y_pred[:, i]) #计算精度、召回率、threshold
        pr_auc = auc(recall, precision)
        plt.plot(recall, precision, label='Class %d (AUC = %0.2f)' % (i, pr_auc))

    plt.xlabel('Recall')
    plt.ylabel('Precision')
    plt.title("10个类别的PR曲线")
    plt.legend(loc="lower left")#放左下角
    plt.show()

PR曲线如下： 

windy__ya
关注
专栏目录
KNN实现手写数字的识别（源码+数据）
05-09
KNN实现手写数字的识别，包含图片数据，已经实现图片数据与文本数据的转换
动手学PaddlePaddle（4）：MNIST（手写数字识别）
10点43的博客
08-11 4273
本次练习将使用 PaddlePaddle 来实现三种不同的分类器，用于识别手写数字。三种分类器所实现的模型分别为 Softmax 回归、多层感知器、卷积神经网络。 您将学会 实现一个基于Softmax回归的分类器，用于识别手写数字 实现一个基于多层感知器的分类器，用于识别手写数字 实现一个基于卷积神经网络的分类器，用于识别手写数字 卷积神经网络的基本组成和搭...
机器学习（2）-- KNN算法之手写数字识别
最新发布
m0_74896766的博客
08-16 1277
本篇介绍了如何使用KNN算法进行手写数字识别：训练模型：收集数据 – 读取图片数据 – 转化灰度图 – 处理图像 – 装进array数组 – 调整数据结构 – 分配标签 – 训练模型测试模型：评估性能 – 识别问题 – 优化和改进测试数据：查看实用性。
利用KNN算法实现手写数字识别
m0_69895716的博客
06-20 290
1.数据文件包含从0到9的手绘数字的灰度图像。2.每个图像高28像素，宽28像素，共784个像素。3 每个像素取值范围[0,255]，取值越大意味着该像素颜色越深4 训练数据集共785列。第一列为 “标签”，为该图片对应的手写数字。其余784列为该图像的像素值5 训练集中的特征名称均有pixel前缀，后面的数字（[0,783])代表了像素的序号。# 导入numpy库和matplotlib库的pyplot模块，用于处理图像数据和绘图# 读取图像文件，这里使用了绝对路径来指定图像文件的位置。
基于MINIST的手写数字体识别
m0_62919535的博客
12-29 2109
基于MINIST的手写数字体识别，通过创建MnistNet类，定义了包含两个卷积层和两个全连接层的深度神经网络。这个网络的设计灵感来自于经典的CNN结构，其中卷积层用于提取图像特征，而全连接层则用于将这些特征映射到最终的类别。通过加载保存的模型权重进行验证，我们成功地对随机选择的五张手写字符图像进行了测试，所有测试样本均被正确分类。这表明我们的模型在实际应用中表现良好。在分析混淆矩阵时，发现对角线上的值比其他地方大，说明模型在训练数据集上表现良好，能够正确地预测大多数样本的类别。手写字符识别模型在设计和实现
手写数字识别：基于决策树算法，KNN算法，支持向量机（SVM）算法与卷积神经网络（CNN）算法
huiyiiiiii的博客
04-28 2264
998年，美国国家标准技术研究所（NIST）发布了MNIST数据集，这是一个用来训练各种图像处理系统的二进制图像数据集，广泛应用于机器学习中的训练和测试。MNIST数据集是从NIST的两个手写数字数据集：Special Database 3 和Special Database 1中分别取出部分图像，并经过一些图像处理后得到的。MNIST数据集共有70000张图像，其中训练集60000张，测试集10000张。所有图像都是28×28的灰度图像，每张图像包含一个手写数字。
KNN实现手写数字识别
03-28
基于opencv-KNN最邻近算法实现手写数字识别，使用Qt做UI实现手写板，可以实时测试，资源包含源代码和可执行程序（release文件夹下的exe文件可以直接运行）
交叉验证网格搜索及利用KNN算法实现手写数字识别
m0_74152166的博客
04-25 379
交叉验证网格搜索（cross-validation grid search）是一种机器学习模型超参数优化的方法。它结合了网格搜索和交叉验证两种技术，以寻找最佳的模型超参数组合。定义超参数空间：首先，需要确定模型的超参数范围。这些超参数是模型的内部参数，不是通过训练数据直接学习得到的，而是通过调整来优化模型性能的参数。创建网格：基于这些超参数的范围，创建一个超参数的网格。每个网格点代表一个可能的超参数组合。交叉验证：对于网格中的每一个超参数组合，使用交叉验证来评估模型的性能。
机器学习入门-kNN算法实现手写数字识别
Keiji582的博客
09-27 6561
实验环境 Python:3.7.0 Anconda:3-5.3.1 64位 操作系统:win10 开发工具:sublime text(非必要) 简介 本次实验中的重点为采用kNN算法进行手写数字识别，其中kNN算法是机器学习中入门的分类算法。其核心思想是将需要进行分类的目标放入已有充足样本的向量集中，求得与其距离最近的前k(自定超参数)个点，并返回这k个点中出现频率最高的类别，并将此类别作为模型的预测结果。 kNN算法 为了实现手写数字的分类，最重要的是取得分类算法 #kNN算法 def kNNclassi
KNN算法实现手写数字识别
热门推荐
李玺
03-24 2万+
KNN 最邻近分类算法： （近邻取样） 邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是机器学习分类技术中最简单的方法之一。 所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 属于监督学习，有类别标记，且KNN是惰性学习。叫做Memory-based learning、也叫instance-based learning. 他...
kNN算法实现手写数字识别（机器学习）
RuijieRen的博客
10-09 1万+
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 前言 一、实验步骤 二、实验过程 1.收集数据：提供文本文件 2.准备数据：将图像转换为测试向量 3.测试算法：使用k-近邻算法识别手写数字 ​ 总结 前言 此时实验利用KNN算法实现手写数字识别，为了简单起见只能识别数字0到9需要识别的数字已经使用图形处理软件处理成相同的色彩和大小：宽高32像素x32像素的黑白图像，并将图像转换为文本格式。 提示：以下是本篇文章正文内容，下面案例可供参考 一
KNN算法实现手写数字识别的三种方法（源码）
04-27
KNN算法使用MNIST数据集、0-1二值图集、自写的数字图片集，做手写数字识别的代码，文件夹分类明确。
openCV+PYTHON实现的knn算法手写数字识别
03-12
机器学习入门KNN算法实现的手写数字识别 基本上照搬了http://lib.csdn.net/article/opencv/30167的代码，只是改了一点bug和增加了一点功能 输入就是直接在一个512*512大小的白色画布上画黑线，然后转化为01矩阵，用knn算法找训练数据中最相近的k个，现在应该是可以对所有字符进行训练和识别，只是训练数据中还只有数字而已，想识别更多更精确的话就需要自己多跑代码多写几百次，现在基本上一个数字写10次左右准确率就挺高了，并且每次识别的时候会将此次识别的数字和01矩阵存入训练数据文件夹中，增加以后识别的正确率，识别错了的话需要输入正确答案来扩充训练数据
利用KNN算法实现手写体数字的识别.zip
08-06
标题中的“利用KNN算法实现手写体数字的识别”是指使用K-最近邻（K-Nearest Neighbor，简称KNN）算法进行计算机视觉领域的手写数字识别任务。这项技术在机器学习领域有着广泛的应用，特别是在模式识别和图像分类中。...
基于KNN实现的手写体数字识别
06-17
基于KNN实现的手写体数字识别C++代码，输出结果有混淆矩阵、召回率、训练准确率、预测数据输出等。
基于KNN算法的手写体数字识别
secretboys的博客
12-09 3007
基于KNN算法的手写体数字识别 KNN分类算法是一种经典的分类算法，属于懒惰学习算法的一种。 1.算法原理 工作原理：存在一个样本数据集合，也称作训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一数据与所属分类的对应关系。输入没有标签的新数据后，将新数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本集中特征最相似数据（最近邻）的分类。一般来说，我们只选择样本数据集中前k个最相似的数据，这就是kNN算法中k的出处，通常k是不大于20的整数。最后，选择k个最相似数据中出现次数最多的
22级智科3班 22116659 胡杭 基于kNN算法的手写体数字识别.zip
01-14
以下是关于kNN算法及其在手写体数字识别中的应用的详细解析： 1. **kNN算法原理**： - kNN算法基于“物以类聚”的思想，通过计算测试样本与训练集中所有样本的距离，找到最近的k个邻居，然后根据这些邻居的类别...
knn实现手写数字识别
mossxzzom的博客
10-04 680
使用knn训练数据 knn原理为某个样本在空间中的k个最近的样本中的最多数属于某一个类别。将数据集分为训练集与测试集两部分 测试集用于训练生成的模型的准确率 其比例为8:2。投票算法使用少数服从多数 y表示target sum表示vote数量。这里使用的是sklearn官方的数据集 导入比较简单。上述代码选择了最大的vote作为预测结果。对于训练集每个点使用下述方式计算距离。公式用python表达也非常简单。取前两个预测数据和测试数据比较下。对于knn距离使用欧拉距离。手写数字识别数据集。
Python基于KNN手写识别系统的设计与实现
06-01
KNN（K-Nearest Neighbors，K近邻算法）是一种基于实例的学习方法，可以用于分类和回归。在手写识别系统中，KNN算法可以用于识别手写数字。 下面是Python基于KNN手写识别系统的设计与实现步骤： 1. 数据集准备：下载MNIST数据集，该数据集包含60,000个训练样本和10,000个测试样本，每个样本是一个28x28像素的图像，表示手写数字0-9。将数据集转换为numpy数组，并将像素值归一化到0到1之间。 2. 特征提取：将每个图像展平成一个784维向量，作为特征向量。 3. 训练模型：使用KNN算法训练模型，将训练数据集的特征向量和标签作为输入，将K设为5或7，计算测试样本与训练样本之间的距离，选取K个离测试样本最近的训练样本，根据这K个样本的标签进行投票，选择得票最多的标签作为测试样本的预测标签。 4. 测试模型：使用测试数据集测试模型的准确率。 5. 可视化结果：将测试样本的图像和预测标签可视化，以便检查分类结果。 代码实现如下： ```python import numpy as np from sklearn.neighbors import KNeighborsClassifier from sklearn.metrics import accuracy_score import matplotlib.pyplot as plt from mnist import MNIST # 读取数据集 mndata = MNIST('data') X_train, y_train = map(np.array, mndata.load_training()) X_test, y_test = map(np.array, mndata.load_testing()) # 特征提取 X_train = X_train.astype(np.float32) / 255.0 X_test = X_test.astype(np.float32) / 255.0 X_train = X_train.reshape(-1, 784) X_test = X_test.reshape(-1, 784) # 训练模型 k = 5 knn = KNeighborsClassifier(n_neighbors=k) knn.fit(X_train, y_train) # 测试模型 y_pred = knn.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # 可视化结果 fig, axes = plt.subplots(4, 4, figsize=(8, 8)) for i, ax in enumerate(axes.flat): ax.imshow(X_test[i].reshape(28, 28), cmap='binary') ax.set_title("Predict: %d" % y_pred[i]) ax.set_xticks([]) ax.set_yticks([]) plt.show() ``` 该代码使用sklearn库中的KNeighborsClassifier类实现KNN算法，使用MNIST库读取数据集。将训练集和测试集的像素值归一化到0到1之间，将图像展平成784维向量作为特征向量。使用KNeighborsClassifier类训练模型，将K设为5，计算测试样本与训练样本之间的距离，选取离测试样本最近的5个训练样本进行投票，选择得票最多的标签作为测试样本的预测标签。最后计算模型的准确率，可视化测试样本的图像和预测标签。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值