例题

现在有一个数据集“北京市空气质量数据.xlsx”，包含日期、AQI、质量等级、PM2.5、PM10、SO2、CO、NO2、O3，其中日期和AQI为无用数据，质量等级包含无、优、良、轻度污染、中度污染、重度污染、严重污染，将其划分为0-6，对PM2.5、PM10、SO2、CO、NO2、O3进行建模分析。

(1) 多元线性回归

(2) 逻辑回归

(3) 贝叶斯分类器

(4) 回归树

(5) 分类树

(6) 袋装策略

(7) 随机森林

(8) AdaBoost

(9) 梯度提升树

(10) 多层感知机回归模型

(11) 多层感知机分类模型

(12) 支持向量机回归模型

(13) 支持向量机分类模型

模型训练

在训练过程中，通过调用train_test_split方法，将数据集划分为训练集和测试集，同时保持测试集大小为原数据集大小的 20%（适当调整）。

接着，使用 LinearRegression 模型进行训练，并通过调用 score 方法计算出模型的准确率，。

如要画出准确率或者mse的图形展示，则代码调用了 matplotlib 库，将 列表传入 plt.plot() 方法中，绘制出了一个折线图或热力图等，调用 plt.show() 显示图形。

(1) 基于多元线性回归预测AQI(空气质量指数)

from sklearn.linear_model import LinearRegression  # 回归
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import matplotlib as mpl

data = pd.read_excel("北京市空气质量数据.xlsx")


future = ['PM2.5', 'PM10', 'SO2', 'NO2', 'CO', 'O3']
# 不同指标的预测准确率
accuracy_list = []
for future_num in range(len(future)):
    X = data[future[future_num:future_num + 1]]
    Y = data['AQI']
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=1)
    # print('训练集大小:', X_train.shape)
    # print('测试集大小:', X_test.shape)
    lrm = LinearRegression()
    lrm.fit(X_train, Y_train)
    accuracy = lrm.score(X_test, Y_test)
    accuracy_list.append(accuracy)
    print(f'使用 {future[future_num]}, 模型准确率为:', accuracy)

mpl.rcParams['font.sans-serif'] = ['SimHei']
plt.plot(future, accuracy_list)
plt.xlabel('预测变量')
plt.ylabel('准确率')
plt.title('不同变量下模型预测准确率')
plt.show()

(2) 逻辑回归

实现了逻辑回归模型的训练、预测和评估，并通过混淆矩阵可视化了预测结果。我们可以通过准确率来评估模型对质量等级的预测能力，并通过混淆矩阵来分析模型的分类效果。

具体步骤：

初始化一个逻辑回归模型，并调用 fit 方法对训练集进行训练。

然后，使用 predict 方法对测试集进行预测，将预测结果保存在 y_pred 中。

继而，通过调用 accuracy_score 方法，计算模型在测试集上的准确率，并将结果保存在 accuracy 变量中。

最后，使用 confusion_matrix 方法计算混淆矩阵，并使用 seaborn 的 heatmap 方法以热图的形式展示混淆矩阵。

热力图：颜色越浅表示数量越多，颜色越深表示数量越少。在逻辑回归模型中，混淆矩阵可以展示真实标签和预测标签之间的对比，以及模型对不同标签的预测准确性。

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
import warnings

warnings.filterwarnings("ignore")

X = data[["PM2.5", "PM10", "SO2", "CO", "NO2", "O3"]]
y = data["质量等级"]

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

# 初始化逻辑回归模型
model = LogisticRegression()

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

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

# 计算模型准确率
accuracy = accuracy_score(y_test, y_pred)
print("模型准确率: ", accuracy)

# 绘制混淆矩阵
cnf_matrix = confusion_matrix(y_test, y_pred)
sns.heatmap(cnf_matrix, annot=True, fmt='d', cmap="YlGnBu")
plt.xlabel('预测标签')
plt.ylabel('真实标签')
plt.show()

(3) 贝叶斯分类器

首先创建了一个朴素贝叶斯分类器对象，然后使用训练数据进行模型训练，之后使用测试数据进行预测，得到预测的标签。接着计算了预测结果与真实标签之间的准确率。

