KNN算法例子（java,scala,python 代码实现）

最新推荐文章于 2023-06-08 16:02:37 发布
最新推荐文章于 2023-06-08 16:02:37 发布
阅读量1.8k 收藏 6
点赞数
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h348592532/article/details/78805833
版权

java 版本

package com.fullshare.test;

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

/**
 * @author huangjiangnan
 * @email huangjiangnanjava@163.com
 * @version 1.0
 * @since 2017年12月14日 上午10:27:35 类说明
 */
public class Knn {

	public static void main(String[] args) {
		// 电影名称 搞笑镜头 拥抱镜头 打斗镜头 电影类型
		Object[][] sample = { 
				{ 1, "宝贝当家", 45, 2, 9, "喜剧片" },
				{ 2, "美人鱼", 21, 17, 5, "喜剧片" },
				{ 3, "澳门风云3", 54, 9, 11, "喜剧片" }, 
				{ 4, "功夫熊猫3", 39, 0, 31, "喜剧片" }, 
				{ 5, "谍影重重", 5, 2, 57, "动作片" },
				{ 6, "叶问3", 3, 2, 65, "动作片" }, 
				{ 7, "伦敦陷落", 2, 3, 55, "动作片" }, 
				{ 8, "我的特工爷爷", 6, 4, 21, "动作片" }, 
				{ 9, "奔爱", 7, 46, 4, "爱情片" }, 
				{ 10, "夜孔雀", 9, 39, 8, "爱情片" },
				{ 11, "代理情人", 9, 38, 2, "爱情片" }, 
				{ 12, "新步步惊心", 8, 34, 17, "爱情片" }, };
		// 求唐人街办案类型
		Object[] movie = { 13, "唐人街探案", 23, 3, 17, null };
		int length = sample.length;
		System.out.println("序号 名称        距离");
		List<MovieDis> movieDisList = new ArrayList<>();

		for (int i = 0; i < length; i++) {
			Object[] mv = sample[i];
			double distances = getDistance(mv, movie);
			MovieDis movieDis = new MovieDis((int) mv[0], (String) mv[1], distances, (String) mv[5]);
			// Object[] disInfo={};
			System.out.println(String.format("%s %s %s", mv[0], mv[1], distances));
			movieDisList.add(movieDis);
		}

		Collections.sort(movieDisList, new Comparator<MovieDis>() {

			@Override
			public int compare(MovieDis o1, MovieDis o2) {
				double sub = (o1.getDistance() - o2.getDistance());
				if (sub == 0) {
					return 0;
				}
				if (sub > 0) {
					return 1;
				}
				return -1;
			}
		});
		
		int k=5;
		System.out.println("按照欧式距离排序，取k=5");
		movieDisList=movieDisList.subList(0,k);
		for (MovieDis movieDis : movieDisList) {
			System.out.println(movieDis);
		}

	}

	public static double getDistance(Object[] movie1, Object[] movie2) {
		double[] ps1 = { (Integer) movie1[2], (Integer) movie1[3], (Integer) movie1[4] };
		double[] ps2 = { (Integer) movie2[2], (Integer) movie2[3], (Integer) movie2[4] };
		return getDistance(ps1, ps2);
	}

	public static double getDistance(double[] ps1, double[] ps2) {
		if (ps1.length != ps1.length) {
			throw new RuntimeException("属性数量不对应");
		}
		int length = ps1.length;
		double total = 0;
		for (int i = 0; i < length; i++) {
			double sub = ps1[i] - ps2[i];
			total = total + (sub * sub);
		}
		return Math.sqrt(total);
	}

}

class MovieDis {
	private int id;
	private String title;
	private double distance;
	private String type;

	public int getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getTitle() {
		return title;
	}

	public void setTitle(String title) {
		this.title = title;
	}

	public double getDistance() {
		return distance;
	}

	public void setDistance(double distance) {
		this.distance = distance;
	}

	public MovieDis(int id, String title, double distance, String type) {
		super();
		this.id = id;
		this.title = title;
		this.distance = distance;
		this.type = type;
	}


	@Override
	public String toString() {
		return "MovieDis [id=" + id + ", title=" + title + ", distance=" + distance + ", type=" + type + "]";
	}

	public String getType() {
		return type;
	}

	public void setType(String type) {
		this.type = type;
	}

}
scala版本 

package com.test.api

class KnnScala {

}

