KNN算法

已于 2024-10-05 00:19:04 修改
阅读量813 收藏 11
点赞数 21
文章标签： 算法 人工智能 机器学习 分类 回归 sklearn
于 2024-10-04 23:58:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50229673/article/details/142709129
版权

KNN算法

一 KNN算法介绍

K-近邻算法（K Nearest Neighbor，简称KNN）.比如根据你的“邻居”来推断出你的类别.

KNN算法思想：如果一个样本在特征空间中的 k 个最相似的样本中的大多数属于某一个类别，则该样本也属于这个类别 .

KNN算法的应用方式:

  • 分类问题处理:

    1.计算未知样本到每一个训练样本的距离

    2.将训练样本根据距离大小升序排列

    3.取出距离最近的 K 个训练样本

    4.进行多数表决，统计 K 个样本中哪个类别的样本个数最多

    5.将未知的样本归属到出现次数最多的类别

  • 回归问题处理:

    1.计算未知样本到每一个训练样本的距离

    2.将训练样本根据距离大小升序排列

    3.取出距离最近的 K 个训练样本

    4.把这个 K 个样本的目标值计算其平均值

    5.平均值作为未知的样本预测值

二 KNN算法API

# 导包 
from sklearn.neighbors import KNeighborsClassifier,KNeighborsRegressor # 分类算法,回归算法

2.1 KNeighborsClassifier 分类算法

英文翻译:
    KNeighborsClassifier # 分类算法  
    estimator # 估量值 估计器

例句:

estimator = KNeighborsClassifier(n_neighbors=3)  

API解释:
    KNeighborsClassifier() # 创建分类算法对象
    n_neighbors=n          # 参数 k 的值 即几个样本(邻居)

应用场景:标签不连续通过分类思想解决.

2.2 KNeighborsRegressor 回归算法

英文翻译:
    KNeighborsRegressor # 回归算法  
    estimator # 估量值 估计器

例句:

estimator = KNeighborsRegressor(n_neighbors=4)

API解释:
    KNeighborsRegressor()  # 创建回归算法对象
    n_neighbors=n          # 参数 k 的值 即几个样本(邻居)

应用场景:标签连续通过回归思想解决.

三 两个经典案例

3.1 鸢尾花案例

本案例通过提取鸢尾花的特征,通过数据集训练模型使其可以分辨不同种类的鸢尾花.在Anaconda2024版本中已经集成了鸢尾花的数据集.方便大家直接使用.

1

2

# 0. 导包
from sklearn.datasets import load_iris  # 加载鸢尾花数据集
import seaborn as sns                   # Seaborn绘图
import matplotlib.pyplot as plt         # matplotlib
import pandas as pd                     # pandas
from sklearn.model_selection import train_test_split  # 切割训练集和测试集
from sklearn.preprocessing import StandardScaler      # 数据标准化处理
from sklearn.neighbors import KNeighborsClassifier    # KNN算法 分类对象
from sklearn.metrics import accuracy_score            # 模型评估

# 1.定义函数 用于加载鸢尾花数据集 并简单查看数据集各部分
def dm01_load_iris():
    # 1.1加载数据集
    iris_data = load_iris()
    # 1.2 打印数据集
    # print(iris_data)
    # 1.3 #打印所有的键 即属性名
    # dict_keys(['data', 'target', 'frame', 'target_names', 'DESCR', 'feature_names', 'filename', 'data_module'])
    # print(iris_data.keys())
    # 1.4 查看数据集字段特征
    print(iris_data.data[:5])
    # 1.5 查看数据集的标签字段
    print(iris_data.target[:5])
    # 1.6 查看数据集的标签名
    # ['setosa' 'versicolor' 'virginica']
    print(iris_data.target_names)
    # 1.7 查看数据集的特征名
    # ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
    print(iris_data.feature_names)
    # 1.8 查看数据集描述信息
    # print(iris_data.DESCR)
    # 1.9 查看数据集文件名
    # print(iris_data.filename)
    # 1.10 查看数据集 数据模型
    # print(iris_data.data_module)

# 2.定义函数 用于通过 Seaborn散点图的方式 对鸢尾花数据集进行可视化
def dm02_show_iris():
    # 1.加载鸢尾花数据集
    iris_data = load_iris()
    # 2.封装成DF 对象 作为可视化展示的数据源
    iris_df = pd.DataFrame(iris_data.data,columns=iris_data.feature_names)
    # 3.给DF 对象新增1列 表示:标签
    iris_df['label'] = iris_data.target
    print(iris_df)
    # 4.可视化 散点图
    # x: x轴值, 这里是: 花瓣的长度,  y: y轴值, 这里是: 花瓣的宽度,  hue: 颜色(根据鸢尾花的标签来分组, 不同分组颜色不同), fit_reg=False, 不绘制拟合回归线.
    sns.lmplot(data=iris_df,x='petal length (cm)',y='petal width (cm)',hue='label',fit_reg=False)
    # 设置标题
    plt.title('iris data')
    # 绘图
    plt.show()
    
