KNN算法API

用户10950404

发布于 2024-07-30 13:24:40

700

发布于 2024-07-30 13:24:40

文章被收录于专栏：人工智能

学习目标

1.K近邻算法

2.分类模型评估算法

3.K值选择

1.K近邻算法API

Sklearn API介绍

示例代码：

from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier

if __name__ == '__main__':
    # 1. 加载数据集  
    iris = load_iris() #通过iris.data 获取数据集中的特征值  iris.target获取目标值

    # 2. 数据标准化
    transformer = StandardScaler()
    x_ = transformer.fit_transform(iris.data) # iris.data 数据的特征值

    # 3. 模型训练
    estimator = KNeighborsClassifier(n_neighbors=3) # n_neighbors 邻居的数量，也就是Knn中的K值
    estimator.fit(x_, iris.target) # 调用fit方法 传入特征和目标进行模型训练

    # 4. 利用模型预测
    result = estimator.predict(x_) 
    print(result)

小结

1、sklearn中K近邻算法的对象：

from sklearn.neighbors import KNeighborsClassifier
 estimator = KNeighborsClassifier(n_neighbors=3)  # K的取值通过n_neighbors传递

K值也就是n_beighbors的选择尤为重要，下文我们会继续介绍

2、sklearn中大多数算法模型训练的API都是同一个套路

estimator = KNeighborsClassifier(n_neighbors=3) # 创建算法模型对象
estimator.fit(x_, iris.target)  # 调用fit方法训练模型
estimator.predict(x_)           # 用训练好的模型进行预测

3、sklearn中自带了几个学习数据集

都封装在sklearn.datasets 这个包中
加载数据后，通过data属性可以获取特征值，通过target属性可以获取目标值，通过DESCR属性可以获取数据集的描述信息

2.分类模型评估方法

我们在建立模型时，少不了对数据的引用，接下来我们首先介绍数据划分及选样的方法

💡💡为什么要划分数据集呢？结论：不能将所有数据集全部用于训练，为了能够评估模型的泛化能力，可以通过实验测试对学习器的泛化能力进行评估，进而做出选择。因此需要使用一个 "测试集" 来测试学习器对新样本的判别能力，以测试集上的 "测试误差" 作为泛化误差的近似。

2. 1留出法（简单交叉验证）

💡留出法 (hold-out) 将数据集 D 划分为两个互斥的集合，其中一个集合作为训练集 S，另一个作为测试集 T。

from sklearn.model_selection import train_test_split
from sklearn.model_selection import StratifiedShuffleSplit
from sklearn.model_selection import ShuffleSplit
from collections import Counter
from sklearn.datasets import load_iris


def test01():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))

    # 2. 留出法(随机分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
    print('随机类别分割:', Counter(y_train), Counter(y_test))

    # 3. 留出法(分层分割)
    x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, stratify=y)
    print('分层类别分割:', Counter(y_train), Counter(y_test))


def test02():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 多次划分(随机分割)
    spliter = ShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机多次分割:', Counter(y[test]))

    print('*' * 40)

    # 3. 多次划分(分层分割)
    spliter = StratifiedShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层多次分割:', Counter(y[test]))


if __name__ == '__main__':
    test01()
    test02()

2.2交叉验证法

💡K-Fold交叉验证，将数据随机且均匀地分成k分，如上图所示（k为10），假设每份数据的标号为0-9

第一次使用标号为0-8的共9份数据来做训练，而使用标号为9的这一份数据来进行测试，得到一个准确率
第二次使用标记为1-9的共9份数据进行训练，而使用标号为0的这份数据进行测试，得到第二个准确率
以此类推，每次使用9份数据作为训练，而使用剩下的一份数据进行测试
共进行10次训练，最后模型的准确率为10次准确率的平均值
这样可以避免了数据划分而造成的评估不准确的问题。

from sklearn.model_selection import KFold
from sklearn.model_selection import StratifiedKFold
from collections import Counter
from sklearn.datasets import load_iris

def test():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 随机交叉验证
    spliter = KFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('随机交叉验证:', Counter(y[test]))

    print('*' * 40)

    # 3. 分层交叉验证
    spliter = StratifiedKFold(n_splits=5, shuffle=True, random_state=0)
    for train, test in spliter.split(x, y):
        print('分层交叉验证:', Counter(y[test]))


if __name__ == '__main__':
    test()

2.3留一法

