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

最新推荐文章于 2024-09-28 07:42:04 发布
最新推荐文章于 2024-09-28 07:42:04 发布
阅读量329 收藏 13
点赞数 10
分类专栏： 数据挖掘 文章标签： 分类 近邻算法 回归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_87715305/article/details/142608358
版权

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

在这里插入图片描述

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

简介

K近邻算法的基本原理

K近邻算法(K-Nearest Neighbors, KNN)是一种基于实例的学习方法，它不进行显式的训练过程，而是将数据存储起来，当有新的输入数据时，通过计算新数据与训练数据集中所有数据的距离，选取距离最近的K个邻居，根据这些邻居的属性来预测新数据的属性。在分类任务中，KNN通常采用多数表决的方式决定新数据的类别；而在回归任务中，KNN则通过计算K个最近邻居的属性平均值来预测新数据的连续值。

示例代码：KNN回归

假设我们有一组数据，其中包含房屋的大小和价格，我们想要预测一个新房屋的价格。以下是一个使用Python和scikit-learn库实现KNN回归的示例：

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 创建示例数据
data = np.array([[100, 200000], [150, 300000], [200, 400000], [250, 500000], [300, 600000]])
X = data[:, 0].reshape(-1, 1)  # 房屋大小
y = data[:, 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=3)

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

# 预测新房屋的价格
new_house_size = np.array([[220]])
predicted_price = knn.predict(new_house_size)
print("预测价格:", predicted_price)

# 评估模型
y_pred = knn.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("均方误差:", mse)

在这个例子中，我们首先创建了一个包含房屋大小和价格的简单数据集。然后，我们使用train_test_split函数将数据集划分为训练集和测试集。接下来，我们创建了一个KNeighborsRegressor模型，并设置n_neighbors参数为3，表示在预测时考虑最近的3个邻居。模型训练后，我们使用它来预测一个新房屋的价格，并通过计算均方误差(MSE)来评估模型的性能。

KNN在分类与回归任务中的区别

KNN算法在分类和回归任务中的应用主要区别在于预测输出的计算方式。在分类任务中，KNN通常采用多数表决的方式，即新数据的类别由其K个最近邻居中出现次数最多的类别决定。而在回归任务中，KNN则通过计算K个最近邻居的属性平均值来预测新数据的连续值。

示例代码：KNN分类

以下是一个使用Python和scikit-learn库实现KNN分类的示例，假设我们有一组数据，其中包含花朵的花瓣长度和宽度，以及它们的种类，我们想要预测一个新花朵的种类：

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

# 创建示例数据
data = np.array([[1.4, 0.2, 0], [1.5, 0.2, 0], [1.4, 0.4, 0], [1.7, 0.4, 0], [1.7, 0.5, 0],
                 [2.2, 1.0, 1], [2.2, 1.2, 1], [2.3, 1.2, 1], [2.1, 1.1, 1], [2.1, 1.5, 1],
                 [5.1, 1.9, 2], [5.9, 3.0, 2], [6.2, 2.8, 2], [6.1, 3.0, 2], [6.3, 3.4, 2]])
X = data[:, :2]  # 花瓣长度和宽度
y = data[:, 2]  # 花朵种类

# 划分训练集和测试集
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)

# 预测新花朵的种类
new_flower = np.array([[2.0, 1.0]])
predicted_species = knn.predict(new_flower)
print("预测种类:", predicted_species)

# 评估模型
y_pred = knn.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("准确率:", accuracy)

在这个分类示例中，我们首先创建了一个包含花朵花瓣长度、宽度和种类的简单数据集。然后，我们使用train_test_split函数将数据集划分为训练集和测试集。接下来，我们创建了一个KNeighborsClassifier模型，并设置n_neighbors参数为3。模型训练后，我们使用它来预测一个新花朵的种类，并通过计算准确率来评估模型的性能。

总结

K近邻算法在分类和回归任务中都有广泛的应用，其核心思想是基于距离度量来寻找最近的邻居。在分类任务中，KNN通过多数表决来预测类别；而在回归任务中，KNN则通过计算平均值来预测连续值。通过调整K值和距离度量方式，KNN可以适应不同的数据集和任务需求。在实际应用中，KNN的性能受到数据集大小、特征维度和邻居数量的影响，因此在使用KNN时需要根据具体情况进行参数调优。

数据预处理

sub目录2.1: 数据清洗和缺失值处理

数据清洗

数据清洗是数据预处理的第一步，旨在去除数据集中的噪声和无关信息，确保数据的质量。这包括识别并纠正错误的数据条目，如异常值、重复记录和不一致的数据。

缺失值处理

数据集中的缺失值是常见的问题，它们可能由于各种原因（如数据收集过程中的错误或遗漏）而出现。处理缺失值的方法有多种，包括删除含有缺失值的记录、填充缺失值（使用平均值、中位数或众数等）和预测缺失值。