object KnnScala {
  def main(args: Array[String]): Unit = {
    var sample: Array[Array[Any]] = Array(
      Array(1, "宝贝当家", 45, 2, 9, "喜剧片"),
      Array(2, "美人鱼", 21, 17, 5, "喜剧片"),
      Array(3, "澳门风云3", 54, 9, 11, "喜剧片"),
      Array(4, "功夫熊猫3", 39, 0, 31, "喜剧片"),
      Array(5, "谍影重重", 5, 2, 57, "动作片"),
      Array(6, "叶问3", 3, 2, 65, "动作片"),
      Array(7, "伦敦陷落", 2, 3, 55, "动作片"),
      Array(8, "我的特工爷爷", 6, 4, 21, "动作片"),
      Array(9, "奔爱", 7, 46, 4, "爱情片"),
      Array(10, "夜孔雀", 9, 39, 8, "爱情片"),
      Array(11, "代理情人", 9, 38, 2, "爱情片"),
      Array(12, "新步步惊心", 8, 34, 17, "爱情片"))
    // 求唐人街办案类型
    var movie = Array(13, "唐人街探案", 23, 3, 17, null);
    var length = sample.length - 1;
    println("序号 名称        距离");
    var movieDisList = List[MovieDis]();

    for (i <- 0 to length) {
      var mv: Array[Any] = sample(i);
      var distances: Double = getDistance(mv, movie);
      var movieDis = new MovieDis(mv(0).asInstanceOf[Int], mv(1).asInstanceOf[String], distances, mv(5).asInstanceOf[String]);
      println(printf("%s %s %s", mv(0), mv(1), distances));
      //列表添加跟java不一样，坑
      movieDisList = (movieDisList.+:(movieDis))
    }
    movieDisList = movieDisList.sortWith((o1: MovieDis, o2: MovieDis) => (o1.distance < o2.distance));

    var k: Int = 5;
    println("按照欧式距离排序，取k=5");
    movieDisList = movieDisList take 5;
    movieDisList.foreach { o => println(o) }
  }

  def getDistance(movie1: Array[Any], movie2: Array[Any]): Double = {
    var ps1 = Array(movie1(2).asInstanceOf[Integer].doubleValue(), movie1(3).asInstanceOf[Integer].doubleValue(), movie1(4).asInstanceOf[Integer].doubleValue());
    var ps2 = Array(movie2(2).asInstanceOf[Integer].doubleValue(), movie2(3).asInstanceOf[Integer].doubleValue(), movie2(4).asInstanceOf[Integer].doubleValue());
    return getDistance(ps1, ps2);
  }

  def getDistance(ps1: Array[Double], ps2: Array[Double]): Double = {
    if (ps1.length != ps1.length) {
      throw new RuntimeException("属性数量不对应");
    }
    var length = ps1.length - 1;
    var total: Double = 0;
    for (i <- 0 to length) {
      var sub = ps1(i) - ps2(i);
      total = total + (sub * sub);
    }
    
    return Math.sqrt(total);
  }

}

class MovieDis extends Serializable {
  var id: Int = 0;
  var title: String = null;
  var distance: Double = 0;
  var movieType: String = null;

  def this(_id: Int, _title: String, _distance: Double, _movieType: String) {
    this();
    this.id = _id;
    this.title = _title;
    this.distance = _distance;
    this.movieType = _movieType;
  }

  override def toString(): String = {
    return "MovieDis [id=" + id + ", title=" + title + ", distance=" + distance + ", movieType=" + movieType + "]";
  }

}


python版本 

#!/usr/bin/env python3
# -*- coding: UTF-8 -*-
# 给多个变量赋值
import math

class MovieDis :
    # 序号
    id = 0
    # 电影标题
    title = ""
    # 差距
    distance = 0.0
    # 电影类型
    movieType = ""

    def __init__(self, id ,title,distance,movieType):
        self.id=id
        self.title=title
        self.distance=distance
        self.movieType=movieType


    def __str__(self):
        return "MovieDis [id=%s, title=%s, distance=%s, movieType=%s]" % (self.id,self.title,self.distance,self.movieType)


def get_distance(ps1,ps2):
    if len(ps1) != len(ps2):
        raise Exception("数组长度不匹配")
    ll = len(ps1)
    total=0
    for i in range(0,ll):
        sub = ps1[i] - ps2[i]
        total = total + (sub * sub)
    return math.sqrt(total)




