数据处理和分析之分类算法：K近邻算法(KNN)：KNN在分类任务中的应用

最新推荐文章于 2024-09-28 07:41:00 发布

kkchenkx

最新推荐文章于 2024-09-28 07:41:00 发布

阅读量537

点赞数 18

分类专栏：数据挖掘文章标签：分类近邻算法数据挖掘

本文链接：https://blog.csdn.net/2401_87715305/article/details/142608290

版权

数据挖掘专栏收录该内容

23 篇文章 0 订阅

订阅专栏

数据处理和分析之分类算法：K近邻算法(KNN)：KNN在分类任务中的应用

在这里插入图片描述

数据处理和分析之分类算法：K近邻算法 (KNN)：KNN在分类任务中的应用

简介

KNN算法的基本概念

K近邻算法（K-Nearest Neighbors, KNN）是一种基于实例的学习方法，用于分类和回归。在分类任务中，KNN通过计算待分类样本与训练集中所有样本的距离，找出距离最近的K个邻居，然后根据这K个邻居的类别来预测待分类样本的类别。KNN算法简单直观，易于理解和实现，但计算量大，对数据的预处理和K值的选择敏感。

KNN算法的工作原理

KNN算法的工作流程如下：

计算距离：对于给定的待分类样本，计算它与训练集中每个样本的距离。
选择邻居：找到距离最近的K个训练样本。
类别决策：根据这K个邻居的类别，采用多数表决的方式决定待分类样本的类别。

KNN算法在分类任务中的优势与局限性

优势

易于理解和实现：KNN算法的原理简单，不需要复杂的数学模型。
对异常值不敏感：由于KNN是基于实例的学习，异常值对结果的影响较小。
可以处理多分类问题：KNN算法可以自然地扩展到多分类问题。

局限性

计算成本高：对于大规模数据集，计算每个样本之间的距离非常耗时。
对K值的选择敏感：K值的选择直接影响分类结果，选择不当可能导致过拟合或欠拟合。
对数据预处理要求高：特征的尺度和数据的分布对KNN的性能有显著影响。

示例：使用Python实现KNN分类

假设我们有以下数据集，用于分类任务：

特征1	特征2	类别
1.0	1.1	A
1.0	1.0	A
0.1	0.2	B
0.0	0.1	B

我们将使用Python的scikit-learn库来实现KNN分类。

# 导入必要的库
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import numpy as np

# 定义数据集
X = np.array([[1.0, 1.1], [1.0, 1.0], [0.1, 0.2], [0.0, 0.1]])
y = np.array(['A', 'A', 'B', 'B'])

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)

# 创建KNN分类器实例
knn = KNeighborsClassifier(n_neighbors=3)

# 训练模型
knn.fit(X_train, y_train)

# 预测新样本的类别
new_sample = np.array([[0.5, 0.6]])
prediction = knn.predict(new_sample)
print("预测类别:", prediction)

# 计算模型的准确率
accuracy = knn.score(X_test, y_test)
print("模型准确率:", accuracy)

代码解释

导入库：我们导入了scikit-learn中的KNeighborsClassifier类，用于实现KNN算法。
定义数据集：X是特征矩阵，y是类别标签。
划分数据集：使用train_test_split函数将数据集划分为训练集和测试集。
创建分类器：KNeighborsClassifier(n_neighbors=3)创建一个KNN分类器，其中n_neighbors参数设置为3，表示选择最近的3个邻居。
训练模型：调用fit方法，使用训练集数据训练模型。
预测：使用predict方法预测新样本的类别。
评估模型：通过score方法计算模型在测试集上的准确率。

K值的选择

K值的选择对KNN算法的性能至关重要。较小的K值会使模型对噪声敏感，容易过拟合；较大的K值则会使模型对数据的局部特征不敏感，容易欠拟合。通常，K值的选择可以通过交叉验证的方法来确定，选择使模型在验证集上表现最好的K值。

数据预处理

