简体中文 繁體中文 English 日本語 Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：是的！我们正在计划一个大动作！
11-02 12:46
通知：Telegram 推送频道https://t.me/+2tB3a7aKXlw2YjA1 及时接收第一手论坛帖子信息～
10-23 09:32
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
通知：加入QQ社群吧 https://qm.qq.com/q/QZibQd1hiq
10-23 09:28
通知：签到时间调整为每日4:00（东八区）
10-23 09:26
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

探索scikit-learn中KNN算法的广泛应用场景从分类到回归的实际案例分析与实践技巧

威震华夏关云长

3万

主题

317

科技点

3万

积分

大区版主

木柜子打湿

积分
31893

财Doro三倍冰淇淋无人之境【一阶】立华奏小樱（小丑装）⑨的冰沙以外的星空【二阶】
发表于 2025-10-3 20:50:01 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

KNN（K-Nearest Neighbors，K近邻）算法是一种基本的分类与回归方法，也是机器学习中最简单直观的算法之一。KNN算法的核心思想是”物以类聚”，即一个样本的类别或属性由其最近的K个邻居决定。作为非参数学习方法，KNN不需要训练过程，是一种”懒惰学习”（Lazy Learning）算法。在scikit-learn库中，KNN算法有完整的实现，可以方便地应用于分类和回归问题。本文将深入探讨KNN算法在分类和回归问题中的广泛应用，通过实际案例分析其使用方法，并分享实践中的优化技巧。

KNN算法在分类问题中的应用

基本原理

KNN分类算法的基本原理是：给定一个训练数据集，对于新的输入实例，在训练集中找到与该实例最邻近的K个实例，这K个实例的多数属于某个类别，就把该输入实例分为这个类别。算法的关键在于如何定义”最近邻”，通常使用距离度量来衡量样本之间的相似性，常用的距离度量包括欧氏距离、曼哈顿距离、闵可夫斯基距离等。

实际案例分析：鸢尾花分类

让我们使用scikit-learn中的KNN分类器来解决一个经典的鸢尾花分类问题。鸢尾花数据集包含3种不同类型的鸢尾花（Setosa、Versicolour和Virginica）的花萼和花瓣的长度和宽度。
  2. # 导入必要的库
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  5. from sklearn import datasets
  6. from sklearn.model_selection import train_test_split
  7. from sklearn.preprocessing import StandardScaler
  8. from sklearn.neighbors import KNeighborsClassifier
  9. from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
  10. import seaborn as sns
  12. # 加载鸢尾花数据集
  13. iris = datasets.load_iris()
  14. X = iris.data
  15. y = iris.target
  17. # 将数据集分为训练集和测试集
  18. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  20. # 数据标准化
  21. scaler = StandardScaler()
  22. X_train_scaled = scaler.fit_transform(X_train)
  23. X_test_scaled = scaler.transform(X_test)
  25. # 创建KNN分类器
  26. knn = KNeighborsClassifier(n_neighbors=3)
  28. # 训练模型
  29. knn.fit(X_train_scaled, y_train)
  31. # 预测测试集
  32. y_pred = knn.predict(X_test_scaled)
  34. # 计算准确率
  35. accuracy = accuracy_score(y_test, y_pred)
  36. print(f"Accuracy: {accuracy:.2f}")
  38. # 输出分类报告
  39. print("\nClassification Report:")
  40. print(classification_report(y_test, y_pred, target_names=iris.target_names))
  42. # 绘制混淆矩阵
  43. cm = confusion_matrix(y_test, y_pred)
  44. plt.figure(figsize=(8, 6))
  45. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=iris.target_names, yticklabels=iris.target_names)
  46. plt.xlabel('Predicted')
  47. plt.ylabel('Actual')
  48. plt.title('Confusion Matrix')
  49. plt.show()
  51. # 寻找最优的K值
  52. k_range = range(1, 31)
  53. k_scores = []
  54. for k in k_range:
  55.     knn = KNeighborsClassifier(n_neighbors=k)
  56.     knn.fit(X_train_scaled, y_train)
  57.     y_pred_k = knn.predict(X_test_scaled)
  58.     k_scores.append(accuracy_score(y_test, y_pred_k))
  60. # 绘制K值与准确率的关系图
  61. plt.figure(figsize=(10, 6))
  62. plt.plot(k_range, k_scores)
  63. plt.xlabel('Value of K for KNN')
  64. plt.ylabel('Testing Accuracy')
  65. plt.title('K Value vs Accuracy')
  66. plt.show()
