机器学习：K-近邻算法（KNN）：分类与回归任务中的应用

机器学习：K-近邻算法（KNN）：分类与回归任务中的应用1机器学习：K-近邻算法（KNN）1.1简介1.1.1KNN算法的基本概念K-近邻算法(K-NearestNeighbors,KNN)是一种基于实例的学习方法，它不进行显式的训练过程，而是将数据集中的每个样本作为学习的实例。当有新的输入数据时，KNN算法会根据输入数据在特征空间中的位置，找到距离它最近的K个训练样本，然后根据这K个样本的类别来预测新数据的类别。对于分类任务，新数据的类别通常由这K个样本中出现最多的类别决定；对于回归任务，则通常采用这K个样本的平均值或加权平均值作为预测值。1.1.2KNN算法的工作原理KNN算法的核心在于计算距离和选择最近的邻居。距离计算可以采用多种方式，如欧氏距离、曼哈顿距离、切比雪夫距离等。一旦确定了距离度量，算法将遍历整个训练数据集，计算新数据与每个训练样本之间的距离，然后选择距离最近的K个样本。对于分类任务，这K个样本中出现最多的类别即为预测类别；对于回归任务，这K个样本的平均值或加权平均值即为预测值。1.1.2.1示例：使用Python实现KNN分类假设我们有以下数据集，其中包含两个特征X1和X2，以及对应的类别Y：X1X2Y120210130331341431我们将使用这个数据集来预测新数据点(2,2)的类别。importnumpyasnp

fromcollectionsimportCounter

fromscipy.spatialimportdistance

#训练数据集

dataset={

'0':[[1,2],[2,1],[1,3]],

'1':[[3,3],[3,4],[4,3]]

}

#新数据点

new_point=[2,2]

#K值

k=3

#计算距离

defcalculate_distance(data_point):

distances=[]

forcategory,pointsindataset.items():

forpointinpoints:

dist=distance.euclidean(point,new_point)

distances.append([dist,category])

distances.sort()

returndistances

#预测类别

defpredict_category(distances,k):

categories=[dist[1]fordistindistances[:k]]

prediction=Counter(categories).most_common(1)[0][0]

returnprediction

#执行KNN算法

distances=calculate_distance(new_point)

prediction=predict_category(distances,k)

print(f'预测类别为:{prediction}')在这个例子中，我们首先定义了训练数据集dataset，其中0和1分别代表两个类别。然后，我们定义了新数据点new_point和K值k。calculate_distance函数用于计算新数据点与训练数据集中每个点的距离，并将结果按距离排序。predict_category函数则从排序后的距离列表中选择最近的K个点，使用collections.Counter来统计类别出现的次数，最后返回出现次数最多的类别作为预测结果。1.1.2.2示例：使用Python实现KNN回归假设我们有以下数据集，其中包含两个特征X1和X2，以及对应的数值型目标变量Y：X1X2Y121021151312332034224325我们将使用这个数据集来预测新数据点(2,2)的目标变量值。importnumpyasnp

fromscipy.spatialimportdistance

#训练数据集

dataset=np.array([

[1,2,10],

[2,1,15],

[1,3,12],

[3,3,20],

[3,4,22],

[4,3,25]

])

#新数据点

new_point=np.array([2,2])

#K值

k=3

#计算距离并预测

defknn_regression(data,query,k):

distances=[]

foriinrange(len(data)):

dist=distance.euclidean(data[i][:-1],query)

distances.append([dist,data[i][-1]])

distances.sort()

neighbors=distances[:k]

prediction=np.mean([n[1]forninneighbors])

returnprediction

#执行KNN回归

prediction=knn_regression(dataset,new_point,k)

print(f'预测值为:{prediction}')在这个回归示例中，我们使用了scipy.spatial.distance.euclidean来计算欧氏距离。knn_regression函数首先计算新数据点与数据集中每个点的距离，然后选择距离最近的K个点，最后计算这K个点的目标变量值的平均值作为预测结果。2KNN在分类任务中的应用2.1选择合适的K值在K-近邻算法中，K值的选择至关重要。K值决定了在预测时考虑多少个最近的邻居。选择较小的K值（如K=1或K=2）会使决策边界变得复杂，容易过拟合；而选择较大的K值会使决策边界变得平滑，可能引入更多的噪声，导致欠拟合。2.1.1示例：使用交叉验证选择K值fromsklearn.datasetsimportload_iris