在使用KNN算法之前，数据预处理是必要的步骤，主要包括：

特征缩放：由于KNN算法基于距离计算，因此特征的尺度会影响结果。通常使用标准化或归一化方法来处理。
缺失值处理：对于有缺失值的特征，需要进行填充或删除。
类别特征编码：对于类别特征，需要将其转换为数值形式，如使用独热编码。

总结

KNN算法是一种简单而有效的分类方法，但在实际应用中需要注意K值的选择和数据预处理，以提高模型的性能。通过上述示例，我们可以看到如何使用Python的scikit-learn库来实现KNN分类，并评估模型的准确率。

数据预处理

数据预处理是机器学习和数据分析中至关重要的步骤，它直接影响到模型的性能和预测的准确性。在应用K近邻算法(KNN)进行分类任务之前，数据预处理包括数据清洗、数据标准化和数据集划分三个关键环节。

数据清洗

数据清洗旨在处理数据集中的缺失值、异常值和重复值，确保数据的质量和完整性。

示例：处理缺失值

假设我们有一个包含年龄、收入和购买意愿的数据集，其中年龄和收入有缺失值。

import pandas as pd
import numpy as np

# 创建示例数据集
data = {
    '年龄': [25, 30, np.nan, 35, 40],
    '收入': [50000, np.nan, 60000, 70000, 80000],
    '购买意愿': ['是', '否', '是', '否', '是']
}
df = pd.DataFrame(data)

# 使用平均值填充缺失值
df['年龄'].fillna(df['年龄'].mean(), inplace=True)
df['收入'].fillna(df['收入'].mean(), inplace=True)

# 打印处理后的数据集
print(df)

示例：检测和处理异常值

异常值可能由于测量错误或数据录入错误而产生，需要进行检测和处理。

# 检测年龄列的异常值
Q1 = df['年龄'].quantile(0.25)
Q3 = df['年龄'].quantile(0.75)
IQR = Q3 - Q1

# 定义异常值的范围
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR

# 将异常值替换为中位数
df.loc[df['年龄'] < lower_bound, '年龄'] = df['年龄'].median()
df.loc[df['年龄'] > upper_bound, '年龄'] = df['年龄'].median()

# 打印处理后的数据集
print(df)

数据标准化

数据标准化是将数据转换为统一尺度的过程，避免特征之间的量纲差异影响KNN算法的性能。

示例：使用Z-score标准化

Z-score标准化将数据转换为均值为0，标准差为1的分布。

from sklearn.preprocessing import StandardScaler

# 创建标准化对象
scaler = StandardScaler()

# 选择需要标准化的列
df_numeric = df[['年龄', '收入']]

# 进行标准化
df_normalized = pd.DataFrame(scaler.fit_transform(df_numeric), columns=df_numeric.columns)

# 将标准化后的数值列替换原始数据集中的数值列
df[['年龄', '收入']] = df_normalized

# 打印标准化后的数据集
print(df)

数据集划分

数据集划分是将数据分为训练集和测试集，以便评估模型的性能。

示例：使用Scikit-learn进行数据集划分

from sklearn.model_selection import train_test_split

# 定义特征和目标变量
X = df[['年龄', '收入']]
y = df['购买意愿']

# 划分数据集，其中测试集占30%
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# 打印训练集和测试集的大小
print("训练集大小:", X_train.shape)
print("测试集大小:", X_test.shape)

通过以上步骤，我们确保了数据的质量，统一了特征的尺度，并准备了用于训练和评估KNN模型的数据集。这些预处理步骤是KNN算法成功应用的基础。

数据处理和分析之分类算法：K近邻算法 (KNN)：KNN在分类任务中的应用

KNN算法实现

计算距离的方法

K近邻算法(KNN)的核心在于计算样本之间的距离，以确定“近邻”的定义。常见的距离计算方法有：