if __name__ == '__main__':
    # dm01_load_iris()
    dm02_show_iris()

3

# 3.定义函数实现划分训练集和测试集
def dm03_train_test_split():
    # 1.加载数据集
    iris_data = load_iris()
    # 2. 划分训练集和测试集
    # iris_data.data => 特征, 一共150条
    # iris_target => 标签, 一共150条
    # test_size => 测试集占比, 0.2 => 训练集 : 测试集 => 8 : 2
    # random_state => 随机种子, 如果种子一样, 则每次划分的数据集都是一样的.
    # 细节: 返回值的时候, 注意下四个参数的顺序, 即: 训练集特征, 测试集特征, 训练集标签, 测试集标签.
    x_train,x_test,y_train,y_test = train_test_split(iris_data.data,iris_data.target,test_size=0.2,random_state=66)
    # 3.打印划分后的结果
    print(f'训练集,x-特征:{len(x_train)}')
    print(f'测试集,x-特征:{len(x_test)}')
    print(f'训练集,y-标签:{len(y_train)}')
    print(f'测试集,y-标签:{len(y_test)}')

# 4.定义函数 实现模型预测和评估
def dm04_predict():
    # 1.加载数据
    iris_data = load_iris()
    # 2.数据预处理 因数据量小且Anaconda2024提前处理过 这里只划分训练集与测试即可
    x_train, x_test, y_train, y_test = train_test_split(iris_data.data, iris_data.target, test_size=0.2,random_state=66)
    # 3.特征工程
    # 3.1 特征提取:查看训练集的 特征, 因为特征是已经提取好的, 所以无需我们手动提取了, 即, 特征为: 花萼的长度, 花萼的宽度, 花瓣长度, 花瓣的宽度.
    # print(x_train)
    # 3.2 特征预处理
    # 创建标准化对象
    transfer = StandardScaler()
    # 标准化训练集的特征
    x_train = transfer.fit_transform(x_train)
    # 查看结果
    # print(x_train)
    # 标准化测试集的特征
    x_test = transfer.transform(x_test)

    # 4.模型训练(机器学习)
    # 4.1 创建估计器对象
    estimator = KNeighborsClassifier(n_neighbors=5)
    # 4.2 模型训练
    estimator.fit(x_train,y_train)  # 传入 训练集的特征和标签

    # 5.模型预测
    # 场景1
    # 对测试集预测 得到预测后的测试集标签
    y_predict = estimator.predict(x_test)
    print(f'测试集预测结果为{y_predict}') # [1 0 0 0 1 1 0 2 0 0 1 1 2 2 0 2 1 1 0 2 2 1 2 1 0 1 0 0 1 2]
    # 场景2 对新数据集做预测
    # step1:定义新的数据集
    my_data = [[2.1, 3.5, 5.6, 3.2]]
    # step2:对新数据集标准化处理
    my_data = transfer.transform(my_data)
    # step3:对新数据集做结果分类预测,打印预测结果
    my_predict = estimator.predict(my_data)
    print(f'新数据集预测结果为{my_predict}')  # 新数据集预测结果为[1]
    # step4:对新数据集做概率预测,看看在各个标签中的概率
    my_predict_proba = estimator.predict_proba(my_data)
    print(f'新数据集在各标签概率预测为{my_predict_proba}') # [[0.  0.6 0.4]] 即 占 0 1 2的概率

    # 6. 模型评估 KNN(K近邻算法), 评估指标主要是: 预测的准确率.
    # 方式1 直接评估 获取准确率
    print(f'直接评估准确率为{estimator.score(x_test,y_test)}')  # 传入测试集特征和标签 # 0.9

    # 方式2 用真实值和预测值评估得到准确率
    print(f'真实值和预测值对比评估结果为{accuracy_score(y_test,y_predict)}')  # 传入测试集标签和预测值标签 # 0.9



if __name__ == '__main__':
    # dm03_train_test_split()
    dm04_predict()

3.2 手写数字识别案例

MNIST_data

# 背景相关
MNIST手写数字识别 
1999年发布，成为分类算法基准测试的基础
MNIST仍然是研究人员和学习者的可靠资源

# 需求
从数万个手写图像的数据集中正确识别数字.
(超级经典的案例,数据集网络资源丰富,本文只手撕代码.)

