KNN算法实现MNIST数据集分类

最新推荐文章于 2024-04-15 23:35:28 发布
最新推荐文章于 2024-04-15 23:35:28 发布
阅读量8.1k 收藏 92
点赞数 8
分类专栏： DeepLearning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongyebiao/article/details/106006236
版权

这里写目录标题

一、MNIST数据集

MNIST数据集是机器学习领域中非常经典的一个数据集，由60000个训练样本和10000个测试样本组成，每个样本都是一张28 * 28像素的灰度手写数字图片。

二、KNN算法

KNN算法，最近邻算法，即将待测试的数据每个特征和训练样本数据的每个特征进行比较，然后提取k个最邻近的训练样本数据，统计这k个训练样本数据的分类标签，其中出现次数最多的标签所表示的类别就是待测试数据的类别。KNN的含义就是k个最相近的“邻居”。
在这里插入图片描述

三、KNN实现MNIST数据分类

载入MNIST数据集

batch_size = 100
path ='./'
train_datasets = datasets.MNIST(root=path, #选择数据的根目录
                                train = True, # 选择训练集
                                transform = None, #不考虑使用任何数据预处理
                                download = True) # 从网络上download图片
test_datasets = datasets.MNIST(root=path,
                               train=False,
                               transform = None, #不考虑使用任何数据预处理
                               download=True)

# 加载数据
train_loader = DataLoader(train_datasets, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_datasets, batch_size=batch_size, shuffle=True)

对训练数据和测试数据进行处理，为提高识别率，首先将数据转化为numpy矩阵，并将28*28的矩阵转化为一维行向量，然后对数据进行归一化处理。

# 对训练数据处理
x_train = train_loader.dataset.data.numpy()
# 归一化处理
mean_image = getXmean(x_train)
x_train = centralized(x_train, mean_image)
y_train = train_loader.dataset.targets.numpy()
# 对测试数据处理，取前num_test个测试数据
num_test = 200
x_test = test_loader.dataset.data[:num_test].numpy()
mean_image = getXmean(x_test)
x_test = centralized(x_test, mean_image)
y_test = test_loader.dataset.targets[:num_test].numpy()

KNN算法具体实现，KNN算法中考虑到距离公式有欧拉公式和曼哈顿公式，因此分别为实现了这两个公式。利用距离公式得到测试数据到每个训练数据的距离，然后将这些数据根据距离进行升序排序，选择前k个数据。利用这k个数据所对应的类别，得到测试数据所属的类别。

def predict(self, k, dis, X_test):
    assert dis == 'E' or dis == 'M','dis must E or M，E代表欧拉距离，M代表曼哈顿距离'
    num_test = X_test.shape[0]
    label_list = []
    # 使用欧拉公式作为距离测量
    if dis == 'E':
        for i in range(num_test):
            distances = np.sqrt(np.sum(((self.Xtr - np.tile(X_test[i],
                                                            (self.Xtr.shape[0], 1)))) ** 2, axis=1))
            nearest_k = np.argsort(distances)
            topK = nearest_k[:k]
            class_count = {}
            for i in topK:
                class_count[self.ytr[i]] = class_count.get(self.ytr[i], 0) + 1
            sorted_class_count = sorted(class_count.items(), key=lambda elem: elem[1], reverse=True)
            label_list.append(sorted_class_count[0][0])
        return np.array(label_list)
    # 使用曼哈顿公式进行度量
    if dis == 'M':
        for i in range(num_test):
            distances = np.abs(np.sum(((self.Xtr - np.tile(X_test[i],
                                                            (self.Xtr.shape[0], 1)))), axis=1))
            nearest_k = np.argsort(distances)
            topK = nearest_k[:k]
            class_count = {}
            for i in topK:
                class_count[self.ytr[i]] = class_count.get(self.ytr[i], 0) + 1
            sorted_class_count = sorted(class_count.items(), key=lambda elem: elem[1], reverse=True)
            label_list.append(sorted_class_count[0][0])
        return np.array(label_list)

四、运行结果

在这里插入图片描述

五、具体代码

Utils.py

import numpy as np