复制代码

在这个例子中，我们首先加载了鸢尾花数据集，并将其分为训练集和测试集。然后，我们对数据进行了标准化处理，因为KNN算法对特征的尺度敏感。接下来，我们创建了一个KNN分类器，设置K=3，并在训练数据上拟合模型。最后，我们在测试数据上进行预测，并计算了准确率和分类报告。

此外，我们还绘制了混淆矩阵，以直观地查看模型在不同类别上的表现。最后，我们尝试了不同的K值（从1到30），并绘制了K值与准确率的关系图，以帮助我们选择最优的K值。

实践技巧

由于KNN算法基于距离度量，特征的尺度会显著影响算法的结果。因此，在使用KNN之前，通常需要对数据进行标准化或归一化处理。scikit-learn中的StandardScaler或MinMaxScaler可以用于此目的。
  2. from sklearn.preprocessing import StandardScaler, MinMaxScaler
  4. # 标准化：均值为0，方差为1
  5. scaler = StandardScaler()
  6. X_train_scaled = scaler.fit_transform(X_train)
  7. X_test_scaled = scaler.transform(X_test)
  9. # 归一化：将特征缩放到[0,1]范围
  10. normalizer = MinMaxScaler()
  11. X_train_normalized = normalizer.fit_transform(X_train)
  12. X_test_normalized = normalizer.transform(X_test)
复制代码

K值的选择对KNN算法的性能有重要影响。较小的K值可能会导致模型过拟合，而较大的K值可能会导致模型欠拟合。通常，通过交叉验证来选择最优的K值。
  2. from sklearn.model_selection import cross_val_score
  4. # 使用交叉验证选择最优K值
  5. k_range = range(1, 31)
  6. k_scores = []
  7. for k in k_range:
  8.     knn = KNeighborsClassifier(n_neighbors=k)
  9.     scores = cross_val_score(knn, X_train_scaled, y_train, cv=10, scoring='accuracy')
  10.     k_scores.append(scores.mean())
  12. # 找到最优K值
  13. best_k = k_range[np.argmax(k_scores)]
  14. print(f"Best K value: {best_k}")
复制代码

KNN算法可以使用不同的距离度量，如欧氏距离、曼哈顿距离、闵可夫斯基距离等。scikit-learn中的KNeighborsClassifier允许通过metric参数指定距离度量。
  2. # 使用欧氏距离（默认）
  3. knn_euclidean = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
  5. # 使用曼哈顿距离
  6. knn_manhattan = KNeighborsClassifier(n_neighbors=5, metric='manhattan')
  8. # 使用闵可夫斯基距离，p=3
  9. knn_minkowski = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=3)
复制代码

在标准的KNN算法中，所有K个邻居的投票权重相同。但是，我们可以根据距离的倒数来加权邻居的投票，使得更近的邻居具有更大的影响力。
  2. # 使用距离权重
  3. knn_weighted = KNeighborsClassifier(n_neighbors=5, weights='distance')
复制代码

为了更准确地评估模型的性能，可以使用交叉验证而不是简单的训练-测试分割。
  2. from sklearn.model_selection import cross_val_score
  4. # 使用10折交叉验证评估模型
  5. knn = KNeighborsClassifier(n_neighbors=5)
  6. scores = cross_val_score(knn, X_scaled, y, cv=10, scoring='accuracy')
  7. print(f"Cross-validation accuracy: {scores.mean():.2f} (+/- {scores.std() * 2:.2f})")
复制代码

KNN算法在回归问题中的应用

基本原理

KNN回归算法的基本原理与分类算法类似，但输出的是连续值而不是离散的类别。对于一个新的输入实例，KNN回归算法在训练集中找到与该实例最邻近的K个实例，然后将这K个实例的目标值的平均值（或加权平均值）作为该输入实例的预测值。

