KNN（最邻近算法）

已于 2022-05-11 13:30:06 修改
阅读量944 收藏 4
点赞数
分类专栏： java机器学习 文章标签： 算法 机器学习 java
于 2022-05-11 13:14:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Knight_ZJY/article/details/124707679
版权

KNN（最邻近算法）

时间：2022/5/4

目录

0.数据集分析

测试使用的数据集为经典的鸢尾花数据集iris.有四个属性，分别为花萼长度（sepallength）、花萼宽度（sepalwidth）、花瓣长度（petallength）、花瓣宽度（petalwidth）。决策属性为种类(setosa、versicolor、virginica)。

在这里插入图片描述

1.算法思想

闵老师在上课时说过，机器学习的本质就是“猜”，用已知的数据去预测未知的数据，而不同的算法就是猜的方法不同。对于KNN算法而言，它猜的思想就像是“近朱者赤，近墨者黑”的思想。正如我们想了解一个人的时候就可以通过他所交的朋友来推测他是个什么样的人，KNN也是如此。KNN通过寻找离预测目标最近的对象作为预测目标的邻居。通过邻居的占比来推测预测目标的标签。

由此可见，KNN算法有一下特点：

  1. 算法是比较简单，没有学习过程，也被称为惰性学习

  2. 算法思想简单易懂，贴合人类思维。算法适应性也是很强，可用于分类回归，可用于多种数据。

  3. 效果是非常好的，KNN算法充分利用了已知数据，对测试目标的预测准确率很高。通过测试可见，

在这里插入图片描述
在这里插入图片描述

多次测试结果KNN的正确率均在90%以上。

  1. KNN也存在一个缺点，复杂度高。对于每个需要预测的目标，均需要计算其与整个训练集的距离。对于每一个测试数据, 复杂度为 O ( ( m + k ) n ) , 其中n为训练数据个数, m为条件属性个数, k为邻居个数.

  2. 一般需要对数据归一化。

  3. 使用过程对内存要求较高，最好是能将数据集全部存入内存中，若是内存空间较小，频繁的进行IO操作，则对算法的时间影响较大。

2.算法流程：

  1. 读入数据集，使用weka.jar包进行数据读取存储。
  2. 拆分数据集，按一定比例划分为训练集与测试集。
  3. 预测测试集：
    1. 取出一个测试对象
    2. 计算测试对象到训练集中训练对象的距离，这里提供两种距离度量：欧式距离和曼哈顿距离；
    3. 选取距离最近的K个邻居
    4. 投票：这里使用的是简单投票，统计邻居种类个数。
    5. 投票最多的标签即为预测对象的标签
  4. 计算预测准确度。

3.代码部分

/**
 * KNN.java
 *
 * @author zjy
 * @date 2022/5/3
 * @Description: KNN算法的学习
 * @version V1.0
 */
package swpu.zjy.ML.KNN;

import weka.core.Instances;

import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;

public class KNN {
    /**
     * 定义KNN使用的距离度量
     */
    //曼哈顿距离
    public static final int MANHATTAN = 0;
    //欧几里得距离
    public static final int EUCLIDEAN = 1;

    public static int distanceMeasure = EUCLIDEAN;

    //邻居数量：K ;默认为7
    public static int numNeighbors = 7;

    //数据集对象 用以存储整个数据集
    Instances datasets;

    /**
     * 训练集与测试集实体
     * 这里老师采用的方法是只存储一个元组的下标，用索引的形式存储训练集与测试集，
     * 这是之前所没有使用形式，经过实际测试，这种方法比使用对象存储数据的方式要更快且更加节省内存。
     */
    //训练集
    int[] trainingSet;
    //测试集
    int[] testingSet;

    //预测标签 ，存储KNN预测的结果
    int[] predictions;

    //随机数生成器
    public static Random random = new Random();