fromsklearn.model_selectionimportcross_val_score

fromsklearn.neighborsimportKNeighborsClassifier

importnumpyasnp

#加载数据集

iris=load_iris()

X,y=iris.data,iris.target

#定义K值范围

k_range=range(1,31)

#使用交叉验证计算不同K值下的准确率

k_scores=[]

forkink_range:

knn=KNeighborsClassifier(n_neighbors=k)

scores=cross_val_score(knn,X,y,cv=10,scoring='accuracy')

k_scores.append(scores.mean())

#找到最佳K值

best_k=k_range[np.argmax(k_scores)]

print(f"BestKvalue:{best_k}")2.2距离度量方法KNN算法依赖于距离度量来确定“近邻”。常见的距离度量方法包括欧氏距离、曼哈顿距离和闵可夫斯基距离。2.2.1欧氏距离欧氏距离是最直观的距离度量方法，它计算两个点在多维空间中的直线距离。2.2.2曼哈顿距离曼哈顿距离，也称为城市街区距离，计算两个点在多维空间中沿坐标轴方向的总距离。2.2.3闵可夫斯基距离闵可夫斯基距离是欧氏距离和曼哈顿距离的泛化，通过调整参数p可以得到不同的距离度量。2.2.4示例：计算不同距离度量importnumpyasnp

fromscipy.spatialimportdistance

#定义两个点

point1=np.array([1,2])

point2=np.array([4,6])

#计算欧氏距离

euclidean=distance.euclidean(point1,point2)

print(f"Euclideandistance:{euclidean}")

#计算曼哈顿距离

manhattan=distance.cityblock(point1,point2)

print(f"Manhattandistance:{manhattan}")

#计算闵可夫斯基距离（p=3）

minkowski=distance.minkowski(point1,point2,p=3)

print(f"Minkowskidistance(p=3):{minkowski}")2.3分类决策规则KNN算法在分类任务中使用多数表决原则。即，预测点的类别由其最近的K个邻居的类别决定。最常见的决策规则是多数类别表决，但也可以使用加权表决，其中距离更近的点具有更大的权重。2.3.1示例：多数表决与加权表决fromsklearn.datasetsimportmake_classification

fromsklearn.model_selectionimporttrain_test_split

fromsklearn.neighborsimportKNeighborsClassifier

#生成分类数据

X,y=make_classification(n_samples=100,n_features=2,n_informative=2,n_redundant=0,n_classes=2,random_state=1)

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

#多数表决

knn_majority=KNeighborsClassifier(n_neighbors=5,weights='uniform')

knn_majority.fit(X_train,y_train)

y_pred_majority=knn_majority.predict(X_test)

#加权表决

knn_weighted=KNeighborsClassifier(n_neighbors=5,weights='distance')

knn_weighted.fit(X_train,y_train)

y_pred_weighted=knn_weighted.predict(X_test)

#打印预测结果

print("Majorityvotingpredictions:",y_pred_majority)

print("Weightedvotingpredictions:",y_pred_weighted)2.4KNN分类算法的实现KNN算法的实现通常包括以下步骤：数据预处理、计算距离、选择最近的邻居、进行分类决策。2.4.1示例：从零开始实现KNN分类器importnumpyasnp

fromcollectionsimportCounter

classKNNClassifier:

def__init__(self,k=3):

self.k=k

deffit(self,X,y):

self.X_train=X

self.y_train=y

defpredict(self,X):

y_pred=[self._predict(x)forxinX]

returnnp.array(y_pred)

def_predict(self,x):

#计算距离

distances=[distance.euclidean(x,x_train)forx_traininself.X_train]

#获取最近的K个邻居

k_indices=np.argsort(distances)[:self.k]

k_nearest_labels=[self.y_train[i]foriink_indices]

#多数表决

most_common=Counter(k_nearest_labels).most_common(1)

returnmost_common[0][0]

#生成数据

X,y=make_classification(n_samples=100,n_features=2,n_informative=2,n_redundant=0,n_classes=2,random_state=1)

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

#实例化KNN分类器

knn=KNNClassifier(k=5)