实际案例分析：房价预测

让我们使用scikit-learn中的KNN回归器来解决一个房价预测问题。我们将使用加州房价数据集，这是一个包含房屋特征和其中位数价值的数据集。
  2. # 导入必要的库
  3. import numpy as np
  4. import matplotlib.pyplot as plt
  5. from sklearn.datasets import fetch_california_housing
  6. from sklearn.model_selection import train_test_split
  7. from sklearn.preprocessing import StandardScaler
  8. from sklearn.neighbors import KNeighborsRegressor
  9. from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error
  11. # 加载加州房价数据集
  12. housing = fetch_california_housing()
  13. X = housing.data
  14. y = housing.target
  16. # 将数据集分为训练集和测试集
  17. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  19. # 数据标准化
  20. scaler = StandardScaler()
  21. X_train_scaled = scaler.fit_transform(X_train)
  22. X_test_scaled = scaler.transform(X_test)
  24. # 创建KNN回归器
  25. knn_reg = KNeighborsRegressor(n_neighbors=5)
  27. # 训练模型
  28. knn_reg.fit(X_train_scaled, y_train)
  30. # 预测测试集
  31. y_pred = knn_reg.predict(X_test_scaled)
  33. # 计算评估指标
  34. mse = mean_squared_error(y_test, y_pred)
  35. rmse = np.sqrt(mse)
  36. mae = mean_absolute_error(y_test, y_pred)
  37. r2 = r2_score(y_test, y_pred)
  39. print(f"Mean Squared Error: {mse:.2f}")
  40. print(f"Root Mean Squared Error: {rmse:.2f}")
  41. print(f"Mean Absolute Error: {mae:.2f}")
  42. print(f"R² Score: {r2:.2f}")
  44. # 绘制预测值与实际值的散点图
  45. plt.figure(figsize=(10, 6))
  46. plt.scatter(y_test, y_pred, alpha=0.5)
  47. plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--', lw=2)
  48. plt.xlabel('Actual')
  49. plt.ylabel('Predicted')
  50. plt.title('Actual vs Predicted Values')
  51. plt.show()
  53. # 绘制残差图
  54. residuals = y_test - y_pred
  55. plt.figure(figsize=(10, 6))
  56. plt.scatter(y_pred, residuals, alpha=0.5)
  57. plt.axhline(y=0, color='r', linestyle='--')
  58. plt.xlabel('Predicted Values')
  59. plt.ylabel('Residuals')
  60. plt.title('Residual Plot')
  61. plt.show()
  63. # 寻找最优的K值
  64. k_range = range(1, 31)
  65. k_scores = []
  66. for k in k_range:
  67.     knn_reg = KNeighborsRegressor(n_neighbors=k)
  68.     knn_reg.fit(X_train_scaled, y_train)
  69.     y_pred_k = knn_reg.predict(X_test_scaled)
  70.     k_scores.append(mean_squared_error(y_test, y_pred_k))
  72. # 绘制K值与均方误差的关系图
  73. plt.figure(figsize=(10, 6))
  74. plt.plot(k_range, k_scores)
  75. plt.xlabel('Value of K for KNN')
  76. plt.ylabel('Mean Squared Error')
  77. plt.title('K Value vs MSE')
  78. plt.show()
复制代码

在这个例子中，我们首先加载了加州房价数据集，并将其分为训练集和测试集。然后，我们对数据进行了标准化处理。接下来，我们创建了一个KNN回归器，设置K=5，并在训练数据上拟合模型。最后，我们在测试数据上进行预测，并计算了均方误差、均方根误差、平均绝对误差和R²分数。

此外，我们还绘制了预测值与实际值的散点图，以直观地查看模型的预测性能。我们还绘制了残差图，以检查模型的假设是否满足。最后，我们尝试了不同的K值（从1到30），并绘制了K值与均方误差的关系图，以帮助我们选择最优的K值。

实践技巧