    /**
     * KNN构造方法，通过传入数据文件路径，构造数据集
     *
     * @param dataSetFileName 数据集文件路径
     */
    public KNN(String dataSetFileName) {
        try {
            FileReader fileReader = new FileReader(dataSetFileName);
            //使用weka包读取数据集
            datasets = new Instances(fileReader);
            //设置数据集决策属性 datasets.numAttributes()获取数据集属性个数
            //本次使用的鸢尾花数据集，将最后一项作为决策属性
            datasets.setClassIndex(datasets.numAttributes() - 1);
            fileReader.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(0);
        }
    }

    /**
     * 设置邻居个数，默认是7，可由用户自己设定
     *
     * @param numNeighbors 邻居个数
     */
    public static void setNumNeighbors(int numNeighbors) {
        KNN.numNeighbors = numNeighbors;
    }

    /**
     * 设置距离度量选择
     *
     * @param distanceMeasure 距离度量类型
     */
    public static void setDistanceMeasure(int distanceMeasure) {
        KNN.distanceMeasure = distanceMeasure;
    }

    /**
     * 洗牌，将数据集随机打乱，以便后续划分训练集与测试集，采用索引方式
     *
     * @param numInstance 数据个数
     * @return 打乱后的数据集
     */
    public static int[] shuffle(int numInstance) {
        //构造索引数组
        int[] tempIndices = new int[numInstance];
        //初始化索引数组
        for (int i = 0; i < numInstance; i++) {
            tempIndices[i] = i;
        }
        //开始洗牌
        int tempFirst, tempSecond, tempIndex;
        for (int i = 0; i < numInstance; i++) {
            //随机选取下标
            tempFirst = random.nextInt(numInstance);
            tempSecond = random.nextInt(numInstance);

            //Swap
            tempIndex = tempIndices[tempFirst];
            tempIndices[tempFirst] = tempIndices[tempSecond];
            tempIndices[tempSecond] = tempIndex;
        }
        return tempIndices;
    }

    /**
     * 训练集与测试集的划分，按照给定的比例分割
     *
     * @param trainingFraction 训练集所占比例。
     */
    public void splitTrainingandTesting(double trainingFraction) {
        int tempSize = datasets.numInstances();
        //洗牌
        int[] tempIndices = shuffle(tempSize);
        //得到训练集长度
        int tempTrainingSize = (int) (tempSize * trainingFraction);

        trainingSet = new int[tempTrainingSize];
        testingSet = new int[tempSize - tempTrainingSize];

        //划分数据集
        for (int i = 0; i < tempTrainingSize; i++) {
            trainingSet[i] = tempIndices[i];
        }
        for (int i = 0; i < tempSize - tempTrainingSize; i++) {
            testingSet[i] = tempIndices[tempTrainingSize + i];
        }
    }

    /**
     * 计算两个实例的距离，根据所选距离度量来计算
     *
     * @param dataA 实例A
     * @param dataB 实例B
     * @return 二者距离
     */
    public double distance(int dataA, int dataB) {
        double resultDistance = 0;
        double tempDistance = 0;
        switch (distanceMeasure) {
            case MANHATTAN:
                /**
                 * 曼哈顿距离，也叫城市距离；distance=|x1-x2|+|y1-y2|
                 */
                for (int i = 0; i < datasets.numAttributes() - 1; i++) {
                    tempDistance = datasets.instance(dataA).value(i) - datasets.instance(dataB).value(i);
                    if (tempDistance < 0) {
                        resultDistance -= tempDistance;
                    } else {
                        resultDistance += tempDistance;
                    }
                }
                break;
            case EUCLIDEAN:
                /**
                 * 欧式距离，distance=sqrt((x1-x2)^2+(y1-y2)^2)
                 * 对于欧式距离，本来应该要开方，但这里的距离度量并不是为了获取精确的数据，
                 * 只是为了比较大小，所有不用开方以减少计算
                 */
                for (int i = 0; i < datasets.numAttributes() - 1; i++) {
                    tempDistance = datasets.instance(dataA).value(i) - datasets.instance(dataB).value(i);
                    resultDistance += tempDistance * tempDistance;
                }
                break;
            default:
                System.out.println("未知的距离度量");
                System.exit(0);
        }
        return resultDistance;
    }