knn.fit(X_train,y_train)

y_pred=knn.predict(X_test)

#打印预测结果

print("Predictions:",y_pred)在上述代码中，我们定义了一个简单的KNN分类器类，它使用欧氏距离进行计算，并通过多数表决进行分类决策。通过调整k值，我们可以控制决策的复杂度。在实际应用中，选择合适的K值、距离度量方法和决策规则对于提高KNN分类器的性能至关重要。3KNN在回归任务中的应用3.1KNN回归的基本思想K-近邻算法(KNN)在回归任务中的应用与分类任务有所不同，但其核心思想仍然基于相似性度量。在回归任务中，KNN算法的目标是预测一个连续值的输出，而不是类别。基本思想如下：计算距离：对于一个新的输入样本，计算它与训练集中的每个样本之间的距离。找到K个最近邻：从训练集中选择距离最近的K个样本。预测输出：预测值通常是这K个最近邻样本的输出值的加权平均或简单平均。3.1.1示例描述假设我们有一组数据，其中包含房屋的特征（如面积、卧室数量）和价格。我们的目标是预测一个新房屋的价格。我们将使用KNN回归算法来实现这一目标。3.1.2数据样例房屋面积（平方米）卧室数量价格（万元）1002501503801202601804120901403.2权重计算方法在KNN回归中，权重计算方法对于预测的准确性至关重要。常见的权重计算方法包括：统一权重：所有K个最近邻的权重相同。距离权重：权重与距离成反比，通常使用距离的倒数或距离的平方的倒数作为权重。3.2.1示例代码importnumpyasnp

fromsklearn.neighborsimportKNeighborsRegressor

#训练数据

X_train=np.array([[100,2],[150,3],[120,2],[180,4],[90,1]])

y_train=np.array([50,80,60,120,40])

#创建KNN回归模型，使用距离权重

knn=KNeighborsRegressor(n_neighbors=3,weights='distance')

#训练模型

knn.fit(X_train,y_train)

#预测新房屋的价格

X_test=np.array([[130,3]])

prediction=knn.predict(X_test)

print("预测价格：",prediction)3.2.2代码解释上述代码中，我们首先导入了必要的库，然后定义了训练数据X_train和对应的标签y_train。接下来，我们创建了一个KNeighborsRegressor模型，其中n_neighbors参数设置为3，表示我们考虑最近的3个邻居，weights参数设置为distance，表示使用距离作为权重。模型训练后，我们使用测试数据X_test进行预测，并输出预测结果。3.3KNN回归算法的实现实现KNN回归算法的关键步骤包括数据预处理、模型训练和预测。在实际应用中，还需要考虑K值的选择、距离度量方式以及权重计算方法。3.3.1示例代码#自定义KNN回归算法

classKNNRegressor:

def__init__(self,n_neighbors=5,weights='uniform'):

self.n_neighbors=n_neighbors

self.weights=weights

deffit(self,X,y):

self.X_train=X

self.y_train=y

defpredict(self,X):

predictions=[]

forxinX:

#计算距离

distances=np.sqrt(np.sum((self.X_train-x)**2,axis=1))

#找到K个最近邻

k_indices=np.argsort(distances)[:self.n_neighbors]

k_nearest_labels=self.y_train[k_indices]

#计算权重

ifself.weights=='distance':

k_weights=1/distances[k_indices]

else:

k_weights=np.ones(self.n_neighbors)

#预测输出

prediction=np.average(k_nearest_labels,weights=k_weights)

predictions.append(prediction)

returnnp.array(predictions)

#使用自定义KNN回归模型

knn_regressor=KNNRegressor(n_neighbors=3,weights='distance')

knn_regressor.fit(X_train,y_train)

prediction=knn_regressor.predict(X_test)

