KNN算法分类问题实现介绍和使用

已于 2023-09-09 19:56:35 修改
阅读量418 收藏 3
点赞数
分类专栏： 人工智能 文章标签： 算法 python 机器学习
于 2023-09-05 12:38:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq1309664161/article/details/132689057
版权

KNN算法详解
sklearn包介绍

一、sklearn包使用KNN算法

1.准备数据:

X =np.array([[5.1, 3.5, 1.4, 0.2],
       [4.9, 3. , 1.4, 0.2],
       [4.7, 3.2, 1.3, 0.2],
       [4.6, 3.1, 1.5, 0.2],
       [5. , 3.6, 1.4, 0.2],
       [5.4, 3.9, 1.7, 0.4],
       [4.6, 3.4, 1.4, 0.3],
       [5. , 3.4, 1.5, 0.2],
       [4.4, 2.9, 1.4, 0.2],
       [4.9, 3.1, 1.5, 0.1],
       [5.4, 3.7, 1.5, 0.2],
       [4.8, 3.4, 1.6, 0.2],
       [4.8, 3. , 1.4, 0.1],
       [4.3, 3. , 1.1, 0.1],
       [5.8, 4. , 1.2, 0.2],
       [5.7, 4.4, 1.5, 0.4],
       [5.4, 3.9, 1.3, 0.4],
       [5.1, 3.5, 1.4, 0.3],
       [5.7, 3.8, 1.7, 0.3],
       [5.1, 3.8, 1.5, 0.3],
       [5.4, 3.4, 1.7, 0.2],
       [5.1, 3.7, 1.5, 0.4],
       [4.6, 3.6, 1. , 0.2],
       [5.1, 3.3, 1.7, 0.5],
       [4.8, 3.4, 1.9, 0.2],
       [5. , 3. , 1.6, 0.2],
       [5. , 3.4, 1.6, 0.4],
       [5.2, 3.5, 1.5, 0.2],
       [5.2, 3.4, 1.4, 0.2],
       [4.7, 3.2, 1.6, 0.2],
       [4.8, 3.1, 1.6, 0.2],
       [5.4, 3.4, 1.5, 0.4],
       [5.2, 4.1, 1.5, 0.1],
       [5.5, 4.2, 1.4, 0.2],
       [4.9, 3.1, 1.5, 0.2],
       [5. , 3.2, 1.2, 0.2],
       [5.5, 3.5, 1.3, 0.2],
       [4.9, 3.6, 1.4, 0.1],
       [4.4, 3. , 1.3, 0.2],
       [5.1, 3.4, 1.5, 0.2],
       [5. , 3.5, 1.3, 0.3],
       [4.5, 2.3, 1.3, 0.3],
       [4.4, 3.2, 1.3, 0.2],
       [5. , 3.5, 1.6, 0.6],
       [5.1, 3.8, 1.9, 0.4],
       [4.8, 3. , 1.4, 0.3],
       [5.1, 3.8, 1.6, 0.2],
       [4.6, 3.2, 1.4, 0.2],
       [5.3, 3.7, 1.5, 0.2],
       [5. , 3.3, 1.4, 0.2],
       [7. , 3.2, 4.7, 1.4],
       [6.4, 3.2, 4.5, 1.5],
       [6.9, 3.1, 4.9, 1.5],
       [5.5, 2.3, 4. , 1.3],
       [6.5, 2.8, 4.6, 1.5],
       [5.7, 2.8, 4.5, 1.3],
       [6.3, 3.3, 4.7, 1.6],
       [4.9, 2.4, 3.3, 1. ],
       [6.6, 2.9, 4.6, 1.3],
       [5.2, 2.7, 3.9, 1.4],
       [5. , 2. , 3.5, 1. ],
       [5.9, 3. , 4.2, 1.5],
       [6. , 2.2, 4. , 1. ],
       [6.1, 2.9, 4.7, 1.4],
       [5.6, 2.9, 3.6, 1.3],
       [6.7, 3.1, 4.4, 1.4],
       [5.6, 3. , 4.5, 1.5],
       [5.8, 2.7, 4.1, 1. ],
       [6.2, 2.2, 4.5, 1.5],
       [5.6, 2.5, 3.9, 1.1],
       [5.9, 3.2, 4.8, 1.8],
       [6.1, 2.8, 4. , 1.3],
       [6.3, 2.5, 4.9, 1.5],
       [6.1, 2.8, 4.7, 1.2],
       [6.4, 2.9, 4.3, 1.3],
       [6.6, 3. , 4.4, 1.4],
       [6.8, 2.8, 4.8, 1.4],
       [6.7, 3. , 5. , 1.7],
       [6. , 2.9, 4.5, 1.5],
       [5.7, 2.6, 3.5, 1. ],
       [5.5, 2.4, 3.8, 1.1],
       [5.5, 2.4, 3.7, 1. ],
       [5.8, 2.7, 3.9, 1.2],
       [6. , 2.7, 5.1, 1.6],
       [5.4, 3. , 4.5, 1.5],
       [6. , 3.4, 4.5, 1.6],
       [6.7, 3.1, 4.7, 1.5],
       [6.3, 2.3, 4.4, 1.3],
       [5.6, 3. , 4.1, 1.3],
       [5.5, 2.5, 4. , 1.3],
       [5.5, 2.6, 4.4, 1.2],
       [6.1, 3. , 4.6, 1.4],
       [5.8, 2.6, 4. , 1.2],
       [5. , 2.3, 3.3, 1. ],
       [5.6, 2.7, 4.2, 1.3],
       [5.7, 3. , 4.2, 1.2],
       [5.7, 2.9, 4.2, 1.3],
       [6.2, 2.9, 4.3, 1.3],
       [5.1, 2.5, 3. , 1.1],
       [5.7, 2.8, 4.1, 1.3],
       [6.3, 3.3, 6. , 2.5],
       [5.8, 2.7, 5.1, 1.9],
       [7.1, 3. , 5.9, 2.1],
       [6.3, 2.9, 5.6, 1.8],
       [6.5, 3. , 5.8, 2.2],
       [7.6, 3. , 6.6, 2.1],
       [4.9, 2.5, 4.5, 1.7],
       [7.3, 2.9, 6.3, 1.8],
       [6.7, 2.5, 5.8, 1.8],
       [7.2, 3.6, 6.1, 2.5],
       [6.5, 3.2, 5.1, 2. ],
       [6.4, 2.7, 5.3, 1.9],
       [6.8, 3. , 5.5, 2.1],
       [5.7, 2.5, 5. , 2. ],
       [5.8, 2.8, 5.1, 2.4],
       [6.4, 3.2, 5.3, 2.3],
       [6.5, 3. , 5.5, 1.8],
       [7.7, 3.8, 6.7, 2.2],
       [7.7, 2.6, 6.9, 2.3],
       [6. , 2.2, 5. , 1.5],
       [6.9, 3.2, 5.7, 2.3],
       [5.6, 2.8, 4.9, 2. ],
       [7.7, 2.8, 6.7, 2. ],
       [6.3, 2.7, 4.9, 1.8],
       [6.7, 3.3, 5.7, 2.1],
       [7.2, 3.2, 6. , 1.8],
       [6.2, 2.8, 4.8, 1.8],
       [6.1, 3. , 4.9, 1.8],
       [6.4, 2.8, 5.6, 2.1],
       [7.2, 3. , 5.8, 1.6],
       [7.4, 2.8, 6.1, 1.9],
       [7.9, 3.8, 6.4, 2. ],
       [6.4, 2.8, 5.6, 2.2],
       [6.3, 2.8, 5.1, 1.5],
       [6.1, 2.6, 5.6, 1.4],
       [7.7, 3. , 6.1, 2.3],
       [6.3, 3.4, 5.6, 2.4],
       [6.4, 3.1, 5.5, 1.8],
       [6. , 3. , 4.8, 1.8],
       [6.9, 3.1, 5.4, 2.1],
       [6.7, 3.1, 5.6, 2.4],
       [6.9, 3.1, 5.1, 2.3],
       [5.8, 2.7, 5.1, 1.9],
       [6.8, 3.2, 5.9, 2.3],
       [6.7, 3.3, 5.7, 2.5],
       [6.7, 3. , 5.2, 2.3],
       [6.3, 2.5, 5. , 1.9],
       [6.5, 3. , 5.2, 2. ],
       [6.2, 3.4, 5.4, 2.3],
       [5.9, 3. , 5.1, 1.8]])