💡 留一法( Leave-One-Out，简称LOO），即每次抽取一个样本做为测试集

from sklearn.model_selection import LeaveOneOut
from sklearn.model_selection import LeavePOut
from sklearn.datasets import load_iris
from collections import Counter


def test01():

    # 1. 加载数据集
    x, y = load_iris(return_X_y=True)
    print('原始类别比例:', Counter(y))
    print('*' * 40)

    # 2. 留一法
    spliter = LeaveOneOut()
    for train, test in spliter.split(x, y):
        print('训练集:', len(train), '测试集:', len(test), test)

    print('*' * 40)

    # 3. 留P法
    spliter = LeavePOut(p=3)
    for train, test in spliter.split(x, y):
        print('训练集:', len(train), '测试集:', len(test), test)


if __name__ == '__main__':
    test01()

2.4自助法

💡每次随机从D中抽出一个样本，将其拷贝放入D，然后再将该样本放回初始数据集D中，使得该样本在下次采样时仍有可能被抽到；这个过程重复执行m次后，我们就得到了包含m个样本的数据集D′，这就是自助采样的结果。

import pandas as pd


if __name__ == '__main__':

    # 1. 构造数据集
    data = [[90, 2, 10, 40],
            [60, 4, 15, 45],
            [75, 3, 13, 46],
            [78, 2, 64, 22]]

    data = pd.DataFrame(data)
    print('数据集:\n',data)
    print('*' * 30)

    # 2. 产生训练集
    train = data.sample(frac=1, replace=True)
    print('训练集:\n', train)

    print('*' * 30)

    # 3. 产生测试集
    test = data.loc[data.index.difference(train.index)]
    print('测试集:\n', test)

我们得知了这几种数据划分的方法，但是哪一种划分得出的预测值是最好的呢？🔒️

2.5如何评估分类算法？

利用训练好的模型使用测试集的特征值进行预测
将预测结果和测试集的目标值比较，计算预测正确的百分比
这个百分比就是准确率 accuracy，准确率越高说明模型效果越好

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
#加载鸢尾花数据
X,y = datasets.load_iris(return_X_y = True)
#训练集 测试集划分
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
# 创建KNN分类器对象 近邻数为6
knn_clf = KNeighborsClassifier(n_neighbors=6)
#训练集训练模型
knn_clf.fit(X_train,y_train)
#使用训练好的模型进行预测
y_predict = knn_clf.predict(X_test)

计算准确率：

sum(y_predict==y_test)/y_test.shape[0]

💣️💣️sklearn封装了计算准确率的相关API：

#计算准确率
from sklearn.metrics import accuracy_score
#方式1：
accuracy_score(y_test,y_predict)
#方式2：
knn_classifier.score(X_test,y_test)

3.K值选择问题

1. K取不同值时带来的影响¶

举例：

有两类不同的样本数据，分别用蓝颜色的小正方形和红色的小三角形表示，而图正中间有一个绿色的待判样本。
问题：如何给这个绿色的圆分类？是判断为蓝色的小正方形还是红色的小三角形？
方法：应用KNN找绿色的邻居，但一次性看多少个邻居呢（K取几合适）？

解决方案：

K=4，绿色圆圈最近的4个邻居，3红色和1个蓝，按少数服从多数，判定绿色样本与红色三角形属于同一类别
K=9，绿色圆圈最近的9个邻居，6红和3个蓝，判定绿色属于红色的三角形一类。

🐵有时候出现K值选择困难的问题

KNN算法的关键是什么？

答案一定是K值的选择，下图中K=3，属于红色三角形，K=5属于蓝色的正方形。这个时候就是K选择困难的时候。

2.GridSearchCV的用法

👋👋使用 scikit-learn 提供的 GridSearchCV 工具, 配合交叉验证法可以搜索参数组合.

# 1. 加载数据集
x, y = load_iris(return_X_y=True)

# 2. 分割数据集
x_train, x_test, y_train, y_test = \
    train_test_split(x, y, test_size=0.2, stratify=y, random_state=0)

# 3. 创建网格搜索对象
estimator = KNeighborsClassifier()
param_grid = {'n_neighbors': [1, 3, 5, 7]}
estimator = GridSearchCV(estimator, param_grid=param_grid, cv=5, verbose=0)
estimator.fit(x_train, y_train)

# 4. 打印最优参数
print('最优参数组合:', estimator.best_params_, '最好得分:', estimator.best_score_)

# 4. 测试集评估模型
print('测试集准确率:', estimator.score(x_test, y_test))