Java实现KNN

原创 已于 2023-06-09 17:03:02 修改 · 1k 阅读 · 4 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#java #算法 #机器学习
于 2023-06-08 16:02:37 首次发布
该文详细介绍了如何使用Java实现KNN（K近邻）算法，包括数据集的读取、训练集与测试集的划分、距离计算（曼哈顿距离和欧氏距离）、获取k个最近邻记录、单条记录预测以及模型的预测准确率计算。代码中包含了实例数据集的读取、随机打乱数据集、预测过程以及评估预测准确性的方法。

Java实现KNN

算法介绍

  1. 在特征空间中统计k个距离最近的样本的标签，选择最多的标签最为自己的标签。
  2. 可以采用多种距离计算策略，如曼哈顿距离、欧氏距离。
  3. KNN是非参且惰性的。
  4. 优点：实现简单、训练快（惰性）、效果好、对异常值不敏感
  5. 缺点：时空复杂度都高、需要合适的归一化等

算法流程

变量准备

在这里准备了两种距离策略、训练集、测试集、验证集和k值。

	//两种距离
    public static final int MANHATTAN = 0;
    public static final int EUCLIDEAN = 1;
    //距离策略
    public int distanceMeasure = EUCLIDEAN;
    //设置随机种子
    public static final Random random = new Random();
    //设置k值
    int numNeighbors = 7;
    //数据集
    Instances dataset;
    //训练集、测试集、验证集数组
    int[] trainingSet;
    int[] testingSet;
    int[] predictions;

用Instances类读取数据集