# 导包
import matplotlib.pyplot as plt                         # matplotlib绘图
import pandas as pd                                     # pandas
from sklearn.model_selection import train_test_split    # 分割训练集和测试集
from sklearn.neighbors import KNeighborsClassifier      # KNN 分类算法
import joblib                                           # 加载或保存模型
from collections import Counter                         # 分组计数

# 1. 定义函数用于查看数字图片
def show_digit(idx):
    """
    定义函数用于查看数字图片
    :param idx: 行索引
    :return: 无
    """
    # 1.读取数据 获取df对象
    data = pd.read_csv('data/手写数字识别.csv')
    # 细节: 非法值校验
    if idx < 0 or idx > len(data)-1:
        return
    # 2. 获取数据: 特征+标签
    x = data.iloc[:,1:]  # 所有行,第二列到最后
    y = data.iloc[:,0]   # 所有行,第一列
    # 3. 查看数据集
    print(f'x的维度{x.shape}')         # (42000, 784)
    print(f'y的各分类数量{Counter(y)}') #Counter({1: 4684, 7: 4401, 3: 4351, 9: 4188, 2: 4177, 6: 4137, 0: 4132, 4: 4072, 8: 4063, 5: 3795})
    # 4.获取具体的某张图片 某一行数据等于一条样本数据
    # step1 把一条样本数据转成(28,28)的二维数组 即模拟28*28像素的图片
    digit = x.iloc[idx].values.reshape(28,28)
    # step2 显示图片
    plt.imshow(digit,cmap='gray')  # cmap='gray'  灰色显示 即 灰度图
    # step3 取消坐标显示
    plt.axis('off')
    # step4 绘图
    plt.show()  # 8
    
# 在main函数中测试
if __name__ == '__main__':
    # 显示数字图片
    show_digit(10)

8

# 2.训练模型
def train_model():
    # 1.读取数据 获取df对象
    data = pd.read_csv('data/手写数字识别.csv')
    # 2.获取数据 特征+标签
    x = data.iloc[:,1:]
    y = data.iloc[:,0]
    # 3.特征预处理
    # step1 X轴(像素点)的归一化处理
    x = x / 255
    # step2 划分训练集和测试集
    # stratify=y 按照y的类别比例进行分割
    x_train,x_test,y_train,y_test = train_test_split(x,y,test_size=0.2,stratify=y,random_state=66)
    # 4.训练模型
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train,y_train)
    # 5.模型评估 评测正确率
    my_score = estimator.score(x_test,y_test)
    print(f'模型评估的正确率为{my_score}')   # 0.9657142857142857
    # 6.保存模型
    joblib.dump(estimator,'model/knn.pth')

# 3. 测试模型
def use_model():
    # 1.加载图片
    img = plt.imread('data/demo.png')  # 28 * 28像素
    plt.imshow(img,cmap='gray') # 灰度图
    plt.show() # 2

shuzi_2

	# 2.加载模型
    estimator = joblib.load('model/knn.pth')

    # 3.预测图片
    img = img.reshape(1,-1)  # 1行 所有列 等同于 (1, 784)
    y_test = estimator.predict(img)
    print(f'预测的数字是{y_test}')  # [2]

# 在main函数中测试
if __name__ == '__main__':
    # 训练模型
    # train_model()  # 0.9657142857142857
    # 测试模型
    use_model()

以上就是要和大分享的KNN算法相关内容,机器学习算法还有很多,后面我还会持续分享其他训练模型的算法.我们下期见!

