KNN算法：从思想到实现（附代码）

引言

K最近邻算法（K Nearest Neighbors, KNN）是一种简单而有效的机器学习算法，用于分类和回归问题。其核心思想基于“近朱者赤，近墨者黑”，即通过测量不同特征值之间的距离来进行分类或预测数值。本文将详细介绍KNN的核心概念、使用方法及其在sklearn中的实现，并展示如何自己动手编写一个简单的KNN算法。

KNN 核心思想

如何做一个样本的推理？首先需要明确这个问题是分类问题还是回归问题。

分类问题
x0到底属于哪一类呢？
对于一个新的样本x0，KNN首先找到与其最近的K个邻居，然后统计这些邻居中出现次数最多的类别作为x0的类别。
回归问题
x0到底是多少？
对于回归问题，KNN同样找到与新样本x0最近的K个邻居，但这次它计算的是这K个邻居标签的平均值，以此作为x0的预测值。

算法特点

惰性学习：KNN几乎没有训练过程，主要工作是在推理阶段完成，因此被称为惰性学习算法，（在推理时直接硬计算，这不属于典型的人工智能！）。

sklearn进行KNN操作

分类问题示例

# 分类任务（鸢尾花数据集）
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
# 加载数据集
X, y = load_iris(return_X_y=True)
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
# 初始化并训练模型
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X=X_train, y=y_train)
# 预测及评估
y_pred = knn.predict(X=X_test)
acc = (y_pred == y_test).mean()
print(acc)

回归问题示例

# 回归任务（波士顿房价数据集）
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor

# 加载数据
data = pd.read_csv(filepath_or_buffer="boston_house_prices.csv", skiprows=1)
X = data.drop(columns=["MEDV"]).to_numpy()
y = data["MEDV"].to_numpy()

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

# 初始化并训练模型
knn = KNeighborsRegressor(n_neighbors=5)
knn.fit(X=X_train, y=y_train)

# 预测及评估
y_pred = knn.predict(X=X_test)
# 计算的是平均绝对误差（MAE）
# 首先，通过abs(y_pred - y_test)计算预测值与实际值之间的绝对差异，即对于每一个测试样本，计算其预测值减去真实值的绝对值。
# 然后，使用.mean()函数计算这些绝对差异的平均值，得到的就是MAE。
mae = abs(y_pred - y_test).mean()
# 这段代码用于计算均方误差（MSE）
# 首先，通过(y_pred - y_test) ** 2计算预测值与实际值之差的平方，这样做的目的是为了放大较大误差的影响，并且消除负号（因为误差可能是正也可能是负）。
# 之后，使用.mean()函数计算这些平方差的平均值，得到的就是MSE。
mse = ((y_pred - y_test) ** 2).mean()
print(mae, mse)
# 4.756078431372549，51.74387450980392

波士顿房价数据集
在这里插入图片描述
MAE衡量的是预测值与实际值之间差距的平均水平，不考虑差距的方向（正负），只关心差距的大小。MAE 提供了一个直观的平均误差度量，易于理解，因为它直接表示了预测值与真实值之间的平均绝对距离。

MSE同样衡量了预测值与实际值之间的差距，但由于采用了平方，它对较大的误差更加敏感，这意味着如果模型的某些预测非常不准确，MSE会显著增大。

这两个指标都是评估回归模型性能的重要工具，它们帮助我们了解模型预测值与真实值之间的接近程度。选择哪个指标取决于具体的业务需求以及你希望如何权衡不同大小的预测误差。例如，如果你认为较大的误差应该被更重地惩罚，那么MSE可能是一个更好的选择；反之，如果你更关注整体的平均表现，那么MAE可能更适合。

手写KNN算法实现

分类问题实现