示例代码：使用Python处理缺失值
import pandas as pd
import numpy as np

# 创建一个包含缺失值的数据框
data = {'A': [1, 2, np.nan, 4],
        'B': [5, np.nan, np.nan, 8],
        'C': [9, 10, 11, 12]}
df = pd.DataFrame(data)

# 打印原始数据框
print("原始数据框:")
print(df)

# 使用平均值填充缺失值
df_filled = df.fillna(df.mean())

# 打印处理后的数据框
print("\n使用平均值填充后的数据框:")
print(df_filled)

描述

在上述示例中，我们首先创建了一个包含缺失值的pandas数据框。然后，我们使用fillna函数来填充这些缺失值。fillna函数可以接受多种参数，如常数、前向填充、后向填充或数据框的统计值（如平均值、中位数或众数）。在这个例子中，我们选择了使用数据框的平均值来填充缺失值，这是一种常见的处理方法，尤其是在数值特征中。

sub目录2.2: 特征选择与降维

特征选择

特征选择是从原始特征集中选择最相关和最有信息量的特征的过程。这有助于减少模型的复杂性，提高计算效率，并可能提高模型的预测性能。

降维

降维是将数据从高维空间转换到低维空间的过程，同时尽量保留数据的原始信息。这有助于减少计算成本，避免维度灾难，并可能提高模型的解释性。

示例代码：使用Python进行特征选择和降维
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.feature_selection import SelectKBest, f_regression

# 创建一个示例数据框
data = {'A': [1, 2, 3, 4],
        'B': [5, 6, 7, 8],
        'C': [9, 10, 11, 12],
        'D': [13, 14, 15, 16]}
df = pd.DataFrame(data)
target = [1, 2, 3, 4]  # 目标变量

# 特征选择：选择与目标变量相关性最高的前两个特征
selector = SelectKBest(score_func=f_regression, k=2)
selected_features = selector.fit_transform(df, target)

# 打印选择后的特征
print("选择后的特征:")
print(selected_features)

# 降维：使用PCA将数据降维到两个主成分
pca = PCA(n_components=2)
reduced_data = pca.fit_transform(df)

# 打印降维后的数据
print("\n降维后的数据:")
print(reduced_data)

描述

在这个示例中，我们首先创建了一个包含四个特征的数据框。然后，我们使用SelectKBest类来选择与目标变量相关性最高的前两个特征。f_regression函数用于计算每个特征与目标变量之间的F值，从而确定它们的相关性。接下来，我们使用PCA（主成分分析）来将数据降维到两个主成分。PCA是一种常用的降维技术，它通过线性组合原始特征来创建新的主成分，这些主成分是数据的正交方向，能够解释数据的大部分方差。

sub目录2.3: 数据标准化与归一化

数据标准化

数据标准化（或Z-score标准化）是一种将数据转换为均值为0，标准差为1的分布的方法。这有助于确保所有特征在相同尺度上，从而避免某些特征因尺度较大而对模型产生过大的影响。

数据归一化

数据归一化是将数据转换为0到1之间的范围的过程。这同样有助于确保所有特征在相同尺度上，但与标准化不同，归一化不假设数据的分布。

示例代码：使用Python进行数据标准化和归一化
import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 创建一个示例数据框
data = {'A': [1, 2, 3, 4],
        'B': [100, 200, 300, 400],
        'C': [1000, 2000, 3000, 4000]}
df = pd.DataFrame(data)

# 数据标准化
scaler = StandardScaler()
df_standardized = scaler.fit_transform(df)

# 打印标准化后的数据
print("标准化后的数据:")
print(df_standardized)

# 数据归一化
normalizer = MinMaxScaler()
df_normalized = normalizer.fit_transform(df)

# 打印归一化后的数据
print("\n归一化后的数据:")
print(df_normalized)

描述

在上述示例中，我们创建了一个包含三个特征的数据框，这些特征的尺度差异很大。我们首先使用StandardScaler类来对数据进行标准化，它将每个特征转换为均值为0，标准差为1的分布。然后，我们使用MinMaxScaler类来对数据进行归一化，它将每个特征的值缩放到0到1之间。这两种方法都是数据预处理中常见的尺度调整技术，它们有助于提高模型的性能和稳定性，尤其是在使用距离度量的算法（如K近邻算法）中。

通过这些示例，我们可以看到数据预处理在机器学习项目中的重要性。数据清洗、特征选择、降维、标准化和归一化都是确保数据质量、减少模型复杂性和提高预测性能的关键步骤。在实际应用中，这些步骤可能需要根据具体的数据集和问题进行调整和优化。

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

KNN回归算法原理

