算法修炼——KNN（入门）

最新推荐文章于 2022-03-06 17:01:27 发布

Pchoy

最新推荐文章于 2022-03-06 17:01:27 发布

阅读量649

点赞数 1

本文链接：https://blog.csdn.net/qq_33182424/article/details/82836174

版权

机器学习算法大概学了一遍但是觉得理解不深，所以决定从头开始再学一遍，写在博客里，加深一下理解，方便以后查阅。

knn作为机器学习的入门算法，虽然它不是很复杂，但是学起来也没有那么简单。因为刚刚接触机器学习领域，knn并不仅仅是作为一个算法来进行学习，它更多的是可以为我们解释机器学习算法使用过程中的细节问题，可以帮助我们更加完整的刻画机器学习应用的流程。

本章我只介绍最为简单的knn算法，进阶版的knn我会在下一章写。

我使用的工具包括：Anaconda 集成环境，Jupyter Notebook 测试、编译代码，Pycharm

knn 算法的优点：

knn 算法的缺点：

原理案例介绍

假设现在设计一个程序判断一个新的肿瘤病人是良性肿瘤还是恶性肿瘤

先基于原有的肿瘤病人的发现时间和肿瘤大小（特征）对应的良性/恶性（值）建立了一张散点图，横坐标是肿瘤大小，纵坐标是发现时间，红色代表良性，蓝色代表恶性，现在要预测的病人的颜色为绿色

首先需要取一个k值（这个k值的取法后面会介绍），然后找到距离要预测的病人的点（绿点）距离最近的k个点
然后用第一步中取到的三个点进行投票，比如本例中投票结果就是蓝：红 = 3：0 ,3>0,所以判断这个新病人幻的事恶性肿瘤

knn的本质：

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

就是在训练集中数据和标签已知的情况下，输入测试数据，将测试数据的特征与训练集中对应的特征进行相互比较，找到训练集中与之最为相似的前K个数据，则该测试数据对应的类别就是K个数据中出现次数最多的那个分类，其算法的描述为：

1）计算测试数据与各个训练数据之间的距离；

2）按照距离的递增关系进行排序；

3）选取距离最小的K个点；

4）确定前K个点所在类别的出现频率；

5）返回前K个点中出现频率最高的类别作为测试数据的预测分类。

knn算法的一个简单实现：

import numpy as np

import matplotlib as plt

原始集合：

#特征

raw_data_x= [ [3.393533211,2.331273381],

[2.110073483,1.781539638],

[1.343808831,3.368360954],

[3.582294042,4.679179110],

[2.280362439,2.866990263],

[7.423436942,4.696522875],

[5.745051997,3.533989803],

[9.172168622,2.511101045],

[7.792783481,3.424088941],

[7.939820817,0.791637231] ]

#所属类别

raw_data_y = [0,0,0,0,0,1,1,1,1,1]

X_train = np.array(raw_data_x)

y_train = np.array(raw_data_y)
# 要预测的点
x = np.array([8.093607318,3.365731514])

接下来让我们绘制一下数据集及预测的点：

scatter([X_train[y_train==0,0]],X_train[y_train==0,1],color='g') # 目标值为0的点

scatter([X_train[y_train==1,0]],X_train[y_train==1,1],color='r') #目标值为1的点

scatter(X[0],X[1],color='b')

KNN算法的封装：

import  numpy as np
from math import sqrt
from collections import  Counter
from .metrics     import accuracy_score