print("预测价格：",prediction)3.3.2代码解释在这个自定义的KNN回归模型中，我们定义了一个KNNRegressor类，它包含初始化、训练和预测方法。在fit方法中，我们简单地存储了训练数据和标签。predict方法中，我们对每个测试样本计算了与训练样本的距离，找到了最近的K个邻居，并根据选择的权重计算方法（统一或距离）计算了预测值。最后，我们使用这个自定义模型进行了预测，并输出了结果。通过以上示例，我们可以看到KNN回归算法在预测连续值输出时的灵活性和实用性。选择合适的K值、距离度量和权重计算方法对于提高预测准确性至关重要。4KNN算法的优缺点4.1KNN算法的优点K-近邻算法(KNN)是一种基于实例的学习方法，它在分类和回归任务中都有广泛的应用。KNN算法的优点主要体现在以下几个方面：简单直观：KNN算法的原理非常直观，容易理解和实现。它不需要训练模型，只需要在预测时计算测试样本与训练样本之间的距离，然后根据最近的K个邻居的类别或数值进行预测。无需训练过程：与许多其他机器学习算法不同，KNN在训练阶段不需要进行复杂的计算，只需要将训练数据存储起来。这意味着KNN可以处理非常大的数据集，只要内存足够。可以处理多分类问题：KNN算法不仅适用于二分类问题，也适用于多分类问题。在多分类问题中，KNN算法可以计算测试样本与每个类别中训练样本的距离，然后根据最近的K个邻居的类别进行投票。对异常值不敏感：由于KNN算法是基于多数投票或平均值的，因此它对异常值的敏感度较低。如果K值选择得当，异常值对预测结果的影响可以被最小化。可以处理非线性问题：KNN算法不需要假设数据的分布或线性关系，因此它可以处理非线性问题。只要数据点之间的距离可以合理地度量，KNN就能找到最近的邻居并进行预测。4.1.1示例代码：KNN分类假设我们有一个简单的二分类数据集，我们将使用Python的scikit-learn库来实现KNN分类。fromsklearn.datasetsimportload_iris

fromsklearn.model_selectionimporttrain_test_split

fromsklearn.neighborsimportKNeighborsClassifier

fromsklearn.metricsimportaccuracy_score

#加载数据集

iris=load_iris()

X=iris.data

y=iris.target

#划分训练集和测试集

X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,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:{accuracy}")在这个例子中，我们使用了Iris数据集，这是一个经典的多分类数据集。我们首先加载数据，然后将其划分为训练集和测试集。接着，我们创建了一个KNN分类器，并使用训练数据对其进行训练。最后，我们使用测试集进行预测，并计算预测的准确率。4.2KNN算法的缺点尽管KNN算法具有上述优点，但它也有一些明显的缺点：计算成本高：在预测阶段，KNN算法需要计算测试样本与所有训练样本之间的距离，这在数据量非常大时会变得非常耗时。因此，KNN算法的预测速度通常比其他算法慢。内存消耗大：KNN算法需要存储所有的训练数据，这在数据量非常大时会占用大量的内存。如果内存不足，可能无法使用KNN算法。K值选择困难：K值的选择对KNN算法的性能有显著影响。如果K值太小，模型可能会过拟合；如果K值太大，模型可能会欠拟合。选择合适的K值通常需要通过交叉验证来确定。受无关特征影响：KNN算法对所有特征都一视同仁，这意味着如果数据集中存在无关或噪声特征，它们可能会影响预测结果。因此，在使用KNN算法之前，通常需要进行特征选择或特征工程。不平衡数据集问题：在处理不平衡数据集时，KNN算法可能会偏向于数量较多的类别。例如，如果一个类别在数据集中占90%，而另一个类别只占10%，那么KNN算法可能会倾向于预测数量较多的类别。4.2.1示例代码：KNN回归下面是一个使用KNN进行回归的示例代码，我们将使用scikit-learn库中的KNeighborsRegressor。importnumpyasnp

fromsklearn.datasetsimportmake_regression

fromsklearn.model_selectionimporttrain_test_split

fromsklearn.neighborsimportKNeighborsRegressor

fromsklearn.metricsimportmean_squared_error

#生成回归数据

X,y=make_regression(n_samples=1000,n_features=10,noise=0.1)

#划分训练集和测试集

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

#创建KNN回归器

knn=KNeighborsRegressor(n_neighbors=5)

#训练模型

knn.fit(X_train,y_train)

#预测

y_pred=knn.predict(X_test)

#计算均方误差

mse=mean_squared_error(y_test,y_pred)