K近邻算法(KNN)不仅在分类任务中表现出色，同样可以应用于回归任务中。在回归任务中，KNN的目标是预测一个连续值的输出，而不是类别。其基本思想是找到特征空间中与待预测样本最接近的K个训练样本，然后基于这K个样本的输出值来预测待预测样本的输出值。

sub目录3.1: 距离度量的选择

在KNN算法中，选择合适的距离度量对于确定“最近”的邻居至关重要。常见的距离度量包括欧氏距离、曼哈顿距离和闵可夫斯基距离。

欧氏距离

欧氏距离是最直观的距离度量方式，它计算两个点在多维空间中的直线距离。对于两个点 x = ( x 1 , x 2 , . . . , x n ) x = (x_1, x_2, ..., x_n) x=(x1​,x2​,...,xn​)和 y = ( y 1 , y 2 , . . . , y n ) y = (y_1, y_2, ..., y_n) y=(y1​,y2​,...,yn​)，欧氏距离定义为：
d ( x , y ) = ∑ i = 1 n ( x i − y i ) 2 d(x, y) = \sqrt{\sum_{i=1}^{n}(x_i - y_i)^2} d(x,y)=i=1∑n​(xi​−yi​)2 ​

曼哈顿距离

曼哈顿距离，也称为城市街区距离，计算两个点在多维空间中沿轴方向的总距离。定义为：
d ( x , y ) = ∑ i = 1 n ∣ x i − y i ∣ d(x, y) = \sum_{i=1}^{n}|x_i - y_i| d(x,y)=i=1∑n​∣xi​−yi​∣

闵可夫斯基距离

闵可夫斯基距离是欧氏距离和曼哈顿距离的泛化，定义为：
d ( x , y ) = ( ∑ i = 1 n ∣ x i − y i ∣ p ) 1 / p d(x, y) = \left(\sum_{i=1}^{n}|x_i - y_i|^p\right)^{1/p} d(x,y)=(i=1∑n​∣xi​−yi​∣p)1/p
其中 p p p是参数，当 p = 1 p=1 p=1时，闵可夫斯基距离退化为曼哈顿距离；当 p = 2 p=2 p=2时，它退化为欧氏距离。

代码示例：计算欧氏距离
import numpy as np

def euclidean_distance(x, y):
    """
    计算两个向量之间的欧氏距离
    :param x: 向量x
    :param y: 向量y
    :return: 欧氏距离
    """
    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)

sub目录3.2: K值的选择

K值的选择对KNN回归的性能有显著影响。较小的K值意味着模型对噪声更敏感，容易过拟合；较大的K值则可能使模型过于平滑，导致欠拟合。

选择K值的方法
  • 交叉验证：通过将数据集分为训练集和验证集，选择使验证集上的预测误差最小的K值。
  • 误差曲线：绘制不同K值下的预测误差曲线，选择误差曲线开始平缓的K值。
代码示例：使用交叉验证选择K值
from sklearn.model_selection import cross_val_score
from sklearn.neighbors import KNeighborsRegressor
from sklearn.datasets import load_boston
import numpy as np

# 加载数据集
data = load_boston()
X, y = data.data, data.target

# 初始化KNN回归器
knn = KNeighborsRegressor()

# 通过交叉验证计算不同K值下的平均得分
k_values = np.arange(1, 30)
cv_scores = [np.mean(cross_val_score(knn.set_params(n_neighbors=k), X, y, cv=5)) for k in k_values]

# 找到最佳K值
best_k = k_values[np.argmax(cv_scores)]
print("最佳K值:", best_k)

sub目录3.3: 权重计算方法

在KNN回归中，可以为每个邻居分配权重，以反映其对预测值的影响程度。权重计算方法包括：

均等权重

每个邻居的权重相等，预测值为K个最近邻居输出值的平均。

距离加权

邻居的权重与它们到待预测样本的距离成反比，距离越近的邻居权重越大。

代码示例：使用距离加权的KNN回归
from sklearn.neighbors import KNeighborsRegressor
from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split

# 加载数据集
data = load_boston()
X, y = data.data, data.target

# 划分训练集和测试集
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, weights='distance')

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

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

# 输出预测结果
print("预测结果:", y_pred)

通过上述原理和代码示例，我们可以看到KNN回归算法在处理连续值预测任务时的灵活性和有效性。选择合适的距离度量、K值和权重计算方法是优化KNN回归模型的关键。

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

KNN回归算法实现

sub目录4.1: 使用Python和scikit-learn实现KNN回归

K近邻算法(KNN)不仅用于分类任务，也可以应用于回归任务。在回归任务中，KNN算法通过找到特征空间中最近的K个邻居，然后计算这些邻居的响应变量的平均值或加权平均值来预测新样本的响应变量。

示例代码
# 导入必要的库
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 创建示例数据
X = np.array([[1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]])
y = np.array([3, 5, 7, 9, 11, 13, 15, 17])