最后，打印出朴素贝叶斯分类器的准确率，并输出分类器的性能报告（包括precision、recall、f1-score等指标）。另外，还输出了混淆矩阵，以进一步了解模型在各个类别上的分类情况。

朴素贝叶斯分类器的准确率为0.686

分类器性能报告提供了各个类别的precision、recall、f1-score等指标，用于评估模型在不同类别上的分类性能。

混淆矩阵则展示了模型在真实标签和预测标签之间的分类情况，可以用于分析模型在各个类别上的分类情况，进而优化模型的性能。

# 朴素贝叶斯分类
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import classification_report, confusion_matrix

# 创建朴素贝叶斯分类器对象
naive_bayes = GaussianNB()

# 训练模型
naive_bayes.fit(X_train, y_train)
# 预测标签
y_pred = naive_bayes.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)

print("朴素贝叶斯分类器的准确率：", accuracy)
print("分类器性能报告:")
print(classification_report(y_test, y_pred,zero_division=1))
print("混淆矩阵:")
print(confusion_matrix(y_test, y_pred))

(4) 回归树

根据MSE值，判断模型的拟合效果。MSE越小，模型的预测效果越好。

首先定义了一个深度列表depths，用于记录不同深度的回归树。接下来创建了一个空的均方误差列表mse_scores，用于存储不同深度下的均方误差。

然后，使用一个循环遍历每个深度。在每次迭代中，创建一个回归树对象，并将深度设置为当前迭代的深度。

接着，在训练数据上拟合回归树模型，然后在测试数据上进行预测，得到预测的目标变量值。计算预测结果与真实目标变量之间的均方误差

最后，使用Matplotlib库绘制了深度和均方误差之间的关系图。直观地观察到不同深度下的回归树的性能变化情况。

结论：

随着深度的增加，均方误差呈现出先下降后上升的趋势

根据均方误差选择最佳深度为2，来使回归树的性能最佳。

通过绘制深度和均方误差之间的关系图，可以直观地观察到不同深度下的回归树的性能变化情况。

import numpy as np
import matplotlib.pyplot as plt
from sklearn.tree import DecisionTreeRegressor
from sklearn.metrics import mean_squared_error

depths = [2, 3, 4, 5, 6, 7, 8]  # 深度列表
mse_scores = []  # 均方误差列表

for depth in depths:
    # 创建回归树对象并设置深度
    reg_tree = DecisionTreeRegressor(max_depth=depth)

    # 在训练数据上拟合回归树模型
    reg_tree.fit(X_train, y_train)

    # 在测试数据上进行预测
    y_pred = reg_tree.predict(X_test)

    # 计算均方误差并添加到均方误差列表
    mse = mean_squared_error(y_test, y_pred)
    mse_scores.append(mse)

plt.plot(depths, mse_scores, marker='o')
plt.xlabel('深度')
plt.ylabel('均方误差')
plt.title('不同深度下的回归树均方误差')
plt.xticks(depths)
plt.grid(True)
plt.show()

(5) 分类树

代码首先创建了使用Gini系数进行划分的决策树对象，并使用训练数据进行训练，然后使用测试数据进行预测，得到预测的标签。接着计算了预测结果与真实标签之间的准确率，存储在accuracy_gini变量中。

接下来，创建了使用Entropy进行划分的决策树对象，并同样进行训练和预测。同样地，计算了预测结果与真实标签之间的准确率，存储在accuracy_entropy变量中。

最后，打印出使用Gini系数进行划分的决策树的训练精度和使用Entropy进行划分的决策树的训练精度。

结论：

使用Gini系数进行划分的决策树的训练精度为0.969

使用Entropy进行划分的决策树的训练精度为0.967

Gini系数的训练精度略大于Entropy，能更好的拟合训练数据

根据训练精度的数值大小可以评估模型的性能，较高的训练精度意味着模型能够较好地拟合训练数据。

# 决策树
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 创建使用 Gini 系数进行划分的决策树对象
tree_gini = DecisionTreeClassifier(criterion="gini")
tree_gini.fit(X_train, y_train)
y_pred_gini = tree_gini.predict(X_test)
accuracy_gini = accuracy_score(y_test, y_pred_gini)

