精华内容
下载资源
问答
  • knn算法knn算法knn算法

    2018-11-19 10:38:22
    kNN算法的核心思想是如果一个样本在特征空间中的k个最相邻的样本中的大多数属于某一个类别,则该样本也属于这个类别,并具有这个类别上样本的特性。该方法在确定分类决策上只依据最邻近的一个或者几个样本的类别来...
  • KNN算法

    万次阅读 2020-10-29 15:12:11
    1 KNN算法 1.1 定义 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。 1.2 距离公式 两个样本的距离可以通过如下公式计算,又叫欧式距离。 ...

    KNN即K-NearestNeighbor,就是k个最近的邻居的意思,说的是每个样本都可以用它最接近的K个邻近值来代表。

    1 KNN算法

    1.1 定义

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

    1.2 距离公式

    两个样本的距离可以通过如下公式计算,又叫欧式距离。

    欧氏距离计算公式如下:

     

    比如存在点a(x1, y1, z1), b(x2, y2, z2)两个点,则a到b的距离为 :

    2 电影类型分析

    假设我们又现在几部电影:

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

    假设我们选定离未知电影距离最近的三个电影为评判标准(即选择k等于3),从上图可以看出,离未知类别电影距离最近的电影分别为He's not Really into dues、Beautiful Woman、California Man,三个距离均为爱情片,即算法推断未知电影类型为爱情片。假设此处3个电影类别为两个爱情片、一个动作片,算法计算的结果也为爱情片(即投票法,少数服从多数)。

    3 KNN算法API

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

    • n_neighbors:int,可选(默认= 5),k_neighbors查询默认使用的邻居数
    • algorithm:{‘auto’,‘ball_tree’,‘kd_tree’,‘brute’},可选用于计算最近邻居的算法:‘ball_tree’将会使用 BallTree,‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

    (sklearn官网:https://scikit-learn.org/stable/modules/generated/sklearn.neighbors.KNeighborsClassifier.html#sklearn.neighbors.KNeighborsClassifier

    4 案例:预测标签位置(kaggle)

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

    train.csv,test.csv 

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

    数据网址:https://www.kaggle.com/navoshta/grid-knn/data

    4.1 分析

    • 对于数据做一些基本处理(这里所做的一些处理不一定达到很好的效果,我们只是简单尝试,有些特征我们可以根据一些特征选择的方式去做处理)
    1. 缩小数据集范围 DataFrame.query()
    2. 删除没用的日期数据 DataFrame.drop(可以选择保留)
    3. 将签到位置少于n个用户的删除place_count = data.groupby('place_id').count()、tf = place_count[place_count.row_id > 3].reset_index()、data = data[data['place_id'].isin(tf.place_id)]
    • 分割数据集
    • 标准化处理
    • knn预测

    4.2 代码

    def knncls():
        """
        K近邻算法预测入住位置类别
        :return:
        """
        # 一、处理数据以及特征工程
        # 1、读取收,缩小数据的范围
        data = pd.read_csv("./train.csv")
    
        # 数据逻辑筛选操作 df.query()
        data = data.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")
    
        # 删除time这一列特征
        data = data.drop(['time'], axis=1)
    
        print(data)
    
        # 删除入住次数少于三次位置
        place_count = data.groupby('place_id').count()
    
        tf = place_count[place_count.row_id > 3].reset_index()
    
        data = data[data['place_id'].isin(tf.place_id)]
    
        # 3、取出特征值和目标值
        y = data['place_id']
        # y = data[['place_id']]
    
        x = data.drop(['place_id', 'row_id'], axis=1)
    
        # 4、数据分割与特征工程?
    
        # (1)、数据分割
        x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)
    
        # (2)、标准化
        std = StandardScaler()
    
        # 队训练集进行标准化操作
        x_train = std.fit_transform(x_train)
        print(x_train)
    
        # 进行测试集的标准化操作
        x_test = std.fit_transform(x_test)
    
        # 二、算法的输入训练预测
        # K值:算法传入参数不定的值    理论上:k = 根号(样本数)
        # K值:后面会使用参数调优方法,去轮流试出最好的参数[1,3,5,10,20,100,200]
        knn = KNeighborsClassifier(n_neighbors=1)
    
        # 调用fit()
        knn.fit(x_train, y_train)
    
        # 预测测试数据集,得出准确率
        y_predict = knn.predict(x_test)
    
        print("预测测试集类别:", y_predict)
    
        print("准确率为:", knn.score(x_test, y_test))
    
        return None

    5. KNN总结

    • 优点:简单,易于理解,易于实现,无需训练
    • 缺点:1.懒惰算法,对测试样本分类时的计算量大,内存开销大

                      2.必须指定K值,K值选择不当则分类精度不能保证

    • 使用场景:小数据场景,几千~几万样本,具体场景具体业务去测试

     

     

     

     

     

    展开全文
  • knn 算法

    2008-08-20 23:15:09
    knn 算法knn 算法knn 算法knn 算法knn 算法knn 算法
  • knn算法

    千次阅读 2020-03-01 12:23:15
    knn算法 K-近邻算法定义 K Nearest Neighbor算法又叫KNN算法,这个算法是机器学习里面一个比较经典的算法, 总体来说KNN算法是相对比较容易理解的算法 , 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)...

    knn算法

    K-近邻算法定义

    K Nearest Neighbor算法又叫KNN算法,这个算法是机器学习里面一个比较经典的算法, 总体来说KNN算法是相对比较容易理解的算法 , 如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别,则该样本也属于这个类别。

    KNN算法流程

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

    2. 按距离递增次序排序

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

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

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

    k近邻算法api初步使用

    机器学习流程 :

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

    Scikit-learn工具介绍:

    Python语言的机器学习工具
    	Scikit-learn包括许多知名的机器学习算法的实现
    	Scikit-learn文档完善,容易上手,丰富的API
    包含内容:
    	分类、聚类、回归
    	特征工程
    	模型选择、调优
    优点:
    	文档多,且规范,包含的算法多,实现起来容易
    目前稳定版本0.19.1
    

    Scikit-learn官网地址

    K-近邻算法API**:

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

    小案例

    # 导入模块
    from sklearn.neighbors import KNeighborsClassifier
    
    # 1.获取数据集
    x = [[0], [1], [2], [3]]
    y = [0, 0, 1, 1]
    # 2.数据基本处理(该案例中省略)
    # 3.特征工程(该案例中省略)
    # 4.机器学习
    # 实例化API
    estimator = KNeighborsClassifier(n_neighbors=2)
    # 使用fit方法进行训练
    estimator.fit(x, y)
    # 输出预测值
    print(estimator.predict([[1]]))
    # 5.模型评估(该案例中省略)
    

    K值选择

    K值选择:

    李航博士的一书「统计学习方法」上所说:

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

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

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

    实际应用中,K值一般取一个比较小的数值,例如采用交叉验证法(简单来说,就是把训练数据在分成两组:训练集和验证集)来选择最优的K值。

    KNN中K值选择

    • K值过小
      • 容易受到异常点的影响
      • 容易过拟合
    • k值过大:
      • 受到样本均衡的问题
      • 容易欠拟合

    kd树

    定义:

    根据KNN每次需要预测一个点时,我们都需要计算训练数据集里每个点到这个点的距离,然后选出距离最近的k个点进行投票。当数据集很大时,这个计算成本非常高

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

    最近邻域搜索:

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

    构造方法:

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

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

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

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

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

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

      解决方法可以是随机选择某一维或按顺序选择,但是更好的方法应该是在数据比较分散的那一维进行划分(分散的程度可以根据方差来衡量)

    2. 如何划分数据;

      好的划分方法可以使构建的树比较平衡,可以每次选择中位数来进行划分。

    kd树的搜索过程:

    1. 二叉树搜索比较待查询节点和分裂节点的分裂维的值,(小于等于就进入左子树分支,大于就进入右子树分支直到叶子结点)
    2. 顺着“搜索路径”找到最近邻的近似点
    3. 回溯搜索路径,并判断搜索路径上的结点的其他子结点空间中是否可能有距离查询点更近的数据点,如果有可能,则需要跳到其他子结点空间中去搜索
    4. 重复这个过程直到搜索路径为空
    

    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大数据集

    • sklearn.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:标签名

    查看数据分布

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

    • seaborn介绍
      • Seaborn 是基于 Matplotlib 核心库进行了更高级的 API 封装,可以让你轻松地画出更漂亮的图形。而 Seaborn 的漂亮主要体现在配色更加舒服、以及图形元素的样式更加细腻。
      • 安装 pip3 install seaborn
      • seaborn.lmplot() 是一个非常有用的方法,它会在绘制二维散点图时,自动完成回归拟合
        • sns.lmplot() 里的 x, y 分别代表横纵坐标的列名,
        • data= 是关联到数据集,
        • hue=*代表按照 species即花的类别分类显示,
        • fit_reg=是否进行线性拟合。
      • 参考链接: api链接
    %matplotlib inline  
    # 内嵌绘图
    import seaborn as sns
    import matplotlib.pyplot as plt
    import pandas as pd
    
    # 把数据转换成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
        • x_train, x_test, y_train, y_test
    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])之间。

    API:

    sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
    	MinMaxScalar.fit_transform(X)
    		X:numpy array格式的数据[n_samples,n_features]
    	返回值:转换后的形状相同的array
    

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

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

    API:

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

    交叉验证,网格搜索

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

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

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

    网格搜索: 通常情况下,有很多参数是需要手动指定的(如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:每次交叉验证后的验证集准确率结果和训练集准确率结果
    

    案例1-鸢尾花种类预测

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

    代码实现:

    from sklearn.datasets import load_iris
    from sklearn.model_selection import train_test_split
    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_)
    

    案例2-预测facebook签到位置

    本次比赛的目的是预测一个人将要签到的地方。 为了本次比赛,Facebook创建了一个虚拟世界,其中包括10公里*10公里共100平方公里的约10万个地方。 对于给定的坐标集,您的任务将根据用户的位置,准确性和时间戳等预测用户下一次的签到位置。 数据被制作成类似于来自移动设备的位置数据。 请注意:您只能使用提供的数据进行预测。

    数据集介绍:

    文件说明 train.csv, test.csv
      row id:签入事件的id
      x y:坐标
      accuracy: 准确度,定位精度
      time: 时间戳
      place_id: 签到的位置,这也是你需要预测的内容
    

    数据来源: 官网:https://www.kaggle.com/navoshta/grid-knn/data

    步骤分析:

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

    代码实现:

    import pandas as pd
    from sklearn.model_selection import train_test_split, GridSearchCV
    from sklearn.neighbors import KNeighborsClassifier
    from sklearn.preprocessing import StandardScaler
    
    # 1.获取数据集
    facebook = pd.read_csv("./data/FBlocation/train.csv")
    
    # 2.基本数据处理
    # 2.1 缩小数据范围
    facebook_data = facebook.query("x>2.0 & x<2.2 & y>2.0 & y<2.2")
    # 2.2 选择时间特征(脱敏)
    time = pd.to_datetime(facebook_data["time"], unit="s")
    # 转换
    time = pd.DatetimeIndex(time)
    facebook_data["day"] = time.day
    facebook_data["hour"] = time.hour
    facebook_data["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)
    
    # 4.机器学习 -- knn+cv
    # 4.1 实例化一个训练器
    estimator = KNeighborsClassifier()
    # 4.2 交叉验证,网格搜索实现,调用gridsearchCV
    param_grid = {"n_neighbors": [1, 3, 5, 7, 9]}
    # n_jobs:指定几个CPU跑程序
    estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5, n_jobs=8)
    # 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_)
    
    展开全文
  • kNN算法

    2018-07-07 01:03:38
    一、kNN算法概述 kNN是k-Nearest Neighbour的缩写,这是一种非常简单且易于理解的分类算法。回想我们从小到大在认知事物的过程当中,我们是如何判断一种事物是属于哪种类别的?通常的一种思路就是,分析当前这个...

    一、kNN算法概述

           kNN是k-Nearest Neighbour的缩写,这是一种非常简单且易于理解的分类算法。回想我们从小到大在认知事物的过程当中,我们是如何判断一种事物是属于哪种类别的?通常的一种思路就是,分析当前这个事物与我们之前所知道的类别特征进行比对,找出最接近的一类,然后就可以把这个东西归属于这一个类别。kNN算法大致就是这么一个思路,直接通过测量不同特征值之间的距离来达到分类的目的。

           kNN中的k是指在分类过程中,我们选择样本数据中前k个最相似的数据,以出现次数最多的分类,作为新数据的分类。这里的k通常是不大于20的正整数,k取3或者5的情况比较常见。


    二、kNN算法的原理

           首先是训练模型。对kNN而言,在编码过程中训练模型实际上就是记录训练集的所有数据,所以我们常说kNN没有训练模型这一过程。

           接着是测试模型。测试过程有以下几个步骤:

    1. 依次计算测试集数据与训练集各个数据之间的距离;
    2. 对计算处理的距离进行递增排序;
    3. 选择距离最小的k个数据;
    4. 选择这k个数据中出现频率最高的类别作为测试数据的预测分类。

           最后是评价模型。根据测试结果计算模型预测分类的准确率。   

         整个过程看上去非常简单、直观、明了。需要说明的是,文中一直提到的距离这个概念,指的是闵可夫斯基距离(Minkowski distance),对应数学上的Lp范数


          当p=1时,为曼哈顿距离(Manhattan distance),也称L1距离;

          当p=2时,为欧式距离(Euclidean distance),也称L2距离;

          当p=∞时,为切比雪夫距离(distance)。

          在我们使用kNN算法时,常用L1距离和L2距离,且以L2距离使用更多。


    三、算法评价

    优点:kNN是最简单、最有效的分类器;精度高;对异常值(边缘值)不敏感。

    缺点:需要记录所有训练集的数据,空间复杂度高;需要进行大量的计算,计算复杂度高;无法提取出数据内涵的结构信息。

    注意点:由于计算距离时使用的是离散型数据,所以kNN算法常用于特征值为数值型和标称型的数据。如果数据特征值为连续值,则需要根据实际情况,对特征值进行离散采样或者采用其他算法模型。


    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,284
精华内容 6,113
关键字:

knn算法