# 划分数据集
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=3)

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

# 预测
y_pred = knn.predict(X_test)

# 评估模型
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')
代码解释

  1. 导入库：使用numpy进行数据处理，sklearn.model_selection中的train_test_split来划分数据集，sklearn.neighbors中的KNeighborsRegressor来实现KNN回归，以及sklearn.metrics中的mean_squared_error来评估模型。

  2. 创建数据：X是特征矩阵，y是响应变量向量。在这个例子中，我们使用了简单的线性关系数据。

  3. 划分数据集：将数据集划分为训练集和测试集，其中测试集占20%。

  4. 创建模型：使用KNeighborsRegressor创建KNN回归模型，设置n_neighbors=3表示考虑最近的3个邻居。

  5. 训练模型：使用训练数据X_train和y_train来训练模型。

  6. 预测：使用训练好的模型对测试集X_test进行预测，得到y_pred。

  7. 评估模型：通过计算预测值y_pred和真实值y_test之间的均方误差(MSE)来评估模型的性能。

sub目录4.2: KNN回归算法的参数调优

KNN回归的性能可以通过调整其参数来优化，主要参数包括n_neighbors、weights和algorithm。

示例代码
# 导入必要的库
from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {
    'n_neighbors': [1, 3, 5, 7, 9],
    'weights': ['uniform', 'distance'],
    'algorithm': ['auto', 'ball_tree', 'kd_tree', 'brute']
}

# 创建KNN回归模型
knn = KNeighborsRegressor()

# 使用GridSearchCV进行参数调优
grid_search = GridSearchCV(knn, param_grid, cv=5, scoring='neg_mean_squared_error')
grid_search.fit(X_train, y_train)

# 输出最佳参数
print(f'Best parameters: {grid_search.best_params_}')

# 使用最佳参数的模型进行预测
best_knn = grid_search.best_estimator_
y_pred = best_knn.predict(X_test)

# 评估模型
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error with best parameters: {mse}')
代码解释

  1. 导入库：使用sklearn.model_selection中的GridSearchCV来进行参数调优。

  2. 定义参数网格：param_grid定义了要搜索的参数组合，包括邻居数量n_neighbors、权重类型weights和搜索算法algorithm。

  3. 创建模型：初始化KNeighborsRegressor模型。

  4. 参数调优：使用GridSearchCV进行交叉验证，以找到最佳参数组合。cv=5表示使用5折交叉验证，scoring='neg_mean_squared_error'表示使用负均方误差作为评估指标。

  5. 输出最佳参数：grid_search.best_params_返回最佳参数组合。

  6. 使用最佳参数的模型进行预测：grid_search.best_estimator_返回使用最佳参数的模型，然后使用该模型对测试集进行预测。

  7. 评估模型：计算使用最佳参数的模型在测试集上的均方误差。

通过上述步骤，我们可以有效地使用KNN算法进行回归任务，并通过参数调优来提高模型的预测性能。

案例分析

sub目录5.1 房价预测案例

在房价预测的场景中，K近邻算法(KNN)可以被用作回归任务的工具，通过分析已知的房屋特征（如面积、卧室数量、地理位置等）和其对应的价格，来预测新房屋的价格。下面，我们将通过一个具体的案例来展示如何使用KNN进行房价预测。

数据准备

假设我们有以下数据集，包含了房屋的特征和价格：

面积（平方米）卧室数量地理位置（以经纬度表示）价格（万元）
120339.9042, 116.4074500
80239.9165, 116.3974300
150439.9038, 116.4071700
90239.9041, 116.4075350
100339.9164, 116.3973450

KNN回归算法实现

我们将使用Python的scikit-learn库来实现KNN回归算法。

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import StandardScaler

# 数据
data = np.array([
    [120, 3, 39.9042, 116.4074],
    [80, 2, 39.9165, 116.3974],
    [150, 4, 39.9038, 116.4071],
    [90, 2, 39.9041, 116.4075],
    [100, 3, 39.9164, 116.3973]
])
prices = np.array([500, 300, 700, 350, 450])

# 特征和标签
X = data[:, :-1]
y = prices

# 数据标准化
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=3)

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

# 预测
new_house = np.array([[110, 3, 39.9043, 116.4075]])
new_house_scaled = scaler.transform(new_house)
predicted_price = knn.predict(new_house_scaled)

代码解释

  1. 数据准备：我们首先定义了房屋数据和价格，然后将数据集分为特征X和标签y。
  2. 数据标准化：使用StandardScaler对特征进行标准化处理，这是因为KNN算法对数据的量纲敏感。
  3. 模型训练：使用train_test_split函数将数据集分为训练集和测试集，然后创建KNN回归模型并训练。
  4. 预测：对一个新的房屋数据进行预测，输出预测价格。

sub目录5.2 股票价格预测案例