与KNN分类算法一样，KNN回归算法也对特征的尺度敏感，因此需要对数据进行标准化或归一化处理。
  2. from sklearn.preprocessing import StandardScaler
  4. # 标准化数据
  5. scaler = StandardScaler()
  6. X_train_scaled = scaler.fit_transform(X_train)
  7. X_test_scaled = scaler.transform(X_test)
复制代码

K值的选择对KNN回归算法的性能同样重要。较小的K值可能会导致模型对噪声敏感，而较大的K值可能会导致模型过于平滑。通常，通过交叉验证来选择最优的K值。
  2. from sklearn.model_selection import GridSearchCV
  4. # 使用网格搜索选择最优K值
  5. param_grid = {'n_neighbors': range(1, 31)}
  6. knn_reg = KNeighborsRegressor()
  7. grid_search = GridSearchCV(knn_reg, param_grid, cv=5, scoring='neg_mean_squared_error')
  8. grid_search.fit(X_train_scaled, y_train)
  10. print(f"Best K value: {grid_search.best_params_['n_neighbors']}")
复制代码

KNN回归算法也可以使用不同的距离度量，如欧氏距离、曼哈顿距离、闵可夫斯基距离等。
  2. # 使用曼哈顿距离
  3. knn_manhattan = KNeighborsRegressor(n_neighbors=5, metric='manhattan')
复制代码

在标准的KNN回归算法中，所有K个邻居的贡献相同。但是，我们可以根据距离的倒数来加权邻居的贡献，使得更近的邻居具有更大的影响力。
  2. # 使用距离权重
  3. knn_weighted = KNeighborsRegressor(n_neighbors=5, weights='distance')
复制代码

对于高维数据，KNN算法可能会受到”维度灾难”的影响。在这种情况下，可以考虑使用特征选择或降维技术，如主成分分析（PCA）。
  2. from sklearn.decomposition import PCA
  4. # 使用PCA降维
  5. pca = PCA(n_components=0.95)  # 保留95%的方差
  6. X_train_pca = pca.fit_transform(X_train_scaled)
  7. X_test_pca = pca.transform(X_test_scaled)
  9. # 在降维后的数据上使用KNN
  10. knn_pca = KNeighborsRegressor(n_neighbors=5)
  11. knn_pca.fit(X_train_pca, y_train)
  12. y_pred_pca = knn_pca.predict(X_test_pca)
  13. mse_pca = mean_squared_error(y_test, y_pred_pca)
  14. print(f"MSE with PCA: {mse_pca:.2f}")
复制代码

KNN算法的参数调优

K值的选择

K值是KNN算法中最重要的参数，它决定了用于预测的邻居数量。选择合适的K值对算法的性能至关重要。
  2. from sklearn.model_selection import cross_val_score
  3. import matplotlib.pyplot as plt
  5. # 创建一个KNN分类器
  6. knn = KNeighborsClassifier()
  8. # 尝试不同的K值
  9. k_range = range(1, 31)
  10. k_scores = []
  12. for k in k_range:
  13.     knn.set_params(n_neighbors=k)
  14.     scores = cross_val_score(knn, X_train_scaled, y_train, cv=10, scoring='accuracy')
  15.     k_scores.append(scores.mean())
  17. # 绘制K值与交叉验证准确率的关系图
  18. plt.figure(figsize=(10, 6))
  19. plt.plot(k_range, k_scores)
  20. plt.xlabel('Value of K for KNN')
  21. plt.ylabel('Cross-Validated Accuracy')
  22. plt.title('K Value vs Accuracy')
  23. plt.show()
  25. # 找到最优的K值
  26. best_k = k_range[np.argmax(k_scores)]
  27. print(f"Best K value: {best_k}")
复制代码

距离度量的选择

KNN算法可以使用不同的距离度量来计算样本之间的距离。常见的距离度量包括欧氏距离、曼哈顿距离、闵可夫斯基距离等。
  2. # 使用欧氏距离（默认）
  3. knn_euclidean = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
  5. # 使用曼哈顿距离
  6. knn_manhattan = KNeighborsClassifier(n_neighbors=5, metric='manhattan')
  8. # 使用闵可夫斯基距离，p=3
  9. knn_minkowski = KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=3)
  11. # 使用余弦相似度
  12. knn_cosine = KNeighborsClassifier(n_neighbors=5, metric='cosine')
