精华内容
下载资源
问答
  • K-近邻算法全面解析
    千次阅读
    2020-11-24 15:52:21

    1 K-近邻算法简介

    K-近邻(K-Nearest Neighbor,KNN),采用的是测量不同特征值之间距离的方法进行分类。对当前待分类样本的分类,需要大量已知分类的样本的支持,因此KNN是一种有监督学习算法。
    在这里插入图片描述

    2 K-近邻算法的三要素

    距离度量、K值的选择、分类决策规则
    在这里插入图片描述

    2.1 样本间距离的计算方法:

    既然要找到待分类样本在当前样本数据集中与自己距离最近的K个邻居,必然就要确定样本间的距离计算方法。样本间距离的计算方法的构建,与样本的向量表示方法有关,当建立样本的向量表示方法时,必须考虑其是否便于样本间距离的计算。

    设特征空间 X \mathcal{X} X n n n 维实数向量空间 R n , x i , x j ∈ X , x i = ( x i ( 1 ) , x i ( 2 ) , ⋯   , x i ( n ) ) T , \mathbf{R}^{n}, x_{i}, x_{j} \in \mathcal{X}, \quad x_{i}=\left(x_{i}^{(1)}, x_{i}^{(2)}, \cdots, x_{i}^{(n)}\right)^{\mathrm{T}}, Rn,xi,xjX,xi=(xi(1),xi(2),,xi(n))T,
    x j = ( x j ( 1 ) , x j ( 2 ) , ⋯   , x j ( n ) ) T , x i , x j x_{j}=\left(x_{j}^{(1)}, x_{j}^{(2)}, \cdots, x_{j}^{(n)}\right)^{\mathrm{T}}, \quad x_{i}, x_{j} xj=(xj(1),xj(2),,xj(n))T,xi,xj L p L_{p} Lp 距离定义为
    L p ( x i , x j ) = ( ∑ l = 1 n ∣ x i ( i ) − x j ( l ) ∣ p ) 1 p L_{p}\left(x_{i}, x_{j}\right)=\left(\sum_{l=1}^{n}\left|x_{i}^{(i)}-x_{j}^{(l)}\right|^{p}\right)^{\frac{1}{p}} Lp(xi,xj)=(l=1nxi(i)xj(l)p)p1
    这里 p ⩾ 1. p \geqslant 1 . p1. p = 2 p=2 p=2 时,称为欧氏距离(Euclidean distance),即
    L 2 ( x i , x j ) = ( ∑ i = 1 n ∣ x i ( l ) − x j ( l ) ∣ 2 ) 1 2 L_{2}\left(x_{i}, x_{j}\right)=\left(\sum_{i=1}^{n}\left|x_{i}^{(l)}-x_{j}^{(l)}\right|^{2}\right)^{\frac{1}{2}} L2(xi,xj)=(i=1nxi(l)xj(l)2)21
    p = 1 p=1 p=1 时,称为曼哈顿距离(Manhattan distance), 即
    L 1 ( x i , x j ) = ∑ l = 1 n ∣ x i ( l ) − x j ( l ) ∣ L_{1}\left(x_{i}, x_{j}\right)=\sum_{l=1}^{n}\left|x_{i}^{(l)}-x_{j}^{(l)}\right| L1(xi,xj)=l=1nxi(l)xj(l)
    p = ∞ p=\infty p= 时,它是各个坐标距离的最大值, 为切比雪夫距离“chebyshev”,即
    L ∞ ( x i , x j ) = max ⁡ l ∣ x i ( l ) − x j ( t ) ∣ L_{\infty}\left(x_{i}, x_{j}\right)=\max _{l}\left|x_{i}^{(l)}-x_{j}^{(t)}\right| L(xi,xj)=lmaxxi(l)xj(t)
    K近邻算法默认的是欧式距离(即p=2的闵可夫斯基距离),我们也一般都用欧式距离来衡量高维空间中俩点的距离。

    带权重闵可夫斯基距离 “wminkowski”
    L p ( x i , x j ) = ( ∑ l = 1 n ( w ∗ ∣ x i ( i ) − x j ( l ) ∣ ) p ) 1 p L_{p}\left(x_{i}, x_{j}\right)=\left(\sum_{l=1}^{n}(w*\left|x_{i}^{(i)}-x_{j}^{(l)}\right|)^{p}\right)^{\frac{1}{p}} Lp(xi,xj)=(l=1n(wxi(i)xj(l))p)p1
    汉明距离 "Hamming Distance"
    在信息理论中,Hamming Distance 表示两个等长字符串在对应位置上不同字符的数目,我们以d(x, y)表示字符串x和y之间的汉明距离。从另外一个方面看,汉明距离度量了通过替换字符的方式将字符串x变成y所需要的最小的替换次数。

    “karolin” and “kerstin” is 3.
    1011101 and 1001001 is 2.

    2.2 K值的选取

    • 如果我们选取较小的k值,那么就会意味着我们的整体模型会变得复杂,容易发生过拟合。所谓的过拟合就是在训练集上准确率非常高,而在测试集上准确率低。K太小会导致过拟合,很容易将一些噪声学习到模型中,而忽略了数据真实的分布!
    • 如果我们选取较大的K值,就相当于用较大邻域中的训练数据进行预测,这时与输入实例较远的(不相似)训练实例也会对预测起作用,使预测发生错误,K值的增大意味着整体模型变得简单。
    • K值既不能过大,也不能过小。那么我们一般怎么选取呢?李航博士的书上讲到,我们一般选取一个较小的数值,通常采取交叉验证法来选取最优的K值。

    2.3 特征归一化的重要性

    首先举例如下,用一个人身高(cm)与脚码(尺码)大小来作为特征值,类别为男性或者女性。我们现在如果有5个训练样本,分布如下:
    A [(179,42),男] B [(178,43),男] C [(165,36)女] D [(177,42),男] E [(160,35),女]
    通过上述训练样本,看出问题了吗?
    很容易看到第一维身高特征是第二维脚码特征的4倍左右,那么在进行距离度量的时候,我们就会偏向于第一维特征。这样造成俩个特征并不是等价重要的,最终可能会导致距离计算错误,从而导致预测错误。
    归一化和标准化的区别:
    归一化:缩放仅仅跟最大、最小值的差别有关,输出范围在0-1之间。
    标准化:缩放和每个点都有关系,通过方差(variance)体现出来。与归一化对比,标准化中所有数据点都有贡献(通过均值和标准差造成影响)。输出范围是负无穷到正无穷。
    在这里插入图片描述

    什么时候用归一化?什么时候用标准化

    • 如果对输出结果范围有要求,用归一化
    • 如果数据较为稳定,不存在极端的最大最小值,用归一化
    • 如果数据存在异常值和较多噪音,用标准化,可以间接通过中心化避免异常值和极端值的影响

    2.4 分类决策规则

    K近邻算法的分类决策规则通俗来说就是K近邻法中的分类决策规则往往是多数表决决定,背后的数学思维是什么?
    K近邻法中的分类决策规则往往是多数表决,即由输入实例的K个近邻的训练实例中的多数类决定输入实例的类。多数表决规则,等价于经验风险最小化。

    3 K-近邻算法优缺点分析

    1. 优点
      (1)K-近邻算法是分类数据最简单最有效的算法,它是一种lazy-learning算法;
      (2)分类器不需要使用训练集进行训练,训练时间复杂度为0;
      (3)对异常值不敏感(个别噪音数据对结果的影响不是很大);
      (4)适合于多分类问题(multi-modal,对象具有多个类别标签),KNN要比SVM表现要好。

    2. 缺点
      (1)计算复杂度高、空间复杂度高:KNN分类的计算复杂度和训练集中的文档数目成正比,也就是说,如果训练集中文档总数为n,那么KNN的分类时间复杂度为O(n);
      (2)耗内存:必须保存全部的数据集,如果训练数据集很大,必须使用大量的存储空间;
      (3)耗时间:必须对数据集中的每一个数据计算距离值,实际使用时可能非常耗时;
      (4)无法给出任何数据的基础结构信息(数据的内在含义),这是k-近邻算法最大的缺点。可解释性差,无法告诉你哪个变量更重要,无法给出决策树那样的规则。

    4 K-近邻算法的问题及解决方案

    问题1:当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的k个邻居中大容量类的样本占多数。
    解决:不同样本给予不同的权重项
    问题2:数字差值最大的属性对计算结果的影响最大
    解决:在处理不同取值范围的特征值时,通常采用的方法是将数值归一化,如将取值范围处理为0到1或者-1到1之间。

    5 K-近邻算法的代码实现

    5.1 scikit-learn 中KNN相关的类库概述

    在scikit-learn 中,与近邻法这一大类相关的类库都在sklearn.neighbors包之中。KNN分类树的类是KNeighborsClassifier,KNN回归树的类是KNeighborsRegressor。除此之外,还有KNN的扩展,即限定半径最近邻分类树的类RadiusNeighborsClassifier和限定半径最近邻回归树的类RadiusNeighborsRegressor, 以及最近质心分类算法NearestCentroid。
    在这些算法中,KNN分类和回归的类参数完全一样。限定半径最近邻法分类和回归的类的主要参数也和KNN基本一样。
    比较特别是的最近质心分类算法,由于它是直接选择最近质心来分类,所以仅有两个参数,距离度量和特征选择距离阈值,比较简单,因此后面就不再专门讲述最近质心分类算法的参数。
    另外几个在sklearn.neighbors包中但不是做分类回归预测的类也值得关注。kneighbors_graph类返回用KNN时和每个样本最近的K个训练集样本的位置。radius_neighbors_graph返回用限定半径最近邻法时和每个样本在限定半径内的训练集样本的位置。NearestNeighbors是个大杂烩,它即可以返回用KNN时和每个样本最近的K个训练集样本的位置,也可以返回用限定半径最近邻法时和每个样本最近的训练集样本的位置,常常用在聚类模型中。

    在这里插入图片描述

    class sklearn.neighbors.KNeighborsClassifier(n_neighbors=5, *, weights=‘uniform’, algorithm=‘auto’, leaf_size=30, p=2, metric=‘minkowski’, metric_params=None, n_jobs=None, **kwargs)

    参数说明:
    n_neighbors: 选择最邻近点的数目k,默认为5。
    weights: 邻近点的计算权重值,uniform代表各个点权重值相等;‘distance’表示与距离成反比;还可以自定义权重函数。
    algorithm: 寻找最邻近点使用的算法,‘auto’,‘ball_tree’, ‘kd_tree’, ‘brute’可选,默认为‘auto。
    leaf_size: 传递给BallTree或kdTree的叶子大小,这会影响构造和查询的速度,以及存储树所需的内存。
    p: Minkowski度量的指数参数。p = 1 代表使用曼哈顿距离 (l1),p = 2 代表使用欧几里得距离(l2),
    metric: 距离度量,点之间距离的计算方法,默认为‘minkowski’。
    metric_params: 额外的关键字度量函数。
    n_jobs: 为邻近点搜索运行的并行作业数。

    5.2 KNN实现鸢尾花分类

    Iris Data Set(鸢尾属植物数据集)是历史比较悠久的数据集,它首次出现在著名的英国统计学家和生物学家Ronald Fisher 1936年的论文《The use of multiple measurements in taxonomic problems》中,被用来介绍线性判别式分析。在这个数据集中,包括了三类不同的鸢尾属植物:Iris Setosa,Iris Versicolour,Iris Virginica。每类收集了50个样本,因此这个数据集一共包含了150个样本。
    该数据集测量了所有150个样本的4个特征,分别是:sepal length(花萼长度)、sepal width(花萼宽度)、petal length(花瓣长度)、petal width(花瓣宽度),以上四个特征的单位都是厘米。

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.metrics import accuracy_score
    import numpy as np
    
    # load data
    data = load_iris()
    X = data['data']
    Y = data['target']
    
    # split arrays or matrices into random train and test subsets
    X_train, X_test, Y_train, Y_test= train_test_split(X, Y, test_size=0.2, random_state=0)
    
    # model train
    model = KNeighborsClassifier(n_neighbors=2)
    model.fit(X_train, Y_train)
    
    # model predict
    Y_pred= model.predict(X_test)
    
    # model evaluation
    correct_pred = np.count_nonzero(Y_pred==Y_test)
    accuracy = correct_pred / len(Y_test)
    print("model accuracy is " + str(accuracy))
    # print(accuracy_score(Y_test, Y_pred))

    参考资料

    k-近邻算法的原理和代码实现
    一文搞懂k近邻(k-NN)算法

    更多相关内容
  • 用官方的话来说,所谓K近邻算法,即是给定一个训练数据集,对新的输入实例,在训练数据集中找到与该实例最邻近的K个实例(也就是上面所说的K个邻居), 这K个实例的多数属于某个类,就把该输入实例分类到这个类中。...
  • k-近邻算法k-Nearest Neighbour algorithm),又称为KNN算法,是数据挖掘技术中原理最简单的算法。 KNN的工作原理:给定一个已知标签类别的训练数据集,输入没有标签的新数据后,在训练数据集中找到与新数据最邻 ...
  • 机器学习实战-k-近邻算法改进约会网站的配对效果,包括KNN.py,datingTestSet.txt,datingTestSet2.txt,testknn.py
  • K - 近邻算法.zip

    2019-09-06 11:59:09
    本实例参照机器学习实战一书在python3上将K-近邻算法进行实现,里面包括喜好分类和手写数字识别
  • 使用Python语言实现的k-近邻算法实现手写数字识别系统代码,包含代码和训练测试集
  • 主要介绍了Python机器学习k-近邻算法(K Nearest Neighbor),结合实例形式分析了k-近邻算法的原理、操作步骤、相关实现与使用技巧,需要的朋友可以参考下
  • K-近邻算法

    2017-11-07 13:05:34
    人工智能 机器学习KNN算法 基于python, 测试集看 http://download.csdn.net/download/yy761845/10107190
  • 暂无描述 iris.csv
  • 使用Weka进行K-近邻算法K-均值算法的使用-附件资源
  • 使用k-近邻算法来进行基础的电影类别分类
  • k-近邻算法

    千次阅读 2021-03-03 20:35:52
    k-近邻算法

    k-近邻算法


    k-近邻算法概述

    k-近邻算法(k-NearestNeighor Algorithm)是采用测量不同特征值之间的距离方法进行分类,简称kNN。

    这里用到的距离计算是欧几里德距离。

    工作原理:存在一个样本数据集合(x_{1}^{i},x_{2}^{i},...,x_{k}^{i},y^{i})i\rightarrow(0,n),也称作训练样本集,并且样本集中每条数据都存在标签y^{i},即我们知道样本集中每一数据与所属分类的对应关系。输入没有标签的新数据后(x_{1},x_{2},...,x_{k}),将新数据的每个特征与样本集中数据对应的特征进行比较,然后算法提取样本集中特征最相似数据(最近邻)的分类标签。一般来说,我们只选择样本数据集中前k个最相似的数据,这就是k-近邻算法中k的出处,通常k是不大于20的整数。

    距离计算如下:

      

    然后把d按照从小到大排序,选择k个最相似数据中出现次数中最多的分类,作为新数据的分类。

    kNN除了做分类任务,还可以做回归任务,在后面的章节中会讲到。


    k-近邻算法的一般流程

    (1)收集数据:方法不限

    (2)准备数据:距离计算所需要的数值,最好是结构化的数据格式

    (3)分析数据:方法不限

    (4)训练算法:此步骤不适用于k-近邻算法(不需要训练,直接计算距离,找出距离最近的k个

    (5)测试算法:计算错误率

    (6)使用算法:首先需要输入样本数据和结构化的输出结果,然后运行k-近邻算法判定输入数据分别属于哪个分类,最后应用对计算出的分类执行后续的处理


    代码实现

    所有代码实现都是在python集成的IDLE上完成,创建名为kNN.py的python模块,本节使用的代码都在这个文件中。

    1.导包

    '''
    KNN是一种最简单最有效的算法,但是KNN必须保留所有的数据集,
    如果训练数据集很大,必须使用大量的存储空间,
    此外,需要对每一个数据计算距离,非常耗时
    另外,它无法给出任何数据的基础结构信息(无法给出一个模型)
    '''
    from numpy import *
    import operator
    import matplotlib
    import matplotlib.pyplot as plt
    from os import listdir
    import numpy as np
    import matplotlib as mpl
    import matplotlib.lines as mlines
    

    2.导入数据

    #使用python导入数据,创建数据集和标签
    def createDataSet():
        group = array([[1.0,1.1],[1.0,1.0],[0,0],[0,0.1]])
        labels = ['A','A','B','B']
        return group,labels
    
    #每次使用数据,调用该函数即可

    3.实施kNN分类算法

    '''
    伪代码
    对未知类别属性的数据集中的每个点依此执行以下操作
    1、计算已知类别数据集中的点与当前点之间的距离;
    2、按照距离递增次序排序;
    3、选取与当前点距离最小的k个点;
    4、确定前k个点所在的类别的出现频率;
    5、返回前k个点出现频率最高的类别作为当前点的预测分类。
    '''
    
    #实施kNN分类算法
    def classify0(inX,dataSet,labels,k):
        dataSetSize = dataSet.shape[0]#查看矩阵的维度
        diffMat = tile(inX,(dataSetSize,1)) - dataSet
        #tile(数组,(在行上重复次数,在列上重复次数))
        sqDiffMat = diffMat**2
        sqDistances = sqDiffMat.sum(axis=1)
        #sum默认axis=0,是普通的相加,axis=1是将一个矩阵的每一行向量相加
        distances = sqDistances**0.5
        sortedDistIndicies = distances.argsort()
        #sort函数按照数组值从小到大排序
        #argsort函数返回的是数组值从小到大的索引值
        classCount={}
        for i in range(k):
            voteIlabel = labels[sortedDistIndicies[i]]
            classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
            #get(key,k),当字典dic中不存在key时,返回默认值k;存在时返回key对应的值
        sortedClassCount = sorted(classCount.items(),
               key=operator.itemgetter(1),reverse=True)
        #python2中用iteritems,python3中用items代替;operator.itemgetter(k),返回第k个域的值
        return sortedClassCount[0][0]

    4、测试

    #测试KNN
    #>>> import KNN
    #>>> group,labels = KNN.createDataSet()
    #>>> KNN.classify0([0,0],group,labels,3) # B
    #>>> KNN.classify0([1.2,1.5],group,labels,3) # A
    

    自行测试~


    总结

    本节实现了比较简单的k-近邻算法,相信看完会加深对kNN的理解!

    欢迎交流~

    下一节将会结合一个实例-手写数字识别系统来加深对kNN的理解!

    展开全文
  • 机器学习_最近邻_k-近邻算法_python实现
  • k-近邻算法的Python实现 一、概述 k-近邻算法k-Nearest Neighbour algorithm),又称为KNN算法,是数据挖掘技术中原理最简单的算法。KNN的工作原理:给定一个已知标签类别的训练数据集,输入没有标签的新数据后,...

    k-近邻算法的Python实现

    一、概述

    k-近邻算法(k-Nearest Neighbour algorithm),又称为KNN算法,是数据挖掘技术中原理最简单的算法。KNN的工作原理:给定一个已知标签类别的训练数据集,输入没有标签的新数据后,在训练数据集中找到与新数据最邻近的k个实例,如果这k个实例的多数属于某个类别,那么新数据就属于这个类别。可以简单理解为:由那些离X最近的k个点来投票决定X归为哪一类。

    在这里插入图片描述

    图1中有红色三角和蓝色方块两种类别,我们现在需要判断绿色圆点属于哪种类别

    当k=3时,绿色圆点属于红色三角这种类别;

    当k=5时,绿色圆点属于蓝色方块这种类别。

    举个简单的例子,可以用k-近邻算法分类一个电影是爱情片还是动作片。(打斗镜头和接吻镜头数量为虚构)

    在这里插入图片描述

    在这里插入图片描述

    我们可以从散点图中大致推断,这个未知电影有可能是爱情片,因为看起来距离已知的三个爱情片更近一点。k-近邻算法是用什么方法进行判断呢?没错,就是距离度量。这个电影分类例子中有两个特征,也就是在二维平面中计算两点之间的距离,就可以用我们高中学过的距离计算公式:
    在这里插入图片描述

    如果是多个特征扩展到N维空间,怎么计算?没错,我们可以使用欧氏距离(也称欧几里得度量),如下所示

    在这里插入图片描述

    通过计算可以得到训练集中所有电影与未知电影的距离,如表2所示

    在这里插入图片描述

    通过表2的计算结果,我们可以知道绿点标记的电影到爱情片《后来的我们》距离最近,为29.1。如果仅仅根据这个结果,判定绿点电影的类别为爱情片,这个算法叫做最近邻算法,而非k-近邻算法。k-近邻算法步骤如下:

    (1)计算已知类别数据集中的点与当前点之间的距离;

    (2)按照距离递增次序排序;

    (3)选取与当前点距离最小的k个点;

    (4)确定前k个点所在类别的出现频率;

    (5)返回前k个点出现频率最高的类别作为当前点的预测类别。

    比如,现在K=4,那么在这个电影例子中,把距离按照升序排列,距离绿点电影最近的前4个的电影分别是《后来的我们》、《前任3》、《无问西东》和《红海行动》,这四部电影的类别统计为爱情片:动作片=3:1,出现频率最高的类别为爱情片,所以在k=4时,绿点电影的类别为爱情片。这个判别过程就是k-近邻算法。

    二、k-近邻算法的Python实现

    在了解k-近邻算法的原理及实施步骤之后,我们用python将这些过程实现。

    1.1构建已经分类好的原始数据集为了方便验证,这里使用python的字典dict构建数据集,然后再将其转化成DataFrame格式。

    import pandas as pd
    
    rowdata = {'电影名称': ['无问东西', '后来的我们', '前任3', '红海行动', '唐人街探案', '战狼'],
               '打斗镜头': [1, 5, 12, 108, 112, 115],
               '接吻镜头': [101, 89, 97, 5, 9, 8],
               '电影类型': ['爱情片', '爱情片', '爱情片', '动作片', '动作片', '动作片']}
    movie_data = pd.DataFrame(rowdata)
    print(movie_data)
    '''
    电影名称  打斗镜头  接吻镜头 电影类型
    0   无问东西     1   101  爱情片
    1  后来的我们     5    89  爱情片
    2    前任3    12    97  爱情片
    3   红海行动   108     5  动作片
    4  唐人街探案   112     9  动作片
    5     战狼   115     8  动作片
    '''
    

    “”“使用{}创建字典”""

    scores = {'张三': 100}
    print(scores)  # {'张三': 100}
    

    2.计算已知类别数据集中的点与当前点之间的距离

    new_data = [24, 67]
    dist = list((((movie_data.iloc[:6, 1:3] - new_data) ** 2).sum(1)) ** 0.5)
    print(dist)
    
    '''创建列表的第二种方式,使用内置函数list()'''
    
    lst2 = list(['hello', 'world', 98])
    print(lst2)  # ['hello', 'world', 98]
    

    在这里插入图片描述

    在这里插入图片描述

    列相加所以sum(1)

    在这里插入图片描述

    在这里插入图片描述

    3.将距离升序排列,然后选取距离最小的k个点

    dist_l = pd.DataFrame({'dist': dist, 'labels': (movie_data.iloc[:6, 3])})
    print(dist_l)
    k = 4;
    dr = dist_l.sort_values(by='dist')[:4]
    print(dr)
    

    在这里插入图片描述

    在这里插入图片描述

    4.确定前k个点所在类别的出现频率

    re = dr.loc[:, 'labels'].value_counts()
    print(re);
    

    在这里插入图片描述

    在这里插入图片描述

    5.选择频率最高的类别作为当前点的预测类别

    result = []
    result.append(re.index[0])
    print(result)#[爱情片]
    
    展开全文
  • 什么是K-近邻算法? 简单的说,K-近邻算法就是采用测量不同特征值之间的距离方法来进行分类。它的工作原理是:存在一个样本数据集合,也称作训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一...
  • 用java实现k-近邻算法分类器的完整工程代码,测试结果正确
  • k-近邻算法(kNN)

    2019-09-20 21:15:43
    采用测量不同特征值之间的距离方法进行分类 工作原理:存在一个样本数据集合... 输入没有标签的新数据后,将新数据的每个特征与样本集中数据对应的特征进行比较,然后算法提取样本集中特征醉相思数据(最近邻)的分类标签。
  • K-近邻算法总结

    千次阅读 2020-12-24 16:59:31
    文章目录K-近邻算法K-近邻算法简介什么是K-近邻算法K-近邻算法(KNN)概念电影类型分析k近邻算法api初步使用Scikit-learn工具介绍安装Scikit-learn包含的内容K-近邻算法API案例步骤分析代码过程距离度量1.欧式距离...

    K-近邻算法

    文章目录

    K-近邻算法简介

    什么是K-近邻算法

    在这里插入图片描述

    • 根据你的“邻居”来推断出你的类别
    K-近邻算法(KNN)概念

    K Nearest Neighbor算法又叫KNN算法,这个算法是机器学习里面一个比较经典的算法, 总体来说KNN算法是相对比较容易理解的算法

    • 定义

    如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。

    来源:KNN算法最早是由Cover和Hart提出的一种分类算法

    • 距离公式

    两个样本的距离可以通过如下公式计算,又叫欧式距离 ,关于距离公式会在后面进行讨论

    在这里插入图片描述

    在这里插入图片描述

    电影类型分析

    假设我们现在有几部电影

    在这里插入图片描述

    其中9 号电影不知道类别,如何去预测?我们可以利用K近邻算法的思想

    在这里插入图片描述

    分别计算每个电影和被预测电影的距离,然后求解

    在这里插入图片描述

    • 该算法的思想是:一个样本与数据集中的k个样本最相似,如果这k个样本中的大多数属于某一个类别.该样本也属于这个类别

    • 实现流程

      1)计算已知类别数据集中的点与当前点之间的距离

      2)按距离递增次序排序

      3)选取与当前点距离最小的k个点

      4)统计前k个点所在的类别出现的频率

      5)返回前k个点出现频率最高的类别作为当前点的预测分类

    k近邻算法api初步使用

    机器学习流程复习:

    在这里插入图片描述

    • 1.获取数据集
    • 2.数据基本处理
    • 3.特征工程
    • 4.机器学习
    • 5.模型评估

    Scikit-learn工具介绍

    • Python语言的机器学习工具
    • Scikit-learn包括许多知名的机器学习算法的实现
    • Scikit-learn文档完善,容易上手,丰富的API
    安装
    pip3 install scikit-learn==0.24.0
    #安装好之后可以通过以下命令查看是否安装成功
    import sklearn
    
    • 注:安装scikit-learn需要Numpy, Scipy等库
    Scikit-learn包含的内容

    在这里插入图片描述

    • 分类、聚类、回归
    • 特征工程
    • 模型选择、调优

    K-近邻算法API

    sklearn.neighbors.KNeighborsClassifier(n_neighbors=5)

    • n_neighbors:int,可选(默认= 5),k_neighbors查询默认使用的邻居数

    案例

    步骤分析
    • 1.获取数据集
    • 2.数据基本处理(该案例中省略)
    • 3.特征工程(该案例中省略)
    • 4.机器学习
    • 5.模型评估(该案例中省略)
    代码过程
    • 导入模块
    from sklearn.neighbors import KNeighborsClassifier
    
    • 构造数据集
    x = [[0], [1], [2], [3]]
    y = [0, 0, 1, 1]
    
    • 机器学习 – 模型训练
    # 实例化API
    estimator = KNeighborsClassifier(n_neighbors=2)
    # 使用fit方法进行训练
    estimator.fit(x, y)
    
    result = estimator.predict([[0],[1],[4]])
    print(result)
    #[0 0 1]
    

    距离度量

    1.欧式距离(Euclidean Distance):

    欧氏距离是最容易直观理解的距离度量方法,我们小学、初中和高中接触到的两个点在空间中的距离一般都是指欧氏距离。

    通过距离平方值进行计算

    在这里插入图片描述

    X=[[1,1],[2,2],[3,3],[4,4]];
    经计算得:
    d = 1.4142    2.8284    4.2426    1.4142    2.8284    1.4142
    

    2.曼哈顿距离(Manhattan Distance):

    在曼哈顿街区要从一个十字路口开车到另一个十字路口,驾驶距离显然不是两点间的直线距离。这个实际驾驶距离就是“曼哈顿距离”。曼哈顿距离也称为“城市街区距离”(City Block distance)。

    通过距离的绝对值进行计算

    在这里插入图片描述

    在这里插入图片描述

    举例:

    X=[[1,1],[2,2],[3,3],[4,4]];
    经计算得:
    d =   2     4     6     2     4     2
    

    3.切比雪夫距离 (Chebyshev Distance):

    国际象棋中,国王可以直行、横行、斜行,所以国王走一步可以移动到相邻8个方格中的任意一个。国王从格子(x1,y1)走到格子(x2,y2)最少需要多少步?这个距离就叫切比雪夫距离。

    通过维度的最大值进行计算

    在这里插入图片描述

    在这里插入图片描述

    X=[[1,1],[2,2],[3,3],[4,4]];
    经计算得:
    d =   1     2     3     1     2     1
    

    4.闵可夫斯基距离(Minkowski Distance):

    闵氏距离不是一种距离,而是一组距离的定义,是对多个距离度量公式的概括性的表述。

    两个n维变量a(x11,x12,…,x1n)与b(x21,x22,…,x2n)间的闵可夫斯基距离定义为:

    在这里插入图片描述

    其中p是一个变参数:

    当p=1时,就是曼哈顿距离;

    当p=2时,就是欧氏距离;

    当p→∞时,就是切比雪夫距离。

    根据p的不同,闵氏距离可以表示某一类/种的距离。

    小结:

    1 闵氏距离,包括曼哈顿距离、欧氏距离和切比雪夫距离都存在明显的缺点:

    e.g. 二维样本(身高[单位:cm],体重[单位:kg]),现有三个样本:a(180,50),b(190,50),c(180,60)。

    a与b的闵氏距离(无论是曼哈顿距离、欧氏距离或切比雪夫距离)等于a与c的闵氏距离。但实际上身高的10cm并不能和体重的10kg划等号。

    2 闵氏距离的缺点:

    (1)将各个分量的量纲(scale),也就是“单位”相同的看待了;

    (2)未考虑各个分量的分布(期望,方差等)可能是不同的。

    前面四个距离公式都是把单位相同看待了,所以计算的过程不是很科学

    5.标准化欧氏距离 (Standardized EuclideanDistance):

    标准化欧氏距离是针对欧氏距离的缺点而作的一种改进。

    在计算过程中添加了标准差,对量纲数据进行处理

    思路:既然数据各维分量的分布不一样,那先将各个分量都“标准化”到均值、方差相等。假设样本集X的均值(mean)为m,标准差(standard deviation)为s,X的“标准化变量”表示为:

    在这里插入图片描述

    如果将方差的倒数看成一个权重,也可称之为加权欧氏距离(Weighted Euclidean distance)。

    X=[[1,1],[2,2],[3,3],[4,4]];(假设两个分量的标准差分别为0.51(((1-2)/0.5)^2 + (1-2/1)^2)^1/2
    (4+1)^1/2
    
    经计算得:
    d =   2.2361    4.4721    6.7082    2.2361    4.4721    2.2361
    

    6.余弦距离(Cosine Distance)

    几何中,夹角余弦可用来衡量两个向量方向的差异;机器学习中,借用这一概念来衡量样本向量之间的差异。

    通过cos思想完成计算

    • 二维空间中向量A(x1,y1)与向量B(x2,y2)的夹角余弦公式:

    在这里插入图片描述

    • 两个n维样本点a(x11,x12,…,x1n)和b(x21,x22,…,x2n)的夹角余弦为:

    在这里插入图片描述

    即:

    在这里插入图片描述

    夹角余弦取值范围为[-1,1]。余弦越大表示两个向量的夹角越小,余弦越小表示两向量的夹角越大。当两个向量的方向重合时余弦取最大值1,当两个向量的方向完全相反余弦取最小值-1。

    举例:

    X=[[1,1],[1,2],[2,5],[1,-4]]
    1*1+1*2/(1^2+1^2)^1/2*(1^2+2^2)^1/2
    3/(2^1/2*5^1/2)
    0.948683
    经计算得:
    d =   0.9487    0.9191   -0.5145    0.9965   -0.7593   -0.8107
    

    7.汉明距离(Hamming Distance)【了解】

    两个等长字符串s1与s2的汉明距离为:将其中一个变为另外一个所需要作的最小字符替换次数。

    一个字符串到另一个字符串需要变换几个字母,进行统计

    例如:

      The Hamming distance between "1011101" and "1001001" is 2. 
      The Hamming distance between "2143896" and "2233796" is 3. 
      The Hamming distance between "toned" and "roses" is 3.
    

    在这里插入图片描述

    随堂练习:
    求下列字符串的汉明距离:
    
      10111011001001  2
    
      21438962233796  3
     
      irie与 rise 3
    

    汉明重量:是字符串相对于同样长度的零字符串的汉明距离,也就是说,它是字符串中非零的元素个数:对于二进制字符串来说,就是 1 的个数,所以 11101 的汉明重量是 4。因此,如果向量空间中的元素a和b之间的汉明距离等于它们汉明重量的差a-b。

    应用:汉明重量分析在包括信息论、编码理论、密码学等领域都有应用。比如在信息编码过程中,为了增强容错性,应使得编码间的最小汉明距离尽可能大。但是,如果要比较两个不同长度的字符串,不仅要进行替换,而且要进行插入与删除的运算,在这种场合下,通常使用更加复杂的编辑距离等算法。

    举例:

    X=[[0,1,1],[1,1,2],[1,5,2]]
    注:以下计算方式中,把2个向量之间的汉明距离定义为2个向量不同的分量所占的百分比。
    
    经计算得:
    d =   0.6667    1.0000    0.3333
    

    8.杰卡德距离(Jaccard Distance)【了解】

    通过交并集进行统计

    杰卡德相似系数(Jaccard similarity coefficient):两个集合A和B的交集元素在A,B的并集中所占的比例,称为两个集合的杰卡德相似系数,用符号J(A,B)表示:

    在这里插入图片描述

    杰卡德距离(Jaccard Distance):与杰卡德相似系数相反,用两个集合中不同元素占所有元素的比例来衡量两个集合的区分度:

    在这里插入图片描述

    举例:

    X=[[1,1,0][1,-1,0],[-1,1,0]]
    注:以下计算中,把杰卡德距离定义为不同的维度的个数占“非全零维度”的比例
    经计算得:
    d =   0.5000    0.5000    1.0000
    

    9.马氏距离(Mahalanobis Distance)【了解】

    通过样本分布进行计算

    下图有两个正态分布图,它们的均值分别为a和b,但方差不一样,则图中的A点离哪个总体更近?或者说A有更大的概率属于谁?显然,A离左边的更近,A属于左边总体的概率更大,尽管A与a的欧式距离远一些。这就是马氏距离的直观解释。

    在这里插入图片描述

    马氏距离是基于样本分布的一种距离。

    马氏距离是由印度统计学家马哈拉诺比斯提出的,表示数据的协方差距离。它是一种有效的计算两个位置样本集的相似度的方法。

    与欧式距离不同的是,它考虑到各种特性之间的联系,即独立于测量尺度。

    **马氏距离定义:**设总体G为m维总体(考察m个指标),均值向量为μ=(μ1,μ2,… …,μm,)`,协方差阵为∑=(σij),

    则样本X=(X1,X2,… …,Xm,)`与总体G的马氏距离定义为:

    在这里插入图片描述

    马氏距离也可以定义为两个服从同一分布并且其协方差矩阵为∑的随机变量的差异程度:如果协方差矩阵为单位矩阵,马氏距离就简化为欧式距离;如果协方差矩阵为对角矩阵,则其也可称为正规化的欧式距离。

    马氏距离特性:

    1.量纲无关,排除变量之间的相关性的干扰;

    2.马氏距离的计算是建立在总体样本的基础上的,如果拿同样的两个样本,放入两个不同的总体中,最后计算得出的两个样本间的马氏距离通常是不相同的,除非这两个总体的协方差矩阵碰巧相同;

    3 .计算马氏距离过程中,要求总体样本数大于样本的维数,否则得到的总体样本协方差矩阵逆矩阵不存在,这种情况下,用欧式距离计算即可。

    4.还有一种情况,满足了条件总体样本数大于样本的维数,但是协方差矩阵的逆矩阵仍然不存在,比如三个样本点(3,4),(5,6),(7,8),这种情况是因为这三个样本在其所处的二维空间平面内共线。这种情况下,也采用欧式距离计算。

    欧式距离&马氏距离:

    在这里插入图片描述

    举例:

    已知有两个类G1和G2,比如G1是设备A生产的产品,G2是设备B生产的同类产品。设备A的产品质量高(如考察指标为耐磨度X),其平均耐磨度μ1=80,反映设备精度的方差σ2(1)=0.25;设备B的产品质量稍差,其平均耐磨损度μ2=75,反映设备精度的方差σ2(2)=4.

    今有一产品G0,测的耐磨损度X0=78,试判断该产品是哪一台设备生产的?

    直观地看,X0与μ1(设备A)的绝对距离近些,按距离最近的原则,是否应把该产品判断设备A生产的?

    考虑一种相对于分散性的距离,记X0与G1,G2的相对距离为d1,d2,则:

    在这里插入图片描述

    因为d2=1.5 < d1=4,按这种距离准则,应判断X0为设备B生产的。

    设备B生产的产品质量较分散,出现X0为78的可能性较大;而设备A生产的产品质量较集中,出现X0为78的可能性较小。

    这种相对于分散性的距离判断就是马氏距离。

    在这里插入图片描述

    k值的选择

    举例说明:

    在这里插入图片描述

    K值过小

    容易受到异常点的影响

    k值过大:

    受到样本均衡的问题


    K值选择问题,李航博士的一书「统计学习方法」上所说:

    1. 选择较小的K值,就相当于用较小的领域中的训练实例进行预测,“学习”近似误差会减小,只有与输入实例较近或相似的训练实例才会对预测结果起作用,与此同时带来的问题是“学习”的估计误差会增大,换句话说,K值的减小就意味着整体模型变得复杂,容易发生过拟合;

    2. 选择较大的K值,就相当于用较大领域中的训练实例进行预测,其优点是可以减少学习的估计误差,但缺点是学习的近似误差会增大。这时候,与输入实例较远(不相似的)训练实例也会对预测器作用,使预测发生错误,且K值的增大就意味着整体的模型变得简单。

    3. K=N(N为训练样本个数),则完全不足取,因为此时无论输入实例是什么,都只是简单的预测它属于在训练实例中最多的类,模型过于简单,忽略了训练实例中大量有用信息。

    在实际应用中,K值一般取一个比较小的数值,例如采用交叉验证法(简单来说,就是把训练数据在分成两组:训练集和验证集)来选择最优的K值。对这个简单的分类器进行泛化,用核方法把这个线性模型扩展到非线性的情况,具体方法是把低维数据集映射到高维特征空间。


    近似误差:对现有训练集的训练误差,关注训练集,如果近似误差过小可能会出现过拟合的现象,对现有的训练集能有很好的预测,但是对未知的测试样本将会出现较大偏差的预测。模型本身不是最接近最佳模型。

    估计误差:可以理解为对测试集的测试误差,关注测试集,估计误差小说明对未知数据的预测能力好,模型本身最接近最佳模型。

    kd树

    问题导入:

    实现k近邻法时,主要考虑的问题是如何对训练数据进行快速k近邻搜索。

    这在特征空间的维数大及训练数据容量大时尤其必要。

    **k近邻法最简单的实现是线性扫描(穷举搜索),即要计算输入实例与每一个训练实例的距离。计算并存储好以后,再查找K近邻。**当训练集很大时,计算非常耗时。

    为了提高kNN搜索的效率,可以考虑使用特殊的结构存储训练数据,以减小计算距离的次数。


    kd树简介

    什么是kd树

    根据KNN每次需要预测一个点时,我们都需要计算训练数据集里每个点到这个点的距离,然后选出距离最近的k个点进行投票。当数据集很大时,这个计算成本非常高,针对N个样本,D个特征的数据集,其算法复杂度为O(DN^2)

    kd树:为了避免每次都重新计算一遍距离,算法会把距离信息保存在一棵树里,这样在计算之前从树里查询距离信息,尽量避免重新计算。其基本原理是,如果A和B距离很远,B和C距离很近,那么A和C的距离也很远。有了这个信息,就可以在合适的时候跳过距离远的点。

    这样优化后的算法复杂度可降低到O(DNlog(N))。感兴趣的读者可参阅论文:Bentley,J.L.,Communications of the ACM(1975)。

    1989年,另外一种称为Ball Tree的算法,在kd Tree的基础上对性能进一步进行了优化。感兴趣的读者可以搜索Five balltree construction algorithms来了解详细的算法信息。

    原理

    在这里插入图片描述

    黄色的点作为根节点,上面的点归左子树,下面的点归右子树,接下来再不断地划分,分割的那条线叫做分割超平面(splitting hyperplane),在一维中是一个点,二维中是线,三维的是面。

    在这里插入图片描述

    黄色节点就是Root节点,下一层是红色,再下一层是绿色,再下一层是蓝色。

    在这里插入图片描述

    1.树的建立;

    2.最近邻域搜索(Nearest-Neighbor Lookup)

    kd树(K-dimension tree)是**一种对k维空间中的实例点进行存储以便对其进行快速检索的树形数据结构。**kd树是一种二叉树,表示对k维空间的一个划分,构造kd树相当于不断地用垂直于坐标轴的超平面将K维空间切分,构成一系列的K维超矩形区域。kd树的每个结点对应于一个k维超矩形区域。利用kd树可以省去对大部分数据点的搜索,从而减少搜索的计算量。

    在这里插入图片描述

    类比“二分查找”:给出一组数据:[9 1 4 7 2 5 0 3 8],要查找8。如果挨个查找(线性扫描),那么将会把数据集都遍历一遍。而如果排一下序那数据集就变成了:[0 1 2 3 4 5 6 7 8 9],按前一种方式我们进行了很多没有必要的查找,现在如果我们以5为分界点,那么数据集就被划分为了左右两个“簇” [0 1 2 3 4]和[6 7 8 9]。

    因此,根本就没有必要进入第一个簇,可以直接进入第二个簇进行查找。把二分查找中的数据点换成k维数据点,这样的划分就变成了用超平面对k维空间的划分。空间划分就是对数据点进行分类,“挨得近”的数据点就在一个空间里面。

    构造方法

    (1)构造根结点,使根结点对应于K维空间中包含所有实例点的超矩形区域;

    (2)通过递归的方法,不断地对k维空间进行切分,生成子结点。在超矩形区域上选择一个坐标轴和在此坐标轴上的一个切分点,确定一个超平面,这个超平面通过选定的切分点并垂直于选定的坐标轴,将当前超矩形区域切分为左右两个子区域(子结点);这时,实例被分到两个子区域。

    (3)上述过程直到子区域内没有实例时终止(终止时的结点为叶结点)。在此过程中,将实例保存在相应的结点上。

    (4)通常,循环的选择坐标轴对空间切分,选择训练实例点在坐标轴上的中位数为切分点,这样得到的kd树是平衡的(平衡二叉树:它是一棵空树,或其左子树和右子树的深度之差的绝对值不超过1,且它的左子树和右子树都是平衡二叉树)。

    KD树中每个节点是一个向量,和二叉树按照数的大小划分不同的是,KD树每层需要选定向量中的某一维,然后根据这一维按左小右大的方式划分数据。在构建KD树时,关键需要解决2个问题:

    (1)选择向量的哪一维进行划分;

    (2)如何划分数据;

    第一个问题简单的解决方法可以是随机选择某一维或按顺序选择,但是更好的方法应该是在数据比较分散的那一维进行划分(分散的程度可以根据方差来衡量)。好的划分方法可以使构建的树比较平衡,可以每次选择中位数来进行划分,这样问题2也得到了解决。

    案例分析

    树的建立

    给定一个二维空间数据集:T={(2,3),(5,4),(9,6),(4,7),(8,1),(7,2)},构造一个平衡kd树。

    在这里插入图片描述

    思路引导:

    根结点对应包含数据集T的矩形,选择x(1)轴,6个数据点的x(1)坐标中位数是6,这里选最接近的(7,2)点,以平面x(1)=7将空间分为左、右两个子矩形(子结点);接着左矩形以x(2)=4分为两个子矩形(左矩形中{(2,3),(5,4),(4,7)}点的x(2)坐标中位数正好为4),右矩形以x(2)=6分为两个子矩形,如此递归,最后得到如下图所示的特征空间划分和kd树。

    在这里插入图片描述

    最近领域的搜索

    假设标记为星星的点是 test point, 绿色的点是找到的近似点,在回溯过程中,需要用到一个队列,存储需要回溯的点,在判断其他子节点空间中是否有可能有距离查询点更近的数据点时,做法是以查询点为圆心,以当前的最近距离为半径画圆,这个圆称为候选超球(candidate hypersphere),如果圆与回溯点的轴相交,则需要将轴另一边的节点都放到回溯队列里面来。

    在这里插入图片描述

    样本集{(2,3),(5,4), (9,6), (4,7), (8,1), (7,2)}

    查找点(2.1,3.1)

    在这里插入图片描述

    在(7,2)点测试到达(5,4),在(5,4)点测试到达(2,3),然后search_path中的结点为<(7,2),(5,4), (2,3)>,从search_path中取出(2,3)作为当前最佳结点nearest, dist为0.141;

    然后回溯至(5,4),以(2.1,3.1)为圆心,以dist=0.141为半径画一个圆,并不和超平面y=4相交,如上图,所以不必跳到结点(5,4)的右子空间去搜索,因为右子空间中不可能有更近样本点了。

    于是再回溯至(7,2),同理,以(2.1,3.1)为圆心,以dist=0.141为半径画一个圆并不和超平面x=7相交,所以也不用跳到结点(7,2)的右子空间去搜索。

    至此,search_path为空,结束整个搜索,返回nearest(2,3)作为(2.1,3.1)的最近邻点,最近距离为0.141。

    查找点(2,4.5)

    在这里插入图片描述

    在(7,2)处测试到达(5,4),在(5,4)处测试到达(4,7)【优先选择在本域搜索】,然后search_path中的结点为<(7,2),(5,4), (4,7)>,从search_path中取出(4,7)作为当前最佳结点nearest, dist为3.202;

    然后回溯至(5,4),以(2,4.5)为圆心,以dist=3.202为半径画一个圆与超平面y=4相交,所以需要跳到(5,4)的左子空间去搜索。所以要将(2,3)加入到search_path中,现在search_path中的结点为<(7,2),(2, 3)>;另外,(5,4)与(2,4.5)的距离为3.04 < dist = 3.202,所以将(5,4)赋给nearest,并且dist=3.04。

    回溯至(2,3),(2,3)是叶子节点,直接平判断(2,3)是否离(2,4.5)更近,计算得到距离为1.5,所以nearest更新为(2,3),dist更新为(1.5)

    回溯至(7,2),同理,以(2,4.5)为圆心,以dist=1.5为半径画一个圆并不和超平面x=7相交, 所以不用跳到结点(7,2)的右子空间去搜索。

    至此,search_path为空,结束整个搜索,返回nearest(2,3)作为(2,4.5)的最近邻点,最近距离为1.5。

    案例:鸢尾花种类预测–数据集介绍

    案例:鸢尾花种类预测

    Iris数据集是常用的分类实验数据集,由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。关于数据集的具体介绍:

    在这里插入图片描述

    scikit-learn中数据集介绍

    scikit-learn数据集API介绍

    sklearn.datasets

    • 加载获取流行数据集
    • datasets.load_*()
      • 获取小规模数据集,数据包含在datasets里
    • datasets.fetch_*(data_home=None)
      • 获取大规模数据集,需要从网络上下载,函数的第一个参数是data_home,表示数据集下载的目录,默认是 ~/scikit_learn_data/

    sklearn小数据集

    sklearn.datasets.load_iris()

    加载并返回鸢尾花数据集

    在这里插入图片描述

    sklearn大数据集

    klearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)

    • subset:‘train’或者’test’,‘all’,可选,选择要加载的数据集。
    • 训练集的“训练”,测试集的“测试”,两者的“全部”
    sklearn数据集返回值介绍

    load和fetch返回的数据类型datasets.base.Bunch(字典格式)

    • data:特征数据数组,是 [n_samples * n_features] 的二维 numpy.ndarray 数组
    • target:标签数组,是 n_samples 的一维 numpy.ndarray 数组
    • DESCR:数据描述
    • feature_names:特征名,新闻数据,手写数字、回归数据集没有
    • target_names:标签名
    from sklearn.datasets import load_iris
    # 获取鸢尾花数据集
    iris = load_iris()
    print("鸢尾花数据集的返回值:\n", iris)
    # 返回值是一个继承自字典的Bench
    print("鸢尾花的特征值:\n", iris["data"])
    print("鸢尾花的目标值:\n", iris.target)
    print("鸢尾花特征的名字:\n", iris.feature_names)
    print("鸢尾花目标值的名字:\n", iris.target_names)
    print("鸢尾花的描述:\n", iris.DESCR)
    
    查看数据分布

    通过创建一些图,以查看不同类别是如何通过特征来区分的。 在理想情况下,标签类将由一个或多个特征对完美分隔。 在现实世界中,这种理想情况很少会发生。

    • seaborn介绍
      • Seaborn 是基于 Matplotlib 核心库进行了更高级的 API 封装,可以让你轻松地画出更漂亮的图形。而 Seaborn 的漂亮主要体现在配色更加舒服、以及图形元素的样式更加细腻。
      • 安装 pip3 install seaborn
      • seaborn.lmplot() 是一个非常有用的方法,它会在绘制二维散点图时,自动完成回归拟合
        • sns.lmplot() 里的 x, y 分别代表横纵坐标的列名,
        • data= 是关联到数据集,
        • hue=*代表按照 species即花的类别分类显示,
        • fit_reg=是否进行线性拟合。
      • 参考链接: api链接
    # 内嵌绘图
    import seaborn as sns
    import matplotlib.pyplot as plt
    import pandas as pd
    from sklearn.datasets import load_iris
    # 获取鸢尾花数据集
    iris = load_iris()
    # 把数据转换成dataframe的格式
    iris_d = pd.DataFrame(iris['data'], columns = ['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width'])
    iris_d['Species'] = iris.target
    
    def plot_iris(iris, col1, col2):
        sns.lmplot(x = col1, y = col2, data = iris, hue = "Species", fit_reg = False)
        plt.xlabel(col1)
        plt.ylabel(col2)
        plt.title('鸢尾花种类分布图')
        plt.show()
    plot_iris(iris_d, 'Petal_Width', 'Sepal_Length')
    

    在这里插入图片描述

    数据集的划分

    机器学习一般的数据集会划分为两个部分:

    • 训练数据:用于训练,构建模型
    • 测试数据:在模型检验时使用,用于评估模型是否有效

    划分比例:

    • 训练集:70% 80% 75%
    • 测试集:30% 20% 25%

    数据集划分api

    • sklearn.model_selection.train_test_split(arrays, *options)
      • x 数据集的特征值
      • y 数据集的标签值
      • test_size 测试集的大小,一般为float
      • random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
      • return 测试集特征训练集特征值值,训练标签,测试标签(默认随机取)
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    # 1、获取鸢尾花数据集
    iris = load_iris()
    # 对鸢尾花数据集进行分割
    # 训练集的特征值x_train 测试集的特征值x_test 训练集的目标值y_train 测试集的目标值y_test
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    print("x_train:\n", x_train.shape)
    # 随机数种子
    x_train1, x_test1, y_train1, y_test1 = train_test_split(iris.data, iris.target, random_state=6)
    x_train2, x_test2, y_train2, y_test2 = train_test_split(iris.data, iris.target, random_state=6)
    print("如果随机数种子不一致:\n", x_train == x_train1)
    print("如果随机数种子一致:\n", x_train1 == x_train2)
    

    特征工程-特征预处理

    什么是特征预处理

    特征预处理定义
    scikit-learn的解释

    provides several common utility functions and transformer classes to change raw feature vectors into a representation that is more suitable for the downstream estimators.

    翻译过来:通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程

    在这里插入图片描述

    为什么我们要进行归一化/标准化?

    • 特征的单位或者大小相差较大,或者某特征的方差相比其他的特征要大出几个数量级容易影响(支配)目标结果,使得一些算法无法学习到其它的特征
    举例:约会对象数据

    在这里插入图片描述

    我们需要用到一些方法进行无量纲化使不同规格的数据转换到同一规格

    包含内容(数值型数据的无量纲化)
    • 归一化
    • 标准化
    特征预处理API
    sklearn.preprocessing
    

    归一化

    定义

    通过对原始数据进行变换把数据映射到(默认为[0,1])之间

    公式

    在这里插入图片描述

    作用于每一列,max为一列的最大值,min为一列的最小值,那么X’’为最终结果,mx,mi分别为指定区间值默认mx为1,mi为0

    那么怎么理解这个过程呢?我们通过一个例子

    在这里插入图片描述

    API

    sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )

    • MinMaxScalar.fit_transform(X)
      • X:numpy array格式的数据[n_samples,n_features]
    • 返回值:转换后的形状相同的array
    数据计算

    我们对以下数据进行运算,在dating.txt中。保存的就是之前的约会对象数据

    milage,Liters,Consumtime,target
    40920,8.326976,0.953952,3
    14488,7.153469,1.673904,2
    26052,1.441871,0.805124,1
    75136,13.147394,0.428964,1
    38344,1.669788,0.134296,1
    
    • 分析

    1、实例化MinMaxScalar

    2、通过fit_transform转换

    import pandas as pd
    from sklearn.preprocessing import MinMaxScaler
    
    def minmax_demo():
        """
        归一化演示
        :return: None
        """
        data = pd.read_csv('../data/dating.txt')
        print(data)
        # 1、实例化一个转换器类
        transfer = MinMaxScaler(feature_range=(2, 3))
        # 2、调用fit_transform
        data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
        print("最小值最大值归一化处理的结果:\n", data)
    
        return None
    
    if __name__ == '__main__':
        minmax_demo()
    #打印结果:
         milage     Liters  Consumtime  target
    0     40920   8.326976    0.953952       3
    1     14488   7.153469    1.673904       2
    2     26052   1.441871    0.805124       1
    3     75136  13.147394    0.428964       1
    4     38344   1.669788    0.134296       1
    ..      ...        ...         ...     ...
    995   11145   3.410627    0.631838       2
    996   68846   9.974715    0.669787       1
    997   26575  10.650102    0.866627       3
    998   48111   9.134528    0.728045       3
    999   43757   7.882601    1.332446       3
    
    [1000 rows x 4 columns]
    最小值最大值归一化处理的结果:
     [[2.44832535 2.39805139 2.56233353]
     [2.15873259 2.34195467 2.98724416]
     [2.28542943 2.06892523 2.47449629]
     ...
     [2.29115949 2.50910294 2.51079493]
     [2.52711097 2.43665451 2.4290048 ]
     [2.47940793 2.3768091  2.78571804]]
    
    问题:如果数据中异常点较多,会有什么影响?

    在这里插入图片描述

    归一化总结

    注意最大值最小值是变化的,另外,最大值与最小值非常容易受异常点影响,所以这种方法鲁棒性较差,只适合传统精确小数据场景。

    标准化

    定义

    通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内

    公式

    在这里插入图片描述

    作用于每一列,mean为平均值,σ为标准差

    所以回到刚才异常点的地方,我们再来看看标准化

    • 对于归一化来说:如果出现异常点,影响了最大值和最小值,那么结果显然会发生改变
    • 对于标准化来说:如果出现异常点,由于具有一定数据量,少量的异常点对于平均值的影响并不大,从而方差改变较小。
    API

    sklearn.preprocessing.StandardScaler( )

    • 处理之后每列来说所有数据都聚集在均值0附近标准差差为1
    • StandardScaler.fit_transform(X)
      • X:numpy array格式的数据[n_samples,n_features]
    • 返回值:转换后的形状相同的array
    数据计算

    同样对上面的数据进行处理

    • 分析

    1、实例化StandardScaler

    2、通过fit_transform转换

    import pandas as pd
    from sklearn.preprocessing import StandardScaler
    
    def stand_demo():
        """
        标准化演示
        :return: None
        """
        data = pd.read_csv("../data/dating.txt")
        print(data)
        # 1、实例化一个转换器类
        transfer = StandardScaler()
        # 2、调用fit_transform
        data = transfer.fit_transform(data[['milage','Liters','Consumtime']])
        print("标准化的结果:\n", data)
        print("每一列特征的平均值:\n", transfer.mean_)
        print("每一列特征的方差:\n", transfer.var_)
    
        return None
    if __name__ == '__main__':
        stand_demo()
        
    #打印结果:
         milage     Liters  Consumtime  target
    0     40920   8.326976    0.953952       3
    1     14488   7.153469    1.673904       2
    2     26052   1.441871    0.805124       1
    3     75136  13.147394    0.428964       1
    4     38344   1.669788    0.134296       1
    ..      ...        ...         ...     ...
    995   11145   3.410627    0.631838       2
    996   68846   9.974715    0.669787       1
    997   26575  10.650102    0.866627       3
    998   48111   9.134528    0.728045       3
    999   43757   7.882601    1.332446       3
    
    [1000 rows x 4 columns]
    标准化的结果:
     [[ 0.33193158  0.41660188  0.24523407]
     [-0.87247784  0.13992897  1.69385734]
     [-0.34554872 -1.20667094 -0.05422437]
     ...
     [-0.32171752  0.96431572  0.06952649]
     [ 0.65959911  0.60699509 -0.20931587]
     [ 0.46120328  0.31183342  1.00680598]]
    每一列特征的平均值:
     [3.36354210e+04 6.55996083e+00 8.32072997e-01]
    每一列特征的方差:
     [4.81628039e+08 1.79902874e+01 2.46999554e-01]
     
    
    
    
    标准化总结

    在已有样本足够多的情况下比较稳定,适合现代嘈杂大数据场景。

    案例:鸢尾花种类预测—流程实现

    再识K-近邻算法API

    sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)

    • n_neighbors:
      • int,可选(默认= 5),k_neighbors查询默认使用的邻居数
    • algorithm:{‘auto’,‘ball_tree’,‘kd_tree’,‘brute’}
      • 快速k近邻搜索算法,默认参数为auto,可以理解为算法自己决定合适的搜索算法。除此之外,用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索,
        • brute是蛮力搜索,也就是线性扫描,当训练集很大时,计算非常耗时。
        • kd_tree,构造kd树存储数据以便对其进行快速检索的树形数据结构,kd树也就是数据结构中的二叉树。以中值切分构造的树,每个结点是一个超矩形,在维数小于20时效率高。
        • ball tree是为了克服kd树高纬失效而发明的,其构造过程是以质心C和半径r分割样本空间,每个节点是一个超球体。

    案例:鸢尾花种类预测

    数据集介绍

    Iris数据集是常用的分类实验数据集,由Fisher, 1936收集整理。Iris也称鸢尾花卉数据集,是一类多重变量分析的数据集。关于数据集的具体介绍:

    在这里插入图片描述

    步骤分析
    • 1.获取数据集
    • 2.数据基本处理
    • 3.特征工程
    • 4.机器学习(模型训练)
    • 5.模型评估
    代码过程
    • 导入模块
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    from sklearn.neighbors import KNeighborsClassifier
    
    • 先从sklearn当中获取数据集,然后进行数据集的分割
    # 1.获取数据集
    iris = load_iris()
    
    # 2.数据基本处理
    # x_train,x_test,y_train,y_test为训练集特征值、测试集特征值、训练集目标值、测试集目标值
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target,random_state=22)
    
    • 进行数据标准化
      • 特征值的标准化
    # 3、特征工程:标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    
    • 模型进行训练预测
    # 4、机器学习(模型训练)
    estimator = KNeighborsClassifier(n_neighbors=9)
    estimator.fit(x_train, y_train)
    # 5、模型评估
    # 方法1:比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("预测结果为:\n", y_predict)
    print("比对真实值和预测值:\n", y_predict == y_test)
    # 方法2:直接计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为:\n", score)
    

    k近邻算法总结

    优点:

    • 简单有效
    • 重新训练的代价低
    • 适合类域交叉样本
      • KNN方法主要靠周围有限的邻近的样本,而不是靠判别类域的方法来确定所属类别的,因此对于类域的交叉或重叠较多的待分样本集来说,KNN方法较其他方法更为适合。
    • 适合大样本自动分类
      • 该算法比较适用于样本容量比较大的类域的自动分类,而那些样本容量较小的类域采用这种算法比较容易产生误分。

    缺点:

    • 惰性学习
      • KNN算法是懒散学习方法(lazy learning,基本上不学习),一些积极学习的算法要快很多
    • 类别评分不是规格化
      • 不像一些通过概率评分的分类
    • 输出可解释性不强
      • 例如决策树的输出可解释性就较强
    • 对不均衡的样本不擅长
      • 当样本不平衡时,如一个类的样本容量很大,而其他类样本容量很小时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数。该算法只计算“最近的”邻居样本,某一类的样本数量很大,那么或者这类样本并不接近目标样本,或者这类样本很靠近目标样本。无论怎样,数量并不能影响运行结果。可以采用权值的方法(和该样本距离小的邻居权值大)来改进。
    • 计算量较大
      • 目前常用的解决方法是事先对已知样本点进行剪辑,事先去除对分类作用不大的样本。

    交叉验证、网格搜索

    什么是交叉验证(cross validation)

    交叉验证:将拿到的训练数据,分为训练和验证集。以下图为例:将数据分成4份,其中一份作为验证集。然后经过4次(组)的测试,每次都更换不同的验证集。即得到4组模型的结果,取平均值作为最终结果。又称4折交叉验证。

    分析

    我们之前知道数据分为训练集和测试集,但是**为了让从训练得到模型结果更加准确。**做以下处理

    • 训练集:训练集+验证集
    • 测试集:测试集

    在这里插入图片描述

    为什么需要交叉验证

    交叉验证目的:为了让被评估的模型更加准确可信

    问题:那么这个只是对于参数得出更好的结果,那么怎么选择或者调优参数呢?

    什么是网格搜索(Grid Search)

    通常情况下,有很多参数是需要手动指定的(如k-近邻算法中的K值),这种叫超参数。但是手动过程繁杂,所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型

    在这里插入图片描述

    交叉验证,网格搜索(模型选择与调优)API:

    sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)

    • 对估计器的指定参数值进行详尽搜索
    • estimator:估计器对象
    • param_grid:估计器参数(dict){“n_neighbors”:[1,3,5]}
    • cv:指定几折交叉验证
    • fit:输入训练数据
    • score:准确率
    • 结果分析:
      • bestscore__:在交叉验证中验证的最好结果
      • bestestimator:最好的参数模型
      • cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果

    鸢尾花案例增加K值调优

    • 使用GridSearchCV构建估计器
    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.preprocessing import StandardScaler
    from sklearn.neighbors import KNeighborsClassifier
    
    # 1、获取数据集
    iris = load_iris()
    # 2、数据基本处理 -- 划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    # 3、特征工程:标准化
    # 实例化一个转换器类
    transfer = StandardScaler()
    # 调用fit_transform
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4、KNN预估器流程
    #  4.1 实例化预估器类
    estimator = KNeighborsClassifier()
    
    # 4.2 模型选择与调优——网格搜索和交叉验证
    # 准备要调的超参数
    param_dict = {"n_neighbors": [1, 3, 5]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=3)
    # 4.3 fit数据进行训练
    estimator.fit(x_train, y_train)
    # 5、评估模型效果
    # 方法a:比对预测结果和真实值
    y_predict = estimator.predict(x_test)
    print("比对预测结果和真实值:\n", y_predict == y_test)
    # 方法b:直接计算准确率
    score = estimator.score(x_test, y_test)
    print("直接计算准确率:\n", score)
    
    • 然后进行评估查看最终选择的结果和交叉验证的结果
    print("在交叉验证中验证的最好结果:\n", estimator.best_score_)
    print("最好的参数模型:\n", estimator.best_estimator_)
    print("每次交叉验证后的准确率结果:\n", estimator.cv_results_)
    
    • 最终结果
    比对预测结果和真实值:
     [ True  True  True  True  True  True  True False  True  True  True  True
      True  True  True  True  True  True False  True  True  True  True  True
      True  True  True  True  True  True  True  True  True  True  True  True
      True  True]
    直接计算准确率:
     0.9473684210526315
    在交叉验证中验证的最好结果:
     0.9732100521574205
    最好的参数模型:
     KNeighborsClassifier()
    每次交叉验证后的准确率结果:
     {'mean_fit_time': array([0.00066702, 0.00033331, 0.00033204]), 'std_fit_time': array([0.00047165, 0.00047137, 0.00046957]), 'mean_score_time': array([0.00099993, 0.00100025, 0.00100136]), 'std_score_time': array([6.23849294e-06, 7.37000982e-07, 2.75989459e-06]), 'param_n_neighbors': masked_array(data=[1, 3, 5],
                 mask=[False, False, False],
           fill_value='?',
                dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}], 'split0_test_score': array([0.97368421, 0.97368421, 0.97368421]), 'split1_test_score': array([0.97297297, 0.97297297, 0.97297297]), 'split2_test_score': array([0.94594595, 0.89189189, 0.97297297]), 'mean_test_score': array([0.96420104, 0.94618303, 0.97321005]), 'std_test_score': array([0.01291157, 0.03839073, 0.00033528]), 'rank_test_score': array([2, 3, 1])}
    
    

    案例2:预测facebook签到位置

    数据集介绍

    在这里插入图片描述

    数据介绍:将根据用户的位置,准确性和时间戳预测用户正在查看的业务。

    train.csv,test.csv 
    row_id:登记事件的ID
    xy:坐标
    准确性:定位准确性 
    时间:时间戳
    place_id:业务的ID,这是您预测的目标
    

    官网:https://www.kaggle.com/navoshta/grid-knn/data

    步骤分析

    • 对于数据做一些基本处理(这里所做的一些处理不一定达到很好的效果,我们只是简单尝试,有些特征我们可以根据一些特征选择的方式去做处理)
      • 1 缩小数据集范围 DataFrame.query()
      • 2 选取有用的时间特征
      • 3 将签到位置少于n个用户的删除
    • 分割数据集
    • 标准化处理
    • k-近邻预测

    代码过程

    • 1.获取数据集
    import pandas as pd
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.preprocessing import StandardScaler
    from sklearn.neighbors import KNeighborsClassifier
    # 1、获取数据集
    facebook = pd.read_csv("../data/FBlocation/train.csv")
    
    • 2.基本数据处理
    # 2.基本数据处理
    # 2.1 缩小数据范围
    facebook_data = facebook.query("x>2.0 & x<2.5 & y>2.0 & y<2.5")
    # 2.2 选择时间特征
    time = pd.to_datetime(facebook_data["time"], unit="s")
    time = pd.DatetimeIndex(time)
    facebook_data.loc[:, 'day'] = time.day
    facebook_data.loc[:, 'hour'] = time.hour
    facebook_data.loc[:, 'weekday'] = time.weekday
    # 2.3 去掉签到较少的地方
    place_count = facebook_data.groupby("place_id").count()
    place_count = place_count[place_count["row_id"]>3]
    facebook_data = facebook_data[facebook_data["place_id"].isin(place_count.index)]
    # 2.4 确定特征值和目标值
    x = facebook_data[["x", "y", "accuracy", "day", "hour", "weekday"]]
    y = facebook_data["place_id"]
    # 2.5 分割数据集
    x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)
    
    • 特征工程–特征预处理(标准化)
    # 3.特征工程--特征预处理(标准化)
    # 3.1 实例化一个转换器
    transfer = StandardScaler()
    # 3.2 调用fit_transform
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)
    
    • 机器学习–knn+cv
    # 4.机器学习--knn+cv
    # 4.1 实例化一个估计器
    estimator = KNeighborsClassifier()
    # 4.2 调用gridsearchCV
    param_grid = {"n_neighbors": [1, 3, 5, 7, 9]}
    estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5)
    # 4.3 模型训练
    estimator.fit(x_train, y_train)
    
    • 模型评估
    # 5.模型评估
    # 5.1 基本评估方式
    score = estimator.score(x_test, y_test)
    print("最后预测的准确率为:\n", score)
    
    y_predict = estimator.predict(x_test)
    print("最后的预测值为:\n", y_predict)
    print("预测值和真实值的对比情况:\n", y_predict == y_test)
    
    # 5.2 使用交叉验证后的评估方式
    print("在交叉验证中验证的最好结果:\n", estimator.best_score_)
    print("最好的参数模型:\n", estimator.best_estimator_)
    print("每次交叉验证后的验证集准确率结果和训练集准确率结果:\n",estimator.cv_results_)
    
    #返回结果
    最后预测的准确率为:
     0.36567336567336567
    最后的预测值为:
     [9983648790 6329243787 9674001925 ... 2990018952 4830766946 7065571836]
    预测值和真实值的对比情况:
     24703810     True
    19445902    False
    18490063     True
    7762709     False
    6505956     False
                ...  
    27632888    False
    23367671    False
    6692268      True
    25834435    False
    13319005    False
    Name: place_id, Length: 17316, dtype: bool
    在交叉验证中验证的最好结果:
     0.3546044971864908
    最好的参数模型:
     KNeighborsClassifier(n_neighbors=1)
    每次交叉验证后的验证集准确率结果和训练集准确率结果:
     {'mean_fit_time': array([0.06821856, 0.06839781, 0.06859961, 0.06818752, 0.06879673]), 'std_fit_time': array([0.00116769, 0.00079952, 0.00049092, 0.0003921 , 0.00074727]), 'mean_score_time': array([0.26117702, 0.2974082 , 0.32080026, 0.3380229 , 0.36039748]), 'std_score_time': array([0.00674374, 0.00500062, 0.00276636, 0.00210554, 0.00367126]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9],
                 mask=[False, False, False, False, False],
           fill_value='?',
                dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}], 'split0_test_score': array([0.35948027, 0.34311838, 0.35235804, 0.35303176, 0.34927815]), 'split1_test_score': array([0.35466795, 0.34369586, 0.35563041, 0.35370549, 0.34821944]), 'split2_test_score': array([0.35524543, 0.34119346, 0.3506256 , 0.35129933, 0.34860443]), 'split3_test_score': array([0.3514294 , 0.34141881, 0.35681971, 0.35537588, 0.35075561]), 'split4_test_score': array([0.35219944, 0.34161132, 0.35152565, 0.34757917, 0.34132255]), 'mean_test_score': array([0.3546045 , 0.34220757, 0.35339188, 0.35219832, 0.34763604]), 'std_test_score': array([0.00283032, 0.00100506, 0.00240687, 0.00265359, 0.00327312]), 'rank_test_score': array([1, 5, 2, 3, 4])}
    

    ([0.06821856, 0.06839781, 0.06859961, 0.06818752, 0.06879673]), ‘std_fit_time’: array([0.00116769, 0.00079952, 0.00049092, 0.0003921 , 0.00074727]), ‘mean_score_time’: array([0.26117702, 0.2974082 , 0.32080026, 0.3380229 , 0.36039748]), ‘std_score_time’: array([0.00674374, 0.00500062, 0.00276636, 0.00210554, 0.00367126]), ‘param_n_neighbors’: masked_array(data=[1, 3, 5, 7, 9],
    mask=[False, False, False, False, False],
    fill_value=’?’,
    dtype=object), ‘params’: [{‘n_neighbors’: 1}, {‘n_neighbors’: 3}, {‘n_neighbors’: 5}, {‘n_neighbors’: 7}, {‘n_neighbors’: 9}], ‘split0_test_score’: array([0.35948027, 0.34311838, 0.35235804, 0.35303176, 0.34927815]), ‘split1_test_score’: array([0.35466795, 0.34369586, 0.35563041, 0.35370549, 0.34821944]), ‘split2_test_score’: array([0.35524543, 0.34119346, 0.3506256 , 0.35129933, 0.34860443]), ‘split3_test_score’: array([0.3514294 , 0.34141881, 0.35681971, 0.35537588, 0.35075561]), ‘split4_test_score’: array([0.35219944, 0.34161132, 0.35152565, 0.34757917, 0.34132255]), ‘mean_test_score’: array([0.3546045 , 0.34220757, 0.35339188, 0.35219832, 0.34763604]), ‘std_test_score’: array([0.00283032, 0.00100506, 0.00240687, 0.00265359, 0.00327312]), ‘rank_test_score’: array([1, 5, 2, 3, 4])}

    
    
    展开全文
  • k-近邻算法K-Nearest Neighbour algorithm),又称KNN算法,是数据挖掘技术中原理最简单的算法。 工作原理:给定一个已知标签类别的训练数据集,输入没有标签的新数据后,在训练数据集中找到与新数据最邻近的k个...
  • 分类的故事之K-近邻算法(KNN) 文章同步更新在公众号“肥宅的日杂铺” KNN(k-Nearest Neighbor),是著名的模式识别统计学方法,也最简单的机器学习算法之一。其中心思想为近朱者赤,近墨者黑(相似即为同类)。 ...
  • k-近邻算法----------回归算法.html
  • K近邻法(k-nearestneighbor,k-NN)是1967年由CoverT和Hart P提出的一种基本分类与回归方法。它的工作原理是:存在一个样本数据集合,也称作为训练样本集,并且样本集中每个数据都存在标签,即我们知道样本集中每一个...
  • 机器学习——K-近邻算法 (一)K-近邻算法概述 (一)K-近邻算法概述 K-近邻法(K-nearest neighbor, K-NN)是1967年由Cover T和Hart P提出的一种基本分类与回归方法。它的工作原理是:存在一个样本数据集合...
  • 机器学习--K-近邻算法(KNN)

    千次阅读 2021-09-07 08:51:21
    1、K近邻算法的特点 k-近邻算法,也叫KNN算法(K-Nearest Neihbor,KNN),是一个非常适合入门的算法,拥有如下特性: 适用于分类问题,尤其是二分类,当然也可以用来预测回归问题 思想极度简单,应用数学...
  • K-近邻算法(KNN)

    万次阅读 2021-03-25 23:04:20
    公众号 Python编程和深度学习《机器学习系列(一)K-近邻算法》 《统计学习方法》第二版 数据酷客 JYRoy博文《kNN算法:K最近邻(kNN,k-NearestNeighbor)分类算法》 文章目录1.K-近邻算法小例子评价2.K-近邻模型...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 34,658
精华内容 13,863
关键字:

k-近邻算法

友情链接: fx4.rar