def getXmean(x_train):
    x_train = np.reshape(x_train, (x_train.shape[0], -1))  # 将28*28像素展开成一个一维的行向量
    mean_image = np.mean(x_train, axis=0)  # 求每一列均值。即求所有图片每一个像素上的平均值
    return mean_image

def centralized(x_test, mean_image):
    x_test = np.reshape(x_test, (x_test.shape[0], -1))
    x_test = x_test.astype(np.float)
    x_test -= mean_image  #减去平均值，实现均一化。
    return x_test

class Knn:
    def __init__(self):
        pass

    def fit(self, X_train, y_train):
        self.Xtr = X_train
        self.ytr = y_train

    def predict(self, k, dis, X_test):
        assert dis == 'E' or dis == 'M','dis must E or M，E代表欧拉距离，M代表曼哈顿距离'
        num_test = X_test.shape[0]
        label_list = []
        # 使用欧拉公式作为距离测量
        if dis == 'E':
            for i in range(num_test):
                distances = np.sqrt(np.sum(((self.Xtr - np.tile(X_test[i],
                                                                (self.Xtr.shape[0], 1)))) ** 2, axis=1))
                nearest_k = np.argsort(distances)
                topK = nearest_k[:k]
                class_count = {}
                for i in topK:
                    class_count[self.ytr[i]] = class_count.get(self.ytr[i], 0) + 1
                sorted_class_count = sorted(class_count.items(), key=lambda elem: elem[1], reverse=True)
                label_list.append(sorted_class_count[0][0])
            return np.array(label_list)
        # 使用曼哈顿公式进行度量
        if dis == 'M':
            for i in range(num_test):
                distances = np.abs(np.sum(((self.Xtr - np.tile(X_test[i],
                                                                (self.Xtr.shape[0], 1)))), axis=1))
                nearest_k = np.argsort(distances)
                topK = nearest_k[:k]
                class_count = {}
                for i in topK:
                    class_count[self.ytr[i]] = class_count.get(self.ytr[i], 0) + 1
                sorted_class_count = sorted(class_count.items(), key=lambda elem: elem[1], reverse=True)
                label_list.append(sorted_class_count[0][0])
            return np.array(label_list)

Mnist_knn.py

import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from Utils import *

batch_size = 100
path ='./'
train_datasets = datasets.MNIST(root=path, #选择数据的根目录
                                train = True, # 选择训练集
                                transform = None, #不考虑使用任何数据预处理
                                download = True) # 从网络上download图片
test_datasets = datasets.MNIST(root=path,
                               train=False,
                               transform = None, #不考虑使用任何数据预处理
                               download=True)

# 加载数据
train_loader = DataLoader(train_datasets, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_datasets, batch_size=batch_size, shuffle=True)

# 对训练数据处理
x_train = train_loader.dataset.data.numpy()
# 归一化处理
mean_image = getXmean(x_train)
x_train = centralized(x_train, mean_image)
y_train = train_loader.dataset.targets.numpy()
# 对测试数据处理，取前num_test个测试数据
num_test = 200
x_test = test_loader.dataset.data[:num_test].numpy()
mean_image = getXmean(x_test)
x_test = centralized(x_test, mean_image)
y_test = test_loader.dataset.targets[:num_test].numpy()

print("train_data:",x_train.shape)
print("train_label:",len(y_train))
print("test_data:",x_test.shape)
print("test_labels:",len(y_test))

#利用KNN计算识别率
for k in range(1, 6, 2): #不同K值计算识别率
    classifier = Knn()
    classifier.fit(x_train, y_train)
    y_pred = classifier.predict(k, 'E', x_test)
    num_correct = np.sum(y_pred == y_test)
    accuracy = float(num_correct) / num_test
    print('Got %d / %d correct when k= %d => accuracy: %f' % (num_correct, num_test, k, accuracy))

参考1: https://developer.aliyun.com/article/726957.
参考2: https://blog.csdn.net/qq_44761480/article/details/103321983.