# 创建使用Entropy进行划分的决策树对象
tree_entropy = DecisionTreeClassifier(criterion="entropy")
tree_entropy.fit(X_train, y_train)
y_pred_entropy = tree_entropy.predict(X_test)
accuracy_entropy = accuracy_score(y_test, y_pred_entropy)

# print(data.shape,X_train.shape, X_test.shape, y_train.shape, y_test.shape)
print("使用 Gini 系数进行划分的决策树的训练精度：", accuracy_gini)
print("使用Entropy进行划分的决策树的训练精度：", accuracy_entropy)

(6) 袋装策略 + (7) 随机森林

分别使用袋装法和随机森林进行分类，并比较了它们的分类准确率。

定义了迭代次数范围，并分别使用袋装法和随机森林进行了分类。在每一次迭代中，计算了模型的准确率，并将准确率存储在对应的列表中。

使用matplotlib库绘制了迭代次数与分类准确率的关系图，将袋装法和随机森林的准确率在同一张图中展示，方便比较它们之间的差别。

根据代码中打印出的结果可以看出，袋装法最后一次迭代的准确率为0.972，随机森林最后一次迭代的准确率为0.967。可以看出，在本例中，袋装法的分类准确率更高。同时，在迭代次数增加的情况下，随机森林的准确率也相应增加，而袋装法的准确率增长的速度相对较慢。

#使用袋装法和随机森林进行分类，给出不同模型分类准确率，绘制分类散点图

from sklearn.ensemble import BaggingClassifier, RandomForestClassifier

# 定义迭代的次数范围
num_iterations = range(1, 20)

accuracies_bagging = []
accuracies_forest = []

for num in num_iterations:
    # 使用袋装法进行分类
    bagging = BaggingClassifier(n_estimators=num, random_state=42)
    bagging.fit(X_train, y_train)
    y_pred_bagging = bagging.predict(X_test)
    bagging_accuracy = accuracy_score(y_test, y_pred_bagging)
    accuracies_bagging.append(bagging_accuracy)
    
    # 使用随机森林进行分类
    random_forest = RandomForestClassifier(n_estimators=num, random_state=42)
    random_forest.fit(X_train, y_train)
    y_pred_forest = random_forest.predict(X_test)
    forest_accuracy = accuracy_score(y_test, y_pred_forest)
    accuracies_forest.append(forest_accuracy)

# 打印最后一次迭代的准确率
last_iteration_bagging = accuracies_bagging[-1]
last_iteration_forest = accuracies_forest[-1]
print("袋装法最后一次迭代的准确率：", last_iteration_bagging)
print("随机森林最后一次迭代的准确率：", last_iteration_forest)

# 创建迭代次数列表
iterations = list(num_iterations)
# 绘制折线图
plt.plot(iterations, accuracies_bagging, label="袋装法")
plt.plot(iterations, accuracies_forest, label="随机森林")
plt.xlabel("迭代次数")
plt.ylabel("准确率")
plt.title("迭代次数与分类准确率关系")
plt.legend()
plt.show()

(8) AdaBoost

创建了AdaBoost分类器对象

使用X_train和y_train训练了AdaBoost分类器，使用adaboost_clf对X_test进行预测，并将预测结果存储在变量y_pred中。

最后，打印出分类器的性能评估报告，包括精确度、召回率和F1得分等指标。

结论：

AdaBoost算法可以用来解决分类任务，并且可以在基分类器性能较弱的情况下获得良好的分类性能。

AdaBoost分类器的性能评估结果通过classification_report函数进行展示，其中包括精确度、召回率、F1得分和支持度等指标，这些指标可以用来评估分类器的性能和交叉验证结果。

AdaBoost分类器的性能表现取决于基分类器、迭代次数和学习速率等参数的设置，进行调整和优化。

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
import warnings

warnings.filterwarnings("ignore")
# 创建AdaBoost分类器
base_clf = DecisionTreeClassifier(max_depth=1)
adaboost_clf = AdaBoostClassifier(base_estimator=base_clf, n_estimators=50, learning_rate=1.0)

# 训练分类器
adaboost_clf.fit(X_train, y_train)

# 预测
y_pred = adaboost_clf.predict(X_test)

# 评估结果
print(classification_report(y_test, y_pred))

(9) 梯度提升树