欧氏距离(Euclidean Distance): 最直观的距离计算方式，适用于数值型特征。
曼哈顿距离(Manhattan Distance): 特征空间中两点各坐标差绝对值之和，适用于网格状分布的数据。
闵可夫斯基距离(Minkowski Distance): 欧氏距离和曼哈顿距离的泛化，通过调整参数可以转换为两者。
余弦相似度(Cosine Similarity): 适用于高维空间中，计算两个向量的夹角余弦值，适用于非数值型特征的向量化表示。

示例代码：欧氏距离计算

import numpy as np

def euclidean_distance(x, y):
    """
    计算两个样本之间的欧氏距离。
    
    参数:
    x, y -- 样本向量，numpy数组形式。
    
    返回:
    距离值。
    """
    return np.sqrt(np.sum((x - y) ** 2))

# 示例数据
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])

# 计算距离
distance = euclidean_distance(x, y)
print("欧氏距离:", distance)

选择K值的策略

K值的选择对KNN算法的性能至关重要。较小的K值容易受到噪声的影响，较大的K值则可能包含过多的无关样本。选择K值的策略包括：

交叉验证(Cross Validation): 通过将数据集分为训练集和验证集，测试不同K值下的模型性能，选择最佳K值。
肘部法则(Elbow Method): 观察不同K值下的误差变化，选择误差开始平缓的K值。

示例代码：使用交叉验证选择K值

from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.datasets import load_iris

# 加载数据
iris = load_iris()
X = iris.data
y = iris.target

# 初始化KNN分类器
knn = KNeighborsClassifier()

# 通过交叉验证测试不同K值
k_range = range(1, 31)
scores = []
for k in k_range:
    knn.set_params(n_neighbors=k)
    score = cross_val_score(knn, X, y, cv=10, scoring='accuracy').mean()
    scores.append(score)

# 找到最佳K值
best_k = k_range[scores.index(max(scores))]
print("最佳K值:", best_k)

KNN算法的步骤

KNN算法的实现步骤如下：

计算距离：计算测试样本与训练集中每个样本的距离。
选择K值：确定K值，找到距离最近的K个训练样本。
分类决策：根据这K个样本的类别，采用多数表决的方式决定测试样本的类别。

示例代码：KNN算法实现

from collections import Counter

def knn_classify(k, train_data, train_labels, test_data):
    """
    使用KNN算法进行分类。
    
    参数:
    k -- 考虑的近邻数量。
    train_data -- 训练数据集，二维numpy数组。
    train_labels -- 训练数据集的标签，一维numpy数组。
    test_data -- 测试数据，一维numpy数组。
    
    返回:
    测试数据的预测类别。
    """
    # 计算距离
    distances = [euclidean_distance(test_data, x) for x in train_data]
    
    # 找到K个最近的样本
    k_indices = np.argsort(distances)[:k]
    k_nearest_labels = [train_labels[i] for i in k_indices]
    
    # 多数表决
    most_common = Counter(k_nearest_labels).most_common(1)
    return most_common[0][0]

# 示例数据
train_data = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]])
train_labels = np.array([0, 0, 0, 1, 1, 1, 1, 1])
test_data = np.array([4.5, 5.5])

# 预测
prediction = knn_classify(3, train_data, train_labels, test_data)
print("预测类别:", prediction)

以上代码示例展示了如何使用欧氏距离计算方法和多数表决策略来实现KNN算法。通过调整K值和距离计算方法，KNN可以适应不同的数据集和分类任务。

数据处理和分析之分类算法：K近邻算法 (KNN) 应用案例

案例分析

手写数字识别

原理与内容

K近邻算法(KNN)在手写数字识别中的应用基于一个简单的概念：相似的数字样本在特征空间中距离更近。手写数字识别通常涉及将数字图像转换为特征向量，然后使用这些特征向量进行分类。KNN算法通过计算待分类样本与训练集中所有样本的特征向量之间的距离，找到距离最近的K个训练样本，然后根据这K个样本的多数类别来预测待分类样本的类别。