class KNNClassifier:

    def __init__(self,k):
        """初始化kNN分类器"""
        """ self在定义时需要定义，但是在调用时会自动传入。
            self的名字并不是规定死的，但是最好还是按照约定是用self
            self总是指调用时的类的实例。"""
        assert k>=1, "k must be valid"
        self.k = k
        self._X_train = None
        self._y_train = None

    def fit(self,X_train,y_train):
        """根据训练数据集X_train和y_train训练kNN分类器"""
        assert X_train.shape[0] == y_train.shape[0], \
            "the size of X_train must equal to the size of y_train"
        assert  self.k <= X_train.shape[0], \
            "the size of X_train must be at least k"
        self._X_train = X_train
        self._y_train = y_train
        return self

    def predict(self,X_predict):
        """给定待预测数据集X——predict,返回表示X_predict的结果向量"""
        assert self._X_train is not None and self._y_train is not None, \
            "must fit before predict"
        assert X_predict.shape[1] == self._X_train.shape[1], \
            "the feature number if X_predict must be equal to X_train"

        y_predict = [self._predict(x) for x in X_predict]

        return np.array(y_predict)

    def _predict(self,x):
        """给定单个待预测数据x，返回x的预测结果值"""
        assert x.shape[0] == self._X_train.shape[1], \
             "the feature number of x must be equal to X_train"
        distances = [sqrt(np.sum((x_train - x)**2)) for x_train in self._X_train]

        nearest = np.argsort(distances)

        topK_y = [self._y_train[i] for i in nearest[:self.k]]

        votes = Counter(topK_y)

        return votes.most_common(1)[0][0]

    def score(self,X_test,y_test):
        """根据测试数据集X_test和y_test 确定当前模型的准确度"""
        y_predict = self.predict(X_test)
        return  accuracy_score(y_test,y_predict)

    def __repr__(self):
        return "KNN(k=%d)" % self.k

让我们再看一下机器学习的原理：

啊

可以说kNN是一个不需要训练过程的算法
  k近邻算法是非常特殊的，可以被认为是没有模型的算法
  为了和其他算法统一，可以认为训练数据集就是模型

判断机器学习算法的性能：

train test split

使用我们自己封装的测试封装函数去分割数据集

def train_test_split(X, y, test_ratio=0.2,seed = None):
    """将数据 X 和 y 按照test_ratio分割成X_train , X_test ,y_train,y_test"""

    assert X.shape[0] == y.shape[0], \
        "the size of X must be equal to the size of y"
    assert 0.0 <= test_ratio <= 1.0, \
        "test_ration must be valid"

    if seed:
        np.random.seed(seed)

    # 先乱序化处理
    shuffle_indexes = np.random.permutation(len(X))
    test_size = int(len(X) * test_ratio)
    test_indexes = shuffle_indexes[:test_size]
    train_indexes = shuffle_indexes[test_size:]
    X_train = X[train_indexes]
    y_train = y[train_indexes]

    X_test = X[test_indexes]
    y_test = y[test_indexes]

    return X_train,X_test,y_train,y_test

测试我们的KNN算法：

这里我使用的是sklearn数据集的鸢尾花数据集。

import numpy as np
from sklearn import datasets

iris = datasets.load_iris()

X = iris.data

y = iris.target

接下来让我们看一下数据集X：