print(f"MeanSquaredError:{mse}")在这个例子中，我们生成了一个回归数据集，然后将其划分为训练集和测试集。接着，我们创建了一个KNN回归器，并使用训练数据对其进行训练。最后，我们使用测试集进行预测，并计算预测的均方误差。总结上述内容，KNN算法在处理分类和回归问题时具有简单直观、无需训练过程、可以处理多分类和非线性问题等优点，但同时也存在计算成本高、内存消耗大、K值选择困难、受无关特征影响以及处理不平衡数据集问题时的局限性。在实际应用中，需要根据具体问题和数据集的特点来权衡这些优缺点。5KNN算法的实际案例5.1手写数字识别5.1.1原理与内容K-近邻算法(KNN)在手写数字识别任务中是一种直观且有效的分类方法。其核心思想是基于特征空间中的K个最近邻样本的多数类别来预测新样本的类别。在手写数字识别中，特征空间通常由像素值构成，每个像素值代表图像中一个点的灰度值。5.1.2示例代码与数据样例假设我们使用MNIST数据集，这是一个包含手写数字的大型数据库，常用于训练各种图像处理系统。下面是一个使用Python和scikit-learn库实现KNN手写数字识别的示例：#导入必要的库

fromsklearn.datasetsimportfetch_openml

fromsklearn.model_selectionimporttrain_test_split

fromsklearn.preprocessingimportStandardScaler

fromsklearn.neighborsimportKNeighborsClassifier

fromsklearn.metricsimportaccuracy_score

#加载MNIST数据集

mnist=fetch_openml('mnist_784',version=1)

X,y=mnist['data'],mnist['target']

#数据预处理

scaler=StandardScaler()

X_scaled=scaler.fit_transform(X)

#划分训练集和测试集

X_train,X_test,y_train,y_test=train_test_split(X_scaled,y,test_size=0.2,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}')5.1.3代码讲解数据加载：使用fetch_openml函数从开放数据源中加载MNIST数据集。数据预处理：通过StandardScaler对数据进行标准化处理，确保每个特征具有相同的尺度，这对于KNN算法的性能至关重要。数据划分：使用train_test_split将数据集划分为训练集和测试集，其中测试集占20%。模型创建：实例化KNeighborsClassifier，设置n_neighbors=3表示在分类时考虑最近的3个邻居。模型训练：调用fit方法，使用训练集数据和标签训练模型。预测：使用predict方法对测试集进行预测。评估：通过accuracy_score计算预测结果与真实标签之间的准确率。5.2房价预测5.2.1原理与内容KNN算法同样可以应用于回归任务，如房价预测。在回归任务中，KNN算法预测的是连续值，而不是类别。预测过程涉及找到特征空间中最近的K个邻居，然后计算这些邻居目标值的平均值作为预测结果。5.2.2示例代码与数据样例下面是一个使用KNN进行房价预测的Python示例，数据集假设为波士顿房价数据集：#导入必要的库

fromsklearn.datasetsimportload_boston

fromsklearn.model_selectionimporttrain_test_split

fromsklearn.preprocessingimportStandardScaler

fromsklearn.neighborsimportKNeighborsRegressor

fromsklearn.metricsimportmean_squared_error

#加载波士顿房价数据集

boston=load_boston()

X,y=boston.data,boston.target

#数据预处理

scaler=StandardScaler()

X_scaled=scaler.fit_transform(X)

#划分训练集和测试集

X_train,X_test,y_train,y_test=train_test_split(X_scaled,y,test_size=0.2,random_state=42)

#创建KNN回归器

knn=KNeighborsRegressor(n_neighbors=5)

#训练模型

knn.fit(X_train,y_train)

#预测

y_pred=knn.predict(X_test)

#计算均方误差

mse=mean_squared_error(y_test,y_pred)