sample = ((1, "宝贝当家", 45, 2, 9, "喜剧片"),
      (2, "美人鱼", 21, 17, 5, "喜剧片"),
      (3, "澳门风云3", 54, 9, 11, "喜剧片"),
      (4, "功夫熊猫3", 39, 0, 31, "喜剧片"),
      (5, "谍影重重", 5, 2, 57, "动作片"),
      (6, "叶问3", 3, 2, 65, "动作片"),
      (7, "伦敦陷落", 2, 3, 55, "动作片"),
      (8, "我的特工爷爷", 6, 4, 21, "动作片"),
      (9, "奔爱", 7, 46, 4, "爱情片"),
      (10, "夜孔雀", 9, 39, 8, "爱情片"),
      (11, "代理情人", 9, 38, 2, "爱情片"),
      (12, "新步步惊心", 8, 34, 17, "爱情片"))

movie = (13, "唐人街探案", 23, 3, 17, "")


length = len(sample) - 1
print("序号 名称        距离")
movieDisList = []

for i in range(0,length):
    mv= sample[i]
    start=mv[2:5]
    end= movie[2:5]
    distances = get_distance(start, end)
    print("%s %s %s" % (mv[0],mv[1],distances))
    movieDis = MovieDis(mv[0], mv[1], distances, mv[5])
    movieDisList.append(movieDis)
movieDisList.sort(key=lambda x:x.distance)
for i in range(0,5):
    print(movieDisList[i])
结果如下

