精华内容
下载资源
问答
  •  本工程采用模型方法为朴素贝叶斯分类算法,它核心算法思想基于概率论。我们称之为“朴素”,是因为整个形式化过程只做最原始、最简单假设。朴素贝叶斯是贝叶斯决策理论一部分,所以讲述朴素贝叶斯之前有...
  • 常用分类算法总结

    万次阅读 2015-08-30 09:13:56
    分类任务就是明确对象属于哪个预定义的目标类。其中预定义的目标类是离散时为分类,连续时为回归。 常用的分类算法有决策树分类法,基于规则的分类算法,...下面主要介绍各个算法的应用场景和一些优缺点 (1)决策树

    分类任务就是明确对象属于哪个预定义的目标类。其中预定义的目标类是离散时为分类,连续时为回归。

    常用的分类算法有决策树分类法,基于规则的分类算法,神经网络,支持向量机和朴素贝叶斯分类法。

    下面主要介绍各个算法的一些特点

    (一)决策树

    (1)决策树归纳是一种构建分类模型的非参数方法。换句话说,它不要求任何先验假设,不假定类和其他的属性服从一定的概率分布。

    (2)找到最佳的决策树是NP问题。许多决策苏算法采取启发式的方法指导对假设空间的搜索。

    (3)即使训练集很大,构建决策树的代价也较小。

    (4)决策树相对容易解释。

    (5)决策树算法对于噪声的干扰具有相当好的鲁棒性。

    (7)冗余属性不会对决策树的准确率造成不利的影响。

    (8)由于大多数的决策树算法都采用自顶向下的递归划分方法,因此沿着树向下,记录会越来越小。在叶节点,记录可能更少,对于叶节点代表的类,不能做出具有统计意义的判决,产生所谓的数据碎片。

    (9)子树可能在决策树中重复多次,使得决策树过于复杂,并且更难解释。

    (二)基于规则的分类算法

    (1)规则集的表达能力几乎等价于决策树,因为决策树可以用互斥和穷觉的规则集表示。基于规则的分类器和决策树分类器都对属性空间进行直线划分,并将类指派到每个划分。

    (2)基于规则的分类器通常用来产生更易于解释的描述性模型,而模型的性能却可与决策树分类器相媲美。

    (3)被很多基于规则的分类器(如RIPPER)所采用的基于类的规则排序方法非常适用于处理类分布不均衡的数据集。

    (三)最近邻分类器

    (1)最近邻分类器是一种基于实例的学习技术,它使用具体的训练实例进行预测,而不必维护源自数据的抽象。

    (2)最近邻分类器是一种消极学习方法,它不需要建立模型,然而测试样例的开销很大,因为需要逐个计算测试样例和训练样例之间的相似度。相反,积极学习方法通过花费大量计算资源来建立模型,模型一旦建立,分类测试样例就会非常快。

    (3)最近邻分类器对噪声非常敏感。因为,最近邻分类器基于局部信息进行预测,而决策树和基于规则的分类器则是在拟合在整个输入空间上的全局模型。

    (4)最近邻分类器的可以生成任意形状的决策边界,这样的决策边界与决策树和基于规则的分类器通常局限的直线决策边界相比,能够提供更加灵活的模型表示。

    (5)除非采用适当的邻近性度量和数据预处理,否则最近邻分类可能做出错误的预测。

    (四)朴素贝叶斯分类器

    (1)面对孤立的噪声点,朴素贝叶斯分类器是健壮的。因为在从数据中估计条件概率时,这些点被平均。通过在建模和分类时忽略样例,朴素贝叶斯分类器也可以处理属性值遗漏问题。

    (2)面对无关属性,该分类器是健壮的。

    (3)相关属性可能会降低朴素贝叶斯分类器的性能。

    (五)贝叶斯信念网络(BBN)

    (1)BBN提供了一种用图形模型来捕获特定领域的先验知识的方法。

    (2)构造网络可能既费时又费力,然而,一旦网络结构确定下来,添加新变量就十分容易。

    (3)贝叶斯网络很适合处理不完整的数据。对有属性遗漏的实例可以通过对该属性的所有可能取值的概率求和或求积分来加以处理。

    (4)因为数据和先验知识以概率的方式结合起来了,所以该方法对模型的过分拟合问题是非常鲁棒的。

    (六)人工网络

    (1)至少含有一个隐藏层的多层神经网络是一种普适近似,即可以用来近似任何目标函数。

    (2)ANN可以处理冗余特征,因为权值在训练过程中自动学习。

    (3)神经网络对训练数据中的噪声非常敏感。

    (4)ANN权值学习使用的梯度下降方法经常会收敛到局部极小值。避免局部极小值的方法是在权值更新公式中加上一个动量项。

    (5)训练ANN是一个很耗时的过程,特别是当隐藏结点数量很大时。然而,测试样例分类时非常快

    (七)支持向量机的特征(SVM)

    (1)SVM学习问题可以表示为凸优化问题,因此可以利用已知的有效算法发现目标函数的全局最小值。而其他的分类方法都采用一种基于贪心学习的策略来搜索假设空间,这种方法一般只能获得局部最优解。

    (2)SVM通过最大化决策边界边缘来控制模型能力。

    (3)通过对数据中每个分类属性引入一个哑变量,SVM可以应用于分类数据。


    参考:数据挖掘导论



    展开全文
  • K近邻分类算法

    千次阅读 2018-09-19 15:59:25
    K最近邻(k-Nearest Neighbor,KNN)分类算法,是一个理论上比较成熟方法,也是最简单机器学习算法之一。该方法思路是:如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个...

    K最近邻(k-Nearest Neighbor,KNN)分类算法,是一个理论上比较成熟的方法,也是最简单的机器学习算法之一。该方法的思路是:如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。
    下面以比较著名的鸾尾花(Iris)数据集举例,讲解K近邻算法
    首先我们先导入数据

    from sklearn.datasets import load_iris
    iris = load_iris()
    print(iris.data.shape)
    print(iris.data)
    

    在这里插入图片描述
    可以看到Iris数据集共有150朵鸾尾花的样本,因为没有测试数据,所以我们随机采用其中75%的数据作为训练数据,采用剩余的25%的数据作为测试数据
    下面对Iris数据集进行分割

    from sklearn.cross_validation import train_test_split
    X_train,X_test,Y_train,Y_test = train_test_split(iris.data,iris.target,test_size=0.25,random_state=33)
    

    分割完成后,到了训练部分,这里我们使用K近邻分类器对鸾尾花的数据进行类别预测

    from sklearn.preprocessing import StandardScaler
    from sklearn.neighbors import KNeighborsClassifier
    
    ss = StandardScaler()
    X_train = ss.fit_transform(X_train)
    X_test = ss.transform(X_test)
    
    knc = KNeighborsClassifier()
    knc.fit(X_train,Y_train)
    Y_predict = knc.predict(X_test)
    

    将预测结果存在Y_predict中
    在这里插入图片描述
    最后我们使用模型自带的评估函数对K近邻分类器在鸾尾花数据上的预测性能进行评估


    可以看到,K近邻分类器对38条鸾尾花测试样本的准确性约为89.47%,平均精确率、召回率以及F1指标分别为0.92、0.89、0.90.

    K近邻算法模型没有参数训练过程,也就是说,该模型并没有通过任何学习算法分析训练数据,而是只是根据测试样本在训练数据的分布直接做出分类决策。因此,K近邻属于无参数模型中非常简单的一种。

    展开全文
  • K邻近(k-Nearest Neighbor,KNN)分类算法是最简单机器学习算法了。它采用测量不同特征值之间距离方法进行分类。它思想很简单:计算一个点A与其他所有点之间距离,取出与该点最近k个点,然后统计这k个点...

    K邻近(k-Nearest Neighbor,KNN)分类算法是最简单的机器学习算法了。它采用测量不同特征值之间的距离方法进行分类。它的思想很简单:计算一个点A与其他所有点之间的距离,取出与该点最近的k个点,然后统计这k个点里面所属分类比例最大的,则点A属于该分类。

    下面用一个例子来说明一下:

    电影名称

    打斗次数

    接吻次数

    电影类型

    California Man

    3

    104

    Romance

    He’s Not Really into Dudes

    2

    100

    Romance

    Beautiful Woman

    1

    81

    Romance

    Kevin Longblade

    101

    10

    Action

    Robo Slayer 3000

    99

    5

    Action

    Amped II

    98

    2

    Action

    简单说一下这个数据的意思:这里用打斗次数和接吻次数来界定电影类型,如上,接吻多的是Romance类型的,而打斗多的是动作电影。还有一部名字未知(这里名字未知是为了防止能从名字中猜出电影类型),打斗次数为18次,接吻次数为90次的电影,它到底属于哪种类型的电影呢?

    KNN算法要做的,就是先用打斗次数和接吻次数作为电影的坐标,然后计算其他六部电影与未知电影之间的距离,取得前K个距离最近的电影,然后统计这k个距离最近的电影里,属于哪种类型的电影最多,比如Action最多,则说明未知的这部电影属于动作片类型。

    在实际使用中,有几个问题是值得注意的:K值的选取,选多大合适呢?计算两者间距离,用哪种距离会更好呢?计算量太大怎么办?假设样本中,类型分布非常不均,比如Action的电影有200部,但是Romance的电影只有20部,这样计算起来,即使不是Action的电影,也会因为Action的样本太多,导致k个最近邻居里有不少Action的电影,这样该怎么办呢?

    没有万能的算法,只有在一定使用环境中最优的算法。

    1.1 算法指导思想

    kNN算法的指导思想是“近朱者赤,近墨者黑”,由你的邻居来推断出你的类别。

    先计算待分类样本与已知类别的训练样本之间的距离,找到距离与待分类样本数据最近的k个邻居;再根据这些邻居所属的类别来判断待分类样本数据的类别。

    1.2相似性度量

    用空间内两个点的距离来度量。距离越大,表示两个点越不相似。距离的选择有很多[13],通常用比较简单的欧式距离。

    欧式距离:

    c5c42b71a40a8ba87621321236db0b15.png

    马氏距离:马氏距离能够缓解由于属性的线性组合带来的距离失真,是数据的协方差矩阵。

    55321ea219a66f389e59a652c41942c9.png

    曼哈顿距离:

    90f9ac07aafe75dce49db42cd628ad7f.png

    切比雪夫距离:

    1efeab412e65189df5e1a7f1776bef8f.png

    闵氏距离:r取值为2时:曼哈顿距离;r取值为1时:欧式距离。

    7b7f8add3a9b517b15b3b1dbc398e7a5.png

    平均距离:

    e644562b97aa08ebe346d41de6d1fafb.png

    弦距离:

    1d8c5234051737b52d9836b68e0950c3.png

    测地距离:

    25f74d036cb02b1656b51762e898f15b.png

    1.2 类别的判定

    投票决定:少数服从多数,近邻中哪个类别的点最多就分为该类。

    加权投票法:根据距离的远近,对近邻的投票进行加权,距离越近则权重越大(权重为距离平方的倒数)

    优缺点

    1.2.1              优点

    简单,易于理解,易于实现,无需估计参数,无需训练;

    适合对稀有事件进行分类;

    特别适合于多分类问题(multi-modal,对象具有多个类别标签), kNN比SVM的表现要好。

    懒惰算法,对测试样本分类时的计算量大,内存开销大,评分慢;

    当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数;

    可解释性较差,无法给出决策树那样的规则。

    1.2.2              缺点

    1.3 常见问题

    1.3.1              k值的设定

    k值选择过小,得到的近邻数过少,会降低分类精度,同时也会放大噪声数据的干扰;而如果k值选择过大,并且待分类样本属于训练集中包含数据数较少的类,那么在选择k个近邻的时候,实际上并不相似的数据亦被包含进来,造成噪声增加而导致分类效果的降低。

    如何选取恰当的K值也成为KNN的研究热点。k值通常是采用交叉检验来确定(以k=1为基准)。

    经验规则:k一般低于训练样本数的平方根。

    1.3.2              类别的判定方式

    投票法没有考虑近邻的距离的远近,距离更近的近邻也许更应该决定最终的分类,所以加权投票法更恰当一些。

    1.3.3              距离度量方式的选择

    高维度对距离衡量的影响:众所周知当变量数越多,欧式距离的区分能力就越差。

    变量值域对距离的影响:值域越大的变量常常会在距离计算中占据主导作用,因此应先对变量进行标准化。

    1.3.4              训练样本的参考原则

    学者们对于训练样本的选择进行研究,以达到减少计算的目的,这些算法大致可分为两类。第一类,减少训练集的大小。KNN算法存储的样本数据,这些样本数据包含了大量冗余数据,这些冗余的数据增了存储的开销和计算代价。缩小训练样本的方法有:在原有的样本中删掉一部分与分类相关不大的样本样本,将剩下的样本作为新的训练样本;或在原来的训练样本集中选取一些代表样本作为新的训练样本;或通过聚类,将聚类所产生的中心点作为新的训练样本。

    在训练集中,有些样本可能是更值得依赖的。可以给不同的样本施加不同的权重,加强依赖样本的权重,降低不可信赖样本的影响。

    1.3.5              性能问题

    kNN是一种懒惰算法,而懒惰的后果:构造模型很简单,但在对测试样本分类地的系统开销大,因为要扫描全部训练样本并计算距离。

    已经有一些方法提高计算的效率,例如压缩训练样本量等。

    1.4 算法流程

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

    选用合适的数据结构存储训练数据和测试元组

    设定参数,如k

    维护一个大小为k的的按距离由大到小的优先级队列,用于存储最近邻训练元组。随机从训练元组中选取k个元组作为初始的最近邻元组,分别计算测试元组到这k个元组的距离,将训练元组标号和距离存入优先级队列

    遍历训练元组集,计算当前训练元组与测试元组的距离,将所得距离L 与优先级队列中的最大距离Lmax

    进行比较。若L>=Lmax,则舍弃该元组,遍历下一个元组。若L < Lmax,删除优先级队列中最大距离的元

    组,将当前训练元组存入优先级队列。

    遍历完毕,计算优先级队列中k 个元组的多数类,并将其作为测试元组的类别。

    9.测试元组集测试完毕后计算误差率,继续设定不同的k 值重新进行训练,最后取误差率最小的k 值。

    Java代码实现

    public classKNN {/*** 设置优先级队列的比较函数,距离越大,优先级越高*/

    private Comparator comparator =new Comparator(){public intcompare(KNNNode o1, KNNNode o2) {if (o1.getDistance() >=o2.getDistance())return -1;else

    return 1;

    }

    };/*** 获取K个不同的随机数

    *@paramk 随机数的个数

    *@parammax 随机数最大的范围

    *@return生成的随机数数组*/

    public List getRandKNum(int k, intmax) {

    List rand = new ArrayList(k);for (int i = 0; i < k; i++) {int temp = (int) (Math.random() *max);if (!rand.contains(temp))

    rand.add(temp);elsei--;

    }returnrand;

    }

    /*计算测试元组与训练元组之前的距离*@param d1 测试元组*@param d2 训练元组* @return距离值*/

    public double calDistance(List d1, Listd2) {double distance = 0.00;for (int i = 0; i < d1.size(); i++)

    distance+= (d1.get(i) - d2.get(i)) *(d1.get(i)-d2.get(i));returndistance;

    }/*** 执行KNN算法,获取测试元组的类别

    *@paramdatas 训练数据集

    *@paramtestData 测试元组

    *@paramk 设定的K值

    *@return测试元组的类别*/

    public String knn(List> datas, List testData, intk) {

    PriorityQueue pq = new PriorityQueue(k,comparator);

    List randNum =getRandKNum(k, datas.size());for (int i = 0; i < k; i++) {int index =randNum.get(i);

    List currData =datas.get(index);

    String c= currData.get(currData.size() - 1).toString();

    KNNNode node= newKNNNode(index, calDistance(testData, currData), c);

    pq.add(node);

    }for (int i = 0; i < datas.size(); i++) {

    List t =datas.get(i);double distance =calDistance(testData, t);

    KNNNode top=pq.peek();if (top.getDistance() >distance) {

    pq.remove();

    pq.add(new KNNNode(i, distance, t.get(t.size() - 1). toString()));

    }

    }return getMostClass(pq);

    }

    /*** 获取所得到的k个最近邻元组的多数类

    *@parampq 存储k个最近近邻元组的优先级队列

    *@return多数类的名称*/

    private String getMostClass(PriorityQueuepq) {

    Map classCount=new HashMap();int pqsize =pq.size();for (int i = 0; i < pqsize; i++) {

    KNNNode node=pq.remove();

    String c=node.getC();if(classCount.containsKey(c))

    classCount.put(c, classCount.get(c)+ 1);elseclassCount.put(c,1);

    }int maxIndex = -1;int maxCount = 0;

    Object[] classes=classCount.keySet().toArray();for (int i = 0; i < classes.length; i++) {if (classCount.get(classes[i]) >maxCount)

    maxIndex= i; maxCount =classCount.get(classes[i]);

    }returnclasses[maxIndex].toString();

    }

    }

    展开全文
  • KNN邻近分类算法

    2016-06-23 17:53:00
    K邻近(k-Nearest Neighbor,KNN)分类算法是最简单机器学习算法了。它采用测量不同特征值之间距离方法进行分类。它思想很简单:计算一个点A与其他所有点之间距离,取出与该点最近k个点,然后统计这k个点...

    K邻近(k-Nearest Neighbor,KNN)分类算法是最简单的机器学习算法了。它采用测量不同特征值之间的距离方法进行分类。它的思想很简单:计算一个点A与其他所有点之间的距离,取出与该点最近的k个点,然后统计这k个点里面所属分类比例最大的,则点A属于该分类。

    下面用一个例子来说明一下:

     

    电影名称

    打斗次数

    接吻次数

    电影类型

    California Man

    3

    104

    Romance

    He’s Not Really into Dudes

    2

    100

    Romance

    Beautiful Woman

    1

    81

    Romance

    Kevin Longblade

    101

    10

    Action

    Robo Slayer 3000

    99

    5

    Action

    Amped II

    98

    2

    Action

    简单说一下这个数据的意思:这里用打斗次数和接吻次数来界定电影类型,如上,接吻多的是Romance类型的,而打斗多的是动作电影。还有一部名字未知(这里名字未知是为了防止能从名字中猜出电影类型),打斗次数为18次,接吻次数为90次的电影,它到底属于哪种类型的电影呢?

    KNN算法要做的,就是先用打斗次数和接吻次数作为电影的坐标,然后计算其他六部电影与未知电影之间的距离,取得前K个距离最近的电影,然后统计这k个距离最近的电影里,属于哪种类型的电影最多,比如Action最多,则说明未知的这部电影属于动作片类型。

    在实际使用中,有几个问题是值得注意的:K值的选取,选多大合适呢?计算两者间距离,用哪种距离会更好呢?计算量太大怎么办?假设样本中,类型分布非常不均,比如Action的电影有200部,但是Romance的电影只有20部,这样计算起来,即使不是Action的电影,也会因为Action的样本太多,导致k个最近邻居里有不少Action的电影,这样该怎么办呢?

    没有万能的算法,只有在一定使用环境中最优的算法。

    1.1 算法指导思想

    kNN算法的指导思想是“近朱者赤,近墨者黑”,由你的邻居来推断出你的类别。

    先计算待分类样本与已知类别的训练样本之间的距离,找到距离与待分类样本数据最近的k个邻居;再根据这些邻居所属的类别来判断待分类样本数据的类别。

     

    1.2相似性度量

    用空间内两个点的距离来度量。距离越大,表示两个点越不相似。距离的选择有很多[13],通常用比较简单的欧式距离。

    欧式距离

     

    马氏距离:马氏距离能够缓解由于属性的线性组合带来的距离失真,是数据的协方差矩阵。

     

    曼哈顿距离

     

    切比雪夫距离

     

    闵氏距离:r取值为2时:曼哈顿距离;r取值为1时:欧式距离。

     

     

    平均距离

     

    弦距离

     

    测地距离

     

     

    1.2 类别的判定

    投票决定:少数服从多数,近邻中哪个类别的点最多就分为该类。

    加权投票法:根据距离的远近,对近邻的投票进行加权,距离越近则权重越大(权重为距离平方的倒数)

     优缺点

    1.2.1              优点

    1. 简单,易于理解,易于实现,无需估计参数,无需训练;
    2. 适合对稀有事件进行分类;
    3. 特别适合于多分类问题(multi-modal,对象具有多个类别标签), kNN比SVM的表现要好。
    4. 懒惰算法,对测试样本分类时的计算量大,内存开销大,评分慢;
    5. 当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数;
    6. 可解释性较差,无法给出决策树那样的规则。

    1.2.2              缺点

    1.3 常见问题

    1.3.1              k值的设定

    k值选择过小,得到的近邻数过少,会降低分类精度,同时也会放大噪声数据的干扰;而如果k值选择过大,并且待分类样本属于训练集中包含数据数较少的类,那么在选择k个近邻的时候,实际上并不相似的数据亦被包含进来,造成噪声增加而导致分类效果的降低。

    如何选取恰当的K值也成为KNN的研究热点。k值通常是采用交叉检验来确定(以k=1为基准)。

    经验规则:k一般低于训练样本数的平方根。

    1.3.2              类别的判定方式

    投票法没有考虑近邻的距离的远近,距离更近的近邻也许更应该决定最终的分类,所以加权投票法更恰当一些。

    1.3.3              距离度量方式的选择

    高维度对距离衡量的影响:众所周知当变量数越多,欧式距离的区分能力就越差。

    变量值域对距离的影响:值域越大的变量常常会在距离计算中占据主导作用,因此应先对变量进行标准化。

    1.3.4              训练样本的参考原则

    学者们对于训练样本的选择进行研究,以达到减少计算的目的,这些算法大致可分为两类。第一类,减少训练集的大小。KNN算法存储的样本数据,这些样本数据包含了大量冗余数据,这些冗余的数据增了存储的开销和计算代价。缩小训练样本的方法有:在原有的样本中删掉一部分与分类相关不大的样本样本,将剩下的样本作为新的训练样本;或在原来的训练样本集中选取一些代表样本作为新的训练样本;或通过聚类,将聚类所产生的中心点作为新的训练样本。

    在训练集中,有些样本可能是更值得依赖的。可以给不同的样本施加不同的权重,加强依赖样本的权重,降低不可信赖样本的影响。

    1.3.5              性能问题

    kNN是一种懒惰算法,而懒惰的后果:构造模型很简单,但在对测试样本分类地的系统开销大,因为要扫描全部训练样本并计算距离。

    已经有一些方法提高计算的效率,例如压缩训练样本量等。

    1.4 算法流程

    1. 准备数据,对数据进行预处理
    2. 选用合适的数据结构存储训练数据和测试元组
    3. 设定参数,如k
    4. 维护一个大小为k的的按距离由大到小的优先级队列,用于存储最近邻训练元组。随机从训练元组中选取k个元组作为初始的最近邻元组,分别计算测试元组到这k个元组的距离,将训练元组标号和距离存入优先级队列
    5. 遍历训练元组集,计算当前训练元组与测试元组的距离,将所得距离L 与优先级队列中的最大距离Lmax
    6. 进行比较。若L>=Lmax,则舍弃该元组,遍历下一个元组。若L < Lmax,删除优先级队列中最大距离的元
    7. 组,将当前训练元组存入优先级队列。
    8. 遍历完毕,计算优先级队列中k 个元组的多数类,并将其作为测试元组的类别。

          9.测试元组集测试完毕后计算误差率,继续设定不同的k 值重新进行训练,最后取误差率最小的k 值。

    Java代码实现

    public class KNN {
        /**
         * 设置优先级队列的比较函数,距离越大,优先级越高
         */
        private Comparator<KNNNode> comparator =new Comparator<KNNNode>(){
            public int compare(KNNNode o1, KNNNode o2) {
                if (o1.getDistance() >= o2.getDistance())
                    return -1;
                else
                    return 1;
            }
        };
        /**
         * 获取K个不同的随机数
         * @param k 随机数的个数
         * @param max 随机数最大的范围
         * @return 生成的随机数数组
         */
        public List<Integer> getRandKNum(int k, int max) {
            List<Integer> rand = new ArrayList<Integer>(k);
            for (int i = 0; i < k; i++) {
                int temp = (int) (Math.random() * max);
                if (!rand.contains(temp))
                    rand.add(temp);
                else
                    i--;
            }
            return rand;
        }
     /* 计算测试元组与训练元组之前的距离
         * @param d1 测试元组
         * @param d2 训练元组
         * @return 距离值
         */
        public double calDistance(List<Double> d1, List<Double> d2) {
            double distance = 0.00;
            for (int i = 0; i < d1.size(); i++)
                distance += (d1.get(i) - d2.get(i)) *(d1.get(i)-d2.get(i));
            return distance;
        }
        
        /**
         * 执行KNN算法,获取测试元组的类别
         * @param datas 训练数据集
         * @param testData 测试元组
         * @param k 设定的K值
         * @return 测试元组的类别
         */
        public String knn(List<List<Double>> datas, List<Double> testData,             int k) {
            PriorityQueue<KNNNode> pq = new PriorityQueue<KNNNode>                                                     (k,comparator);
            List<Integer> randNum = getRandKNum(k, datas.size());
            for (int i = 0; i < k; i++) {
                int index = randNum.get(i);
                List<Double> currData = datas.get(index);
                String c = currData.get(currData.size() - 1).toString();
                KNNNode node = new KNNNode(index, calDistance(testData,                                         currData), c);
                pq.add(node);
            }
            for (int i = 0; i < datas.size(); i++) {
                List<Double> t = datas.get(i);
                double distance = calDistance(testData, t);
                KNNNode top = pq.peek();
                if (top.getDistance() > distance) {
                    pq.remove();
                    pq.add(new KNNNode(i, distance, t.get(t.size() - 1).                                     toString()));
                }
            }
            return getMostClass(pq);
    }

     

    /**
         * 获取所得到的k个最近邻元组的多数类
         * @param pq 存储k个最近近邻元组的优先级队列
         * @return 多数类的名称
         */
        private String getMostClass(PriorityQueue<KNNNode> pq) {
            Map<String, Integer> classCount=new HashMap<String,Integer>();
            int pqsize = pq.size();
            for (int i = 0; i < pqsize; i++) {
                KNNNode node = pq.remove();
                String c = node.getC();
                if (classCount.containsKey(c))
                    classCount.put(c, classCount.get(c) + 1);
                else
                    classCount.put(c, 1);
            }
            int maxIndex = -1;
            int maxCount = 0;
            Object[] classes = classCount.keySet().toArray(); 
            for (int i = 0; i < classes.length; i++) { 
                if (classCount.get(classes[i]) > maxCount)
                    maxIndex = i; maxCount = classCount.get(classes[i]);
            } 
            return classes[maxIndex].toString();
        }
    }

     

     

     

    转载于:https://www.cnblogs.com/sumuncle/p/5611705.html

    展开全文
  • 最近邻分类算法.ppt

    2019-12-16 08:54:34
    K最近邻分类(KNN) 数据挖掘算法 K最近邻分类KNN 该方法思路是如果一个样本在特征空间中k个最相近(即特征空间中最邻近)样本中大多数属于某一个类别则该样本也属于这个类别即近朱者赤近墨者黑由你邻居来推断...
  • 【Python】分类算法KNN

    2020-04-24 15:28:26
    思想很简单:如果一个样本在特征空间中k个最近邻(最相似)样本中大多数都属于某一个类别,则该样本也属于这个类别。第一个字母k可以小写,表示外部定义近邻数量。这句话不难理解,但有点拗口,下面通过...
  • 常见分类算法应用范围/数据要求

    千次阅读 2019-10-28 19:58:08
    是的,下面有几个其他算法的具体介绍 单一的分类算法:决策树、贝叶斯、人工神经网络、K-近邻、支持向量机和基于关联规则的分类,HMM 组合分类算法:Bagging和Boosting k-近邻(kNN,k-Nearest Neighbors)算法 找出...
  • 判断最后一部电影是什么类型,通过计算6部电影与未知电影距离,从而判断未知电影属于哪一种类型。 可以看到第二部电影和未知电影距离最近,而第二部电影是爱情片,所以未知电影也是爱情片。 2.KNN定义 3. ...
  • 最邻近分类算法,故名思意就是在距离空间里,如果一个样本最接近k个邻居里绝大多数属于某个类别,则该样本也属于这个类别。 下面我们分别举两个例子实现,分别是电影分类(两个特征,便于之间通过散点图观察)和...
  • 综述 1.1 Cover和Hart在1968年提出了最初邻近算法 1.2 分类(classification)算法 1.3 输入基于实例学习(instance-based learning), 懒惰学习(lazy ...下面这个简易模型预测未知电影属于什么类型? 3. 算法详...
  • k近邻分类算法(kNN)

    千次阅读 2014-01-13 21:39:55
    如上图所示,最中间圆点,如果是3NN,则属于红色三角形,如果是5NN,则属于蓝色正方形。这就是kNN最基本思想。但是,kNN对于每一个待分类的点,都需要和全部...在下面,我们将通过一段python代码来演示kNN算法
  • KNN的算法过程是是这样: 从上图中我们可以看到,图中数据集是良好数据,即都打好了label,一类是蓝色正方形,一类是红色三角形,那个绿色圆形是我们待分类的数据。 如果K=3,那么离绿色点最近有2个...
  • KNN算法的实现

    2019-10-06 02:59:18
    思路是:如果一个样本在特征空间中k个最相似(即特征空间中最邻近)样本中大多数属于某一个类别,则该样本也属于这个类别,其中K通常是不大于20整数。KNN算法中,所选择邻居都是已经正确分类的对象。该...
  • 邻近算法,或者说是K最邻近算法,是一个相对简单分类算法,其基本工作原理为: 首先我们存在一个训练集,训练集中每个图片都存在标签(已知图片属于哪一类).对于我们输入没有标签数据,我们将新数据中每个...
  • knn算法( k nearest neighbor也叫K临近算法)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻,就是k个最近的邻居的意思,说的是每个样本都可以用它最接近的k个邻居来代表。 经典案例 有两类不同的样本...
  • 算法介绍网上很多,我也是参考网上描述,下面有一个python实现简单knn算法大体描述: 事先有样本数据,每个数据都有标签,然后拿一个未知样本,让程序判断它属于什么标签类别。 基本思想就是: 根据未知样本...
  • GBDT算法

    2018-07-04 16:41:00
    GBDT通过多轮迭代,每轮迭代产生一个弱分类器,其中弱分类器通常选择为CART树,每个分类器在上一轮分类残差基础上进行训练。 对于GBDT算法,其中重要知识点为: 1、GBDT是梯度下降法从参数空间上升到函数空间...
  • 核心思想非常简单,给定一个训练数据,对于新输入实例,在训练数据集中赵傲与该实例最邻近额度k个实例,这k个实例最多数属于某个类,就把输入实例分成这个类。k近邻模型实际上是对特徵空间划分,模型三...
  • 由于下半年要准备工作了,也知道排序算法的重要性(据说是面试必问的知识点),所以又花了点时间重新研究了一下。  排序大的分类可以分为两种:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序...
  • 上次介绍了分类算法K近邻,其属于预测分类一种,那么这次我们就学习一下数据挖掘算法中关联算法Apriori,其最原始应用就是挖掘交易数据中商品之间关联,最经典就是“尿布和啤酒”案例,当然在当今这个...
  • 上次大概地介绍了一下现在常用推荐算法下面来介绍两种比较优化的算法。 Apriori算法 关联规则挖掘发现大量数据中项集之间有趣关联或相关联系。它在数据挖掘中是一个重要课题,最近几年已被业界所广泛...
  • 可以这么说,算法在数据挖掘中做出了极大贡献,如果我们要了解数据挖掘话就不得不了解这些算法下面我们就继续给大家介绍一下有关数据挖掘的算法知识。 1.The Apriori algorithm, Apriori算法是一种最有影响...
  • KNN 概述: Knn(k-nearestNeighbor)算法是一种基本的...该算法的核心意思即是:一个样本在数据集中于其他的K个样本相似,而其他的样本属于一类,那么这个样本也属于这个类别。 下面我们用实例分析一下:   ...
  • 上次介绍了分类算法K近邻,其属于预测分类一种,那么这次我们就学习一下数据挖掘算法中关联算法Apriori,其最原始应用就是挖掘交易数据中商品之间关联,最经典就是“尿布和啤酒”案例,当然在当今这个...
  • 下面排序都是属于内排序。内排序有可以分为以下几类:(1)、插入排序:直接插入排序、二分法插入排序、希尔排序。(2)、选择排序:简单选择排序、堆排序。(3)、交换排序:冒泡排序、快速排序。(4)、归并排序(5)、...
  • 邻近算法,或者说是K最邻近算法,是一个相对简单分类算法,其基本工作原理为: 首先我们存在一个训练集,训练集中每个图片都存在标签(已知图片属于哪一类).对于我们输入没有标签数据,我们将新数据中每...
  • 排序算法,从大的分类可以分为两种:内排序和外排序。在排序过程中,全部记录存放在内存,则称为内排序。如果排序过程中需要使用外存,则称为外排序。下面排序都是属于内排序。内排序有可以分为以下几类: 插入...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 330
精华内容 132
关键字:

下面属于分类算法的是