提升法的训练过程是先定义一个基分类器，然后反复迭代，针对分类错误的样本增加权重，再训练下一个分类器。这样每个分类器都关注于错误的样本，能够不断地提高分类的准确性。

梯度提升法是建立在训练决策树模型的基础上，每棵树都是基于之前所有树分类错误的梯度信息去训练，损失函数被优化以使得每次迭代都能够减少残差。这样每个分类器都能够适应更复杂和非线性的情形。

我们可以看到提升法的准确率为0.568，这意味着该模型仅能正确分类出不到一半的数据。梯度提升法的准确率为0.979，这意味着该模型能够在测试集上正确分类出接近于全部的数据。

因此，我们可以得出结论，对于北京市空气质量数据.xlsx，这个数据集而言，梯度提升法比提升法更适合用于分类任务。

#提升法和梯度提升法进行分类，给出不同模型分类准确率，绘制分类散点图

# -*- coding: utf-8 -*-
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import AdaBoostClassifier, GradientBoostingClassifier
from sklearn.metrics import accuracy_score
import matplotlib.pyplot as plt

# 数据集读取和处理
data = pd.read_excel("北京市空气质量数据.xlsx")

# #检查是否有空值或者缺失值
# missing_values = data.isnull().sum()
# print("缺失值统计：\n", missing_values)
# empty_values = data.isna().sum()
# print("空值统计：\n", empty_values)
# 数据集读取和处理
data = pd.read_excel("北京市空气质量数据.xlsx")
data = data.drop(columns=["日期", "AQI"])   # 去除无用数据（日期和AQI）,其中AQI决定质量等级

label_mapping = {"无": 0, "优": 1, "良": 2, "轻度污染": 3, "中度污染": 4, "重度污染": 5, "严重污染": 6}  # 将质量等级转换为数值标签（0-6）
data["质量等级"] = data["质量等级"].map(label_mapping)

# 提取特征和标签
X = data.drop(columns=["质量等级"])
y = data["质量等级"]

# 分离训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) #此处训练集占比为20%

# 使用提升法进行分类
ada_boost = AdaBoostClassifier(n_estimators=100, random_state=42)
ada_boost.fit(X_train, y_train)
y_pred_boost = ada_boost.predict(X_test)
boost_accuracy = accuracy_score(y_test, y_pred_boost)
print("提升法分类准确率:", boost_accuracy)

# 使用梯度提升法进行分类
gradient_boost = GradientBoostingClassifier(n_estimators=100, random_state=42)
gradient_boost.fit(X_train, y_train)
y_pred_gradient = gradient_boost.predict(X_test)
gradient_accuracy = accuracy_score(y_test, y_pred_gradient)
print("梯度提升法分类准确率:", gradient_accuracy)

# 绘制分类散点图
plt.rcParams["font.sans-serif"] = "SimHei"     #中文显示
plt.scatter(X_test["PM2.5"], X_test["PM10"], c=y_test)
plt.title("空气质量分类")
plt.xlabel("PM2.5")
plt.ylabel("PM10")
plt.show()

(10) 多层感知机回归模型

使用sklearn库中的MLPRegressor构建了一个多元感知机回归模型，并设置了隐藏层的数量、激活函数、最大迭代次数、求解器和随机状态等参数。

然后，使用X_train和y_train拟合了多元感知机回归模型，得到了训练好的模型mlp。接下来，使用mlp对X_test进行预测，得到了预测结果y_pred。通过计算预测结果和真实结果之间的均方误差，评估了模型的性能并将结果打印出来。

最后，构建了一个新的数据集new_data，并对其进行预处理，然后使用训练好的模型mlp对其进行预测，并将结果打印出来。

结论：

多元感知机回归模型可以用于解决回归任务，并且在大多数情况下表现良好。

使用sklearn库中的MLPRegressor可以方便地构建多元感知机回归模型，并设置隐藏层数、激活函数、最大迭代次数、求解器和随机状态等参数以调整模型性能。

使用模型对新数据进行预测，预测目标变量的值为2即空气质量等级为“良”

通过计算均方误差，可以评估模型性能并使用其进行比较和优化。这里的均方误差为0.24，在可接受范围内

#多元感知机回归模型
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPRegressor
from sklearn.metrics import mean_squared_error