示例代码与数据样例

# 导入必要的库
import numpy as np
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

# 加载手写数字数据集
digits = load_digits()
X = digits.data
y = digits.target

# 划分数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 特征缩放
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 创建KNN分类器
knn = KNeighborsClassifier(n_neighbors=3)

# 训练模型
knn.fit(X_train, y_train)

# 预测测试集
y_pred = knn.predict(X_test)

# 输出分类报告
print(classification_report(y_test, y_pred))

数据样例：手写数字数据集包含8x8像素的图像，每个像素的灰度值作为特征。例如，一个样本可能如下所示：

sample = [  0.,   0.,   5.,  13.,   9.,   1.,   0.,   0.,
           0.,   0.,  13.,  15.,  10.,  15.,   5.,   0.,
           0.,   3.,  15.,   2.,   0.,  11.,   8.,   0.,
           0.,   4.,  12.,   0.,   0.,   8.,   8.,   0.,
           0.,   5.,   8.,   0.,   0.,   9.,   8.,   0.,
           0.,   4.,  11.,   0.,   1.,  12.,   7.,   0.,
           0.,   2.,  14.,   5.,  10.,  12.,   0.,   0.,
           0.,   0.,   6.,  13.,  10.,   0.,   0.,   0.]

客户分类分析

原理与内容

在客户分类分析中，KNN算法可以用于根据客户的特征（如年龄、收入、购买历史等）将他们分类到不同的客户群体中。这有助于企业更好地理解其客户基础，进行市场细分，从而制定更有效的营销策略。KNN算法通过计算新客户与已知客户群体的特征向量之间的距离，找到最近的K个客户，然后根据这K个客户的多数类别来预测新客户的类别。

示例代码与数据样例

# 导入必要的库
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

# 加载客户数据
data = pd.read_csv('customer_data.csv')
X = data[['Age', 'Income', 'Purchase_History']]
y = data['Customer_Group']

# 划分数据集为训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 特征缩放
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 创建KNN分类器
knn = KNeighborsClassifier(n_neighbors=5)

# 训练模型
knn.fit(X_train, y_train)

# 预测测试集
y_pred = knn.predict(X_test)

# 输出分类报告
print(classification_report(y_test, y_pred))

数据样例：客户数据可能包含以下特征：

data = {
    'Age': [25, 30, 35, 40, 45, 50],
    'Income': [50000, 60000, 70000, 80000, 90000, 100000],
    'Purchase_History': [1, 2, 3, 4, 5, 6],
    'Customer_Group': ['A', 'B', 'A', 'C', 'B', 'C']
}

在这个例子中，Customer_Group是目标变量，而Age、Income和Purchase_History是用于分类的特征。通过使用KNN算法，我们可以预测新客户属于哪个客户群体。

以上两个案例展示了K近邻算法在不同场景下的应用，通过计算特征向量之间的距离，KNN能够有效地进行分类任务。在实际应用中，选择合适的K值和距离度量方法对于提高分类准确率至关重要。

评估与优化

评估分类器的性能

在机器学习中，评估分类器的性能是确保模型有效性和可靠性的重要步骤。对于K近邻算法（KNN），我们主要关注以下几个性能指标：

1. 准确率（Accuracy）

准确率是最直观的评估指标，它衡量分类器正确分类的样本数占总样本数的比例。计算公式如下：

$\text{Accuracy} = \frac{\text{正确分类的样本数}}{\text{总样本数}}$

示例代码

假设我们使用了scikit-learn库中的KNeighborsClassifier来训练一个KNN分类器，并使用train_test_split函数将数据集分为训练集和测试集。

from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
import numpy as np

# 假设数据集X和标签y已经定义
X = np.array([[1, 2], [2, 4], [3, 6], [4, 8], [5, 10], [6, 12]])
y = np.array([0, 0, 0, 1, 1, 1])

# 划分数据集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, random_state=42)