array([[5.1, 3.5, 1.4, 0.2], [4.9, 3. , 1.4, 0.2], [4.7, 3.2, 1.3, 0.2], [4.6, 3.1, 1.5, 0.2], [5. , 3.6, 1.4, 0.2], [5.4, 3.9, 1.7, 0.4], [4.6, 3.4, 1.4, 0.3], [5. , 3.4, 1.5, 0.2], [4.4, 2.9, 1.4, 0.2], [4.9, 3.1, 1.5, 0.1], [5.4, 3.7, 1.5, 0.2], [4.8, 3.4, 1.6, 0.2], [4.8, 3. , 1.4, 0.1], [4.3, 3. , 1.1, 0.1], [5.8, 4. , 1.2, 0.2], [5.7, 4.4, 1.5, 0.4], [5.4, 3.9, 1.3, 0.4], [5.1, 3.5, 1.4, 0.3], [5.7, 3.8, 1.7, 0.3], [5.1, 3.8, 1.5, 0.3], [5.4, 3.4, 1.7, 0.2], [5.1, 3.7, 1.5, 0.4], [4.6, 3.6, 1. , 0.2], [5.1, 3.3, 1.7, 0.5], [4.8, 3.4, 1.9, 0.2], [5. , 3. , 1.6, 0.2], [5. , 3.4, 1.6, 0.4], [5.2, 3.5, 1.5, 0.2], [5.2, 3.4, 1.4, 0.2], [4.7, 3.2, 1.6, 0.2], [4.8, 3.1, 1.6, 0.2], [5.4, 3.4, 1.5, 0.4], [5.2, 4.1, 1.5, 0.1], [5.5, 4.2, 1.4, 0.2], [4.9, 3.1, 1.5, 0.1], [5. , 3.2, 1.2, 0.2], [5.5, 3.5, 1.3, 0.2], [4.9, 3.1, 1.5, 0.1], [4.4, 3. , 1.3, 0.2], [5.1, 3.4, 1.5, 0.2], [5. , 3.5, 1.3, 0.3], [4.5, 2.3, 1.3, 0.3], [4.4, 3.2, 1.3, 0.2], [5. , 3.5, 1.6, 0.6], [5.1, 3.8, 1.9, 0.4], [4.8, 3. , 1.4, 0.3], [5.1, 3.8, 1.6, 0.2], [4.6, 3.2, 1.4, 0.2], [5.3, 3.7, 1.5, 0.2], [5. , 3.3, 1.4, 0.2], [7. , 3.2, 4.7, 1.4], [6.4, 3.2, 4.5, 1.5], [6.9, 3.1, 4.9, 1.5], [5.5, 2.3, 4. , 1.3], [6.5, 2.8, 4.6, 1.5], [5.7, 2.8, 4.5, 1.3], [6.3, 3.3, 4.7, 1.6], [4.9, 2.4, 3.3, 1. ], [6.6, 2.9, 4.6, 1.3], [5.2, 2.7, 3.9, 1.4], [5. , 2. , 3.5, 1. ], [5.9, 3. , 4.2, 1.5], [6. , 2.2, 4. , 1. ], [6.1, 2.9, 4.7, 1.4], [5.6, 2.9, 3.6, 1.3], [6.7, 3.1, 4.4, 1.4], [5.6, 3. , 4.5, 1.5], [5.8, 2.7, 4.1, 1. ], [6.2, 2.2, 4.5, 1.5], [5.6, 2.5, 3.9, 1.1], [5.9, 3.2, 4.8, 1.8], [6.1, 2.8, 4. , 1.3], [6.3, 2.5, 4.9, 1.5], [6.1, 2.8, 4.7, 1.2], [6.4, 2.9, 4.3, 1.3], [6.6, 3. , 4.4, 1.4], [6.8, 2.8, 4.8, 1.4], [6.7, 3. , 5. , 1.7], [6. , 2.9, 4.5, 1.5], [5.7, 2.6, 3.5, 1. ], [5.5, 2.4, 3.8, 1.1], [5.5, 2.4, 3.7, 1. ], [5.8, 2.7, 3.9, 1.2], [6. , 2.7, 5.1, 1.6], [5.4, 3. , 4.5, 1.5], [6. , 3.4, 4.5, 1.6], [6.7, 3.1, 4.7, 1.5], [6.3, 2.3, 4.4, 1.3], [5.6, 3. , 4.1, 1.3], [5.5, 2.5, 4. , 1.3], [5.5, 2.6, 4.4, 1.2], [6.1, 3. , 4.6, 1.4], [5.8, 2.6, 4. , 1.2], [5. , 2.3, 3.3, 1. ], [5.6, 2.7, 4.2, 1.3], [5.7, 3. , 4.2, 1.2], [5.7, 2.9, 4.2, 1.3], [6.2, 2.9, 4.3, 1.3], [5.1, 2.5, 3. , 1.1], [5.7, 2.8, 4.1, 1.3], [6.3, 3.3, 6. , 2.5], [5.8, 2.7, 5.1, 1.9], [7.1, 3. , 5.9, 2.1], [6.3, 2.9, 5.6, 1.8], [6.5, 3. , 5.8, 2.2], [7.6, 3. , 6.6, 2.1], [4.9, 2.5, 4.5, 1.7], [7.3, 2.9, 6.3, 1.8], [6.7, 2.5, 5.8, 1.8], [7.2, 3.6, 6.1, 2.5], [6.5, 3.2, 5.1, 2. ], [6.4, 2.7, 5.3, 1.9], [6.8, 3. , 5.5, 2.1], [5.7, 2.5, 5. , 2. ], [5.8, 2.8, 5.1, 2.4], [6.4, 3.2, 5.3, 2.3], [6.5, 3. , 5.5, 1.8], [7.7, 3.8, 6.7, 2.2], [7.7, 2.6, 6.9, 2.3], [6. , 2.2, 5. , 1.5], [6.9, 3.2, 5.7, 2.3], [5.6, 2.8, 4.9, 2. ], [7.7, 2.8, 6.7, 2. ], [6.3, 2.7, 4.9, 1.8], [6.7, 3.3, 5.7, 2.1], [7.2, 3.2, 6. , 1.8], [6.2, 2.8, 4.8, 1.8], [6.1, 3. , 4.9, 1.8], [6.4, 2.8, 5.6, 2.1], [7.2, 3. , 5.8, 1.6], [7.4, 2.8, 6.1, 1.9], [7.9, 3.8, 6.4, 2. ], [6.4, 2.8, 5.6, 2.2], [6.3, 2.8, 5.1, 1.5], [6.1, 2.6, 5.6, 1.4], [7.7, 3. , 6.1, 2.3], [6.3, 3.4, 5.6, 2.4], [6.4, 3.1, 5.5, 1.8], [6. , 3. , 4.8, 1.8], [6.9, 3.1, 5.4, 2.1], [6.7, 3.1, 5.6, 2.4], [6.9, 3.1, 5.1, 2.3], [5.8, 2.7, 5.1, 1.9], [6.8, 3.2, 5.9, 2.3], [6.7, 3.3, 5.7, 2.5], [6.7, 3. , 5.2, 2.3], [6.3, 2.5, 5. , 1.9], [6.5, 3. , 5.2, 2. ], [6.2, 3.4, 5.4, 2.3], [5.9, 3. , 5.1, 1.8]])