KNN算法同样可以应用于股票价格的预测，通过分析历史股票数据（如开盘价、收盘价、成交量等）来预测未来的股票价格。下面是一个使用KNN进行股票价格预测的示例。

数据准备

假设我们有以下股票历史数据：

开盘价收盘价成交量股票价格
100105100000103
95988000096
110115120000113
10210890000105
9810285000100

KNN回归算法实现

我们将使用Python的pandas和scikit-learn库来处理和预测股票价格。

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import StandardScaler

# 创建数据框
df = pd.DataFrame({
    '开盘价': [100, 95, 110, 102, 98],
    '收盘价': [105, 98, 115, 108, 102],
    '成交量': [100000, 80000, 120000, 90000, 85000],
    '股票价格': [103, 96, 113, 105, 100]
})

# 特征和标签
X = df.drop('股票价格', axis=1)
y = df['股票价格']

# 数据标准化
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=3)

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

# 预测
new_stock = np.array([[103, 107, 95000]])
new_stock_scaled = scaler.transform(new_stock)
predicted_stock_price = knn.predict(new_stock_scaled)

代码解释

  1. 数据准备：使用pandas创建数据框，包含股票的开盘价、收盘价、成交量和股票价格。
  2. 数据标准化：对特征进行标准化处理，以确保模型的准确性。
  3. 模型训练：将数据集分为训练集和测试集，创建KNN回归模型并进行训练。
  4. 预测：对一个新的股票数据进行预测，输出预测的股票价格。

通过这两个案例，我们可以看到KNN算法在回归任务中的应用，无论是预测房价还是股票价格，KNN都能提供一个基于最近邻数据点的预测结果。然而，需要注意的是，KNN算法的性能很大程度上依赖于数据的质量和特征的选择，以及k值的选择，因此在实际应用中需要对这些参数进行仔细的调整和优化。

评估与优化

sub目录6.1: 回归模型的评估指标

在回归任务中，评估模型的性能至关重要。这不仅帮助我们理解模型的预测能力，还为模型的优化提供了方向。K近邻算法（KNN）应用于回归时，我们同样需要一套评估指标来衡量其表现。以下是一些常用的回归模型评估指标：

均方误差（Mean Squared Error, MSE）

均方误差是最常用的回归评估指标之一，它计算预测值与真实值之间的平均平方差。MSE越小，模型的预测性能越好。

示例代码
import numpy as np
from sklearn.metrics import mean_squared_error

# 假设的预测值和真实值
y_true = np.array([1.0, 2.0, 3.0, 4.0, 5.0])
y_pred = np.array([1.1, 1.9, 3.2, 3.8, 5.1])

# 计算MSE
mse = mean_squared_error(y_true, y_pred)
print(f'MSE: {mse}')

均方根误差（Root Mean Squared Error, RMSE）

均方根误差是MSE的平方根，它以与数据相同的单位来表示误差，使得结果更直观。

示例代码
import numpy as np
from sklearn.metrics import mean_squared_error

# 使用MSE计算RMSE
rmse = np.sqrt(mean_squared_error(y_true, y_pred))
print(f'RMSE: {rmse}')

平均绝对误差（Mean Absolute Error, MAE）

平均绝对误差计算预测值与真实值之间的平均绝对差，它对异常值不敏感，但没有MSE那样强调大误差的影响。

示例代码
from sklearn.metrics import mean_absolute_error

# 计算MAE
mae = mean_absolute_error(y_true, y_pred)
print(f'MAE: {mae}')

R² 分数（R-Squared）

R² 分数，也称为决定系数，表示模型解释了数据中多少变异。R² 分数范围从0到1，值越接近1，模型的拟合度越好。

示例代码
from sklearn.metrics import r2_score

# 计算R² 分数
r2 = r2_score(y_true, y_pred)
print(f'R² 分数: {r2}')

sub目录6.2: KNN回归算法的优化策略

KNN回归算法的性能可以通过调整几个关键参数来优化，包括K值、距离度量方法和权重函数。

K值的选择

K值的选择对KNN回归的性能有显著影响。较小的K值可能会导致过拟合，而较大的K值可能会导致欠拟合。通常，我们通过交叉验证来选择最佳的K值。

示例代码
from sklearn.model_selection import GridSearchCV
from sklearn.neighbors import KNeighborsRegressor

# 创建KNN回归模型
knn = KNeighborsRegressor()

# 定义要搜索的K值范围
param_grid = {'n_neighbors': np.arange(1, 30)}

# 使用GridSearchCV进行交叉验证
grid_search = GridSearchCV(knn, param_grid, cv=5, scoring='neg_mean_squared_error')
grid_search.fit(X_train, y_train)

# 输出最佳K值
best_k = grid_search.best_params_['n_neighbors']
print(f'最佳K值: {best_k}')