from collections import Counter
import numpy as np
class MyKNeighborsClassifier(object):
    """
        自定义KNN分类算法
    """
    def __init__(self, n_neighbors=5):
        """
            初始化方法：
                - 接收 超参数
        """
        self.n_neighbors = n_neighbors

    def fit(self, X, y):
        """
            训练过程
        """
        self.X = X
        self.y = y

    def predict(self, X):
        """
            推理过程
            这段代码实现了 KNN 分类的核心逻辑：
            1.对于输入的新样本集 X 中的每一个样本 x，
            2.计算它与训练集中所有样本之间的欧几里得距离，
            3.找出距离最近的 K 个邻居，
            4.统计这些邻居的目标变量（标签）中哪个类别出现次数最多，
            5.将出现次数最多的类别作为当前新样本 x 的预测类别，
            6.将所有新样本的预测结果汇总成一个数组并返回。
        """
        # X:[batch_size, num_features]
        
        # 第一步：寻找样本的 K个邻居
        # 第二步：对 K 个邻居的标签进行投票
        results = []
        # 循环遍历输入的新样本集 X 中的每一个样本 x。
        for x in X:
        	#计算距离
        	# self.X：训练数据集中的所有样本。
        	# (self.X - x)：计算训练集中的每个样本与当前新样本 x 在各个特征上的差异。
        	# ** 2：对差异进行平方操作，确保所有值都是正数。
        	# .sum(axis=1)：沿着每个样本的所有特征维度求和，得到每个训练样本到新样本 x 的欧几里得距离的平方和。
        	# ** 0.5：取平方根，得到实际的欧几里得距离。
            distance = ((self.X - x) ** 2).sum(axis=1) ** 0.5
            # 找到最近的 K 个邻居
            # distance.argsort()：返回按升序排列的距离索引列表，即距离最近的样本排在前面。
            # [:self.n_neighbors]：选取前 self.n_neighbors 个最小距离对应的索引，即找到最近的 K 个邻居的索引。
            idxes = distance.argsort()[:self.n_neighbors]
            # 获取这些邻居的标签
            # self.y：训练集中对应样本的标签（目标变量）。
            # 使用之前找到的最近邻居的索引 idxes 来获取这些邻居的标签 labels。
            labels = self.y[idxes]
            # 对 K 个邻居的标签进行投票
            # 使用 collections.Counter 对这 K 个邻居的标签进行计数，统计每个标签出现的次数。
            # Counter(labels).most_common(1)：返回一个列表，包含最常见的标签及其出现次数，按频率降序排列。most_common(1) 只返回出现次数最多的那个标签及其计数。
            # [0][0]：从上述列表中提取出最常见的标签（第一个元素的第一个值），作为最终的预测标签 final_label。
            final_label = Counter(labels).most_common(1)[0][0]
            results.append(final_label)
        return np.array(results)
## 使用自定义KNN进行分类
my_knn = MyKNeighborsClassifier(n_neighbors=5)
my_knn.fit(X=X_train, y=y_train)
y_pred = my_knn.predict(X=X_test)
print((y_pred == y_test).mean())

回归问题实现

class MyKNeighborsRegressor(object):
    """
        自定义KNN回归算法
    """
    def __init__(self, n_neighbors=5):
        """
            初始化方法：
                - 接收 超参数
        """
        self.n_neighbors = n_neighbors

    def fit(self, X, y):
        """
            训练过程
        """
        self.X = X
        self.y = y

    def predict(self, X):
        """
            推理过程
            这段代码实现了 KNN 回归的核心逻辑：
			1.对于输入的新样本集 X 中的每一个样本 x，
			2.计算它与训练集中所有样本之间的欧几里得距离，
			3.找出距离最近的 K 个邻居，
			4.计算这些邻居的目标变量（标签）的平均值作为预测结果，
			5.将所有新样本的预测结果汇总成一个数组并返回。
        """
        # X:[batch_size, num_features]
        
        # 第一步：寻找样本的 K个邻居
        # 第二步：对K个邻居的标签取均值
        results = []
        # 循环遍历输入的新样本集 X 中的每一个样本 x
        for x in X:
        	# 计算距离
        	# self.X：训练数据集中的所有样本。
        	# (self.X - x)：计算训练集中的每个样本与当前新样本 x 在各个特征上的差异。
        	# ** 2：对差异进行平方操作，以确保所有值都是正数。
        	# .sum(axis=1)：沿着每个样本的所有特征维度求和，得到每个训练样本到新样本 x 的欧几里得距离的平方和。
        	# ** 0.5：取平方根，得到实际的欧几里得距离。
            distance = ((self.X - x) ** 2).sum(axis=1) ** 0.5
            # 找到最近的 K 个邻居
            # distance.argsort()：返回按升序排列的距离索引列表，即距离最近的样本排在前面。
            # [:self.n_neighbors]：选取前 self.n_neighbors 个最小距离对应的索引，即找到最近的 K 个邻居的索引。
            idxes = distance.argsort()[:self.n_neighbors]
            # 获取这些邻居的标签
            # self.y：训练集中对应样本的标签（目标变量）。
            # 使用之前找到的最近邻居的索引 idxes 来获取这些邻居的标签 labels。
            labels = self.y[idxes]
            # 计算最终预测值
            # 对于回归问题，计算这 K 个最近邻居的标签值的平均值作为当前新样本 x 的预测值 final_label。
            final_label = labels.mean()
            results.append(final_label)
        return np.array(results)

# 使用自定义KNN进行回归
knn = MyKNeighborsRegressor(n_neighbors=5)
knn.fit(X=X_train, y=y_train)
y_pred = knn.predict(X=X_test)
mae = abs(y_pred - y_test).mean()
mse = ((y_pred - y_test) ** 2).mean()
print(mae, mse)