Ctrl_Z31
关注
  • 8
    点赞
  • 踩
  • 92
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
机器学习算法之KNN识别mnist数据集
hola_f的博客
09-30 3309
KNN算法又称K邻近算法（K Nearest Neighbor），其基本思想为：样本空间中，某样本的类别为距离其最近的k个邻居所属类别中最多的那个类别。 MNIST数据集为一个带标注的手写数字识别的数据集，其官方下载地址为http://yann.lecun.com/exdb/mnist/。数据集包含60000个训练集和10000个测试集。该数据集中的文件以二进制方式保存，因此在读入时需要以二进制
机器学习之knn算法----手写数字识别mnist
PY_smallH的博客
12-01 3288
机器学习之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 callabl
机器学习实践案例，mnist数据集，KNN算法分类、决策树分类Iris数据集、朴素贝叶斯分类西瓜数据集、逻辑斯蒂回归，随机梯度
06-21
机器学习实践案例，mnist数据集，KNN算法分类、决策树分类Iris数据集、朴素贝叶斯分类西瓜数据集、逻辑斯蒂回归，随机梯度 mnist数据集，KNN算法分类。 决策树分类Iris数据集（鸢尾花）。 朴素贝叶斯分类西瓜数据集（demo），trec06c数据集（垃圾邮件）分类。 一元线性回归之普通最小二乘法（OLS）。 逻辑斯蒂回归，随机梯度下降与全梯度下降，mnist中8和9的二分类，titanic数据集。 机器学习实践案例，mnist数据集，KNN算法分类、决策树分类Iris数据集、朴素贝叶斯分类西瓜数据集、逻辑斯蒂回归，随机梯度 mnist数据集，KNN算法分类。 决策树分类Iris数据集（鸢尾花）。 朴素贝叶斯分类西瓜数据集（demo），trec06c数据集（垃圾邮件）分类。 一元线性回归之普通最小二乘法（OLS）。 逻辑斯蒂回归，随机梯度下降与全梯度下降，mnist中8和9的二分类，titanic数据集。 机器学习实践案例，mnist数据集，KNN算法分类、决策树分类Iris数据集、朴素贝叶斯分类西瓜数据集、逻辑斯蒂回归，随机梯度 mnist数据集，KNN算法分类。
使用KNN实现MNIST数据分类（详细解释附完整程序）
Qlz的博客
01-29 5848
数据读取 import operator import os import matplotlib.pyplot as plt import numpy as np import torchvision.datasets as dsets from torch.utils.data import DataLoader relative_path = os.getcwd() batch_size = 100 train_dataset = dsets.MNIST(root=relative_path +.
手工实现KNN算法预测mnist数据集
m0_51672193的博客
01-03 423
KNN算法是机器学习最基础的算法，它的基本原理就是找到训练数据集里面离需要预测的样本点“距离最近”的k个对象，取其中出现最多的标签作为预测值。其他更先进的机器学习算法是在训练集上花大量时间训练出一个模型，预测时只要用这个模型直接快速预测，而无需再去处理训练集。而KNN算法恰好相反，其没有训练过程，但在预测过程中要遍历训练集，因而预测花费较大。这里采用手工方式对mnist数据集进行预测。
图像分类（二）—KNN算法实战之MNIST数据集（附代码）
lalalala97的博客
04-15 1853
阐释KNN算法在图像分类中应用的基础和扩展上做得非常详细，清晰地展示了从理论到实际应用的整个过程，包括预处理、数据集的处理以及算法的实现和验证。
使用KNN方法进行MNIST数据集分类
u014509577的博客
06-11 7484
声明：本文的代码部分可以戳这里下载~ 一、MNIST数据集 MNIST是深度学习的经典入门demo，他是由6万张训练图片和1万张测试图片构成的，每张图片都是28*28大小（如下图），而且都是黑白色构成（这里的黑色是一个0-1的浮点数，黑色越深表示数值越靠近1），这些图片是采集的不同的人手写从0到9的数字。TensorFlow将这个数据集和相关操作封装到了库中。 ...
python knn算法数据集和结果_python用K近邻（KNN）算法分类MNIST数据集和Fashion MNIST数据集...
weixin_39521068的博客
12-03 712
三、数据集介绍MNIST数据集，训练集60000张图片和标签；测试集有10000张图片和标签。读取28*28图片以后，要将每张图片转换为1*784的向量。四、KNN算法实现和结果分析代码实现：from numpy import *import operatorimport osimport numpy as npimport matplotlib.pyplot as pltfrom matplot...
java使用knn实现mnist_KNN 实现mnist数据集分类
weixin_39929721的博客
02-27 257
一 数据预处理训练数据集和验证数据集分别为train.csv和test.csv。数据集下载地址：http://pan.baidu.com/s/1eQyIvZG要分别对训练数据集和验证数据集进行分析，分析其内部数据的特征，下面分别对两个数据集进行处理：1.1 训练数据集处理train.csv 里面结构为42001 * 785。其中第一行为文字说明，应该去掉，其余每一行均表示一个图像，大小为28*28...
python kNN算法实现MNIST数据集分类 k值1-120
03-14
在这个项目中，我们将详细探讨如何使用Python实现kNN算法来对MNIST数据集进行分类，并观察不同k值（1到120）对分类性能的影响。 首先，我们需要导入必要的库，包括`numpy`用于数值计算，`pandas`处理数据，`...
KNN算法对MNIST数据集分类
12-24
代码使用matlab编写，压缩包中包含MNIST数据集及其读取函数、KNN算法实现和ReadMe.txt。 KNN算法中使用了PCA降维处理数据减少运行时间，正确率可达95%，有部分注释。请结合ReadMe文件使用。
mnist数据集knn实现.rar
05-09
描述中提到，这个实现的KNN算法在MNIST数据集上的识别误差非常小，这意味着算法设计得相当有效。在实际应用中，可能会考虑优化K值、距离度量方法以及处理异常值等因素来进一步提高识别性能。 总的来说，这个压缩包...
K近邻算法实现(使用MNIST数据集)_Python环境
07-15
首先，我们需要导入必要的库，如`numpy`用于数值计算，`matplotlib`进行图像处理，以及`sklearn`中的`datasets`模块来加载MNIST数据集和`neighbors`模块来实现KNN算法。 ```python import numpy as np import ...
MATLAB实现KNN算法（MNIST数据集）
kylinhyl510的博客
05-15 4662
基于MOOC人工智能之模式识别的课程完成的第五次作业 MATLAB实现KNN算法（MNIST数据集） MOOC地址：人工智能之模式识别 k-近邻分类器又称为 KNN 算法（K Nearest Neighbors Algorithm），它是指需要从训练集中找出待识别样本的 k 个最近邻，然后依据这 k 个最近邻分别所属的类别来决定应当把待识别样本划分到哪个类别中。 k-近邻分类器原理简单，无需对样本集进行回归分析或者概率分布统计，实现起来十分方便。 距离度量、k 值的选择及分类决策规则是 k 近邻算法的三个
pi_heif-0.17.0-pp310-pypy310_pp73-macosx_12_0_x86_64.whl
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
mmexport1722080103662.jpg
07-27
mmexport1722080103662.jpg
matlab 20244a 6
07-27
matlab 20244a 6
pi_heif-0.17.0-cp310-cp310-macosx_12_0_x86_64.whl
最新发布
07-27
pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。pip install 直接安装，无需再下载，直接用。
能帮我用PCA对MNIST数据集进行降维，然后用KNN算法对MNIST数据集进行分类吗
05-29
当然可以！MNIST是一个手写数字识别数据集，里面包含了很多28x28的图片。我们可以使用PCA对这些图片进行降维，然后使用KNN算法对这些图片进行分类。 首先，我们需要加载MNIST数据集。你可以使用Python中的`sklearn.datasets`模块来加载MNIST数据集。这里是代码示例： ```python from sklearn.datasets import fetch_openml mnist = fetch_openml('mnist_784') X = mnist.data y = mnist.target ``` 然后，我们可以使用PCA对数据集进行降维。这里我们可以使用`sklearn.decomposition`模块中的`PCA`类。代码示例： ```python from sklearn.decomposition import PCA pca = PCA(n_components=50) # 取50个主成分 X_pca = pca.fit_transform(X) ``` 最后，我们可以使用KNN算法对降维后的数据进行分类。这里我们可以使用`sklearn.neighbors`模块中的`KNeighborsClassifier`类。代码示例： ```python from sklearn.neighbors import KNeighborsClassifier knn = KNeighborsClassifier() knn.fit(X_pca, y) ``` 现在，我们已经完成了对MNIST数据集的降维和分类。你可以将上面的代码整合起来，得到完整的代码。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值