复制代码

权重函数的选择

在标准的KNN算法中，所有K个邻居的投票权重相同。但是，我们可以根据距离的倒数来加权邻居的投票，使得更近的邻居具有更大的影响力。
  2. # 使用均匀权重（默认）
  3. knn_uniform = KNeighborsClassifier(n_neighbors=5, weights='uniform')
  5. # 使用距离权重
  6. knn_distance = KNeighborsClassifier(n_neighbors=5, weights='distance')
复制代码

算法选择

scikit-learn中的KNN算法提供了三种不同的算法来计算最近邻：
  2. # 使用暴力搜索
  3. knn_brute = KNeighborsClassifier(n_neighbors=5, algorithm='brute')
  5. # 使用KD树
  6. knn_kd_tree = KNeighborsClassifier(n_neighbors=5, algorithm='kd_tree')
  8. # 使用球树
  9. knn_ball_tree = KNeighborsClassifier(n_neighbors=5, algorithm='ball_tree')
  11. # 自动选择（默认）
  12. knn_auto = KNeighborsClassifier(n_neighbors=5, algorithm='auto')
复制代码

KNN算法在大数据集上的优化策略

当处理大规模数据集时，标准的KNN算法可能会面临计算效率和内存限制的问题。以下是一些优化策略：

1. 使用KD树或球树

KD树和球树是用于加速最近邻搜索的数据结构。它们通过划分数据空间来减少需要计算距离的样本数量。
  2. # 使用KD树加速
  3. knn_kd_tree = KNeighborsClassifier(n_neighbors=5, algorithm='kd_tree')
  5. # 使用球树加速
  6. knn_ball_tree = KNeighborsClassifier(n_neighbors=5, algorithm='ball_tree')
复制代码

2. 近似最近邻搜索

对于非常大的数据集，可以考虑使用近似最近邻（Approximate Nearest Neighbor, ANN）算法，如局部敏感哈希（Locality-Sensitive Hashing, LSH）或随机投影树（Random Projection Trees）。
  2. # 使用annoy库进行近似最近邻搜索
  3. from annoy import AnnoyIndex
  5. # 创建Annoy索引
  6. f = X_train.shape[1]  # 特征数量
  7. t = AnnoyIndex(f, 'euclidean')
  9. # 添加训练数据到索引
  10. for i, vector in enumerate(X_train):
  11.     t.add_item(i, vector)
  13. # 构建索引
  14. t.build(10)  # 10棵树
  16. # 查询最近邻
  17. indices, distances = t.get_nns_by_vector(X_test[0], 5, include_distances=True)
复制代码

3. 降维

对于高维数据，可以考虑使用降维技术，如主成分分析（PCA）或线性判别分析（LDA），来减少特征数量。
  2. from sklearn.decomposition import PCA
  4. # 使用PCA降维
  5. pca = PCA(n_components=0.95)  # 保留95%的方差
  6. X_train_pca = pca.fit_transform(X_train)
  7. X_test_pca = pca.transform(X_test)
  9. # 在降维后的数据上使用KNN
  10. knn_pca = KNeighborsClassifier(n_neighbors=5)
  11. knn_pca.fit(X_train_pca, y_train)
  12. accuracy = knn_pca.score(X_test_pca, y_test)
  13. print(f"Accuracy with PCA: {accuracy:.2f}")
复制代码

4. 特征选择

通过选择最重要的特征，可以减少特征数量，从而提高KNN算法的效率。
  2. from sklearn.feature_selection import SelectKBest, f_classif
  4. # 选择最重要的10个特征
  5. selector = SelectKBest(f_classif, k=10)
  6. X_train_selected = selector.fit_transform(X_train, y_train)
  7. X_test_selected = selector.transform(X_test)
  9. # 在选择后的特征上使用KNN
  10. knn_selected = KNeighborsClassifier(n_neighbors=5)
  11. knn_selected.fit(X_train_selected, y_train)
  12. accuracy = knn_selected.score(X_test_selected, y_test)
  13. print(f"Accuracy with feature selection: {accuracy:.2f}")