距离度量方法

KNN算法依赖于距离度量来确定最近的邻居。不同的距离度量方法（如欧氏距离、曼哈顿距离）可能会影响模型的预测性能。

示例代码
# 创建KNN回归模型，使用曼哈顿距离
knn = KNeighborsRegressor(n_neighbors=best_k, metric='manhattan')
knn.fit(X_train, y_train)

权重函数

权重函数决定了邻居对预测值的影响程度。常见的权重函数包括“uniform”（所有邻居权重相同）和“distance”（距离越近的邻居权重越大）。

示例代码
# 创建KNN回归模型，使用基于距离的权重
knn = KNeighborsRegressor(n_neighbors=best_k, weights='distance')
knn.fit(X_train, y_train)

通过上述方法，我们可以有效地评估和优化KNN回归模型，以提高其在回归任务中的性能。

总结与应用建议

sub目录7.1: KNN回归算法的优缺点总结

优点

  1. 简单直观:
    KNN算法易于理解和实现，不需要复杂的数学模型和公式，基于直观的“近朱者赤，近墨者黑”原理。

  2. 无须训练:
    KNN是一种懒惰学习算法，不需要显式的训练阶段，所有计算在预测阶段进行，这使得模型构建非常快速。

  3. 适应性强:
    KNN可以处理多分类问题和回归问题，对于数据的分布没有假设，能够适应各种类型的数据。

  4. 非参数方法:
    由于KNN不依赖于数据分布的假设，它是一种非参数方法，这意味着它不需要事先知道数据的分布类型。

缺点

  1. 计算成本高:
    在预测阶段，KNN需要计算测试样本与所有训练样本之间的距离，当数据集非常大时，这会变得非常耗时。

  2. 存储成本高:
    KNN需要存储所有训练数据，这在数据量大时会占用大量存储空间。

  3. 对K值敏感:
    K值的选择对模型性能有显著影响。K值太小容易受到噪声的影响，K值太大则可能包含过多的无关信息。

  4. 受维度灾难影响:
    当特征空间的维度很高时，KNN的性能会下降，因为高维空间中距离的计算变得不那么有意义。

  5. 不平衡数据集问题:
    在不平衡数据集中，KNN可能偏向于多数类，导致预测不准确。

sub目录7.2: KNN回归算法的应用场景与建议

应用场景

  1. 推荐系统:
    KNN可以用于推荐系统中，通过找到与用户兴趣相似的其他用户，推荐他们喜欢的项目。

  2. 异常检测:
    在异常检测中，KNN可以用来识别与大多数数据点距离较远的点，这些点可能代表异常或离群值。

  3. 回归预测:
    KNN回归可以用于预测连续值，如房价预测、股票价格预测等。

应用建议

  1. 数据预处理:
    在使用KNN之前，对数据进行预处理，包括缺失值处理、数据标准化或归一化，以减少维度灾难的影响。

  2. 特征选择:
    使用特征选择技术来减少特征空间的维度，这有助于提高KNN的性能。

  3. K值选择:
    通过交叉验证来选择最优的K值，避免过拟合或欠拟合。

  4. 距离度量:
    根据数据的特性选择合适的距离度量方法，如欧氏距离、曼哈顿距离等。

  5. 处理不平衡数据集:
    对于不平衡数据集，可以使用过采样、欠采样或合成样本的方法来平衡数据。

示例代码

假设我们有一个简单的房价预测数据集，包含房屋的面积和卧室数量作为特征，以及房屋的价格作为目标变量。我们将使用KNN回归来预测房屋的价格。

# 导入必要的库
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsRegressor
from sklearn.metrics import mean_squared_error

# 创建示例数据
X = np.array([[100, 2], [150, 3], [200, 4], [250, 5], [300, 6]])
y = np.array([100000, 150000, 200000, 250000, 300000])

# 数据预处理
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=3)

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

# 预测
y_pred = knn.predict(X_test)

# 评估模型
mse = mean_squared_error(y_test, y_pred)
print(f'Mean Squared Error: {mse}')

在这个例子中，我们首先创建了一个简单的数据集，然后使用StandardScaler对数据进行标准化处理，以确保特征在相同的尺度上。接着，我们使用train_test_split将数据集划分为训练集和测试集。创建KNN回归模型时，我们选择了K值为3。模型训练后，我们使用测试集进行预测，并通过计算均方误差（MSE）来评估模型的性能。

结论

KNN回归算法在处理回归任务时具有其独特的优势，但同时也存在一些挑战。通过适当的预处理和参数调整，可以有效地应用KNN回归算法来解决实际问题。