y=np.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, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
       2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

2.切分数据,80%用于训练，20%用于验证

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True, random_state=0)#shuffle是洗牌的意思，即随机抽取20%为验证数据。random_state类似于seed的含义。

3.训练和验证数据

from sklearn.neighbors import KNeighborsClassifier
# 第一步：构建一个对象
knn = KNeighborsClassifier(n_neighbors=5)
# 第二步:训练
knn.fit(X=X_train, y=y_train)
# 第三步：预测
y_pred = knn.predict(X=X_test)
# 此时,y_test是正确的数据,y_pred是预测数据，计算准确率:
(y_test == y_pred).mean()

二、自定义KNN算法

from collections import Counter
class MyKNeighborsClassifier(object):
    """
        自定义个一个KNN分类器
    """
    
    def __init__(self, n_neighbors=5):
        """
            初始化函数
        """
        self.n_neighbors = n_neighbors
    
    def fit(self, X, y):
        """
            训练函数
            - 惰性计算
        """
        # 转类型
        X = np.array(X)
        y = np.array(y)
        
        # 基本校验
        if X.ndim != 2 or y.ndim != 1:
            raise ValueError("输入的参数维度有错误!!!!")
        
        # 把训练集挂到模型上面
        self.X = X
        self.y = y
    
    def predict(self, X):
        """
            预测函数
                - 第一步：先从训练集中，找出跟待预测的样本很类似的 n 个样本（欧式距离）
                - 第二步：这 n 样本中，哪个类别出现的最多，这个样本就属于哪个类别
        """
        # 类型转换
        X = np.array(X)
        
        # 基本校验
        if X.ndim != 2:
            raise ValueError("输入参数必须是二维的！！！")
        
        # 求距离
        results = []
        for x in X:
            # 求出待测样本跟训练集中所有样本的距离
            distances = ((self.X - x) ** 2).sum(axis=1)
            # 求出距离最近（最相似）的 n_neighbors 个邻居，返回的是邻居标签
            indices = distances.argsort(axis=0)[:self.n_neighbors]
            labels = self.y[indices]
            # 投票机制 top 1
            label = Counter(labels).most_common(1)[0][0]
            results.append(label)
        return np.array(results)