    /**
     * 寻找当前数据的K个邻居
     *
     * @param currentData 当前数据索引
     * @return 当前数据的K个邻居
     */
    public int[] findNeighbors(int currentData) {
        //存放当前数据所有距离
        double[] tempDistances = new double[trainingSet.length];
        //存放K个邻居
        int[] neighbors = new int[numNeighbors];
        double tempNearDistance = 0;
        int tempindex = 0;

        //计算距离
        for (int i = 0; i < trainingSet.length; i++) {
            tempDistances[i] = distance(currentData, i);
        }
        //寻找邻居
        for (int i = 0; i < numNeighbors; i++) {
            tempNearDistance = Double.MAX_VALUE;
            for (int j = 0; j < trainingSet.length; j++) {
                if (tempDistances[j] == -1)
                    continue;
                if (tempDistances[j] < tempNearDistance) {
                    tempNearDistance = tempDistances[j];
                    tempindex = j;
                }
            }
            neighbors[i] = tempindex;
            tempDistances[tempindex] = -1;
        }

        //System.out.println("The nearest of " + currentData + " are: " + Arrays.toString(neighbors));
        return neighbors;
    }

    /**
     * 简单投票，无权重统计邻居类别
     *
     * @param neighbors K个邻居
     * @return 预测类别
     */
    public int simpleVoting(int[] neighbors) {
        int[] tempVotes = new int[datasets.numClasses()];
        for (int i = 0; i < neighbors.length; i++) {
            tempVotes[(int) datasets.instance(neighbors[i]).classValue()]++;
        }

        int tempMaxVotingIndex = 0;
        int tempMaxVoting = 0;
        for (int i = 0; i < tempVotes.length; i++) {
            if (tempVotes[i] > tempMaxVoting) {
                tempMaxVoting = tempVotes[i];
                tempMaxVotingIndex = i;
            }
        }
        return tempMaxVotingIndex;
    }

    /**
     * 预测整个测试集
     */
    public void predict() {
        predictions = new int[testingSet.length];
        for (int i = 0; i < testingSet.length; i++) {
            predictions[i] = predict(testingSet[i]);
        }
    }

    /**
     * 预测单个数据标签
     *
     * @param paraIndex 数据索引
     * @return 数据预测标签
     */
    public int predict(int paraIndex) {
        int[] tempNeighbors = findNeighbors(paraIndex);
        int resultPrediction = simpleVoting(tempNeighbors);

        return resultPrediction;
    }

    /**
     * 展示预测结果
     */
    public void showPredicts() {
        for (int i = 0; i < testingSet.length; i++) {
            System.out.println("数据：" + testingSet[i] + ",预测标签：" + predictions[i] + ",实际标签：" + datasets.instance(testingSet[i]).classValue());
        }
    }

    /**
     * 计算预测正确率
     *
     * @return 正确率
     */
    public double getAccuracy() {
        double tempCorrect = 0;
        for (int i = 0; i < predictions.length; i++) {
            if (predictions[i] == datasets.instance(testingSet[i]).classValue())
                tempCorrect++;
        }
        return tempCorrect / testingSet.length;
    }

    public static void main(String[] args) {
        KNN knnTest = new KNN("E:\\DataSet\\iris.arff");
        knnTest.splitTrainingandTesting(0.8);
        for (int i = 3; i < 10; i++) {
            KNN.setNumNeighbors(i);
            knnTest.predict();
//        knnTest.showPredicts();

            System.out.printf("K=" + i + ",正确率为：%.2f%% \n", (knnTest.getAccuracy() * 100));
        }
    }

}

4.运行结果

在这里插入图片描述

对于K的选取对于KNN算法的效果影响还是比较明显的；

5.优化思考

对于KNN算法的优化可以从它的主要算法步骤入手

  1. 首先是计算距离。在这一步骤中我们可以通过选取更加合适的距离度量来进行距离计算，以期得到更精确的预测。在闵老师的推荐下，后面学习了基于M-distance的KNN。
  2. 其次是选取K个邻居。在这里可以通过引入排序算法实现选取时间复杂度的降低。使用插入排序选取K个的时间复杂度为：O(KN)；在张星移同学的测试中，引入大小为N的堆，对单个测试集的中心结点测试的复杂度可以从O(kN)优化为O(k+N)。总复杂度为O(M(N+k))。由此可见采用更高效的排序算法可优化KNN的时间复杂度。
  3. 最后则是在投票环节，除了简单投票外，还可以采用基于距离的加权投票，距离越近权重越高。借此增加预测准确率。

