189 8069 5689

knn分类器java代码 knn是分类算法吗

KNN-分类算法

KNN,K-NearestNeighbor,即K个最近的邻居的意思。对于一个输入样本,用特征上最接近它的K个临近值大多数属于的标签来对它进行分类。KNN是最简单的机器学习算法之一,可以用于分类和回归,是一种监督学习算法。

创新互联专注于谢家集企业网站建设,成都响应式网站建设,成都做商城网站。谢家集网站建设公司,为谢家集等地区提供建站服务。全流程按需定制制作,专业设计,全程项目跟踪,创新互联专业和态度为您提供的服务

具体实现过程如下:

①准备数据,对数据进行预处理

在已经分好类的情况下,我们需要对没有分类的物品进行分类 。

②计算测试样本点(也就是待分类点)到其他每个样本点的距离。

其实就是计算(x1,y1)和(x2,y2)的距离。拓展到多维空间,则公式变成这样:

k值是KNN算法的一个参数,K的含义即参考”邻居“标签值的个数。

如果当K的取值过小时,一旦有噪声得成分存在们将会对预测产生比较大影响,例如取K值为1时,一旦最近的一个点是噪声,那么就会出现偏差,K值的减小就意味着整体模型变得复杂,容易发生过拟合;

如果K的值取的过大时,就相当于用较大邻域中的训练实例进行预测,学习的近似误差会增大。这时与输入目标点较远实例也会对预测起作用,使预测发生错误。K值的增大就意味着整体的模型变得简单;

如果K==N的时候,那么就是取全部的实例,即为取实例中某分类下最多的点,就对预测没有什么实际的意义了

在划分好数据集后,我们可以通过交叉验证法来得到最佳的K值

优点:

1.无数据输入假定,在分类完的情况下进行测试

2.预测精度高

3.对异常值不敏感

缺点:

1.时间复杂度和空间复杂度高,计算到每一个点的距离,计算量较大

2.当样本不平衡的时候,比如一个类的样本容量大,另一个类的样本容量很小,对于测试识别的样本来说,投票结果更容易靠近样本容量大的类,从而导致分类错误

KNN算法,结果报错,帮忙怎么改

knn算法(k-Nearest Neighbor algorithm).是一种经典的分类算法.

注意,不是聚类算法.所以这种分类算法必然包括了训练过程.

然而和一般性的分类算法不同,knn算法是一种 懒惰算法 .它并非

像其他的分类算法先通过训练建立分类模型.,而是一种被动的分类

过程.它是边测试边训练建立分类模型.

算法的一般描述过程如下:

1.首先计算每个测试样本点到其他每个点的距离.

这个距离可以是欧氏距离,余弦距离等.

KNN算法,k近邻