文柏AI共享
关注
KNN算法（k近邻算法）原理及总结
m0_74405427的博客
10-09 7万+
KNN 算法，或者称 k最邻近算法，是有监督学习中的分类算法。它可以用于分类或回归问题，但它通常用作分类算法。
knn算法
weixin_45439324的博客
03-01 1849
knn算法 K-近邻算法定义 K Nearest Neighbor算法又叫KNN算法，这个算法是机器学习里面一个比较经典的算法， 总体来说KNN算法是相对比较容易理解的算法 ， 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。 KNN算法流程 计算已知类别数据集中的点与当前点之间的距离 按距离递增次序排序 选取与当前点距...
优化KNN算法
aouiylfjh的博客
07-03 1964
读者可看此文章，为复现的knn算法python实现KNN算法_AGuiRong的博客-CSDN博客该文章为针对复现的knn算法进行优化。对KNN算法采取了10折运算原理，在给定的参数范围内选取最优参数值，并给出了可视化效果。
KNN算法（一） KNN算法原理
热门推荐
weixin_45014385的博客
03-20 12万+
一.KNN算法概述 KNN可以说是最简单的分类算法之一，同时，它也是最常用的分类算法之一，注意KNN算法是有监督学习中的分类算法，它看起来和另一个机器学习算法Kmeans有点像（Kmeans是无监督学习算法），但却是有本质区别的。那么什么是KNN算法呢，接下来我们就来介绍介绍吧。 二.KNN算法介绍 KNN的全称是K Nearest Neighbors，意思是K个最近的邻居，从这个名字我们就能看出一些KNN算法的蛛丝马迹了。K个最近邻居，毫无疑问，K的取值肯定是至关重要的。那么最近的邻居又是怎么回事呢
KNN算法的运用案例
2301_77698138的博客
08-15 1274
KNN（K-Nearest Neighbors，K最近邻）算法是一种基本的分类与回归方法。尽管它理论上可以应用于回归问题，但在实践中更常用于分类任务。KNN算法的核心思想是：给定一个测试样本，基于某种距离度量找出训练集中与其最靠近的K个样本，然后基于这K个“邻居”的信息来进行预测。对于分类任务，通常选择这K个样本中出现最多的类别作为预测结果；对于回归任务，则可以将这K个样本的实值输出做平均来作为预测值。
头歌KNN算法详解
2302_80089843的博客
04-22 3120
可以看出宅男和文艺青年的比分是 2:2，那么可以尝试将属于宅男的 2 个样本与我的总距离和属于文艺青年的 2 个样本与我的总距离进行比较。在这个例子中预测结果为文艺青年(宅男的总距离为 4.2+9.5，文艺青年的总距离为 7.7+5.8)。根据提示，在右侧编辑器的 begin-end 区域补充代码，完成 kNNClassifier 类中的 fit 函数与 predict 函数。假设现在有这样的一个样本空间，该样本空间里有宅男和文艺青年这两个类别，其中红圈表示宅男，绿圈表示文艺青年。
KNN算法详解
weixin_47552266的博客
05-05 1666
在KNN分类中，通过将新数据点的特征与训练数据中的所有点进行比较，确定其最近邻居，并将新数据点分配给与其最近邻居具有最相似特征的类别。K最近邻回归（K-Nearest Neighbors Regression，KNN Regression）算法是一种基于特征空间中K个最近邻居的回归方法，用于预测连续型变量的值。: 可以考虑使用降维算法（如主成分分析PCA）来降低特征空间的维度，从而提高KNN回归算法的效率。: 是的，KNN回归算法可以处理多输出的情况，例如可以使用KNN回归算法来预测多个目标变量的值。
KNN算法（K近邻算法）
TXQIHYJ的博客
10-09 7769
KNN（K-Nearest Neighbor）即K邻近法，是机器学习算法中最基础、最简单的算法之一。它既能用于分类，也能用于回归。KNN通过测量不同特征值之间的距离来进行分类，用老话说：“人以群分，物以类聚”。KNN 算法是有监督学习中的分类算法，它看起来和另一个机器学习算法 K-means 有点像（K-means 是无监督学习算法），但却是有本质区别的。
机器学习实战 - k近邻算法（KNN算法）总结
04-12
机器学习实战 - k近邻算法（KNN算法）总结 适合机器学习实战入门新手 K-近邻算法，又称为 KNN 算法，是数据挖掘技术中原理最简单的算法。 KNN 的工作原理：给定一个已知类别标签的数据训练集，输入没有标签的新数据...
KNN算法实验报告.pdf
10-30
KNN 算法实验报告 KNN（K-Nearest Neighbor）算法是机器学习领域中的一种常用算法，属于监督学习算法的一种。该算法的核心思想是，如果一个样本在特征空间中的 k 个最相似（即特征空间中最邻近）的样本中的大多数...
matlab、python：基于KNN算法的电影分类与约会配对
04-30
1. **基本概念**：KNN算法基于“物以类聚”的思想，即一个样本点的类别由其最近的K个邻居共同决定。这里的“近”通常是指欧几里得距离或曼哈顿距离等度量方式。 2. **分类过程**：对于未知类别的数据点，计算它与...
【C++算法】9.双指针_四数之和
最新发布
hlyd520的博客
10-04 319
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1112
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
排序算法之归并排序
qq_64039411的博客
10-01 483
需要注意的是，在实际应用中，归并排序的空间复杂度较高，需要额外的空间来存储临时数组。如果对空间复杂度有要求，可以考虑使用其他排序算法。归并排序是一种分治算法，它将一个数组分成两个子数组，然后递归地对子数组进行排序，最后将两个有序的子数组合并成一个有序的数组。归并排序的时间复杂度是O(nlogn)，其中n是数组的长度。它是一种稳定的排序算法，适用于各种数据类型的排序。合并排序的关键在于合并操作。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1299
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 234
本文主要介绍按既定顺序创建目标数组问题
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值