复制代码

5. 并行计算

scikit-learn中的KNN算法支持并行计算，可以通过设置n_jobs参数来使用多个CPU核心。
  2. # 使用所有可用的CPU核心
  3. knn_parallel = KNeighborsClassifier(n_neighbors=5, n_jobs=-1)
复制代码

6. 数据采样

对于非常大的数据集，可以考虑对数据进行采样，以减少训练集的大小。
  2. from sklearn.utils import resample
  4. # 对训练数据进行采样
  5. X_train_sampled, y_train_sampled = resample(X_train, y_train, n_samples=1000, random_state=42)
  7. # 在采样后的数据上使用KNN
  8. knn_sampled = KNeighborsClassifier(n_neighbors=5)
  9. knn_sampled.fit(X_train_sampled, y_train_sampled)
  10. accuracy = knn_sampled.score(X_test, y_test)
  11. print(f"Accuracy with sampling: {accuracy:.2f}")
复制代码

KNN算法与其他算法的比较

KNN vs 决策树
  2. from sklearn.tree import DecisionTreeClassifier
  4. # 比较KNN和决策树在鸢尾花数据集上的性能
  5. # KNN
  6. knn = KNeighborsClassifier(n_neighbors=3)
  7. knn.fit(X_train_scaled, y_train)
  8. knn_accuracy = knn.score(X_test_scaled, y_test)
  10. # 决策树
  11. dt = DecisionTreeClassifier(random_state=42)
  12. dt.fit(X_train, y_train)  # 决策树不需要数据标准化
  13. dt_accuracy = dt.score(X_test, y_test)
  15. print(f"KNN Accuracy: {knn_accuracy:.2f}")
  16. print(f"Decision Tree Accuracy: {dt_accuracy:.2f}")
复制代码

KNN vs 随机森林
  2. from sklearn.ensemble import RandomForestClassifier
  4. # 比较KNN和随机森林在鸢尾花数据集上的性能
  5. # KNN
  6. knn = KNeighborsClassifier(n_neighbors=3)
  7. knn.fit(X_train_scaled, y_train)
  8. knn_accuracy = knn.score(X_test_scaled, y_test)
  10. # 随机森林
  11. rf = RandomForestClassifier(random_state=42)
  12. rf.fit(X_train, y_train)  # 随机森林不需要数据标准化
  13. rf_accuracy = rf.score(X_test, y_test)
  15. print(f"KNN Accuracy: {knn_accuracy:.2f}")
  16. print(f"Random Forest Accuracy: {rf_accuracy:.2f}")
复制代码

KNN vs SVM
  2. from sklearn.svm import SVC
  4. # 比较KNN和SVM在鸢尾花数据集上的性能
  5. # KNN
  6. knn = KNeighborsClassifier(n_neighbors=3)
  7. knn.fit(X_train_scaled, y_train)
  8. knn_accuracy = knn.score(X_test_scaled, y_test)
  10. # SVM
  11. svm = SVC(random_state=42)
  12. svm.fit(X_train_scaled, y_train)  # SVM需要数据标准化
  13. svm_accuracy = svm.score(X_test_scaled, y_test)
  15. print(f"KNN Accuracy: {knn_accuracy:.2f}")
  16. print(f"SVM Accuracy: {svm_accuracy:.2f}")
复制代码

实际应用案例

案例1：手写数字识别