# 创建并训练KNN分类器
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)

# 预测测试集
y_pred = knn.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f'准确率: {accuracy}')

2. 精确率（Precision）

精确率衡量了被分类器预测为正类的样本中，实际为正类的比例。计算公式如下：

$\text{Precision} = \frac{\text{真正例（TP）}}{\text{真正例（TP）} + \text{假正例（FP）}}$

3. 召回率（Recall）

召回率衡量了实际为正类的样本中，被分类器正确预测为正类的比例。计算公式如下：

$\text{Recall} = \frac{\text{真正例（TP）}}{\text{真正例（TP）} + \text{假反例（FN）}}$

示例代码

使用scikit-learn库中的classification_report函数可以同时获取精确率和召回率。

from sklearn.metrics import classification_report

# 输出分类报告
report = classification_report(y_test, y_pred)
print(report)

优化KNN算法的策略

KNN算法的性能可以通过以下几种策略进行优化：

1. 选择合适的K值

K值的选择对KNN算法的性能有显著影响。较小的K值容易受到噪声的影响，较大的K值则可能包含更多无关的样本。可以通过交叉验证（Cross-Validation）来选择最佳的K值。

示例代码

使用GridSearchCV函数进行K值的搜索。

from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {'n_neighbors': np.arange(1, 50)}

# 创建GridSearchCV对象
knn_cv = GridSearchCV(knn, param_grid, cv=5)

# 拟合数据
knn_cv.fit(X_train, y_train)

# 输出最佳参数
print(f'最佳K值: {knn_cv.best_params_}')

2. 特征缩放

KNN算法基于距离进行分类，因此特征的尺度对结果有直接影响。使用特征缩放（如标准化或归一化）可以确保所有特征在相同尺度上，从而提高模型的性能。

示例代码

使用StandardScaler进行特征标准化。

from sklearn.preprocessing import StandardScaler

# 创建标准化对象
scaler = StandardScaler()

# 对训练集和测试集进行标准化
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 使用标准化后的数据训练KNN分类器
knn.fit(X_train_scaled, y_train)

# 预测测试集
y_pred_scaled = knn.predict(X_test_scaled)

# 计算准确率
accuracy_scaled = accuracy_score(y_test, y_pred_scaled)
print(f'标准化后的准确率: {accuracy_scaled}')

3. 使用加权距离

在计算最近邻时，可以给距离更近的样本更高的权重，这通常可以提高分类的准确性。

示例代码

在KNeighborsClassifier中设置weights参数为'distance'。

# 创建并训练加权KNN分类器
knn_weighted = KNeighborsClassifier(n_neighbors=3, weights='distance')
knn_weighted.fit(X_train_scaled, y_train)

# 预测测试集
y_pred_weighted = knn_weighted.predict(X_test_scaled)

# 计算准确率
accuracy_weighted = accuracy_score(y_test, y_pred_weighted)
print(f'加权后的准确率: {accuracy_weighted}')

4. 选择合适的距离度量

KNN算法默认使用欧氏距离，但根据数据的特性，可能需要选择其他距离度量，如曼哈顿距离或闵可夫斯基距离。

示例代码

在KNeighborsClassifier中设置metric参数为'manhattan'。

# 创建并训练使用曼哈顿距离的KNN分类器
knn_manhattan = KNeighborsClassifier(n_neighbors=3, metric='manhattan')
knn_manhattan.fit(X_train_scaled, y_train)

# 预测测试集
y_pred_manhattan = knn_manhattan.predict(X_test_scaled)

# 计算准确率
accuracy_manhattan = accuracy_score(y_test, y_pred_manhattan)
print(f'使用曼哈顿距离的准确率: {accuracy_manhattan}')

通过上述策略，可以有效地评估和优化KNN分类器的性能，确保模型在实际应用中能够达到最佳效果。

总结与应用建议

KNN算法的总结