KNN算法的效果影响还是比较明显的；

还在写BUG呢
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
KN_3029.pdf
03-28
KN3029标准电子版
kNN（邻近算法）算法
05-18
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是...
KNN算法实现鸢尾花数据集分类 C语言实现(附数据集)
懒
11-28 4805
KNN的全称是K Nearest Neighbors，意思是K个最近的邻居，从这个名字我们就能看出一些KNN算法的蛛丝马迹了。K个最近邻居，毫无疑问，K的取值肯定是至关重要的。那么最近的邻居又是怎么回事呢？其实啊，KNN的原理就是当预测一个新的值x的时候，根据它距离最近的K个点是什么类别来判断x属于哪个类别。
机器学习--K近邻
搬砖少年。
11-18 178
机器学习--K近邻概述算法思想总结所使用数学公式介绍合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 概述 笔者目前是一名大三的机...
机器学习笔记（八）KNN原理详解和实践
haveanybody的博客
01-06 2395
一、KNN原理 K近邻法(k-nearest neighbors,KNN)是一种应用比较多的机器学习算法模型，其核心思想就是未知的对象总是和距离自己最近的群体类似。简单地说就是一个人如果经常和好人走的近，那么我们可以认为（大概率）他是好人，如果他经常和坏人混迹在一起，那么我们就会认为他更可能是坏人，在推荐领域，KNN 可以用来为消费行为相似的人推荐商品。现在还有一个不确定的问题，就是距离最近的群体怎么衡量呢？这也正是KNN中K的含义，就是找距离自己最近的K个样本。这里需要注意 KNN 中的 K 和 K-M
最近邻算法
Supre_yuan的博客
09-06 1万+
最近邻算法 最近邻算法又称为KNN算法，是一种基本的分类与回归方法，这种方法没有训练阶段，对新样本直接与训练集做分类或者回归预测。 分类 假设有5个点，坐标分别为A(1, 1)，B(1.5, 1.1)，C(1, 1.5)，D(2.5, 1.05)，E(3, 1.1)，F(3, 1.2)。其中A、B和C是同一类“1”，D、E、F是同一类“2”。 此时出现了一点G(2, 1)，我们判断下G是属于类“1”还是类“2”。 首先我们采用欧式距离作为我们的衡量标准。 A点与样本点之间的距离为1，B点与样本点之间的距离
K-最邻近算法总结
weixin_34256074的博客
07-24 799
1.基本介绍      K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。KNN算法中，所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所...
机器学习之KNN最邻近分类算法
热门推荐
pengjunlee的博客
09-15 19万+
KNN算法简介 KNN（K-Nearest Neighbor）最邻近分类算法是数据挖掘分类（classification）技术中最简单的算法之一，其指导思想是”近朱者赤，近墨者黑“，即由你的邻居来推断出你的类别。 KNN最邻近分类算法的实现原理：为了判断未知样本的类别，以所有已知类别的样本作为参照，计算未知样本与所有已知样本的距离，从中选取与未知样本距离最近的K个已知样本，根据少数服从多数...
最近邻算法（KNN算法）
abc1234564546的博客
07-28 9079
最近邻算法（KNN算法）
插值法(最邻近，双线性，双三次）的原理及实现
weixin_40163266的博客
02-10 2万+
插值法(最邻近，双线性，双三次）的原理及实现 常用的插值方法有最邻近插值法、双现象插值法和双三次插值法等，主要用于图像的放大或缩小。 缩小图像（或称为下采样（subsampled） 或降采样（downsampled） ） 的主要目的有两个： 1、 使得图像符合显示区域的大小； 2、 生成对应图像的缩略图。 放大图像（或称为上采样（upsampling） 或图像插值（interpolating） ） 的主要目的是放大原图像,从而可以显示在更高分辨率的显示设备上。 一、最邻近插值法 最邻近插值（The near
最邻近插值法原理分析及c++实现
weixin_45116749的博客
08-13 2750
最邻近插值法原理分析及c++实现 最邻近插值法 : 其核心思想是选取离目标点最近的点作为待插入的新值点 公式推导过程 上述图片中像素点的说明： Q11，Q21，Q12，Q22 分别为四个真实存在的像素点 P 为最邻近插值法待插值点 因为P点与Q12很接近，所以P ( i , j )=Q12 ( x , y+1 ) 用opencv进行图像处理时，根据下面公式来计算目标像素值在源图像中所处的位置： （src：原图像 dst：目的图像） srcX =dstX * ( srcWidth / dst
numpy复现knn最邻近算法内含数据集
10-16
numpy复现knn最邻近算法内含数据集
模糊knn最邻近算法
11-01
FKNN Fuzzy k-nearest neighbor classification rule；参考文献：A Fuzzy K-Nearest Neighbor Algorithm", IEEE Transactions on Systems, Man, and Cybernetics, Vol. 15, No. 4, pp. 580-585.
Python实现KNN邻近算法
09-20
主要为大家详细介绍了Python实现KNN邻近算法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
knn手写识别
ailinyingai的博客
02-05 286
# coding=utf-8 import matplotlib matplotlib.use('Qt4Agg') # 手写数字分类 from sklearn.model_selection import train_test_split from sklearn import preprocessing from sklearn.metrics import accuracy_score fr...
K-最邻近算法(KNN算法)
Warms的博客
11-30 1998
概述 K-最邻近算法是一种分类算法，假设有一个训练集DDD，DDD包含n个训练样例，现有一个测试样例sss，计算sss与训练集DDD中每个样例的相似度，找出k个与sss最相似的样本，这k个样本中哪个类别占比最多则作为测试样例sss的类别。一般用欧几里得距离衡量相似度，其定义为: dist(s,di)=∑l=1m(al−ail)2dist(s,d_i)=\sqrt{\sum_{l=1}^{m}(a_...
1.6. 最邻近算法
u010016927的博客
08-07 9768
最邻近法 主要是一种非监督或基于临近的监督学习方法. 非监督最邻近法是许多其他学习算法的基础，特别是流行学习方法及谱聚类方法. 基于临近的监督分类主要在一下两方面具有优势: 具有离散标签数据的`分类`和 连续标签数据的`回归`.. The principle behind nearest neighbor methods is to find a predefined number of
机器学习KNN算法原理和应用分析
jameschen9051的博客
05-09 1988
KNN原理解析 K邻近算法(KNN)，是一种非常简单有效的机器学习算法。KNN是通过计算不同特征值距离作为分类依据，即计算一个待分类对象不同特征值与样本库中每一个样本上对应特征值的差值，将每个维度差值求和也就得到了该组数据与样本之间的距离，一般使用欧式距离进行计算，通过对所有样本求距离，最终得到离待分类对象最近的K个样本，将这K个点作为分类依据。 KNN算法是直接对每个样本进行距离计算，因此要求每个特征必须为数值型数据。由于没有训练过程，KNN也是一种弱训练的机器学习算法，只要我们准备足够多的的样本就可
机器学习——最邻近算法 Nearest neighbour method / K邻近算法（KNN）
学习中
10-15 3196
References 从K近邻算法、距离度量谈到KD树、SIFT+BBF算法 最邻近算法 / K邻近算法 / KNN。 找到离「当前点」最近的「K个数据点」，然后根据「少数服从多数」原则，对「当前点」进行分类。 如果K取值太小，可能导致过度拟合。即，如果邻近样本是「噪声」，则会对训练结果造成影响——训练结果在训练集中表现变好，但在测试集中表现变差——近似误差减少，估计误差增大 如果K值...
讲解KNN最邻近算法
最新发布
08-19
KNN（K-Nearest Neighbors）最邻近算法是一种基本的监督学习算法，用于分类和回归问题。它基于一个简单的假设：相似的样本在特征空间中更有可能属于同一类别。 算法的工作流程如下： 1. 首先，将训练样本集中的每个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值