1' 然后直接看文档copy实例即可。 2,一般均分; 根据k值截取邻居里面前k个 for (var i in this。留一法就是每次只留下一个样本做测试集, k) { for (var i in this; var b = neighbor.i - this; 判断邻居里哪个样本类型多 if(types[',这里是把刚生成的数据结构里的对象传入,'.d.d - this.samples) { /;/ /,所以我们可以判断未知样本类型为红色三角形;/ var c = neighbor; rCount.a,我们这里采用欧式距离.neighbors[i];/ 把所有邻居按距离排序 this.log(err; } }.prototype; } else { this.sortByDistance = function() { this; sIdx++ ){ var sht = bk, e; //,如果k=3;.e - this.push( new Sample(this; var d = neighbor; }): 0 };data; 检验属性是否属于对象自身 if (object, this.random() - 0,诸如决策树归纳;],',有一个蓝色的三正方形。 k倍验证时定义了个方法先把数组打乱随机摆放; rIdx 有两种类别 1和-1 var types = { ',它被广泛应用于模式识别;: 0.push(sample); var j = neighbor; } /types['.type) continue,而训练我们识别的过程就对应于泛化这一概念; 猜测预测样本类型 this..type = '.f; 初始化未知样本的邻居 this.sqrt(a*a + b*b + c*c + d*d + e*e + f*f + g*g + h*h + i*i + j*j + k*k),'.measureDistances = function(a.k).f; 把传过来的对象上的属性克隆到新创建的样本上 for (var key in object) { //.open('。 3;/,最后猜测类型;/.j;/.determineUnknown = function() { for (var i in this.sortByDistance().type = ',cIdx),', '.e.samples; /.add = function(sample) { this;/,我们还是能认得出来它;/.measureDistances(this;/.samples[i];b' 最后分别计算10倍交叉验证和留一法交叉验证的精度;,生成一个新的样本, b。knn基于类比学习.column,不只是颜色这一个标签.g, this, this.h; types[neighbor; 生成邻居集 for (var j in this; 将邻居样本根据与预测样本间距离排序 Sample,贝叶斯分类等都是急切学习法的例子,当然也不能过度调教2333;.neighbors = [].samples = []; 判断被预测样本类别 Sample,过度调教它要把其他手机也认成iphone那就不好了;/,然后再来看上面的理论应该会明白很多;/ node;-1', cCount = sht。惰性学习法(lazy learner)正好与其相反;/,'e', d; for(var cIdx = 0,是不是某些同学想大喊一声.sheets[sIdx].prototype.count,调用未知样本原型上的方法来计算邻居到它的距离;)。最后是样本集的原型上定义一个方法; return; helper函数 将数组里的元素随机摆放 function ruffle(array) { array;/, rCount = sht,把所有邻居按距离排序.a;} var shtCount = bk,并对新的输入给出合理的判断.neighbors.samples[i].neighbors) { var neighbor = this,直到给定一个待接受分类的新元组之后.samples[j],使用truetype和type来预测样本类型和对比判断是否分类成功;k'/ 计算欧式距离 neighbor; }.distance - b, this,才开始根据训练元组构建分类模型;/ 将文件中的数据映射到样本的属性var map = [' } } } 再定义一个样本集的构造函数 /。可以用这个最简单的分类算法来入高大上的ML的门,我们选取距离其最近的k个几何图形源于数据挖掘的一个作业,学习后的模型已经就绪。这k个训练元祖就是待预测元组的k个最近邻.sort(function (a;],样本有1和-1两种类型, g.push(item); /.prototype。主要是因为我们在脑海像给这个苹果贴了很多标签一样。 / } 然后我们会在样本的原型上定义很多方法.k - this; 如果碰到未知样本 跳过 if ( ;, 这里用Node,'h' }) } 剩余测试代码好写.k),需要我们好好调教它; var k = neighbor;/ }).samples[i], j.k,多次被教后再看到的时候我们自己就能认出来这些事物了;/,其它样本做训练集,找出最接近未知元组的k个训练元组,'/.f - this; 计算所有邻居与预测样本的距离 this,所以称为急切学习法! this。 /.g;g'/.samples[i].b;,我们可以看到有两个红色的三角形.row; / SampleSet管理所有样本 参数k表示KNN中的kvar SampleSet = function(k) { this; } } 注意到我这里的数据有a-k共11个属性,训练集大的话会很慢; } } }.distance。缺点就是进行分类时要扫描所有训练样本得到距离; Sample表示一个样本 var Sample = function (object) { /,最后的平均测试结果可以衡量模型的性能.cell(rIdx, b) { return a.sort(function (a。本文的knn算法就是一种惰性学习法。 / for(var rIdx = 0.j - this,惰性学习法在分类进行时做更多的工作;,可能还有苹果的形状大小等等, c,包含未知类型样本 SampleSet。这些标签让我们看到苹果的时候不会误认为是橘子;/ for(var sIdx = 0.c;node-xlrd'.b, h; } data;1'.samples) { /,由于红色三角形所占比例高,这里的距离就是我们根据样本的特征所计算出来的数值, function(err。那么求距离其实不同情况适合不同的方法。取一份作为测试样本,在此之前只是存储着训练元组。这个过程重复K次; var a = neighbor, err! this.neighbors.message),这k个几何图形就是未知类型样本的邻居.count;.slice(0;i'.c - this; shtCount。 K倍交叉验证将所有样本分成K份;a'.prototype,',剩余K-1份作为训练样本;-1',这里的k即是knn中的k; cIdx++){ item[map[cIdx]] = sht; sIdx ,搜索模式空间,但蠢计算机就不知道怎么做了; }。 /,但却能在很多关键的地方发挥作用并且效果非常好.h - this,绿色的圆代表未知样本。 k-nearest-neighbor-classifier 还是先严谨的介绍下; var e = neighbor,这样每个样本都可以用这些方法.k = k; 读取文件 xls。所以特征就是提取对象的信息.samples[i];/ var g = neighbor; 如果发现没有类型的样本 if ( ,把数据解析后插入到自己的数据结构里;! 还是来通俗的解释下。综上所述knn分类的关键点就是k的选取和距离的计算.samples[i].b - this。扩展到一般情况时,将未知的新元组与训练元组进行对比; 等文件读取完毕后 执行测试 run().g - this.distance = Math; var h = neighbor.prototype,这里就不贴了. 总结 knn算法非常简单;/.5, this.d, this;d'.neighbors.speak Chinese,即可预测样本类型,并生成他们的邻居集; 然后定义一个构造函数Sample表示一个样本,这个红的是苹果等等。 /.xls', k)) { var neighbor = this; this, this.neighbors[i];1'j'.c; var i = neighbor;/ this; var f = neighbor.hasOwnProperty(key)) { this[key] = object[key].samples[j]) ),这是小鸭子。测试结果为用余弦距离等计算方式可能精度会更高, b) { return Math;c'。其实这些标签就对应于机器学习中的特征这一重要概念.guessType(this。 var data = [];/, i.e,bk){ if(err) {console。 balabala了这么多。小时候妈妈会指着各种各样的东西教我们,这对于我们人来说非常简单,泛化就是学习到隐含在这些特征背后的规律, this;;]){ this; } /.sheet; /。急切学习法(eager learner)是在接受待分类的新元组之前就构造了分类模型; rIdx++){ var item = {};/.name,再找出距离未知类型样本最近的K个样本.a - this.js用来读取xls文件的包 var xls = require('-1'.h; / / 将样本加入样本数组 SampleSet. 实现我的数据是一个xls文件。一台iphone戴了一个壳或者屏幕上有一道划痕,那么我去npm搜了一下选了一个叫node-xlrd的包直接拿来用,该方法可以在整个样本集里寻找未知类型的样本; 计算样本间距离 采用欧式距离 Sample; } } /.type) { / 构建总样本数组.guessType = function(k) { /,其实这就叫过度泛化,'f',那我们哼哧哼哧的看着应答着,', f,所以称为惰性学习法.trueType] += 1; cIdx ,会有点小小的成就感; cCount。我们可以看上图.js技术来实现一下这个机器学习中最简单的算法之一k-nearest-neighbor算法(k最近邻分类法),急着对未知的元组进行分类.count.i

java 分类器算法问题!!急。。。。

SVM主要通过训练集进行训练之后,用来进行数据分类(通常是二分类)。在对SVM进行训练之前你要确定输入的特征向量是什么,期望输出又是什么,对于你的系统很显然期望输出可以假定为:+1和-1,其中+1表示正面的,-1表示负面的,训练集就是那两张英文词列表,你可以用这两英文词列表来对SVM进行训练从而得到一个SVM模型,然后就可以用这个模型来对新的英文序列(中文词的英文翻译序列)进行“极性”分类了。其实分类器并不只有SVM,你还可以使用BP神经网络,AdaBoost等来实现数据分类。如果还有不明白的地方可以给我留言:blog.sina.com.cn/kwapoong

建议你在Matlab下进行试验,这样效率会快些。

分类模型fit有几个参数

机器学习主要用于解决分类、回归和聚类问题,分类属于监督学习算法,是指根据已有的数据和标签(分类的类别)进行学习,预测未知数据的标签。分类问题的目标是预测数据的类别标签(class label),可以把分类问题划分为二分类和多分类问题。二分类是指在两个类别中选择一个类别,在二分类问题中,其中一个类别称作正类(positive class),另一个类别称作负类(negative class),比如判断垃圾邮件。多分类问题是指从多个分类中选择一个类别。

一,分类的一般步骤

总体来说,数据分类是一个二阶段的过程,第一个阶段是学习阶段,用于训练分类模型,第二个阶段是预测阶段,使用模型预测新数据的类标签。此外,由于现实生活中的数据不是完美的,在开始训练模型之前,需要对数据进行预处理。在模型构建之后,还需要对模型进行评估和调参,选择最优的参数,达到最优的分类效果。

举个例子,下面的代码实现了一个最简单的knn分类器,没有对数据进行预处理,也没有对模型进行评估和调参。从代码中可以看出,knn分类模型是由两部分构成的:第一部分是拟合数据(fit),也就是训练模型,第二部分是预测数据(predict)。

使用Node.js如何实现K最近邻分类算法

源于数据挖掘的一个作业, 这里用Node.js技术来实现一下这个机器学习中最简单的算法之一k-nearest-neighbor算法(k最近邻分类法)。

k-nearest-neighbor-classifier

还是先严谨的介绍下。急切学习法(eager learner)是在接受待分类的新元组之前就构造了分类模型,学习后的模型已经就绪,急着对未知的元组进行分类,所以称为急切学习法,诸如决策树归纳,贝叶斯分类等都是急切学习法的例子。惰性学习法(lazy learner)正好与其相反,直到给定一个待接受分类的新元组之后,才开始根据训练元组构建分类模型,在此之前只是存储着训练元组,所以称为惰性学习法,惰性学习法在分类进行时做更多的工作。

本文的knn算法就是一种惰性学习法,它被广泛应用于模式识别。knn基于类比学习,将未知的新元组与训练元组进行对比,搜索模式空间,找出最接近未知元组的k个训练元组,这里的k即是knn中的k。这k个训练元祖就是待预测元组的k个最近邻。

balabala了这么多,是不是某些同学想大喊一声..speak Chinese! 还是来通俗的解释下,然后再来看上面的理论应该会明白很多。小时候妈妈会指着各种各样的东西教我们,这是小鸭子,这个红的是苹果等等,那我们哼哧哼哧的看着应答着,多次被教后再看到的时候我们自己就能认出来这些事物了。主要是因为我们在脑海像给这个苹果贴了很多标签一样,不只是颜色这一个标签,可能还有苹果的形状大小等等。这些标签让我们看到苹果的时候不会误认为是橘子。其实这些标签就对应于机器学习中的特征这一重要概念,而训练我们识别的过程就对应于泛化这一概念。一台iphone戴了一个壳或者屏幕上有一道划痕,我们还是能认得出来它,这对于我们人来说非常简单,但蠢计算机就不知道怎么做了,需要我们好好调教它,当然也不能过度调教2333,过度调教它要把其他手机也认成iphone那就不好了,其实这就叫过度泛化。

所以特征就是提取对象的信息,泛化就是学习到隐含在这些特征背后的规律,并对新的输入给出合理的判断。

我们可以看上图,绿色的圆代表未知样本,我们选取距离其最近的k个几何图形,这k个几何图形就是未知类型样本的邻居,如果k=3,我们可以看到有两个红色的三角形,有一个蓝色的三正方形,由于红色三角形所占比例高,所以我们可以判断未知样本类型为红色三角形。扩展到一般情况时,这里的距离就是我们根据样本的特征所计算出来的数值,再找出距离未知类型样本最近的K个样本,即可预测样本类型。那么求距离其实不同情况适合不同的方法,我们这里采用欧式距离。

综上所述knn分类的关键点就是k的选取和距离的计算。

2. 实现

我的数据是一个xls文件,那么我去npm搜了一下选了一个叫node-xlrd的包直接拿来用。

// node.js用来读取xls文件的包

var xls = require('node-xlrd');

然后直接看文档copy实例即可,把数据解析后插入到自己的数据结构里。

var data = [];// 将文件中的数据映射到样本的属性var map = ['a','b','c','d','e','f','g','h','i','j','k'];// 读取文件

xls.open('data.xls', function(err,bk){

if(err) {console.log(err.name, err.message); return;}

var shtCount = bk.sheet.count;

for(var sIdx = 0; sIdx shtCount; sIdx++ ){

var sht = bk.sheets[sIdx],

rCount = sht.row.count,

cCount = sht.column.count;

for(var rIdx = 0; rIdx rCount; rIdx++){

var item = {};

for(var cIdx = 0; cIdx cCount; cIdx++){

item[map[cIdx]] = sht.cell(rIdx,cIdx);

}

data.push(item);

}

}

// 等文件读取完毕后 执行测试

run();

});

然后定义一个构造函数Sample表示一个样本,这里是把刚生成的数据结构里的对象传入,生成一个新的样本。

// Sample表示一个样本

var Sample = function (object) {

// 把传过来的对象上的属性克隆到新创建的样本上

for (var key in object)

{

// 检验属性是否属于对象自身

if (object.hasOwnProperty(key)) {

this[key] = object[key];

}

}

}

再定义一个样本集的构造函数

// SampleSet管理所有样本 参数k表示KNN中的kvar SampleSet = function(k) {

this.samples = [];

this.k = k;

};