kkchenkx
关注
专栏目录
K-近邻算法KNN学习笔记
01-27
K-近邻算法（K-Nearest Neighbor, KNN）是一种基础的机器学习算法，主要用于分类和回归任务。它的核心思想是基于实例的学习，通过在训练数据集中寻找与新样本最为相似的邻居来做出预测。KNN算法由Cover T和Hart P在...
数据处理和分析之分类算法：K近邻算法(KNN)：KNN在分类任务中的应用
2401_87715305的博客
09-28 537
KNN算法是一种简单而有效的分类方法，但在实际应用中需要注意K值的选择和数据预处理，以提高模型的性能。通过上述示例，我们可以看到如何使用Python的库来实现KNN分类，并评估模型的准确率。K近邻算法（K-Nearest Neighbors, KNN）是一种基于实例的学习方法，用于分类和回归任务。其核心思想是：对于一个给定的样本，根据其在特征空间中最近的K个邻居的类别来预测该样本的类别。计算距离：选择一个距离度量方法（如欧氏距离），计算待分类样本与训练集中每个样本的距离。找到K个最近邻。
数据处理和分析之分类算法：K近邻算法(KNN)：K近邻算法原理与应用
2401_87715305的博客
09-28 508
在应用KNN算法时，合理选择K值、权重函数和距离度量是至关重要的。通过调整这些参数，可以优化模型的性能，避免过拟合或欠拟合的问题。在实际操作中，可以通过交叉验证等方法来寻找最佳的参数组合。请注意，上述代码示例使用了sklearn库中的类来实现KNN算法。在运行代码之前，确保已经安装了sklearn库。此外，数据集load_iris提供了鸢尾花数据，用于演示KNN算法的分类能力。通过调整weights和metric参数，可以观察到不同设置下模型性能的变化。虽然使用sklearn。
数据处理和分析之分类算法：K近邻算法(KNN)：KNN在实际项目中的部署
2401_87715305的博客
09-28 303
K近邻算法(K-Nearest Neighbors, KNN)是一种基于实例的学习方法，广泛应用于分类和回归任务中。其核心思想是：对于一个给定的样本，根据其在特征空间中最近的K个邻居的类别来预测该样本的类别。计算距离：选择一个距离度量方法，如欧氏距离，计算待分类样本与训练集中每个样本的距离。找到K个最近邻：从距离最近的样本中选择K个。分类决策：根据这K个最近邻的类别，采用多数表决的方式决定待分类样本的类别。
数据处理和分析之分类算法：K近邻算法(KNN)：距离度量方法
最新发布
2401_87715305的博客
09-28 457
K近邻算法（K-Nearest Neighbors, KNN）是一种基于实例的学习方法，用于分类和回归。在分类问题中，KNN通过计算待分类样本与训练集中所有样本的距离，然后选取距离最近的K个样本，根据这K个样本的类别来预测待分类样本的类别。KNN算法简单直观，易于理解和实现，但计算量大，特别是在数据量庞大的情况下。
数据处理和分析之分类算法：K近邻算法(KNN)：K值的选择策略
2401_87715305的博客
09-28 429
K近邻算法(K-Nearest Neighbors, KNN)是一种基于实例的学习方法，用于分类和回归。在分类问题中，KNN通过计算待分类样本与训练集中所有样本的距离，然后选取距离最近的K个样本，根据这K个样本的类别来预测待分类样本的类别。KNN算法的决策过程简单直观，易于理解和实现。
数据处理和分析之分类算法：K近邻算法(KNN)：KNN算法的优化技术
2401_87715305的博客
09-28 420
K近邻算法(KNN)是一种基于实例的学习方法，其核心思想是通过计算待分类样本与训练集中样本的距离，选取距离最近的K个样本，根据这些样本的类别来预测待分类样本的类别。
数据处理和分析之分类算法：K近邻算法(KNN)：机器学习概论
2401_87715305的博客
09-28 272
KNN算法是一种简单直观的分类算法，通过计算距离和多数表决来预测样本类别。在实际应用中，选择合适的距离计算方法和K值是关键。通过上述示例，我们可以看到如何使用Python和库来实现KNN算法，进行数据分类。请注意，虽然在要求中提到“严禁输出主题”和“严禁输出‘基本原则’等冗余输出”，但为了撰写一个完整的教程，上述内容包含了对主题的介绍和基本原则的解释，这是理解KNN算法实现所必需的。如果严格遵循要求，这部分内容将被省略，但这样将无法提供一个完整的教程文档。
探索K-近邻算法（KNN）：原理、实践应用与文本分类实战
pengyi123的博客
04-06 1966
在词袋模型的基础上，引入TF-IDF（Term Frequency-Inverse Document Frequency）权重，以突出那些在特定文档中频繁出现但在整体文档集合中不常见的词语，从而增强特征表示的区分度。在学术和工业界，针对KNN算法的优化和扩展一直是研究热点，不断涌现新的研究成果和技术解决方案，以适应大数据时代对算法性能的更高要求。：如科技新闻、体育新闻、财经新闻等多类别分类，KNN同样可以应用于此，通过计算文本向量间的距离，将新闻文章分配给最接近的类别。
K-近邻算法： k-nearest neighbor classification (kNN) 详细介绍
热门推荐
chenhepg的博客
04-09 4万+
@创建于：2020.04.09 @修改于：2020.04.09，2024.06.22 文章目录1、kNN介绍2、k近邻法的三要素详解2.1 距离度量2.2 k值的选择2.3 分类决策规则3、k近邻法的实现：kd树4、Python实现过程5、优缺点6、常见问题 1、kNN介绍 kNN是一个基本而简单的分类算法，作为监督学习，那么KNN模型需要的是有标签的训练数据，对于新样本的类别由与新样本距离最近的k个训练样本点按照分类...
knn分类算法_knn_k近邻_K._数据集分类_近邻分类_源码
10-04
k近邻（K-Nearest Neighbors，简称KNN）算法是一种基础且广泛应用的监督学习方法，主要用于分类和回归问题。在本项目中，我们关注的是它的分类功能，特别是使用Visual Studio 2017来实现这个算法。下面将详细阐述kNN...
kNNregression.rar_K._K近邻算法_knn regression_knnregression_k近邻回归
07-14
k近邻（k-Nearest Neighbors，简称kNN）算法是一种基础且广泛应用的监督学习方法，主要用于分类和回归任务。在这个压缩包“kNNregression.rar”中，重点是探讨kNN算法在回归问题上的应用，即kNN回归（kNN Regression...
kNN.zip_K._knn_k近邻算法 KNN
09-21
k近邻（K-Nearest Neighbors，简称kNN）是一种简单而强大的监督学习算法，主要用于分类和回归问题。在本教程中，我们将深入探讨kNN算法的核心概念、工作原理以及如何通过Python实现。 kNN算法的核心思想是...
欺诈文本分类检测（十七）：支持分类原因训练
golfxiao的专栏
09-27 640
进行了数据增强，本文将使用增强后的数据对模型进行进一步训练，以便得到能同时预测出分类标签、欺诈者、原因分析多个信息。总共进行了5折数据10轮训练，每折数据进行了两轮训练。训练结果中共包含三个信息，由于三个信息的输出类型不同，需要分别分析每个字段的评测方式。
ResNet50V2:口腔癌分类
2301_76606951的博客
09-27 626
本文为为内部文章原作者：K同学啊。
基于python深度学习遥感影像地物分类与目标识别、分割实践技术
weixin_58566962的博客
09-23 610
随着小卫星星座的普及，对地观测已具备3次以上的全球覆盖能力，遥感影像也不断被更深入的应用于矿产勘探、精准农业、城市规划、林业测量、军事目标识别和灾害评估中。最近借助深度学习方法，基于卷积神经网络的遥感影像自动地物识别取得了令人印象深刻的结果。深度卷积网络采用“端对端”的特征学习，通过多层处理机制揭示隐藏于数据中的非线性特征，能够从大量训练集中自动学习全局特征（这种特征被称为“学习特征”），是其在遥感影像自动目标识别取得成功的重要原因，也标志特征模型从手工特征向学习特征转变。
python 实现knn sklearn K近邻分类算法
luthane的博客
09-27 254
K近邻（K-Nearest Neighbors，简称KNN）分类算法是sklearn（scikit-learn）库中一种常用的机器学习算法，属于有监督学习范畴。它基于这样一个原理：对于待分类的样本，算法会找到训练数据集中与其最相似的K个样本（即K个最近邻），然后根据这K个样本的类别进行投票，将待分类样本归类到票数最多的类别中。构建已分类的数据集：作为训练集，其中包含了已知分类标签的样本数据。计算距离：当输入没有标签的新数据时，算法会计算这个新数据与训练集中每个样本之间的距离。
第L4周：机器学习-KNN总结-分类
差点就差一点点的专栏
09-24 563
解释一下:X_pred.shape[0] 就是结果总数30. X_pred.shape的结果是（30， 1），那么shpae[0]就是30.可以看到，30个特征值预测了30个结果。把数据集做切分，按8：2比例切，80%用来训练，20%用来预测。第1个：Sepal.Length（花萼长度），单位是cm。第3个：Petal.Length（花瓣长度），单位是cm。第4个：Petal.Width（花瓣宽度），单位是cm;第2个：Sepal.Width（花萼宽度），单位是cm。标签数据中的0，1，2又代表什么呢？
KNN算法详解：回归与分类差异及手写识别应用
KNN（k近邻算法）是一种基于实例的学习方法，它通过寻找新样本在特征空间中最接近的已知样本来进行预测。在处理分类和回归问题时，其核心思想是利用邻域原则，依据邻近样本的性质来推断未知样本的类别或属性。 KNN...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值