使用构造方法，读取数据集并存入Instances类中。

    /**
     * 构造方法，用Instances类读取数据集
     * @param paraFilename 数据集地址
     */
    public Knn(String paraFilename) {
        try {
            FileReader fileReader = new FileReader(paraFilename);
            //这里用Instances读取数据集
            dataset = new Instances(fileReader);
            //将当前Istances类的标签下标设置为（数据集的属性数-1）？
            dataset.setClassIndex(dataset.numAttributes() - 1);
            fileReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

打乱数据集并划分训练集与测试集

在这里将原本的数据集随机交换打乱，再按照比例将数据集划分为训练集与测试集。

    /**
     * 获得一个随机序列
     * @param paraLength 序列长度
     * @return 打乱后的序列
     */
    public static int[] getRandomIndices(int paraLength) {
        int[] resultIndices = new int[paraLength];
        //按序号赋值
        for(int i = 0; i < paraLength; i++) {
            resultIndices[i] = i;
        }
        //随机交换打乱
        int tempFirst, tempSecond, tempValue;
        for(int i = 0; i < paraLength; i++) {
            tempFirst = random.nextInt(paraLength);
            tempSecond = random.nextInt(paraLength);
            tempValue = resultIndices[tempFirst];
            resultIndices[tempFirst] = resultIndices[tempSecond];
            resultIndices[tempFirst] = tempValue;
        }
        return resultIndices;
    }
    /**
     * 划分训练集与验证集，输入训练集的占比，将数据集的下标放入trainingSet和testingSet中
     * @param paraTrainingFraction 训练集比例
     */
    public void splitTrainingTesting(double paraTrainingFraction) {
        //获得数据集记录数
        int tempSize = dataset.numInstances();
        //得到长度为tempSize的随机序列
        int[] tempIndices = getRandomIndices(tempSize);
        //获得训练集记录数
        int tempTrainingSize = (int)(tempSize * paraTrainingFraction);
        //声明训练集与测试集
        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 paraI 一个记录下标
     * @param paraJ 另一条记录下标
     * @return 距离结果
     */
    public double distance(int paraI, int paraJ) {
        double resultDistance = 0;
        double tempDifference;
        //两种距离策略分开计算
        switch (distanceMeasure) {
            case MANHATTAN:
                //对除去标签以外的所有属性进行处理
                for (int i = 0; i < dataset.numAttributes() - 1; i++) {
                    //归一化处理？
                    tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
                    if (tempDifference < 0) {
                        resultDistance -= tempDifference;
                    } else {
                        resultDistance += tempDifference;
                    }
                }
                break;
            case EUCLIDEAN:
                for (int i = 0; i < dataset.numAttributes() - 1; i++) {
                    tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
                    resultDistance += tempDifference * tempDifference;
                }
                break;
            default:
                System.out.println("Unsupported distance measure: " + distanceMeasure);
        }
        return resultDistance;
    }

得到k个最近记录

该部分是输入当前记录的下标，计算距离最近的k个记录，并返回。

    /**
     * 得到距离最近的k个记录，存放在数组中
     * @param paraCurrent 当前记录的下标
     * @return 返回k个最近记录
     */
    public int[] computeNearests(int paraCurrent) {
        //声明空间为k的数组
        int[] resultNearests = new int[numNeighbors];
        //声明长度同训练集的数组，作用是判断对应训练集记录是否已经被加入resultNearests数组
        boolean[] tempSelected = new boolean[trainingSet.length];
        double tempMinimalDistance;
        int tempMinimalIndex = 0;
        //
        double[] tempDistances = new double[trainingSet.length];
        for (int i = 0; i < trainingSet.length; i ++) {
            tempDistances[i] = distance(paraCurrent, trainingSet[i]);
        }
        for (int i = 0; i < numNeighbors; i++) {
            tempMinimalDistance = Double.MAX_VALUE;

            for (int j = 0; j < trainingSet.length; j++) {
                if (tempSelected[j]) {
                    continue;
                }
                if (tempDistances[j] < tempMinimalDistance) {
                    tempMinimalDistance = tempDistances[j];
                    tempMinimalIndex = j;
                }
            }
            resultNearests[i] = trainingSet[tempMinimalIndex];
            tempSelected[tempMinimalIndex] = true;
        }
        System.out.println("The nearest of " + paraCurrent + " are: " + Arrays.toString(resultNearests));
        return resultNearests;
    }

对单条记录进行预测

该部分是输入一条记录，利用得到的k个最近记录，实现预测功能。

    /**
     * 对单条记录进行预测
     * @param paraNeighbors k个最近记录
     * @return 返回预测得到的标签
     */
    public int simpleVoting(int[] paraNeighbors) {
        //以数据集的标签个数建立数组，目的是统计对于当前记录而言，最接近哪个标签
        int[] tempVotes = new int[dataset.numClasses()];
        //循环统计最近的k个记录，将k个记录的所属标签计入数组
        for (int i = 0; i < paraNeighbors.length; i++) {
            tempVotes[(int) dataset.instance(paraNeighbors[i]).classValue()]++;
        }
        //选择最多的标签作为自己的标签
        int tempMaximalVotingIndex = 0;
        int tempMaximalVoting = 0;
        for (int i = 0; i < dataset.numClasses(); i++) {
            if (tempVotes[i] > tempMaximalVoting) {
                tempMaximalVoting = tempVotes[i];
                tempMaximalVotingIndex = i;
            }
        }
        //返回所属标签的下标
        return tempMaximalVotingIndex;
    }

    /**
     * 预测单条记录的标签
     * @param paraIndex 单条记录的下标
     * @return 返回标签值的序号
     */
    public int predict(int paraIndex) {
        //得到距离最近的k个记录
        int[] tempNeighbors = computeNearests(paraIndex);
        //投票得到k个记录中最多的标签值
        int resultPrediction = simpleVoting(tempNeighbors);
        //返回预测标签的序号
        return resultPrediction;
    }

对测试集进行预测存入验证集

利用单条记录预测功能实现全部测试集的预测功能。

    /**
     * 将测试集的预测结果放在验证集中
     */
    public void predict() {
        //为验证集赋予空间
        predictions = new int[testingSet.length];
        //将测试集的预测结果放在验证集中
        for (int i = 0; i < predictions.length; i++) {
            predictions[i] = predict(testingSet[i]);
        }
    }

计算准确率

根据验证集的结果与真实结果进行比对，计算模型预测准确率。

    /**
     * 根据验证集的结果与真实结果进行比对，计算模型预测准确率
     * @return 预测准确率
     */
    public double getAccuracy() {
        double tempCorrect = 0;
        for (int i = 0; i < predictions.length; i++) {
            if (predictions[i] == dataset.instance(testingSet[i]).classValue()) {
                tempCorrect++;
            }
        }
        return tempCorrect / testingSet.length;
    }

详细注释

package knn_nb;

import weka.core.Instances;

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

public class Knn {
    //两种距离
    public static final int MANHATTAN = 0;
    public static final int EUCLIDEAN = 1;
    //距离策略
    public int distanceMeasure = EUCLIDEAN;
    //设置随机种子
    public static final Random random = new Random();
    //设置k值
    int numNeighbors = 7;
    //数据集
    Instances dataset;
    //训练集、测试集、验证集数组
    int[] trainingSet;
    int[] testingSet;
    int[] predictions;
    /**
     * 构造方法，用Instances类读取数据集
     * @param paraFilename 数据集地址
     */
    public Knn(String paraFilename) {
        try {
            FileReader fileReader = new FileReader(paraFilename);
            //这里用Instances读取数据集
            dataset = new Instances(fileReader);
            //将当前Istances类的标签下标设置为（数据集的属性数-1）？
            dataset.setClassIndex(dataset.numAttributes() - 1);
            fileReader.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获得一个随机序列
     * @param paraLength 序列长度
     * @return 打乱后的序列
     */
    public static int[] getRandomIndices(int paraLength) {
        int[] resultIndices = new int[paraLength];
        //按序号赋值
        for(int i = 0; i < paraLength; i++) {
            resultIndices[i] = i;
        }
        //随机交换打乱
        int tempFirst, tempSecond, tempValue;
        for(int i = 0; i < paraLength; i++) {
            tempFirst = random.nextInt(paraLength);
            tempSecond = random.nextInt(paraLength);
            tempValue = resultIndices[tempFirst];
            resultIndices[tempFirst] = resultIndices[tempSecond];
            resultIndices[tempFirst] = tempValue;
        }
        return resultIndices;
    }

    /**
     * 划分训练集与验证集，输入训练集的占比，将数据集的下标放入trainingSet和testingSet中
     * @param paraTrainingFraction 训练集比例
     *
     */
    public void splitTrainingTesting(double paraTrainingFraction) {
        //获得数据集记录数
        int tempSize = dataset.numInstances();
        //得到长度为tempSize的随机序列
        int[] tempIndices = getRandomIndices(tempSize);
        //获得训练集记录数
        int tempTrainingSize = (int)(tempSize * paraTrainingFraction);
        //声明训练集与测试集
        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];
        }
    }

    /**
     * 将测试集的预测结果放在验证集中
     */
    public void predict() {
        //为验证集赋予空间
        predictions = new int[testingSet.length];
        //将测试集的预测结果放在验证集中
        for (int i = 0; i < predictions.length; i++) {
            predictions[i] = predict(testingSet[i]);
        }
    }

    /**
     * 预测单条记录的标签
     * @param paraIndex 单条记录的下标
     * @return 返回标签值的序号
     */
    public int predict(int paraIndex) {
        //得到距离最近的k个记录
        int[] tempNeighbors = computeNearests(paraIndex);
        //投票得到k个记录中最多的标签值
        int resultPrediction = simpleVoting(tempNeighbors);
        //返回预测标签的序号
        return resultPrediction;
    }

    /**
     * 计算两条记录之间对应的距离
     * @param paraI 一个记录下标
     * @param paraJ 另一条记录下标
     * @return 距离结果
     */
    public double distance(int paraI, int paraJ) {
        double resultDistance = 0;
        double tempDifference;
        //两种距离策略分开计算
        switch (distanceMeasure) {
            case MANHATTAN:
                //对除去标签以外的所有属性进行处理
                for (int i = 0; i < dataset.numAttributes() - 1; i++) {
                    //归一化处理？
                    tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
                    if (tempDifference < 0) {
                        resultDistance -= tempDifference;
                    } else {
                        resultDistance += tempDifference;
                    }
                }
                break;
            case EUCLIDEAN:
                for (int i = 0; i < dataset.numAttributes() - 1; i++) {
                    tempDifference = dataset.instance(paraI).value(i) - dataset.instance(paraJ).value(i);
                    resultDistance += tempDifference * tempDifference;
                }
                break;
            default:
                System.out.println("Unsupported distance measure: " + distanceMeasure);
        }
        return resultDistance;
    }

    /**
     * 根据验证集的结果与真实结果进行比对，计算模型预测准确率
     * @return 预测准确率
     */
    public double getAccuracy() {
        double tempCorrect = 0;
        for (int i = 0; i < predictions.length; i++) {
            if (predictions[i] == dataset.instance(testingSet[i]).classValue()) {
                tempCorrect++;
            }
        }
        return tempCorrect / testingSet.length;
    }

    /**
     * 得到距离最近的k个记录，存放在数组中
     * @param paraCurrent 当前记录的下标
     * @return 返回k个最近记录
     */
    public int[] computeNearests(int paraCurrent) {
        //声明空间为k的数组
        int[] resultNearests = new int[numNeighbors];
        //声明长度同训练集的数组，作用是判断对应训练集记录是否已经被加入resultNearests数组
        boolean[] tempSelected = new boolean[trainingSet.length];
        double tempMinimalDistance;
        int tempMinimalIndex = 0;
        //
        double[] tempDistances = new double[trainingSet.length];
        for (int i = 0; i < trainingSet.length; i ++) {
            tempDistances[i] = distance(paraCurrent, trainingSet[i]);
        }
        for (int i = 0; i < numNeighbors; i++) {
            tempMinimalDistance = Double.MAX_VALUE;

            for (int j = 0; j < trainingSet.length; j++) {
                if (tempSelected[j]) {
                    continue;
                }
                if (tempDistances[j] < tempMinimalDistance) {
                    tempMinimalDistance = tempDistances[j];
                    tempMinimalIndex = j;
                }
            }
            resultNearests[i] = trainingSet[tempMinimalIndex];
            tempSelected[tempMinimalIndex] = true;
        }
        System.out.println("The nearest of " + paraCurrent + " are: " + Arrays.toString(resultNearests));
        return resultNearests;
    }

    /**
     * 对单条记录进行预测
     * @param paraNeighbors k个最近记录
     * @return 返回预测得到的标签
     */
    public int simpleVoting(int[] paraNeighbors) {
        //以数据集的标签个数建立数组，目的是统计对于当前记录而言，最接近哪个标签
        int[] tempVotes = new int[dataset.numClasses()];
        //循环统计最近的k个记录，将k个记录的所属标签计入数组
        for (int i = 0; i < paraNeighbors.length; i++) {
            tempVotes[(int) dataset.instance(paraNeighbors[i]).classValue()]++;
        }
        //选择最多的标签作为自己的标签
        int tempMaximalVotingIndex = 0;
        int tempMaximalVoting = 0;
        for (int i = 0; i < dataset.numClasses(); i++) {
            if (tempVotes[i] > tempMaximalVoting) {
                tempMaximalVoting = tempVotes[i];
                tempMaximalVotingIndex = i;
            }
        }
        //返回所属标签的下标
        return tempMaximalVotingIndex;
    }

    /**
     * 主函数，启动预测并展示准确率
     * @param args
     */
    public static void main(String args[]) {
        Knn knn = new Knn("C:\\Users\\hp\\Desktop\\deepLearning\\src\\main\\java\\knn_nb\\iris.arff");
        knn.splitTrainingTesting(0.8);
        knn.predict();
        System.out.println("The accuracy of the classifier is: " + knn.getAccuracy());
    }

}
outragee
关注
Java实现kNN算法
05-05
Java实现kNN算法
spring-redisearch:Spring+ RediSearch演示
03-27
spring-redisearch:Spring+ RediSearch演示
机器学习算法——KNN分类算法介绍以及Java实现
XiaoXiao_Yang77的博客
10-13 3786
KNN分类算法介绍一、什么是分类分类是指通过对大量的训练样本进行提取和分析，训练出用来分类的规则，即分类器或者分类模型，最终判断未知样本的类别。常见的分类算法有：决策树（ID3和C4.5），朴素贝叶斯，人工神经网络 （Artificial Neural Networks，ANN），k-近邻(kNN)，支持向量机（SVM），基于关联规则的分类，Adaboosting方法等等。这篇文章主要介绍KNN算法
数据挖掘原理与算法笔记
qq_43615815的博客
10-04 1076
第一章绪论 1. 数据挖掘的定义 从数据中抽取隐含的、事先不知道的、潜在有 用的信息 – 采用自动或半自动的方法，分析大量的数据以 期发现有意义的模式 – 在知识发现过程中，通过特定的算法在可接受 的计算效率限制内生成特定模式的一个步骤 **2. 数据挖掘的任务和本课程的研究内容 3. 数据挖掘面临的挑战** 可伸缩性(算法的时间复杂度) 高维数据 复杂和异构数据 数据质量（测量误差、噪声、缺失、重复） 数据所有权和分布 隐私保护(进行必要的预处理) 能叙述数据挖掘的基本任务。 能说出数据挖掘
数据挖掘Java——KNN算法的实现
qq_54162207的博客
12-18 2653
KNN算法的思想比较简单。假定每个类包含多个训练数据，且每个训练数据都有一个唯一的类别标记，KNN算法的主要思想就是计算每个训练数据到待分类元组的距离，取和待分类元组距离最近的k个训练数据，k个数据中哪个类别的训练数据占多数，则待分类元组就属于哪个类别。
用JAVA实现KNN算法
weixin_63522596的博客
10-11 605
用JAVA实现KNN算法
KNN算法JAVA实现
一HUA一世界的专栏
09-22 8884
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻，就是k个最近的邻居的意思，说的是每个样本都可以用它最接近的k个邻居来代表。 kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几
【机器学习】K近邻算法（K-NearestNeighbors , KNN）详解 + Java代码实现
热门推荐
知不足而奋进，望远山而前行
01-09 2万+
邻近算法，或者说K最邻近（KNN，K-NearestNeighbors）分类算法是分类方法中最简单的方法之一。所谓K最近邻，就是K个最近的邻居的意思，说的是每个样本都可以用它最接近的K个邻近值来代表。近邻算法就是将数据集合中每一个记录进行分类的方法。KNN 最初由 Cover 和 Hart 于1968年提出，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。
Java语言实现K-近邻算法 (K-Nearest Neighbors, KNN)
zy0412326的专栏
09-24 360
可以根据需求扩展此实现，例如改进投票机制、支持加权投票等。
JAVA实现KNN分类
小鸡慢慢的专栏
04-05 1万+
KNN算法又叫近邻算法，是数据挖掘中一种常用的分类算法，接单的介绍KNN算法的核心思想就是：寻找与目标最近的K个个体，这些样本属于类别最多的那个类别就是目标的类别
KNN分类器-Java实现
随心而笑
01-05 2542
KNN，即K近邻算法。其基本思想或者说是实现步骤如下： （1）计算样本数据点到每个已知类别的数据集中点的距离 （2）将（1）中得到的距离按递增顺序排列 （3）选取（2）中前K个点（即与当前样本距离最小的K个已知类别的数据点） （4）统计（3）中得到的K个点所在类别的出现频率 （5）返回（4）中出现频率最高的类别作为样本点的预测类别 在给出具体实现代码之前，说明一点
邻近分类算法---KNN（Java实现+公式计算例子）
whiteBearClimb的博客
02-18 4267
名词解释： KNN：K-Nearest-Neighbor K值最邻近 所以网上有好几种叫法：最近邻，邻近…其实都是指的KNN，其实按照翻译都对。KNN算法产生于1968年，是数据挖掘和数据分类技术中最简单的入门级算法。 按照字面意思，就是计算出距离K值最近的邻居数据，设对应数据为X，然后把待分类数据归类为X。 原理 基于大量不同维度的训练数据，做循环比较分析，具体经历下面四步流程： ①准备数据，对数据进行预处理 。 ②计算测试样本点（也就是待分类点）到其他每个样本点的距离 。 ③对每个距离进行排序，然后选择
022、基于Java的k-近邻算法(kNN)
Code is fun.
11-11 740
k-近邻算法(k-Nearest Neighbor, kNN)是一种基础且强大的机器学习算法，它可以用于分类和回归。本文将详细介绍kNN算法的原理，并使用Java语言实现这一算法。kNN的核心思想是：对于一个待分类的数据点，我们找出训练集中离它最近的k个邻居，然后让这k个邻居进行投票，票数最多的类别就作为待分类点的类别。首先通过一个完整的Java实现来深入理解kNN算法。
【Java实现KNN算法】KNN（k邻近）详解与java实现
王小鬼的博客
03-11 7402
1.KNN算法         KNN 法最初由Cover 和Hart 于1968 年提出, 是一个理论上比较成熟的方法。KNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别，则该样本也属于这个类别，并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的K(K=1,2,3…，n，其中，n<=D)个样本的类别来决定待分样本所属的类别。 由于KNN
用Java实现KNN算法及电影分类应用
weixin_35906794的博客
09-05 1265
本文还有配套的精品资源，点击获取 简介：本项目介绍如何使用Java语言实现K近邻（KNN）算法，并利用Access数据库中电影数据进行分类。KNN是一种基于最近邻分类的监督学习算法，我们使用"接吻次数"和"战斗次数"两个特征来区分电影类型。实现步骤包括数据预处理、算法编码、分类预测、性能评估与优化以及代码结构设计。通过本项目，可以深入理解KNN算法原理和应用，提升在数据分类...
java手写识别项目（一）：初识KNN算法和GUI框架搭建
weixin_73541770的博客
11-29 1164
这篇博客深入探索了一个基于KNN算法的手写识别项目的初步构建。作者以Java为基础，从搭建GUI界面、介绍KNN算法的Java实现示例开始，逐步展示了项目的整体结构和GUI的搭建过程。重点关注了细节问题，如继承JPanel而非JFrame、setPreferredSize()函数的运用等，并展示了鼠标事件处理以实现手绘功能。博客给出了代码示例和相关的注意事项，为读者提供了探索和学习该项目的良好起点。
近邻算法详解：原理、Java实现及应用场景
q_913246828的博客
06-03 1007
近邻算法（Nearest Neighbor Algorithm）是一种基于实例的学习方法，主要用于分类和回归问题。本文详细介绍了K近邻算法（K-Nearest Neighbors, KNN）的原理、步骤及其Java实现。KNN的核心思想是通过计算待分类样本与训练样本的距离，选择最近的K个样本，根据它们的类别信息来决定待分类样本的类别。本文提供了Java实现代码，包括数据点类、KNN算法类及测试方法，并详细说明了KNN在图像识别、文本分类、推荐系统和医疗诊断等领域的应用场景。
K-means聚类算法
qq_61153017的博客
12-29 1722
鸢尾花数据集是一个经典的机器学习数据集，包含150个样本，每个样本有4个特征（花萼长度、花萼宽度、花瓣长度、花瓣宽度），共有3个目标类别（setosa、versicolor、virginica）。选取了两个指标（内部指标和外部指标）对聚类算法进行评估。本次实验的初始化中心的设置如下图所示。不考虑无法收敛的情况。
KNN算法的Java实现与优化
最新发布
weixin_42608299的博客
08-13 886
K-Nearest Neighbors (KNN) 算法是一种基础的分类与回归方法，广泛应用于模式识别和统计估计领域。其核心思想是：一个数据点的分类由它最近的K个邻居来决定。KNN在训练过程中不进行任何显式的学习，仅存储数据，因此也被认为是一种懒惰学习算法。它适用于各种数据类型，尤其在样本量不是特别大时，能够得到较为满意的结果。欧氏距离是几何中常用的一种距离度量方法，在K-Nearest Neighbors (KNN) 算法中，欧氏距离是最直观且常用的距离度量方式。
JavaGUI实战（一） 基于KNN算法实现手写数字识别
这里是阿安的博客
09-18 727
JavaGUI实战（一） 基于KNN算法实现手写数字识别
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值