// 将样本加入样本数组

SampleSet.prototype.add = function(sample) {

this.samples.push(sample);

}

然后我们会在样本的原型上定义很多方法,这样每个样本都可以用这些方法。

// 计算样本间距离 采用欧式距离

Sample.prototype.measureDistances = function(a, b, c, d, e, f, g, h, i, j, k) {

for (var i in this.neighbors)

{

var neighbor = this.neighbors[i];

var a = neighbor.a - this.a;

var b = neighbor.b - this.b;

var c = neighbor.c - this.c;

var d = neighbor.d - this.d;

var e = neighbor.e - this.e;

var f = neighbor.f - this.f;

var g = neighbor.g - this.g;

var h = neighbor.h - this.h;

var i = neighbor.i - this.i;

var j = neighbor.j - this.j;

var k = neighbor.k - this.k;

// 计算欧式距离

neighbor.distance = Math.sqrt(a*a + b*b + c*c + d*d + e*e + f*f + g*g + h*h + i*i + j*j + k*k);

}

};

// 将邻居样本根据与预测样本间距离排序

Sample.prototype.sortByDistance = function() {

this.neighbors.sort(function (a, b) {

return a.distance - b.distance;

});

};

// 判断被预测样本类别

Sample.prototype.guessType = function(k) {

// 有两种类别 1和-1

var types = { '1': 0, '-1': 0 };

// 根据k值截取邻居里面前k个

for (var i in this.neighbors.slice(0, k))

{

var neighbor = this.neighbors[i];

types[neighbor.trueType] += 1;

}

// 判断邻居里哪个样本类型多

if(types['1']types['-1']){

this.type = '1';

} else {

this.type = '-1';

}

}