利用Python实现kNN算法的代码
09-18
kNN（K-Nearest Neighbors）算法是...在Python中实现kNN算法时，可以结合Scikit-learn库，它提供了现成的KNeighborsClassifier类，简化了kNN的实现过程。不过，理解算法的基本原理并能手动实现有助于深入学习机器学习。
K-近邻算法（k-NN）的原理及python代码案例实现
A496608119的博客
02-28 2208
1 K-NN算法的原理 1.1 K-NN概念 K Nearest Neighbor算法⼜叫KNN算法， 这个算法是机器学习⾥⾯⼀个⽐较经典的算法， 总体来说KNN算法是相对⽐ 较容易理解的算法。 定义： 如果⼀个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某⼀个类别， 则该样本也属于这 个类别。（起源：KNN最早是由Cover和Hart提出的一种分类算法）；俗话就是：根据“邻居”来推断出你的类别。 1.2 基本流程 1)计算已知类别数据集中...
KNN(最邻近值算法) scala实现
壮哥哥
03-26 2089
最邻近值算法实现 工程目录结构 代码 训练模型 package com.knn.model /** * 训练数据模型 * * @param aA 数据a * @param bA 数据b * @param typeA 类型 */ class KNNModel(aA:Double,bA:Double,typeA:String) { var a:Do...
最简单的分类算法之一：KNN（原理解析+代码实现）
热门推荐
KI的博客
07-12 13万+
KNN（K- Nearest Neighbor），即K最邻近算法，是数据挖掘分类技术中最简单的方法之一。简单来说，它是根据“邻近”这一特征来对样本进行分类。
Java实现KNN
最新发布
Zhang_ing的博客
06-08 819
在特征空间中统计k个距离最近的样本的标签，选择最多的标签最为自己的标签。可以采用多种距离计算策略，如曼哈顿距离、欧氏距离。KNN是非参且惰性的。优点：实现简单、训练快（惰性）、效果好、对异常值不敏感缺点：时空复杂度都高、需要合适的归一化等。
kNN算法实现和延申项目，练习笔记
weixin_45191675的博客
07-27 193
实战步骤： 1.定义问题（这里理解为输入数据） 2.数据理解（描述性或可视化） 3.数据准备（预处理数据） 4.评估算法 5.优化模型（这里没用到） 6.使用算法 kNN算法实现要点： 1.输入数据集，特征和分类标签即groups和labels 2.计算测试集和数据集中各个点的距离 3.按照递增次序排序 4.选取前k个点 5.确定前K个点的最多的类别，利用字典 6.将出现的最多的类别定为最终的类别 以下是对电影的类别进行分类，特征分别是打斗次数和亲吻次数 import numpy as np import
KNN算法Python实现代码.zip
04-03
以上就是关于KNN算法及其Python实现的基本介绍，通过这个压缩包中的"02KNN"文件，你可以进一步了解具体的代码实现细节和实践应用。在实际项目中，结合具体问题调整和优化KNN算法，可以有效地解决分类问题。
Python代码实现KNN算法
09-20
### Python代码实现KNN算法详解 #### 一、KNN算法简介 KNN（K-Nearest Neighbors）算法是一种基于实例的学习方法，主要用于分类任务，也可以用于回归问题。KNN算法的基本思想非常简单直观：对于给定的测试数据点，...
python实现KNN算法
07-25
2. `Knn.py`：这是实现KNN算法的Python代码文件。可能包括了数据预处理、距离计算、邻居搜索、类别投票等功能。KNN的核心部分是找到K个最近的邻居，然后根据这些邻居的类别进行预测。在Python中，可以使用numpy库...
【机器学习】K近邻算法（K-NearestNeighbors , KNN）详解 + Java代码实现
知不足而奋进，望远山而前行
01-09 2万+
邻近算法，或者说K最邻近（KNN，K-NearestNeighbors）分类算法是分类方法中最简单的方法之一。所谓K最近邻，就是K个最近的邻居的意思，说的是每个样本都可以用它最接近的K个邻近值来代表。近邻算法就是将数据集合中每一个记录进行分类的方法。KNN 最初由 Cover 和 Hart 于1968年提出，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。
《KNN算法Java实现》KNN算法demo
03-30
KNN算法详解，查看我的博客关于KNN算法的浅析，博客连接：https://blog.csdn.net/wang_xiaogui/article/details/61413594............
KNN实现代码
02-27
KNN实现代码
邻近分类算法---KNN（Java实现+公式计算例子）
whiteBearClimb的博客
02-18 3875
名词解释： KNN：K-Nearest-Neighbor K值最邻近 所以网上有好几种叫法：最近邻，邻近…其实都是指的KNN，其实按照翻译都对。KNN算法产生于1968年，是数据挖掘和数据分类技术中最简单的入门级算法。 按照字面意思，就是计算出距离K值最近的邻居数据，设对应数据为X，然后把待分类数据归类为X。 原理 基于大量不同维度的训练数据，做循环比较分析，具体经历下面四步流程： ①准备数据，对数据进行预处理 。 ②计算测试样本点（也就是待分类点）到其他每个样本点的距离 。 ③对每个距离进行排序，然后选择
《机器学习实战（Scala实现）》（二）——k-邻近算法
03-18 6372
算法流程1.计算中的set中每一个点与Xt的距离。 2.按距离增序排。 3.选择距离最小的前k个点。 4.确定前k个点所在的label的出现频率。 5.返回频率最高的label作为测试的结果。实现python# -*- coding: utf-8 -*- ''' Created on 2017年3月18日@author: soso ''' from numpy import * impo
Spark学习笔记-KNN算法实现
PURSUE ONE PIECE
09-04 1万+
原理可以参见：数据挖掘笔记-分类-KNN-1
spark-knn的简易实现
qq_14950717的博客
02-06 2418
spark-knn，spark是一个很优秀的分布式计算框架，本文实现的knn是基于欧几里得距离公式实现的，下面开始起简单的实现，可能有多问题希望大家能够给指出来。 Logger.getLogger("org.apache.spark").setLevel(Level.WARN) Logger.getLogger("org.eclipse.jetty.server").setLevel(
基于KNN的相关内容推荐
CxCo的专栏
12-02 1722
如果做网站的内容运营，相关内容推荐可以帮助用户更快地寻找和发现感兴趣的信息，从而提升网站内容浏览的流畅性，进而提升网站的价值转化。相关内容推荐最常见的两块就是“关联推荐”和“相关内容推荐”，关联推荐就是我们常说的购物篮分析，即使用购买了某商品的用户同时购买了什么这个规则来发现商品间的潜在联系，之前有相关的文章介绍——向上营销、交叉营销与关联推荐；关联推荐是基于用户行为分析的推荐，而相关内容推荐是基
大数据机器学习之KNN（k近邻）算法Spark mllib实现案例
xiaohu21的博客
11-01 2243
大数据机器学习之KNN（k近邻）算法Spark mllib实现案例 背景 在大数据场景下，spark框架提供了支持分类，聚合，协同过滤，回归四大类场景的mllib模块 本文讲述的knn刚好是spark mllib不支持，但可以自行实现的算法。 案例 数据 标注的训练数据 label,f1,f2,f3,f4,f5 0,10,20,30,40,30 0,12,22,29,42,35 0,11,21,31,40,34 0,13,22,30,42,32 0,12,22,32,41,33 0,10,21,
knn(k-NearestNeighbor) with scala
oochen_98的博客
11-02 652
knn
Python实现KNN算法详解及代码实现
"python实现KNN分类算法" KNN（K-Nearest Neighbor）分类算法是一种基于实例的学习方法，其基本思想是通过查找与未知类别样本最接近的k个已知类别的样本（即k个邻居），然后根据这k个邻居的类别信息来决定未知样本...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值