手写数字识别是机器学习中的经典问题，我们可以使用KNN算法来解决这个问题。
  2. from sklearn.datasets import load_digits
  3. from sklearn.model_selection import train_test_split
  4. from sklearn.preprocessing import StandardScaler
  5. from sklearn.neighbors import KNeighborsClassifier
  6. from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
  7. import matplotlib.pyplot as plt
  8. import seaborn as sns
  10. # 加载手写数字数据集
  11. digits = load_digits()
  12. X = digits.data
  13. y = digits.target
  15. # 显示一些数字图像
  16. fig, axes = plt.subplots(2, 5, figsize=(10, 4))
  17. for i, ax in enumerate(axes.ravel()):
  18.     ax.imshow(digits.images[i], cmap='binary')
  19.     ax.set_title(f"Label: {digits.target[i]}")
  20.     ax.axis('off')
  21. plt.tight_layout()
  22. plt.show()
  24. # 将数据集分为训练集和测试集
  25. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  27. # 数据标准化
  28. scaler = StandardScaler()
  29. X_train_scaled = scaler.fit_transform(X_train)
  30. X_test_scaled = scaler.transform(X_test)
  32. # 创建KNN分类器
  33. knn = KNeighborsClassifier(n_neighbors=3)
  35. # 训练模型
  36. knn.fit(X_train_scaled, y_train)
  38. # 预测测试集
  39. y_pred = knn.predict(X_test_scaled)
  41. # 计算准确率
  42. accuracy = accuracy_score(y_test, y_pred)
  43. print(f"Accuracy: {accuracy:.2f}")
  45. # 输出分类报告
  46. print("\nClassification Report:")
  47. print(classification_report(y_test, y_pred))
  49. # 绘制混淆矩阵
  50. cm = confusion_matrix(y_test, y_pred)
  51. plt.figure(figsize=(10, 8))
  52. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
  53. plt.xlabel('Predicted')
  54. plt.ylabel('Actual')
  55. plt.title('Confusion Matrix')
  56. plt.show()
  58. # 显示一些预测错误的图像
  59. incorrect_indices = np.where(y_pred != y_test)[0]
  60. if len(incorrect_indices) > 0:
  61.     fig, axes = plt.subplots(2, 5, figsize=(10, 4))
  62.     for i, ax in enumerate(axes.ravel()):
  63.         if i < len(incorrect_indices):
  64.             idx = incorrect_indices[i]
  65.             ax.imshow(digits.images[idx + len(X_train)], cmap='binary')
  66.             ax.set_title(f"True: {y_test[idx]}, Pred: {y_pred[idx]}")
  67.         ax.axis('off')
  68.     plt.tight_layout()
  69.     plt.show()
复制代码

案例2：客户流失预测

