knn 订阅
邻近算法,或者说K最近邻(KNN,K-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻,就是K个最近的邻居的意思,说的是每个样本都可以用它最接近的K个邻近值来代表。近邻算法就是将数据集合中每一个记录进行分类的方法 [1]  。 展开全文
邻近算法,或者说K最近邻(KNN,K-NearestNeighbor)分类算法是数据挖掘分类技术中最简单的方法之一。所谓K最近邻,就是K个最近的邻居的意思,说的是每个样本都可以用它最接近的K个邻近值来代表。近邻算法就是将数据集合中每一个记录进行分类的方法 [1]  。
信息
范    畴
数据挖掘分类技术
外文名
k-NearestNeighbor
简    称
kNN算法
含    义
每个样本都可以用它最接近的k个邻近值来代表
用    途
用于分类,对未知事物的识别
中文名
k最邻近分类算法
邻近算法简介
KNN(K- Nearest Neighbor)法即K最邻近法,最初由 Cover和Hart于1968年提出,是一个理论上比较成熟的方法,也是最简单的机器学习算法之一。该方法的思路非常简单直观:如果一个样本在特征空间中的K个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别 [2]  。该方法的不足之处是计算量较大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最邻近点。目前常用的解决方法是事先对已知样本点进行剪辑,事先去除对分类作用不大的样本。另外还有一种 Reverse KNN法,它能降低KNN算法的计算复杂度,提高分类的效率 [2]  。KNN算法比较适用于样本容量比较大的类域的自动分类,而那些样本容量较小的类域采用这种算法比较容易产生误分 [2]  。
收起全文
精华内容
下载资源
问答
  • KNN

    千次阅读 2019-03-03 21:29:47
    KNN KNN:K-Nearest Neighbor 数据挖掘算法中最简单的一种 工作原理 示例:我们根据电影的打斗次数、接吻次数等指标来统计电影的类型。 分类:我们将打斗次数作为X轴,接吻次数作为Y轴,放在二维坐标轴上...

    KNN

    KNN:K-Nearest Neighbor
    数据挖掘算法中最简单的一种

    工作原理

    示例:我们根据电影的打斗次数、接吻次数等指标来统计电影的类型。

    分类:我们将打斗次数作为X轴,接吻次数作为Y轴,放在二维坐标轴上标记,对未知的电影分类我们看它在坐标轴的位置附近的电影类型。

    1. 计算待分类物体与其他物体之间的距离;
    2. 统计距离最近的K个邻居;
    3. 对于K个最近的邻居,它们属于哪个分类最多,待分类物体就属于哪一类。

    KNN可以应用到 线性非线性 问题中,也可以用于回归分析。

    K值的选择

    K值的选择对于分类十分重要。

    欠拟合: 与训练集误差较大,原因的特征维度过少,导致拟合的函数无法满足训练集,误差较大。

    **过拟合: **与训练集误差较小,原因的特征维度过多,导致拟合的函数完美的经过训练集,对新测结果交叉。

    鲁棒性: 也称为是强壮性、或者稳健性。

    • K值过小:相当于未分类的物体与它的邻居非常接近才行,产生一个问题如果邻居是个噪声点,那么未分类物体的分类会产生误差,那么KNN分类就会产生过拟合
    • K值过大:相当于距离过远的点也会对未知物体的分类产生影响,虽然这种情况 的好处是 鲁棒性 强,但是不足也很明显,会产生 欠拟合 情况,也就是没有把未分类的物体真正分类出来。

    距离的计算

    两个样本之间的距离代表了这两个样本之间的相似度。距离越大,差异性越大;距离越小,差异性越大。

    距离计算的方式有以下五种:

    1. 欧氏距离;
    2. 曼哈顿距离;
    3. 闵可夫斯基距离;
    4. 切比雪夫距离;
    5. 余弦距离。

    前三种距离是KNN常用的距离。

    欧氏距离

    最常用的距离公式,也叫做欧几里得距离,在二维空间中,两点的欧氏距离就是。

    d = ( x 1 − y 1 ) 2 + ( x 2 − y 2 ) 2 d = \sqrt{(x_1 - y_1)^2 + (x_2 - y_2)^2} d=(x1y1)2+(x2y2)2

    n维空间中的距离: d = ( x 1 − y 1 ) 2 + ( x 2 − y 2 ) 2 + … + ( x n − y n ) 2 = ∑ k = 1 n ( x i − y i ) 2 d = \sqrt{(x_1 - y_1)^2 + (x_2 - y_2)^2 + … + (x_n - y_n)^2} = \sqrt{\sum\limits_{k=1}^n(x_i-y_i)^2} d=(x1y1)2+(x2y2)2++(xnyn)2 =k=1n(xiyi)2

    曼哈顿距离

    在几何空间用的较多,等于在两个点在坐标轴上绝对轴距综合。

    d = ∣ x 1 − y 1 ∣ + ∣ x 2 − y 2 ∣ d = |x_1 - y_1| + |x_2 - y_2| d=x1y1+x2y2

    闵可夫斯基距离

    不是一个距离,而是一组距离的定义。对于n维空间的两个点x(x1,x2,..,xn),x和y两点之间的距离。

    d = p ∑ i = 1 n ∣ x i − y i ∣ p d = p\sqrt{\sum\limits_{i=1}^n|x_i - y_i|^p} d=pi=1nxiyip

    其中p代表空间的维数,当p=1时,就是曼哈顿距离;当p=2时,就是欧氏距离;当p=∞时,就是切比雪夫距离。

    切比雪夫距离

    两个点之间的切比雪夫距离就是两个点坐标数值的绝对值得最大值。

    m a x ( ∣ x 1 − y 1 ∣ , ∣ x 2 − y 2 ∣ ) max(|x_1 - y_1|, |x_2 - y_2|) max(x1y1,x2y2)

    余弦距离

    实际上计算的是两个向量的夹角,是在方向上计算两者之间的差异,对绝对值不敏感。

    在兴趣相关性上,角度关系比距离关系的绝对值更重要,因此余弦距离可以用于衡量用户对内容兴趣的区分度。

    **搜索关键词推荐:**比如我们用搜索引擎搜索某个关键词,它还会给你推荐其他的相关搜多,这些推荐搜索的关键词就是采用余弦距离计算得到的。

    KD树

    是一个二叉树的数据结构,方便存储K维空间的数据。

    KNN的计算过程是大量计算样本点之间的距离,为了减少计算距离次数,提升KNN的搜索效率,提出KD树。

    KD树: 对数据点在K维空间中划分的一种数据结构。在KD树构造中,每个节点都是K维数值点的二叉树。可以采用二叉树的增删查改操作,提升了搜索效率。

    用KNN做回归

    KNN不仅可以做分类,还可以做回归。

    分类: 对未知电影根据打斗次数来进行类型划分。

    回归: 根据打斗次数来获取电影属于那种类型。

    对于一个新的点,我们找到改点K个最相近的点,然后将这些点的属性平均值赋值给改点,就得到了改点的属性。

    展开全文
  • knn

    千次阅读 2016-06-15 15:26:17
    KNN算法 看到的一个很简单的例子,用knn算法来实现分类,引用sklearn 很简单就实现 import numpy as np from sklearn import neighbors knn = neighbors.KNeighborsClassifier() #取得knn分类器 data = np....
    
    
    KNN算法

    看到的一个很简单的例子,用knn算法来实现分类,引用 sklearn 很简单就实现
    import numpy as np
    from sklearn import neighbors
    knn = neighbors.KNeighborsClassifier() #取得knn分类器
    data = np.array([[3,104],[2,100],[1,81],[101,10],[99,5],[98,2]]) # data对应着打斗次数和接吻次数
    labels = np.array([1,1,1,2,2,2]) #labels则是对应Romance和Action
    knn.fit(data,labels) #导入数据进行训练'''
    knn.predict([18,90])
    from numpy import *
    import operator


    然而中间过程细节都被隐藏了,发现一个写内部过程的代码,和模式识别课上一样
    # create a dataset which contains 4 samples with 2 classes
    def createDataSet():
    # create a matrix: each row as a sample
    group = array([[3,104],[2,100],[1,81],[101,10],[99,5],[98,2]])
    labels = ['A', 'A','A', 'B', 'B', 'B'] # four samples and two classes
    return group, labels
    
    # classify using kNN
    def kNNClassify(newInput, dataSet, labels, k):
    numSamples = dataSet.shape[0] # shape[0] stands for the num of row
    
    ## step 1: calculate Euclidean distance
    # tile(A, reps): Construct an array by repeating A reps times
    # the following copy numSamples rows for dataSet
    diff = tile(newInput, (numSamples, 1)) - dataSet # Subtract element-wise
    squaredDiff = diff ** 2 # squared for the subtract
    squaredDist = sum(squaredDiff, axis = 1) # sum is performed by row
    distance = squaredDist ** 0.5
    
    ## step 2: sort the distance
    # argsort() returns the indices that would sort an array in a ascending order
    sortedDistIndices = argsort(distance)
    
    classCount = {} # define a dictionary (can be append element)
    for i in xrange(k):
    ## step 3: choose the min k distance
    voteLabel = labels[sortedDistIndices[i]]
    
    ## step 4: count the times labels occur
    # when the key voteLabel is not in dictionary classCount, get()
    # will return 0
    classCount[voteLabel] = classCount.get(voteLabel, 0) + 1
    
    ## step 5: the max voted class will return
    maxCount = 0
    for key, value in classCount.items():
    if value > maxCount:
    maxCount = value
    maxIndex = key
    
    return maxIndex
    dataSet, labels = createDataSet()
    
    testX = array([18, 90])
    k = 3
    outputLabel = kNNClassify(testX, dataSet, labels, 3)
    print "Your input is:", testX, "and classified to class: ", outputLabel


    用的是同样的参数
    这个语言不错
    展开全文
  • 机器学习之KNN最邻近分类算法

    万次阅读 多人点赞 2018-09-15 13:13:33
    KNN算法简介 KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。 KNN最邻近分类算法的...

    前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到教程

    KNN算法简介

    KNN(K-Nearest Neighbor)最邻近分类算法是数据挖掘分类(classification)技术中最简单的算法之一,其指导思想是”近朱者赤,近墨者黑“,即由你的邻居来推断出你的类别。

    KNN最邻近分类算法的实现原理:为了判断未知样本的类别,以所有已知类别的样本作为参照,计算未知样本与所有已知样本的距离,从中选取与未知样本距离最近的K个已知样本,根据少数服从多数的投票法则(majority-voting),将未知样本与K个最邻近样本中所属类别占比较多的归为一类。

              以上就是KNN算法在分类任务中的基本原理,实际上K这个字母的含义就是要选取的最邻近样本实例的个数,在 scikit-learn 中 KNN算法的 K 值是通过 n_neighbors 参数来调节的,默认值是 5。

              如下图所示,如何判断绿色圆应该属于哪一类,是属于红色三角形还是属于蓝色四方形?如果K=3,由于红色三角形所占比例为2/3,绿色圆将被判定为属于红色三角形那个类,如果K=5,由于蓝色四方形比例为3/5,因此绿色圆将被判定为属于蓝色四方形类。

    由于KNN最邻近分类算法在分类决策时只依据最邻近的一个或者几个样本的类别来决定待分类样本所属的类别,而不是靠判别类域的方法来确定所属类别的,因此对于类域的交叉或重叠较多的待分样本集来说,KNN方法较其他方法更为适合。

               KNN算法的关键:

               (1) 样本的所有特征都要做可比较的量化

               若是样本特征中存在非数值的类型,必须采取手段将其量化为数值。例如样本特征中包含颜色,可通过将颜色转换为灰度值来实现距离计算。

               (2) 样本特征要做归一化处理

               样本有多个参数,每一个参数都有自己的定义域和取值范围,他们对距离计算的影响不一样,如取值较大的影响力会盖过取值较小的参数。所以样本参数必须做一些 scale 处理,最简单的方式就是所有特征的数值都采取归一化处置。

               (3) 需要一个距离函数以计算两个样本之间的距离

               通常使用的距离函数有:欧氏距离、余弦距离、汉明距离、曼哈顿距离等,一般选欧氏距离作为距离度量,但是这是只适用于连续变量。在文本分类这种非连续变量情况下,汉明距离可以用来作为度量。通常情况下,如果运用一些特殊的算法来计算度量的话,K近邻分类精度可显著提高,如运用大边缘最近邻法或者近邻成分分析法。

    以计算二维空间中的A(x1,y1)、B(x2,y2)两点之间的距离为例,欧氏距离和曼哈顿距离的计算方法如下图所示:

    (4) 确定K的值

               K值选的太大易引起欠拟合,太小容易过拟合,需交叉验证确定K值。

    KNN算法的优点:

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

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

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

    KNN算法的缺点:

               KNN算法在分类时有个主要的不足是,当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数,如下图所示。该算法只计算最近的邻居样本,某一类的样本数量很大,那么或者这类样本并不接近目标样本,或者这类样本很靠近目标样本。无论怎样,数量并不能影响运行结果。可以采用权值的方法(和该样本距离小的邻居权值大)来改进。

    该方法的另一个不足之处是计算量较大,因为对每一个待分类的文本都要计算它到全体已知样本的距离,才能求得它的K个最近邻点。

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

    KNN算法实现

    要自己动手实现KNN算法其实不难,主要有以下三个步骤:

               算距离:给定待分类样本,计算它与已分类样本中的每个样本的距离;

               找邻居:圈定与待分类样本距离最近的K个已分类样本,作为待分类样本的近邻;

               做分类:根据这K个近邻中的大部分样本所属的类别来决定待分类样本该属于哪个分类;

    以下是使用Python实现KNN算法的简单示例:

    import math
    import csv
    import operator
    import random
    import numpy as np
    from sklearn.datasets import make_blobs
    
    #Python version 3.6.5
    
    # 生成样本数据集 samples(样本数量) features(特征向量的维度) centers(类别个数)
    def createDataSet(samples=100, features=2, centers=2):
        return make_blobs(n_samples=samples, n_features=features, centers=centers, cluster_std=1.0, random_state=8)
    
    # 加载鸢尾花卉数据集 filename(数据集文件存放路径)
    def loadIrisDataset(filename):
        with open(filename, 'rt') as csvfile:
            lines = csv.reader(csvfile)
            dataset = list(lines)
            for x in range(len(dataset)):
                for y in range(4):
                    dataset[x][y] = float(dataset[x][y])
            return dataset
        
    # 拆分数据集 dataset(要拆分的数据集) split(训练集所占比例) trainingSet(训练集) testSet(测试集)
    def splitDataSet(dataSet, split, trainingSet=[], testSet=[]):
        for x in range(len(dataSet)):
            if random.random() <= split:
                trainingSet.append(dataSet[x])
            else:
                testSet.append(dataSet[x])
    # 计算欧氏距离 
    def euclideanDistance(instance1, instance2, length):
        distance = 0
        for x in range(length):
            distance += pow((instance1[x] - instance2[x]), 2)
        return math.sqrt(distance)
    
    # 选取距离最近的K个实例
    def getNeighbors(trainingSet, testInstance, k):
        distances = []
        length = len(testInstance) - 1
        for x in range(len(trainingSet)):
            dist = euclideanDistance(testInstance, trainingSet[x], length)
            distances.append((trainingSet[x], dist))
        distances.sort(key=operator.itemgetter(1))
        
        neighbors = []
        for x in range(k):
            neighbors.append(distances[x][0])
        return neighbors
    
    #  获取距离最近的K个实例中占比例较大的分类
    def getResponse(neighbors):
        classVotes = {}
        for x in range(len(neighbors)):
            response = neighbors[x][-1]
            if response in classVotes:
                classVotes[response] += 1
            else:
                classVotes[response] = 1
        sortedVotes = sorted(classVotes.items(), key=operator.itemgetter(1), reverse=True)
        return sortedVotes[0][0]
    
    # 计算准确率
    def getAccuracy(testSet, predictions):
        correct = 0
        for x in range(len(testSet)):
            if testSet[x][-1] == predictions[x]:
                correct += 1
        return (correct / float(len(testSet))) * 100.0
    
    
    def main():
        # 使用自定义创建的数据集进行分类
        # x,y = createDataSet(features=2)
        # dataSet= np.c_[x,y]
        
        # 使用鸢尾花卉数据集进行分类
        dataSet = loadIrisDataset(r'C:\DevTolls\eclipse-pureh2b\python\DeepLearning\KNN\iris_dataset.txt')
            
        print(dataSet)
        trainingSet = []
        testSet = []
        splitDataSet(dataSet, 0.75, trainingSet, testSet)
        print('Train set:' + repr(len(trainingSet)))
        print('Test set:' + repr(len(testSet)))
        predictions = []
        k = 7
        for x in range(len(testSet)):
            neighbors = getNeighbors(trainingSet, testSet[x], k)
            result = getResponse(neighbors)
            predictions.append(result)
            print('>predicted=' + repr(result) + ',actual=' + repr(testSet[x][-1]))
        accuracy = getAccuracy(testSet, predictions)
        print('Accuracy: ' + repr(accuracy) + '%')
    main()
        
    

    尾花卉数据文件百度网盘下载链接:https://pan.baidu.com/s/10vI5p_QuM7esc-jkar2zdQ 密码:4und

    KNN算法应用

    使用KNN算法处理简单分类任务

    在scikit-learn中,内置了若干个玩具数据集(Toy Datasets),还有一些API让我们可以自己动手生成一些数据集。接下来我们将使用scikit-learn的make_blobs函数来生成一个样本数量为200,分类数量为2的数据集,并使用KNN算法来对其进行分类。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    # 导入数据集生成器
    from sklearn.datasets import make_blobs
    # 导入KNN 分类器
    from sklearn.neighbors import KNeighborsClassifier
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    
    # 生成样本数为200,分类数为2的数据集
    data=make_blobs(n_samples=200, n_features=2,centers=2, cluster_std=1.0, random_state=8)
    X,Y=data
    
    # 将生成的数据集进行可视化
    # plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    
    clf = KNeighborsClassifier()
    clf.fit(X,Y)
    
    # 绘制图形
    x_min,x_max=X[:,0].min()-1,X[:,0].max()+1
    y_min,y_max=X[:,1].min()-1,X[:,1].max()+1
    xx,yy=np.meshgrid(np.arange(x_min,x_max,.02),np.arange(y_min,y_max,.02))
    z=clf.predict(np.c_[xx.ravel(),yy.ravel()])
    
    z=z.reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title("Classifier:KNN")
    
    # 把待分类的数据点用五星表示出来
    plt.scatter(6.75,4.82,marker='*',c='red',s=200)
    
    # 对待分类的数据点的分类进行判断
    res = clf.predict([[6.75,4.82]])
    plt.text(6.9,4.5,'Classification flag: '+str(res))
    
    plt.show()

     程序执行后得到结果如下图所示:

    使用KNN算法处理多元分类任务

    接下来,我们再使用scikit-learn的make_blobs函数来生成一个样本数量为500,分类数量为5的数据集,并使用KNN算法来对其进行分类。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    # 导入数据集生成器
    from sklearn.datasets import make_blobs
    # 导入KNN 分类器
    from sklearn.neighbors import KNeighborsClassifier
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    
    # 生成样本数为500,分类数为5的数据集
    data=make_blobs(n_samples=500, n_features=2,centers=5, cluster_std=1.0, random_state=8)
    X,Y=data
    
    # 将生成的数据集进行可视化
    # plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    
    clf = KNeighborsClassifier()
    clf.fit(X,Y)
    
    # 绘制图形
    x_min,x_max=X[:,0].min()-1,X[:,0].max()+1
    y_min,y_max=X[:,1].min()-1,X[:,1].max()+1
    xx,yy=np.meshgrid(np.arange(x_min,x_max,.02),np.arange(y_min,y_max,.02))
    z=clf.predict(np.c_[xx.ravel(),yy.ravel()])
    
    z=z.reshape(xx.shape)
    plt.pcolormesh(xx,yy,z,cmap=plt.cm.Pastel1)
    plt.scatter(X[:,0], X[:,1],s=80, c=Y,  cmap=plt.cm.spring, edgecolors='k')
    plt.xlim(xx.min(),xx.max())
    plt.ylim(yy.min(),yy.max())
    plt.title("Classifier:KNN")
    
    # 把待分类的数据点用五星表示出来
    plt.scatter(0,5,marker='*',c='red',s=200)
    
    # 对待分类的数据点的分类进行判断
    res = clf.predict([[0,5]])
    plt.text(0.2,4.6,'Classification flag: '+str(res))
    plt.text(3.75,-13,'Model accuracy: {:.2f}'.format(clf.score(X, Y)))
    
    plt.show()

     程序执行后得到结果如下图所示:

    使用KNN算法进行回归分析

    这里我们使用scikit-learn的make_regression生成数据集来进行实验,演示KNN算法在回归分析中的表现。

    # 导入画图工具
    import matplotlib.pyplot as plt
    # 导入数组工具
    import numpy as np
    
    # 导入用于回归分析的KNN模型
    from sklearn.neighbors import KNeighborsRegressor
    # 导入数据集拆分工具
    from sklearn.model_selection import train_test_split
    # 导入数据集生成器
    from sklearn.datasets.samples_generator import make_regression
    from docutils.utils.math.math2html import LineWriter
    
    # 生成样本数为200,分类数为2的数据集
    X,Y=make_regression(n_samples=100,n_features=1,n_informative=1,noise=50,random_state=8)
    
    # 将生成的数据集进行可视化
    # plt.scatter(X,Y,s=80, c='orange',  cmap=plt.cm.spring, edgecolors='k')
    # plt.show()
    reg = KNeighborsRegressor(n_neighbors=5)
    
    reg.fit(X,Y)
    
    # 将预测结果用图像进行可视化
    z = np.linspace(-3,3,200).reshape(-1,1)
    plt.scatter(X,Y,c='orange',edgecolor='k')
    plt.plot(z,reg.predict(z),c='k',Linewidth=3)
    #
    plt.title("KNN Regressor")
    
    plt.show()

      程序执行后得到结果如下图所示:

    KNN算法项目实战----酒的分类

    from sklearn.datasets.base import load_wine
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    import numpy as np
    
    # 从 sklearn的datasets模块载入数据集加载酒的数据集
    wineDataSet=load_wine()
    print(wineDataSet)
    print("红酒数据集中的键:\n{}".format(wineDataSet.keys()))
    print("数据概况:\n{}".format(wineDataSet['data'].shape))
    print(wineDataSet['DESCR'])
    
    # 将数据集拆分为训练数据集和测试数据集
    X_train,X_test,y_train,y_test=train_test_split(wineDataSet['data'],wineDataSet['target'],random_state=0)
    print("X_train shape:{}".format(X_train.shape))
    print("X_test shape:{}".format(X_test.shape))
    print("y_train shape:{}".format(y_train.shape))
    print("y_test shape:{}".format(y_test.shape))
    
    knn = KNeighborsClassifier(n_neighbors=1)
    knn.fit(X_train,y_train)
    print(knn)
    
    # 评估模型的准确率
    print('测试数据集得分:{:.2f}'.format(knn.score(X_test,y_test)))
    
    # 使用建好的模型对新酒进行分类预测
    X_new = np.array([[13.2,2.77,2.51,18.5,96.6,1.04,2.55,0.57,1.47,6.2,1.05,3.33,820]])
    prediction = knn.predict(X_new)
    print("预测新酒的分类为:{}".format(wineDataSet['target_names'][prediction]))

     执行程序后打印如下结果:

    X_train shape:(133, 13)
    X_test shape:(45, 13)
    y_train shape:(133,)
    y_test shape:(45,)
    KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
               metric_params=None, n_jobs=1, n_neighbors=1, p=2,
               weights='uniform')
    测试数据集得分:0.76
    预测新酒的分类为:['class_2']

    参考书籍:《深入浅出 Python 机器学习》 作者:段小手

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 61,122
精华内容 24,448
关键字:

knn