print(f'均方误差:{mse}')5.2.3代码讲解数据加载：使用load_boston函数加载波士顿房价数据集。数据预处理：通过StandardScaler对数据进行标准化处理，确保每个特征具有相同的尺度。数据划分：使用train_test_split将数据集划分为训练集和测试集，其中测试集占20%。模型创建：实例化KNeighborsRegressor，设置n_neighbors=5表示在预测时考虑最近的5个邻居。模型训练：调用fit方法，使用训练集数据和标签训练模型。预测：使用predict方法对测试集进行预测。评估：通过mean_squared_error计算预测结果与真实标签之间的均方误差，这是回归任务中常用的评估指标。通过以上两个示例，我们可以看到KNN算法在分类和回归任务中的应用，以及如何使用Python和scikit-learn库来实现这些任务。在实际应用中，选择合适的K值和预处理数据是提高模型性能的关键步骤。6KNN算法的参数调优6.1K值的选择策略K-近邻算法(KNN)中，K值的选择至关重要，它直接影响模型的性能。选择较小的K值会使模型对噪声点更加敏感，容易过拟合；而较大的K值则会使决策边界更加平滑，可能引入更多的错误分类，导致欠拟合。6.1.1示例：使用交叉验证选择最佳K值fromsklearn.datasetsimportload_iris

fromsklearn.model_selectionimportcross_val_score

fromsklearn.neighborsimportKNeighborsClassifier

importnumpyasnp

#加载数据集

iris=load_iris()

X,y=iris.data,iris.target

#定义K值范围

k_range=range(1,31)

#使用交叉验证计算不同K值下的准确率

k_scores=[]

forkink_range:

knn=KNeighborsClassifier(n_neighbors=k)

scores=cross_val_score(knn,X,y,cv=10,scoring='accuracy')

k_scores.append(scores.mean())

#找到最佳K值

best_k=k_range[np.argmax(k_scores)]

print(f"BestKvalue:{best_k}")6.2特征缩放的重要性在KNN算法中，特征缩放是必要的，因为距离度量（如欧氏距离）对量纲和量级敏感。如果一个特征的范围远大于其他特征，那么这个特征将主导距离计算，导致模型性能下降。6.2.1示例：使用标准化进行特征缩放fromsklearn.preprocessingimportStandardScaler

#使用StandardScaler进行特征缩放

scaler=StandardScaler()

X_scaled=scaler.fit_transform(X)

#使用缩放后的数据重新训练模型并选择K值

k_scores_scaled=[]

forkink_range:

knn=KNeighborsClassifier(n_neighbors=k)

scores=cross_val_score(knn,X_scaled,y,cv=10,scoring='accuracy')

k_scores_scaled.append(scores.mean())

#比较缩放前后的最佳K值

best_k_scaled=k_range[np.argmax(k_scores_scaled)]

print(f"BestKvaluewithscaling:{best_k_scaled}")6.3距离度量的选择KNN算法中的距离度量选择也会影响模型的性能。常见的距离度量有欧氏距离、曼哈顿距离和闵可夫斯基距离等。不同的度量方式适用于不同类型的数据分布。6.3.1示例：使用不同距离度量的KNN分类#使用欧氏距离

knn_euclidean=KNeighborsClassifier(n_neighbors=best_k_scaled,metric='euclidean')

knn_euclidean.fit(X_scaled,y)

print("AccuracywithEuclideandistance:",knn_euclidean.score(X_scaled,y))

#使用曼哈顿距离

knn_manhattan=KNeighborsClassifier(n_neighbors=best_k_scaled,metric='manhattan')

knn_manhattan.fit(X_scaled,y)

print("AccuracywithManhattandistance:",knn_manhattan.score(X_scaled,y))

#使用闵可夫斯基距离

knn_minkowski=KNeighborsClassifier(n_neighbors=best_k_scaled,metric='minkowski',p=3)

knn_minkowski.fit(X_scaled,y)

print("AccuracywithMinkowskidistance(p=3):",knn_minkowski.score(X_scaled,y))通过上述示例，我们可以看到如何通过交叉验证选择最佳的K值，如何使用标准化进行特征缩放，以及如何尝试不同的距离度量以优化KNN模型的性能。在实际应用中，这些步骤是提高模型准确性和泛化能力的关键。7KNN算法的扩展7.1加权KNN7.1.1原理在传统的K-近邻算法中，每个邻居对预测结果的贡献是相等的。然而，在实际应用中，距离更近的邻居可能对预测结果有更大的影响。加权KNN通过赋予不同距离的邻居不同的权重来解决这个问题，通常权重与距离成反比。这样，更近的邻居对预测结果的影响更大，而较远的邻居影响较小。7.1.2实现示例假设我们有以下数据集：特征1特征2类别11A22A33B44B55B我们将使用加权KNN来预测点(2.5,2.5)的类别。importnumpyasnp