mlp = MLPRegressor(hidden_layer_sizes=(4, 4), activation="relu", max_iter=10000, solver="lbfgs", random_state=42)
mlp.fit(X_train, y_train)
y_pred = mlp.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
print("均方误差: {:.2f}".format(mse))

# 输入新数据以进行预测
new_data = pd.DataFrame({
    "PM2.5": [50.0],
    "PM10": [40.0],
    "SO2": [30.0],
    "CO": [0.8],
    "NO2": [30.0],
    "O3": [70.0]
})
new_data = (new_data - X.mean()) / X.std()
y_new = mlp.predict(new_data)
print("预测的空气质量等级: {:.2f}".format(y_new[0]))

(11) 多层感知机分类模型

结论：

使用模型对新数据进行预测，以预测目标变量的值为2，结果和回归模型类似，结果也是“良”。

通过计算准确率，可以评估模型性能并使用其进行比较和优化。此处的准确率为0.75，在可接受范围内

#多层感知机分类模型
from sklearn.neural_network import MLPClassifier
mlp = MLPClassifier(hidden_layer_sizes=(4, 4), activation="relu", max_iter=10000, solver="lbfgs", random_state=42)
mlp.fit(X_train, y_train)
y_pred = mlp.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print("准确率: {:.2f}".format(accuracy))

# 输入新数据以进行预测
new_data = pd.DataFrame({
    "PM2.5": [50.0],
    "PM10": [40.0],
    "SO2": [30.0],
    "CO": [0.8],
    "NO2": [30.0],
    "O3": [70.0]
})
y_new = mlp.predict(new_data)
print("质量等级: {}".format(y_new[0]))

(12) 支持向量机回归模型

首先使用sklearn库中的SVC模块导入SVM分类模型。

接下来，使用train_test_split函数将数据集划分为训练集和测试集，其中测试集占比为20%。然后，使用导入的SVC模型建立SVM分类模型，并使用fit函数在训练集上拟合模型。

然后，使用predict函数在测试集上进行预测。最后，使用classification_report函数打印出分类报告，其中包含了模型在测试集上的精确度、召回率、F1值等指标。

结论：

支持向量机（SVM）分类模型可以用于解决二分类或多分类任务，具有较好的分类性能。

SVM模型中的rbf核函数是一种常用的核函数，可以处理非线性可分的情况。

通过调整C参数的值，可以对模型进行正则化，控制模型的复杂度和容错性。

通过使用分类报告，我们可以获得模型在测试集上的准确率、召回率、F1值等评估指标，从而更全面地评价模型的性能。

#支持向量机分类模型
from sklearn.svm import SVC
from sklearn.metrics import classification_report
from sklearn.model_selection import train_test_split


# 筛选出需要的特征列
features = ["PM2.5", "PM10", "SO2", "CO", "NO2", "O3"]
X = data[features]
y = data["质量等级"]

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

# SVM分类模型
svm_clf = SVC(kernel='rbf', C=1000)
svm_clf.fit(X_train, y_train)

# 在测试集上进行预测
y_pred = svm_clf.predict(X_test)

# 分类报告
print("分类报告：\n", classification_report(y_test, y_pred))

(13) 支持向量机分类模型

使用predict函数对测试集进行预测，得到预测结果y_pred。最后，使用mean_squared_error函数计算模型在测试集上的均方误差（MSE），并将结果打印出来。

结论：

支持向量机（SVM）回归模型可以用于解决回归任务，具有较好的回归性能。

SVR模型的默认参数可以用于建立基本的支持向量机回归模型。

通过计算均方误差（MSE），我们可以评估模型在测试集上的预测误差大小，MSE越小表示模型的预测能力越好。此处的MSE为0.1185，说明了模型的预测能力很好

# 支持向量机回归模型
# 准备数据集
import pandas as pd
from sklearn.svm import SVR
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler

# 提取特征和标签
X = data[["PM2.5", "PM10", "SO2", "CO", "NO2", "O3"]]
y = data["质量等级"]

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

# 创建支持向量机回归模型
model = SVR()

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

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

# 计算均方误差
mse = mean_squared_error(y_test, y_pred)
print("均方误差(MSE):", mse)