客户流失预测是商业分析中的重要问题，我们可以使用KNN算法来预测客户是否会流失。
  2. import pandas as pd
  3. from sklearn.model_selection import train_test_split
  4. from sklearn.preprocessing import StandardScaler, LabelEncoder
  5. from sklearn.neighbors import KNeighborsClassifier
  6. from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, roc_curve, auc
  7. import matplotlib.pyplot as plt
  8. import seaborn as sns
  10. # 假设我们有一个客户数据集
  11. # 这里我们创建一个模拟数据集
  12. np.random.seed(42)
  13. n_samples = 1000
  15. # 创建特征
  16. age = np.random.normal(40, 15, n_samples)
  17. income = np.random.normal(50000, 15000, n_samples)
  18. tenure = np.random.randint(1, 72, n_samples)
  19. monthly_charge = np.random.normal(70, 20, n_samples)
  20. usage = np.random.normal(20, 10, n_samples)
  22. # 创建目标变量（客户是否流失）
  23. churn_prob = 1 / (1 + np.exp(-(-5 + 0.01 * age - 0.00002 * income - 0.02 * tenure + 0.03 * monthly_charge - 0.05 * usage)))
  24. churn = np.random.binomial(1, churn_prob)
  26. # 创建DataFrame
  27. data = pd.DataFrame({
  28.     'Age': age,
  29.     'Income': income,
  30.     'Tenure': tenure,
  31.     'MonthlyCharge': monthly_charge,
  32.     'Usage': usage,
  33.     'Churn': churn
  34. })
  36. # 显示数据的前几行
  37. print(data.head())
  39. # 将数据集分为特征和目标
  40. X = data.drop('Churn', axis=1)
  41. y = data['Churn']
  43. # 将数据集分为训练集和测试集
  44. X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
  46. # 数据标准化
  47. scaler = StandardScaler()
  48. X_train_scaled = scaler.fit_transform(X_train)
  49. X_test_scaled = scaler.transform(X_test)
  51. # 创建KNN分类器
  52. knn = KNeighborsClassifier(n_neighbors=5)
  54. # 训练模型
  55. knn.fit(X_train_scaled, y_train)
  57. # 预测测试集
  58. y_pred = knn.predict(X_test_scaled)
  59. y_pred_proba = knn.predict_proba(X_test_scaled)[:, 1]
  61. # 计算准确率
  62. accuracy = accuracy_score(y_test, y_pred)
  63. print(f"Accuracy: {accuracy:.2f}")
  65. # 输出分类报告
  66. print("\nClassification Report:")
  67. print(classification_report(y_test, y_pred))
  69. # 绘制混淆矩阵
  70. cm = confusion_matrix(y_test, y_pred)
  71. plt.figure(figsize=(8, 6))
  72. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
  73. plt.xlabel('Predicted')
  74. plt.ylabel('Actual')
  75. plt.title('Confusion Matrix')
  76. plt.show()
  78. # 绘制ROC曲线
  79. fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
  80. roc_auc = auc(fpr, tpr)
  82. plt.figure(figsize=(8, 6))
  83. plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')
  84. plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
  85. plt.xlim([0.0, 1.0])
  86. plt.ylim([0.0, 1.05])
  87. plt.xlabel('False Positive Rate')
  88. plt.ylabel('True Positive Rate')
  89. plt.title('Receiver Operating Characteristic (ROC) Curve')
  90. plt.legend(loc="lower right")
  91. plt.show()
  93. # 寻找最优的K值
  94. k_range = range(1, 31)
  95. k_scores = []
  96. for k in k_range:
  97.     knn = KNeighborsClassifier(n_neighbors=k)
  98.     knn.fit(X_train_scaled, y_train)
  99.     y_pred_k = knn.predict(X_test_scaled)
  100.     k_scores.append(accuracy_score(y_test, y_pred_k))
  102. # 绘制K值与准确率的关系图
  103. plt.figure(figsize=(10, 6))
  104. plt.plot(k_range, k_scores)
  105. plt.xlabel('Value of K for KNN')
  106. plt.ylabel('Testing Accuracy')
  107. plt.title('K Value vs Accuracy')
  108. plt.show()
  110. # 找到最优的K值
  111. best_k = k_range[np.argmax(k_scores)]
  112. print(f"Best K value: {best_k}")
  114. # 使用最优K值重新训练模型
  115. knn_best = KNeighborsClassifier(n_neighbors=best_k)
  116. knn_best.fit(X_train_scaled, y_train)
  117. y_pred_best = knn_best.predict(X_test_scaled)
  118. accuracy_best = accuracy_score(y_test, y_pred_best)
  119. print(f"Accuracy with best K: {accuracy_best:.2f}")
复制代码

总结与展望

KNN算法是一种简单而强大的机器学习算法，可以用于分类和回归问题。在scikit-learn库中，KNN算法通过KNeighborsClassifier和KNeighborsRegressor类实现，提供了丰富的参数和选项，可以满足不同场景的需求。

本文详细介绍了KNN算法在分类和回归问题中的应用，包括基本原理、实际案例分析和实践技巧。我们还讨论了KNN算法的优缺点、参数调优方法、在大数据集上的优化策略，以及与其他算法的比较。

尽管KNN算法有一些缺点，如计算复杂度高和内存需求大，但通过适当的优化策略，如使用KD树或球树、降维、特征选择等，可以在一定程度上克服这些问题。

随着机器学习领域的不断发展，KNN算法也在不断演进。例如，近似最近邻搜索算法的发展使得KNN算法可以应用于更大规模的数据集；深度学习与KNN的结合也产生了一些新的算法，如深度KNN（Deep KNN）等。

总的来说，KNN算法是一种值得掌握的机器学习算法，它在许多实际应用中表现出色，特别是在数据量不大、特征维度不高的情况下。通过理解KNN算法的原理和应用技巧，我们可以更好地利用它来解决实际问题。
算法, 场景, 案例, 技巧
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
次元宅社
次元宅社
开放、共创，CHANGE SEKAI！
频道订阅

频道订阅

加入社群

加入社群

联系我们|TG频道|RSS

Powered by Pixtech

© 2025 Pixtech Team.