[MoonML]-K邻近分类器

最新推荐文章于 2019-02-21 20:53:34 发布
最新推荐文章于 2019-02-21 20:53:34 发布
阅读量342 收藏
点赞数
分类专栏： 机器学习 文章标签： 机器学习 分类算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lazy_moon/article/details/73743945
版权

正文

K-邻近算法(K-NearestNeighbor)简称KNN，我觉得这个真的是分类器中最好理解、最好实现的分类器，它最实用于数值型特征数据，下面让我们看看它的基本思想。

样本数据是由N维特征向量所组成，所有样本数据就是在这个N维空间中的离散点，当然每个离散点都对应这自己的类别。已知特征向量要预测它的类别，我们把这个已知向量放入样本空间中，去K个离它最近的点，这些点中，出现类别次数最多就是此向量对应的类别。

再精简一点说就是：筛选最近的K个点，在K中找类别频次。

为什么要这样做呢?

首先，“最近”就说明了我所找的这些点是与我所有求解的特征最相似，其次“少数服从多数”，谁出现的概率大，就选择谁。是不是很好理解？

接下来就是求两点之间的距离，这里采用欧氏空间距离公式（这应该是高中的内容了）：

一直向量a(x1,y1,z1和b(x2,y2,z2)，求a与b之间的距离d

根据维度自行调整里面的内容

根据KNN算法的基本原理，整理一下步骤：

  1. 求出指定向量到样本中每个向量的距离
  2. 找出离指定向量最近的K个向量
  3. 在K个向量中找出出现次数最多的类别，作为输出结果

是不是很简单？如果你说很简单那就错了，这里有一个坑，让我们举个例子，例子能说明一切

Example：市场需求总量、市场供应总量、市场集中三个因素(x,y,z)影响着企业决策类型，

假设向量a=(100000,250000,0.11)，b=(120000,280000,0.55)，求ab的距离d


根据业务来看，三个影响因素的应该是等权重的也就是同样重要。但是在上面的计算当中，市场集中度即使差距很大，也很难对最终结果造成影响，这很明显不符合业务的标准。

在处理不同范围特征值时，为了将数据等权重，消除因为取值范围的差异而导致结果倾斜，我们将数据归一化，把数据的取值范围控制在0到1之间

newValue=(oldValue-minValue)/(maxValue-minValue)

maxValue和minValue分别表示最大特征值，最小特征值，是这一特征当中的最值，并不是整个集合中的最值。

虽然归一化处理增加了分类器的复杂度，但是为了得到准确的结果，只能这样做。这样就把样本特征等权重了。

KNN分类器我们得到了，接下来让我们看一下KNN算法的扩展

上述的方式，最终得到的类别是一个标称型数据，如果针对结果是数值型的数据，我们该如何处理呢？

我们知道，KNN算法，提取了离指定点最近的K个点，这K个点就是与指定向量最相似的点，特征最相似，结果也是最相似的，所以针对数值型结果的数据，我们可以对这K个最相似的结果进行处理，得到最终结果，最常见的就是对K个数值型结果进行求均值来确定指定向量的结果，当然也可以根据自己的业务做加权平均。这是一个很好的扩展，使KNN算法可以不进适用于标称型结果的分类，还可以适应数值型结果的预测。

代码实现

先给出通用的代码：

结果信息类，实现了Compareable接口，根据距离进行排序，为的是找到K个最近的点

package moon.ml.knearestneighbor;

/**
 * @ClassName ResultMapper
 * @Description 结果信息
 * @author "liumingxin"
 * @Date 2017年5月22日 下午4:30:04
 * @version 1.0.0
 */
public class ResultInfo implements Comparable<ResultInfo>{
	private Object classify;
	private Integer frequency = 0;//频次
	private Double totalDistance = 0d;
	public Object getClassify() {
		return classify;
	}
	public void setClassify(Object classify) {
		this.classify = classify;
	}
	public Integer getFrequency() {
		return frequency;
	}
	public void setFrequency(Integer frequency) {
		this.frequency = frequency;
	}
	
	public Double getTotalDistance() {
		return totalDistance;
	}
	public void setTotalDistance(Double totalDistance) {
		this.totalDistance = totalDistance;
	}
	
	public int compareTo(ResultInfo that) {
		if(this.getFrequency() == this.getFrequency()){
			return this.getTotalDistance().compareTo(that.getTotalDistance());
		}
		return this.getFrequency().compareTo(that.getFrequency());
	}
	
}

归一化的方法类

package moon.ml.util;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import moon.ml.record.RecordWithFeaturesDouble;

/**
 * @ClassName Uniformization
 * @Description 归一化计算类
 * @author "liumingxin"
 * @Date 2017年5月22日 下午1:47:30
 * @version 1.0.0
 */
public class Uniformization {


    /**
     * @Title: getUniformizationResult
     * @Description: 归一化结果
     * @param list
     * @return
     * @return List<List<Double>>
     */
    public static List<List<Double>> getUniformizationResult(List<List<Double>> list){
        if(list == null){
            return null;
        }
        List<List<Double>> results = new ArrayList<List<Double>>();
        for(int i=0;i<list.size();i++){
            results.add(new ArrayList<Double>());
        }
        int colSize = list.get(0).size();
        int rowSize = list.size();
        for(int i=0;i<colSize;i++){
            Double maxElement = list.get(0).get(i);
            Double minElement = list.get(0).get(i);
            //获取每一列的最大值最小值
            for(List<Double> strs : list){
                Double element = strs.get(i);
                if(element > maxElement){
                    maxElement = element;
                }
                if(element < minElement){
                    minElement = element;
                }
            }
            
            //归一化
            for(int j=0;j<rowSize;j++){
                List<Double> result = results.get(j);
                if(result == null){
                    result = new ArrayList<Double>();
                    results.add(result);
                }
                Double element = list.get(j).get(i);
                element = (element - minElement)/(maxElement - minElement);
                result.add(element);
                
            }
        }
        return results;
    }
}

KNN算法的主要算法，但是这里抽象了分类策略，这样可以针对不同结果类型，进行具体实现

package moon.ml.knearestneighbor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import moon.ml.record.DistanceMapperDouble;
import moon.ml.record.RecordWithFeaturesDouble;
import moon.ml.util.Uniformization;

/**
 * @ClassName KNearestNeighbor
 * @Description 分类预测
 * 				优点：精度高、对异常数据不敏感、无数据输入假定
 * 				缺点：计算复杂度高、空间复杂度高
 * @author "liumingxin"
 * @Date 2017年5月23日 上午9:55:10
 * @version 1.0.0
 */
public abstract class KNearestNeighbor {

	/**
	 * @Title: normalization
	 * @Description: 数据集的归一化处理
	 * @param dataSet
	 * @return
	 * @return List<RecordWithFeaturesDouble>
	 */
	public List<RecordWithFeaturesDouble> normalization(List<RecordWithFeaturesDouble> dataSet){
		List<RecordWithFeaturesDouble> result = new ArrayList<RecordWithFeaturesDouble>();
		List<List<Double>> doubleList = new ArrayList<List<Double>>();
		for(RecordWithFeaturesDouble r : dataSet){
			doubleList.add(r.getFeatures());
		}
		List<List<Double>> normalResults = Uniformization.getUniformizationResult(doubleList);
		for(int i=0;i<normalResults.size();i++){
			RecordWithFeaturesDouble r = new RecordWithFeaturesDouble();
			r.setCategory(dataSet.get(i).getCategory());
			r.setFeatures(normalResults.get(i));
			result.add(r);
		}
		return result;
	}
	
	/**
	 * @Title: getResult
	 * @Description: 得出结果
	 * @param dataSet 数据集
	 * @param test 测试数据
	 * @param K K值
	 * @return
	 * @return Object
	 */
	public Object getResult(List<RecordWithFeaturesDouble> dataSet, List<Double> test, Integer K){
		//将测试数据，加入到dataset中，然后归一化处理，再分离测试数据
		RecordWithFeaturesDouble testRecord = new RecordWithFeaturesDouble();
		testRecord.setFeatures(test);
		dataSet.add(testRecord);
		
		dataSet = normalization(dataSet);
		testRecord = dataSet.get(dataSet.size()-1);
		dataSet = dataSet.subList(0, dataSet.size()-1);
		
		List<DistanceMapperDouble> mappers = new ArrayList<DistanceMapperDouble>();
		for(RecordWithFeaturesDouble data : dataSet){
			//计算两个向量的距离
			Double distance = data.featuresList2RealVector().getDistance(testRecord.featuresList2RealVector());
			DistanceMapperDouble mapper = new DistanceMapperDouble();
			mapper.setData(data);
			mapper.setDistance(distance);
			mappers.add(mapper);
		}
		//根据聚类升序排序
		Collections.sort(mappers);
		//截取前K个，这就是所有的K邻近中的K的作用
		mappers = mappers.subList(0, K);
		return getCategory(mappers);
	}
	
	/**
	 * @Title: getCategory
	 * @Description: 自定义策略
	 * @param mappers
	 * @return
	 * @return Object
	 */
	public abstract Object getCategory(List<DistanceMapperDouble> mappers);
	
}
标称型结果的策略实现和测试

package moon.ml.knearestneighbor;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import moon.ml.record.DistanceMapperDouble;
import moon.ml.record.RecordWithFeaturesDouble;

/**
 * @ClassName CategoryForecastKNN
 * @Description 类别预测KNN方法类
 * @author "liumingxin"
 * @Date 2017年6月20日 下午3:56:18
 * @version 1.0.0
 */
public class CategoryForecastKNN extends KNearestNeighbor{

    @Override
    public Object getCategory(List<DistanceMapperDouble> mappers) {

        Map<Object,ResultInfo> resultInfoMap = new HashMap<Object,ResultInfo>();
        for(DistanceMapperDouble mapper : mappers){
            RecordWithFeaturesDouble data = mapper.getData();
            Object classify = data.getCategory();
            //种类为KEY
            ResultInfo resultInfo = resultInfoMap.get(classify);
            if(resultInfo == null){
                resultInfo = new ResultInfo();
            }
            resultInfo.setClassify(classify);
            //频次+1
            resultInfo.setFrequency(resultInfo.getFrequency()+1);
            //总距离相加
            resultInfo.setTotalDistance(resultInfo.getTotalDistance()+mapper.getDistance());
            resultInfoMap.put(classify, resultInfo);
        }

        
        List<ResultInfo> resultInfos = new ArrayList<ResultInfo>();
        for(Object key :resultInfoMap.keySet()){
            resultInfos.add(resultInfoMap.get(key));
        }
        Collections.sort(resultInfos);
        return resultInfos.get(0).getClassify();
    
    }

    public static void main(String[] args) {

        List<List<String>> trains = new ArrayList<List<String>>();
        trains.add(Arrays.asList("2", "357", "9888", "0.54", "no"));
        trains.add(Arrays.asList("3", "452", "8888", "0.35", "no"));
        trains.add(Arrays.asList("1", "335", "7894", "0.13", "yes"));
        trains.add(Arrays.asList("7", "645", "5648", "0.97", "yes"));
        trains.add(Arrays.asList("6", "255", "6794", "0.65", "yes"));
        trains.add(Arrays.asList("8", "388", "8015", "0.34", "no"));
        trains.add(Arrays.asList("4", "458", "6798", "0.66", "yes"));
        trains.add(Arrays.asList("6", "687", "8764", "0.79", "no"));
        trains.add(Arrays.asList("8", "388", "8754", "0.68", "yes"));
        trains.add(Arrays.asList("1", "546", "9768", "0.67", "yes"));
        trains.add(Arrays.asList("8", "488", "9537", "0.35", "yes"));
        trains.add(Arrays.asList("3", "612", "5491", "0.97", "yes"));
        trains.add(Arrays.asList("8", "548", "6724", "0.64", "yes"));
        trains.add(Arrays.asList("4", "356", "9768", "0.88", "no"));
        
        List<RecordWithFeaturesDouble> trainList = new ArrayList<RecordWithFeaturesDouble>();
        for(List<String> l : trains){
            List<Double> ds = new ArrayList<Double>();
            for(int i=0;i<l.size()-1;i++){
                ds.add(Double.parseDouble(l.get(i)));
            }
            RecordWithFeaturesDouble r = new RecordWithFeaturesDouble();
            r.setCategory(l.get(l.size()-1));
            r.setFeatures(ds);
            trainList.add(r);
        }
        
        List<Double> testList = new ArrayList<Double>();
        testList.add(4d);
        testList.add(488d);
        testList.add(7564d);
        testList.add(0.66d);
        CategoryForecastKNN knn = new CategoryForecastKNN();
        String result = knn.getResult(trainList, testList, 3).toString();
        System.out.println(result);
    }

}

数值型结果的策略实现和测试

先看一下数据长什么样


业务背景是这样的：我们认为前几天的股票走势，是影响接下来股票价格的因素，所以把前四天股票的收盘价格定为四个特征，当天收盘价作为结果，这样，我们就可以根据最近四天的收盘价，预测接下来一天的收盘价

下面是具体实现

package moon.ml.knearestneighbor;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.List;

import moon.ml.record.DistanceMapperDouble;
import moon.ml.record.RecordWithFeaturesDouble;

/**
 * @ClassName FigureForecastKNN
 * @Description 数字预测KNN方法类
 * @author "liumingxin"
 * @Date 2017年6月20日 下午3:56:39
 * @version 1.0.0
 */
public class FigureForecastKNN extends KNearestNeighbor{
        /* (非 Javadoc)
      * <p>Title: getCategory</p>
      * <p>Description: 求K个结果的平均值，作为预测结果</p>
      * @param mappers
      * @return
      * @see moon.ml.knearestneighbor.KNearestNeighbor#getCategory(java.util.List)
      */
	@Override
	public Object getCategory(List<DistanceMapperDouble> mappers) {

		Double result = 0d;
		for (DistanceMapperDouble mapper : mappers) {
			result += Double.parseDouble(mapper.getData().getCategory().toString());
		}
		result = result / mappers.size();
		return result;

	}

	
	/**
	 * 读取测试文档
	 */
	private static List<RecordWithFeaturesDouble> readTest(String fileIn) {
		List<RecordWithFeaturesDouble> outList = new ArrayList<RecordWithFeaturesDouble>();
		try {
			File file = new File(fileIn);
			FileReader reader = new FileReader(file);
			BufferedReader in = new BufferedReader(reader);
			String line = null;
			while ((line = in.readLine()) != null) {
				RecordWithFeaturesDouble record = new RecordWithFeaturesDouble();
				List<Double> list = new ArrayList<Double>();
				String[] mArray = line.split(",");
				for (Integer i = 0; i < mArray.length - 1; i++) {
					list.add(Double.parseDouble(mArray[i]));
				}
				record.setFeatures(list);
				record.setCategory(mArray[mArray.length - 1]);
				outList.add(record);
			}
			in.close();
			reader.close();
		} catch (Exception e) {
			System.out.println("读取出错");
			e.printStackTrace();
		}
		return outList;
	}
	
	
	public static void main(String[] args) {

		
		//K值
		Integer K = 10;
		
		List<RecordWithFeaturesDouble> trainList = readTest("data/knn/knn.txt");
		List<Double> testList = new ArrayList<Double>();
		testList.add(6.14);
		testList.add(6.28);
		testList.add(6.42);
		testList.add(6.38);
		FigureForecastKNN knn = new FigureForecastKNN();
		Object theoretical =  knn.getResult(trainList, testList, K);
		System.out.println(theoretical);
	}

}
代码我已经放在了github上了 https://github.com/moonLazy/MoonML.git




lazy_moon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2、最近邻分类器
青星大学
07-06 6983
2、最近邻分类器 接下来我们来开发一个图像分类器：最近邻分类器。这个分类器在实践中很少用，但是可以让我们对数据驱动的图像分类方法有一个概念性的理解。 图像分类样例数据集：CIFAR-10，这是一个有名的图像分类数据集。包含6万张32X32像素的小图，每张图片都标记为10个分类中的某一个(比如airplane, automobile, bird，等等)。这6万张图片已经分为两组，训练数据5万张，...
k-近邻算法实现分类器
Cumu Blog
11-30 4859
k-近邻算法介绍 k-近邻算法（kNN）是采用测试不同特征值之间的距离方法进行分类。工作原理：存在一个样本数据集（训练样本集），并且样本集中每组数据都存在分类标签，当输入没有标签的新数据后，将新数据的每个特征与样本集中的数据对应特征进行比较，然后算法提取样本集中特征最相似数据的前K个（最近邻）的分类标签，行啊unzek个最相似数据中出现次数最多的分类，作为新数据的分类。我们距离的计算一般用欧氏距
给大家分享一篇 从零开始构造邻近分类器KNN
qq_41235053的博客
08-11 405
起步 本章介绍如何自行构造 KNN 分类器，这个分类器的实现上算是比较简单的了。不过这可能需要你之前阅读过这方面的知识。 前置阅读 分类算法之邻近算法:KNN（理论篇） 分类算法之邻近算法:KNN（应用篇） 欧拉公式衡量距离 关于距离的测量方式有多种，这边采用欧拉距离的测量方式: 对应的 python 代码: import math def euler_distance(p...
K近邻算法--电影分类实例
尚未佩妥剑 转眼便江湖
02-21 2575
简介 算法的基本原理：存在一个样本数据集合，也称作为训练样本集，并且样本集中每个数据都存在标签，即我们知道样本集中每一个数据与所属分类的对应关系。输入没有标签的新数据后，将新的数据的每个特征与样本集中数据对应的特征进行比较，然后算法提取样本最相似数据(最近邻)的分类标签。一般来说，我们只选择样本数据集中前k个最相似的数据，这就是k-近邻算法中k的出处，通常k是不大于20的整数。最后，选择k个最相似...
[MoonML]-朴素贝叶斯分类器
lazy_moon的博客
06-23 243
前不久，公司有一项业务需要给出下一周的的预测（这是公司业务，这里不细说）。于是，我接触到了机器学习领域的知识，我觉得机器学习真是一个很奇妙的领域，它是一门交叉的学科，对各个业务领域冲击性很大。可以说，在任何领域都有运用机器学习的相关知识。 我并没有很完善的数学理论基础，但我会用我自己的理解来讲述所涉及到的算法，我想这样也是有好处的，那就是将复杂难懂的公式转换成了更接地气更让人明白的方式展现给大家。接下来的内容，如果有错，请大家多多指教。
knn.zip_K._KNN 特征_k邻近分类器
09-24
KNN 是K最邻近结点算法（k-Nearest Neighbor algorithm）的缩写形式，是电子信息分类器算法的一种。KNN方法对包容型数据的特征变量筛选尤其有效。
java实现k-近邻算法分类器
02-06
用java实现k-近邻算法分类器的完整工程代码，测试结果正确
K-means.zip_K._K_邻近分类_k-邻近算法
07-15
此算法为k邻近算法，能很好的对数据进行分类，而且运算速度快
k邻近分类回归python实现
10-27
2. **构建KNN分类器**：定义KNN分类器类，包含`fit()`方法（训练模型，存储训练数据和标签）、`predict()`方法（根据测试数据预测类别）和`k_nearest_neighbors()`方法（找到最近的K个邻居）。 3. **分类过程**：...
kNN.rar_K._k-邻近算法_knn_k近邻
09-24
邻近算法，或者说K最近邻(kNN，k-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。
最近邻分类器（KNN）
Zealot的专栏
12-03 1万+
介绍最近邻分类器
深度学习与计算机视觉系列(2)_图像分类与KNN
热门推荐
寒小阳
11-20 5万+
图像分类问题这是很久以前就引起关注的一类图像相关问题。 对于一张输入的图片，要判定它属于给定的一些标签/类别中的哪一个。看似很简单的一个问题，这么多年却一直是计算机视觉的一个核心问题。应用场景也非常之多，它的重要性还体现在，其实其他的一些计算机视觉的问题(比如说物体识别、图像内容分割等)都可以基于它去完成。举个例子说说这个问题哈。 计算机拿到如下的一张图片，然后需要给出它对应{猫，狗，帽子，杯子
Opencv Python版学习笔记（八）字符识别-分类器（SVM，KNearest，RTrees，Boost，MLP）
gjy095的专栏
07-07 1万+
Opencv提供了几种分类器，例程里通过字符识别来进行说明的 1、支持向量机（SVM）：给定训练样本，支持向量机建立一个超平面作为决策平面，使得正例和反例之间的隔离边缘被最大化。 函数原型：训练原型 cv2.SVM.train(trainData, responses[, varIdx[, sampleIdx[, params]]])                    其中 trainD
最近邻分类器及MATLAB实现
yi_tech_blog的博客
04-15 1万+
应用背景：在前面一些图像处理相关的文章中，已经说到图像的特征提取，在选择好一些主要特征之后，那么我们用这些特征做什么用呢，我们的主要目的是利用这些特征对图像进行分类。接下来的问题是怎么分类，这里介绍最近邻分类，它是一种最简单的分类方法。 基本思想：最近邻分类，顾名思义，距邻居最近，则与邻居同类。也就是说，一个待分类的单个样本A，放入已分好类的多个样本群Q中，从Q中选择k个A的邻居，通过计算A与邻
OpenCV（2）ML库->K-Nearest Neighbour分类器
Rana专栏
04-01 2548
KNN也是最邻近结点算法（k-Nearest Neighbor algorithm）的缩写形式，也可称为邻近算法。是电子信息分类器算法的一种。KNN方法对包容型数据的特征变量筛选尤其有效。最邻近结点算法采用向量空间模型来分类，概念为相同类别的案例，彼此的相似度高，而可以借由计算与已知类别案例之相似度，来评估未知类别案例可能的分类。 目标：分类未知类别案例。 输入：待分类未知类别案例项目。已知类
kNN(K-Nearest Neighbor)最邻近规则分类
runfeel
05-02 856
KNN最邻近规则，主要应用领域是对未知事物的识别，即判断未知事物属于哪一类，判断思想是，基于欧几里得定理，判断未知事物的特征和哪一类已知事物的的特征最接近； K最近邻(k-Nearest Neighbor，KNN)分类算法，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。该方法的思路是：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也...
（留存记录）近邻分类算法KNN
u014735409的专栏
04-20 589
K-近邻（K-Nearest Neighbors, KNN）是一种很好理解的分类算法，简单说来就是从训练样本中找出K个与其最相近的样本，然后看这K个样本中哪个类别的样本多，则待判定的值（或说抽样）就属于这个类别。 KNN算法的步骤 计算已知类别数据集中每个点与当前点的距离；选取与当前点距离最小的K个点；统计前K个点中每个类别的样本出现的频率；返回前K个点出现频率最高的类别作为当
opencv K临近算法（knearest)
Xiaoli_Coding
06-04 4290
理解 K 近邻原理 kNN 是最简单的监督学习分类器
k近邻分类器(KNN)
最新发布
07-29
K近邻分类器(KNN)是一种经典且简单的有监督学习方法。它是一种懒惰学习算法，没有显式的学习或训练过程。KNN算法在数据的分布只有很少或没有任何先验知识时，是一个不错的选择。在KNN算法中，当对测试样本进行预测时...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值