使用:

# 构建模型
my_knn = MyKNeighborsClassifier(n_neighbors=5)
# 训练模型
my_knn.fit(X=X_train, y=y_train)
# 测试模型
y_pred = my_knn.predict(X=X_test)
#准确率
(y_pred == y_test).mean()
敲代码的小小酥
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
机器学习实战笔记(Python实现)-01-K近邻算法(KNN)
weixin_30706691的博客
12-11 122
--------------------------------------------------------------------------------------- 本系列文章为《机器学习实战》学习笔记，内容整理自书本，网络以及自己的理解，如有错误欢迎指正。 源码在Python3.5上测试均通过，代码及数据 -->https://github.com/Wellat/MLact...
机器学习基础——分类算法之K近邻算法（KNN)、预测facebook签到位置案例
qq_47250064的博客
08-12 1325
机器学习里面的knn算法，比较细节得分析了一个 kaggle上面的完整案例，包括处理数据、拟合模型和测试模型，计算准确率等。
KNN（最近邻）算法总结
weixin_40405758的博客
04-21 2714
KNN（最近邻）算法 参考：本文参考选取的案例来自以下： https://blog.csdn.net/qq_41228463/article/details/84341762 李奇峰 https://blog.csdn.net/mrliqifeng/article/details/82592867 一、定义及原理 knn算法是通过计算两个个体之间的距离及相似性来进行分类，几乎适合于任...
KNN算法原理和代码详解
qq_52310720的博客
07-06 1001
有这样一条河流like that，河流的左边是rich 人家，河流的右边是poor 人家，这时新搬来一家小甲，这个算法是看小甲是有钱人家还是没钱人家。要解决这个问题，那么就可以说立着他最近的几个人家是富人多还是穷人多就可以判别了，K户人家，最近距离就是欧氏距离或者曼哈顿距离，切比雪夫距离。这是欧氏距离，在中学都有学过。advantage: 显而易见的简单以实现，而且对于边界不规则的数据效果较好disadvantage： 只适合小的数据集，数据不平衡就没法用了肯定就难受了，数据必须标准化因为非富有即贫穷没有中
K近邻(KNN) | 算法实现
热门推荐
Data Hero
09-22 2万+
01 KNN可以做点什么呢？ 在李航的《统计学习方法》中，详细讲解了一中分类算法：K近邻(K Nearest Neighbor)，具体的算法过程和关键点可以参考这篇文章： 统计学习方法 | k近邻法 算法的理论基础有了，下一步就是自己动手去实现了。 今天我们的文章就是利用python去实现KNN算法，利用这套算法可以做什么呢？ 比如，我们已经知道一组鸢尾花的花瓣、花萼长宽以及对应的鸢尾花品...
python实现KNN分类算法
01-20
一、KNN算法简介 邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN...
基于MATLAB的KNN算法实现多分类
04-14
KNN（K-Nearest Neighbors）算法是一种监督学习方法，常用于分类和回归问题，尤其在数据挖掘领域中有着广泛的应用。MATLAB作为一种强大的数值...通过理解和掌握这些步骤，可以灵活地应用KNN算法解决实际的分类问题。
python运用sklearn实现KNN分类算法
12-25
KNN（K-Nearest-Neighbours Classiflication）分类算法，供大家参考，具体...通过sklearn对数据使用KNN算法进行分类 代码如下： ## 导入鸢尾花数据集 iris = datasets.load_iris() data = iris.data[:, :2] target
python:基于KNN算法的电影分类
04-26
使用python实现KNN原理，同时应用到电影分类过程中，训练集和测试集都来自李航的《统计学方法》中KNN那一章。
KNN算法的matlab实现
05-07
本篇将详细介绍KNN算法的原理及其在Matlab环境中的实现。 ### KNN算法基本原理 1. **定义**: KNN算法基于“物以类聚”的思想，通过寻找训练集中与未知类别样本最近的K个邻居，根据这些邻居的类别进行投票，决定...
机器学习之利用KNN近邻算法预测数据
wylycool的博客
07-06 1万+
前半部分是简介, 后半部分是案例 KNN近邻算法: 简单说就是采用测量不同特征值之间的距离方法进行分类（k-Nearest Neighbor，KNN） 优点: 精度高、对异常值不敏感、无数据输入假定 缺点：时间复杂度高、空间复杂度高 1、当样本不平衡时，比如一个类的样本容量很大，其他类的样本容量很小，输入一个样本的时候，K个临近值中大多数都是大样本容量的那个类，这时可能就会导致分...
KNN算法
qq_42420425的博客
10-05 4759
import numpy as np from sklearn.model_selection import train_test_split from sklearn.neighbors import KNeighborsClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.datasets import...
K近邻算法(KNN)及案例（Python）
qq_42433311的博客
04-19 2万+
1 算法简介 K近邻算法（英文为K-Nearest Neighbor，因而又简称KNN算法）是非常经典的机器学习算法。 K近邻算法的原理非常简单：对于一个新样本，K近邻算法的目的就是在已有数据中寻找与它最相似的K个数据，或者说“离它最近”的K个数据，如果这K个数据大多数属于某个类别，则该样本也属于这个类别。 （K的含义）以下图为例，假设五角星代表爱情片，三角形代表科幻片。此时加入一个新样本正方形，需要判断其类别。当选择以离新样本最近的3个近邻点（K＝3）为判断依据时，这3个点由1个五角星和2个三角形
python knn预测_python机器学习之KNN预测QSAR生物浓缩类别
weixin_39583013的博客
12-03 331
KNN预测QSAR生物浓缩类别importnumpyimport pandas #导入Excel文件from sklearn.neighbors import KNeighborsClassifier #机器学习算法库，没有深度学习算法shen=pandas.read_csv(r"D:\Python\代码\Machine-Learn\1-KNN\data\shenwu.csv")print...
【非参】python实现KNN回归估计
weixin_44590417的博客
12-13 972
python实现非参数模型的KNN回归
机器学习入门KNN近邻算法(一)
weixin_30894583的博客
07-16 220
1 机器学习处理流程: 2 机器学习分类: 有监督学习 主要用于决策支持，它利用有标识的历史数据进行训练，以实现对新数据的表示的预测 1 分类 分类计数预测的数据对象是离散的。如短信是否为垃圾短信，用户是否喜欢电子产品 常用方法: K近邻、朴素贝叶斯、决策树、SVM 2 回归 回归技术预测的数据对象是连续值。例如温度变化或时间变化。包括一元回归和多元回归，线性回归和非线性回归 常用...
数据分析【机器学习】-KNN分类模型
weixin_58163585的博客
04-17 4248
KNN分类模型的原理与使用 目录 文章目录 前言 一、KNN模型 1.概念 2.距离 3.k值的重要性 二、使用步骤（鸢尾花分类的实现） 1.引入库 2.读入数据 3.训练模型 4.模型的评价 5.对未知数据的分类 总结 前言 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的分中的KNN模型。KNN模型可以用来解决分类和回归问题。 一、KNN模型 1.概念 简单的说，K-近邻算法采用不同...
最基础的分类算法-KNN
ysl的博客
08-05 471
1.K近邻算法基础​​​​​​ import numpy as np import matplotlib.pyplot as plt from math import sqrt from collections import Counter """输入原始数据""" raw_data_X=[[3.39,2.33], [3.11,1.78], ...
机器学习：K近邻（KNN）
weixin_44766179的博客
04-27 3864
KNN是一种基本的机器学习算法。KNN既可以用作分类，也可以用作回归。KNN做分类预测时，一般是选择多数表决法，即训练集里和预测的样本特征最近的K个样本，预测为里面有最多类别数的类别。而KNN做回归时，一般是选择平均法，即最近的K个样本的样本输出的平均值作为回归预测值。 一般通过交叉验证选择最优的K值。对于距离的度量方式，最常见的是欧氏距离： KNN的主要优点有： 1） 理论成熟，思想简单，既可...
使用KNN算法实现鸢尾花数据的分类
最新发布
06-10
鸢尾花数据集是一个经典的分类问题，我们可以使用KNN算法对其进行分类。 首先，我们需要将数据集拆分成训练集和测试集。训练集用于训练模型，测试集用于测试模型的准确度。在这里，我们可以使用sklearn库中的train_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

敲代码的小小酥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值