K近邻算法（K-Nearest Neighbors, KNN）是一种基于实例的学习方法，用于分类和回归任务。其核心思想是：对于一个给定的样本，根据其在特征空间中最近的K个邻居的类别来预测该样本的类别。KNN算法的步骤如下：

计算距离：选择一个距离度量方法（如欧氏距离），计算待分类样本与训练集中每个样本的距离。
找到K个最近邻：从距离最近的样本中选择K个。
分类决策：根据这K个最近邻的类别，采用多数表决的方式决定待分类样本的类别。

代码示例

假设我们有以下数据集，我们将使用KNN算法进行分类：

特征1	特征2	类别
1.0	1.1	A
1.0	1.0	A
0.1	0.2	B
0.0	0.1	B

import numpy as np
from collections import Counter
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# 生成数据集
X, y = make_classification(n_samples=100, n_features=2, n_redundant=0, n_informative=2,
                            n_clusters_per_class=1, random_state=1)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=1)

# 定义KNN分类器
class KNNClassifier:
    def __init__(self, k=3):
        self.k = k

    def fit(self, X, y):
        self.X_train = X
        self.y_train = y

    def predict(self, X):
        predicted_labels = [self._predict(x) for x in X]
        return np.array(predicted_labels)

    def _predict(self, x):
        # 计算距离
        distances = [np.sqrt(np.sum((x_train - x) ** 2)) for x_train in self.X_train]
        # 找到K个最近邻
        k_indices = np.argsort(distances)[:self.k]
        # 获取K个最近邻的类别
        k_nearest_labels = [self.y_train[i] for i in k_indices]
        # 多数表决
        most_common = Counter(k_nearest_labels).most_common(1)
        return most_common[0][0]

# 创建KNN分类器实例
knn = KNNClassifier(k=3)
# 训练模型
knn.fit(X_train, y_train)
# 预测测试集
predictions = knn.predict(X_test)

在实际项目中应用KNN的建议

在实际项目中应用KNN算法时，有几点建议需要考虑：

特征缩放：KNN算法对特征的尺度敏感，因此在应用前应进行特征缩放，如标准化或归一化，以确保所有特征在距离计算中具有相同的重要性。
K值选择：K值的选择对模型性能有显著影响。较小的K值容易受到噪声的影响，较大的K值则可能包含其他类别的样本，影响分类准确性。通常，K值的选择可以通过交叉验证来确定。
距离度量：根据数据的性质选择合适的距离度量方法。欧氏距离是最常用的距离度量，但在某些情况下，如文本数据，可能需要使用余弦相似度或其他度量。
数据集大小：KNN算法在数据集较大时计算量较大，因此对于大规模数据集，可能需要考虑使用更高效的算法或数据结构（如KD树）来加速最近邻搜索。
异常值处理：KNN对异常值敏感，因此在应用前应进行异常值检测和处理，以减少其对模型性能的影响。

示例：特征缩放

from sklearn.preprocessing import StandardScaler

# 创建标准化器实例
scaler = StandardScaler()
# 拟合并转换训练集
X_train_scaled = scaler.fit_transform(X_train)
# 转换测试集
X_test_scaled = scaler.transform(X_test)

# 使用缩放后的数据重新训练KNN模型
knn_scaled = KNNClassifier(k=3)
knn_scaled.fit(X_train_scaled, y_train)
# 预测测试集
predictions_scaled = knn_scaled.predict(X_test_scaled)

示例：K值选择

from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {'k': [1, 3, 5, 7, 9]}
# 创建KNN分类器实例
knn = KNNClassifier()
# 创建GridSearchCV实例
grid_search = GridSearchCV(knn, param_grid, cv=5)
# 拟合数据
grid_search.fit(X_train, y_train)
# 获取最佳参数
best_k = grid_search.best_params_['k']
# 使用最佳参数重新训练模型
knn_best = KNNClassifier(k=best_k)
knn_best.fit(X_train, y_train)
# 预测测试集
predictions_best = knn_best.predict(X_test)