注意到我这里的数据有a-k共11个属性,样本有1和-1两种类型,使用truetype和type来预测样本类型和对比判断是否分类成功。

最后是样本集的原型上定义一个方法,该方法可以在整个样本集里寻找未知类型的样本,并生成他们的邻居集,调用未知样本原型上的方法来计算邻居到它的距离,把所有邻居按距离排序,最后猜测类型。

// 构建总样本数组,包含未知类型样本

SampleSet.prototype.determineUnknown = function() {

for (var i in this.samples)

{

// 如果发现没有类型的样本

if ( ! this.samples[i].type)

{

// 初始化未知样本的邻居

this.samples[i].neighbors = [];

// 生成邻居集

for (var j in this.samples)

{

// 如果碰到未知样本 跳过

if ( ! this.samples[j].type)

continue;

this.samples[i].neighbors.push( new Sample(this.samples[j]) );

}

// 计算所有邻居与预测样本的距离

this.samples[i].measureDistances(this.a, this.b, this.c, this.d, this.e, this.f, this.g, this.h, this.k);

// 把所有邻居按距离排序

this.samples[i].sortByDistance();

// 猜测预测样本类型

this.samples[i].guessType(this.k);

}

}

};

最后分别计算10倍交叉验证和留一法交叉验证的精度。

留一法就是每次只留下一个样本做测试集,其它样本做训练集。

K倍交叉验证将所有样本分成K份,一般均分。取一份作为测试样本,剩余K-1份作为训练样本。这个过程重复K次,最后的平均测试结果可以衡量模型的性能。

k倍验证时定义了个方法先把数组打乱随机摆放。

// helper函数 将数组里的元素随机摆放

function ruffle(array) {

array.sort(function (a, b) {

return Math.random() - 0.5;

})

}

剩余测试代码好写,这里就不贴了。

测试结果为

用余弦距离等计算方式可能精度会更高。

3. 总结

knn算法非常简单,但却能在很多关键的地方发挥作用并且效果非常好。缺点就是进行分类时要扫描所有训练样本得到距离,训练集大的话会很慢。

可以用这个最简单的分类算法来入高大上的ML的门,会有点小小的成就感。


分享文章:knn分类器java代码 knn是分类算法吗
网址分享:http://cdxtjz.cn/article/dodgiii.html

其他资讯