fromscipy.spatialimportdistance

#数据集

X=np.array([[1,1],[2,2],[3,3],[4,4],[5,5]])

y=np.array(['A','A','B','B','B'])

#预测点

x_pred=np.array([2.5,2.5])

#计算距离

distances=[distance.euclidean(x_pred,x)forxinX]

#K值

K=3

#获取K个最近的邻居

k_indices=np.argsort(distances)[:K]

k_nearest_labels=y[k_indices]

#加权投票

weights=1/np.array(distances)[k_indices]

weighted_votes={label:np.sum(weights[k_nearest_labels==label])forlabelinnp.unique(k_nearest_labels)}

predicted_label=max(weighted_votes,key=weighted_votes.get)

print(predicted_label)7.1.3解释在上述代码中，我们首先计算了预测点与数据集中每个点之间的欧氏距离。然后，我们选择了距离最近的K个点，并计算了它们的类别。最后，我们根据距离的倒数作为权重，对这些类别进行加权投票，以确定预测点的类别。7.2自适应KNN7.2.1原理自适应KNN是一种动态调整K值的方法，它基于数据点的局部密度。在某些区域，数据点可能非常密集，而在其他区域，数据点可能非常稀疏。在密集区域，较小的K值可能就足够了，而在稀疏区域，可能需要较大的K值以确保有足够的信息。自适应KNN通过计算每个数据点的局部密度，然后根据这个密度来调整K值，从而提高预测的准确性。7.2.2实现示例假设我们有以下数据集：特征1特征2类别11A22A33B44B55B66B我们将使用自适应KNN来预测点(2.5,2.5)的类别。importnumpyasnp

fromscipy.spatialimportdistance

#数据集

X=np.array([[1,1],[2,2],[3,3],[4,4],[5,5],[6,6]])

y=np.array(['A','A','B','B','B','B'])

#预测点

x_pred=np.array([2.5,2.5])

#计算所有点的局部密度

deflocal_density(X):

distances=distance.cdist(X,X,'euclidean')

sorted_distances=np.sort(distances,axis=1)

returnnp.mean(sorted_distances[:,1:],axis=1)

density=local_density(X)

#动态调整K值

defadaptive_k(x_pred,X,density,min_k=1,max_k=5):

distances=[distance.euclidean(x_pred,x)forxinX]

k=min_k

whilek<=max_k:

k_indices=np.argsort(distances)[:k]

k_density=np.mean(density[k_indices])

ifk_density>np.mean(density):

break

k+=1

returnk

K=adaptive_k(x_pred,X,density)

#使用调整后的K值进行预测

k_indices=np.argsort(distances)[:K]

k_nearest_labels=y[k_indices]

predicted_label=max(set(k_nearest_labels),key=list(k_nearest_labels).count)

print(predicted_label)7.2.3解释在上述代码中，我们首先计算了数据集中所有点的局部密度。然后，我们定义了一个函数adaptive_k来动态调整K值。这个函数通过计算预测点的K个最近邻居的平均密度，并与整个数据集的平均密度进行比较，来确定K值。如果K个最近邻居的平均密度大于整个数据集的平均密度，那么我们就停止增加K值。最后，我们使用调整后的K值进行预测。通过这种方式，自适应KNN可以更好地适应数据的局部特性，从而提高预测的准确性。8KNN算法的总结K-近邻算法（KNN）是一种基于实例的学习方法，它在分类和回归任务中都有广泛应用。KNN算法的核心思想是，对于一个未知样本，通过计算其与训练集中所有样本的距离，选取距离最近的K个样本，然后根据这K个样本的类别或数值来预测未知样本的类别或数值。8.1分类任务中的KNN在分类任务中，KNN算法通常采用多数表决的方式进行预测。具体步骤如下：计算距离：计算测试样本与训练集中每个样本的距离。找到K个最近邻：从训练集中选取距离最近的K个样本。多数表决：这K个样本中出现次数最多的类别作为测试样本的预测类别。8.2回归任务中的KNN在回归任务中，KNN算法通常采用平均值或加权平均值的方式进行预测。具体步骤如下：计算距离：与分类任务相同，计算测试样本与训练集中每个样本的距离。找到K个最近邻：从训练集中选取距离最近的K个样本。预测数值：这K个样本的目