再看一下目标集y：

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2])

首先使用train_test_split去分割数据集。

from knn8.model_selection import train_test_split

X_train,y_train,X_test,y_test = train_test_split(X,y,0.2)

在jupyter notebook中调用我们自己的knn算法：

from knn8.knn import KNNClassifier
knn_clf = KNNClassifier(k=6) #生成k值为6的分类器

knn_clf.fit(X_train,y_train) #训练数据

y_predict = knn_clf.predict(X_test) #预测测试数据。

y_predict

sum(y_predict==y_test) / len(y_test) # 简单的计算一下精度。

96%的精确度，还是可以的，hhhhh

接下来，我们使用scikit-learn提供的knn算法：

from sklearn.neighbors import KNeighborsClassifier
clf_knn = KNeighborsClassifier(n_neighbors=6)
clf_knn.fit(X_train,y_train)
y_predict = clf_knn.predict(X_test)

clf_knn.score(X_test,y_test)

因为scikit-learn内部的knn使用了交叉验证等一系列方法，所以结果更加真实。

好了，写到这里，最简单的knn已经差不多结束了。下一次我会写knn的进阶版，包括超参数的选择，会考虑距离的权重，明可夫斯基距离，网格搜索，数据归一化。

刚刚开始学习，有不对的地方，还望多多指正。

Pchoy

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
算法修炼——KNN（入门）

机器学习算法大概学了一遍但是觉得理解不深，所以决定从头开始再学一遍，写在博客里，加深一下理解，方便以后查阅。knn作为机器学习的入门算法，虽然它不是很复杂，但是学起来也没有那么简单。因为刚刚接触机器学习领域，knn并不仅仅是作为一个算法来进行学习，它更多的是可以为我们解释机器学习算法使用过程中的细节问题，可以帮助我们更加完整的刻画机器学习应用的流程。本章我只介绍最为简单的knn算法，进阶版...
复制链接

扫一扫