python数据分析—葡萄酒质量预测

 1 # 需要绘制直方图的特征列列表
 2 flistt = ['alcohol','sulphates','citric_acid','volatile_acidity']
 3 
 4 # 根据不同质量等级将数据分为三个子集
 5 low = df_aux[df_aux['quality'] == 'low']
 6 medium = df_aux[df_aux['quality'] == 'med']
 7 high = df_aux[df_aux['quality'] == 'high']
 8 
 9 # 更改字体大小
10 plt.rcParams.update({'font.size': 8})
11 
12 # 创建2x2的4个子图
13 plot, graphs = plt.subplots(nrows= 2, ncols= 2, figsize=(12,6))
14 graphs = graphs.flatten()
15 
16 # 循环绘制4个特征的直方图
17 for i, graph in enumerate(graphs):
18     graph.figure
19     
20     # 计算每个直方图的bin宽度
21     binwidth= (max(df_aux[flistt[i]]) - min(df_aux[flistt[i]]))/30
22     bins = np.arange(min(df[flistt[i]]), max(df_aux[flistt[i]]) + binwidth, binwidth)
23     
24     # 将三个子集的数据分别添加到直方图中，设置透明度、标签和颜色，并绘制标准化后的直方图
25     graph.hist([low[flistt[i]],medium[flistt[i]],high[flistt[i]]], bins=bins, alpha=0.6, normed=True, label=['Low','Medium','High'], color=['red','green','blue'])
26     
27     # 添加图例到右上角
28     graph.legend(loc='upper right')
29     
30     # 设置子图标题
31     graph.set_title(flistt[i])
32 
33 # 自适应调整子图布局
34 plt.tight_layout()

1 #从相关系数矩阵中选择绝对值大于0.2的相关系数，以查找与目标列（此处为quality）强相关的列。
2 correlations[abs(correlations) > 0.2]

1 # 从数据框中选择4个特征列作为自变量，将“quality”列作为因变量。
2 X = df.loc[:,['alcohol','sulphates','citric_acid','volatile_acidity']]
3 Y = df.iloc[:,11]
4 
5 # 将数据划分为训练集和测试集，并使用线性回归模型进行拟合和预测。
6 # 此处采用70%的数据作为训练集，其余30%作为测试集，设置随机种子为42，以确保每次运行时产生相同的结果。
7 X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=42)

 1 # 构建线性回归模型，并对模型进行训练和预测。
 2 regressor = LinearRegression()
 3 regressor.fit(X_train, y_train)
 4 y_prediction_lr = regressor.predict(X_test)
 5 y_prediction_lr = np.round(y_prediction_lr)
 6 # 对模型的预测结果进行可视化展示。
 7 plt.scatter(y_test,y_prediction_lr)
 8 plt.title("Prediction Using Linear Regression")
 9 plt.xlabel("Real Quality")
10 plt.ylabel("Predicted")
11 plt.show()

 1 # 使用混淆矩阵展示线性回归模型的分类效果。
 2 # 首先，计算模型预测结果的混淆矩阵。
 3 cm_linear_regression = confusion_matrix(y_test,y_prediction_lr)
 4 
 5 # 将混淆矩阵转换为数据框，并设置标签和格式。
 6 cm_lr = pd.DataFrame(cm_linear_regression,
 7                      index = ['3','4','5','6','7','8'], 
 8                      columns = ['3','4','5','6','7','8'])
 9 sns.heatmap(cm_lr,annot=True,fmt="d")
10 
11 # 设置横纵坐标的标签。
12 label_aux = plt.subplot()
13 label_aux.set_xlabel('Predicted Quality')
14 label_aux.set_ylabel('True Quality')

 1 # 构建决策树回归模型，并对模型进行训练和预测。
 2 regressor = DecisionTreeRegressor()
 3 regressor.fit(X_train, y_train)
 4 y_prediction_dt = regressor.predict(X_test)
 5 y_prediction_dt = np.round(y_prediction_dt)
 6 
 7 # 对模型的预测结果进行可视化展示。
 8 plt.scatter(y_test,y_prediction_dt)
 9 plt.title("Prediction Using Decision Tree Regression")
10 plt.xlabel("Real Quality")
11 plt.ylabel("Predicted")
12 plt.show()

 1 # 构建决策树回归模型并对模型进行预测后，使用混淆矩阵展示其分类效果。
 2 # 首先，计算模型预测结果的混淆矩阵。
 3 cm_decision_tree_regression = confusion_matrix(y_test,y_prediction_dt)
 4 
 5 # 将混淆矩阵转换为数据框，并设置标签和格式。
 6 cm_dt = pd.DataFrame(cm_decision_tree_regression,
 7                      index = ['3','4','5','6','7','8'], 
 8                      columns = ['3','4','5','6','7','8'])
 9 sns.heatmap(cm_dt,annot=True,fmt="d")
10 
11 # 设置横纵坐标的标签。
12 label_aux = plt.subplot()
13 label_aux.set_xlabel('Predicted Quality')
14 label_aux.set_ylabel('True Quality')

 1 # 构建随机森林回归模型，并对模型进行训练和预测。
 2 regressor = RandomForestRegressor(n_estimators=10,random_state = 42)
 3 regressor.fit(X_train, y_train)
 4 y_prediction_rf = regressor.predict(X_test)
 5 y_prediction_rf = np.round(y_prediction_rf)
 6 
 7 # 对模型的预测结果进行可视化展示。
 8 plt.scatter(y_test,y_prediction_rf)
 9 plt.title("Prediction Using Random Forest Regression")
10 plt.xlabel("Real Quality")
11 plt.ylabel("Predicted")
12 plt.show()

 1 # 对随机森林回归模型的预测结果进行混淆矩阵展示。
 2 label_aux = plt.subplot()
 3 cm_random_forest_regression = confusion_matrix(y_test,y_prediction_rf)
 4 cm_rf = pd.DataFrame(cm_random_forest_regression,
 5 index = ['3','4','5','6','7','8'], 
 6 columns = ['3','4','5','6','7','8'])
 7 sns.heatmap(cm_rf,annot=True,fmt="d")
 8 
 9 # 设置横纵坐标的标签。
10 label_aux.set_xlabel('Predicted Quality')
11 label_aux.set_ylabel('True Quality')

1 # 计算线性回归模型的RMSE并输出。
3 RMSE = sqrt(mean_squared_error(y_test, y_prediction_lr))
5 print(RMSE)

1 # 计算决策树回归模型的RMSE并输出。
3 RMSE = sqrt(mean_squared_error(y_test, y_prediction_dt))
5 print(RMSE)

1 # 计算随机森林回归模型的RMSE并输出。
2 
3 RMSE = sqrt(mean_squared_error(y_test, y_prediction_rf))
4 
5 print(RMSE)

 1 # 定义函数，将回归模型预测结果与真实值之间相差1的样本的预测值调整为真实值。
 2 def one_accuracy(predicted, true):
 3     i = 0
 4     for x,y in zip(predicted,true):
 5         if(abs(x-y)==1):
 6             predicted[i] = y
 7         i = i + 1
 8 
 9 # 分别对线性回归、决策树回归和随机森林回归模型的预测结果进行一次精度修正。
10 one_accuracy(y_prediction_lr, y_test)
11 one_accuracy(y_prediction_dt, y_test)
12 one_accuracy(y_prediction_rf, y_test)
13 
14 # 展示线性回归模型在测试集上的混淆矩阵。
15 label_aux = plt.subplot()
16 cm_linear_regression = confusion_matrix(y_test,y_prediction_lr)
17 cm_lr = pd.DataFrame(cm_linear_regression,
18                      index = ['3','4','5','6','7','8'], 
19                      columns = ['3','4','5','6','7','8'])
20 sns.heatmap(cm_lr,annot=True,fmt="d")
21 label_aux.set_xlabel('Predicted Quality');label_aux.set_ylabel('True Quality');

 1 # 创建一个新的图表或子图，并将其赋值给变量label_aux。
 2 label_aux = plt.subplot()
 3 
 4 # 计算决策树回归模型在测试集上的混淆矩阵，将结果赋值给变量cm_decision_tree_regression。
 5 cm_decision_tree_regression = confusion_matrix(y_test, y_prediction_dt)
 6 
 7 # 创建一个以质量等级为标签的DataFrame，将混淆矩阵作为数据，行索引和列索引均使用质量等级。
 8 cm_dt = pd.DataFrame(cm_decision_tree_regression,
 9   index=['3', '4', '5', '6', '7', '8'],
10     columns=['3', '4', '5', '6', '7', '8'])
11 
12 # 使用sns.heatmap()函数绘制混淆矩阵的热图，其中annot=True表示需要显示数值标签，fmt="d"表示标签采用整数格式。
13 sns.heatmap(cm_dt, annot=True, fmt="d")
14 
15 # 为图表和子图添加横纵坐标轴的标签。
16 label_aux.set_xlabel('Predicted Quality')
17 label_aux.set_ylabel('True Quality')

 1 2 # 创建一个新的图表或子图，并将其赋值给变量label_aux。
 3 label_aux = plt.subplot()
 4 
 5 # 计算随机森林回归模型在测试集上的混淆矩阵，将结果赋值给变量cm_random_forest_regression。
 6 cm_random_forest_regression = confusion_matrix(y_test, y_prediction_rf)
 7 
 8 # 创建一个以质量等级为标签的DataFrame，将混淆矩阵作为数据，行索引和列索引均使用质量等级。
 9 cm_rf = pd.DataFrame(cm_random_forest_regression,
10                      index=['3', '4', '5', '6', '7', '8'],
11                      columns=['3', '4', '5', '6', '7', '8'])
12 
13 # 使用sns.heatmap()函数绘制混淆矩阵的热图，其中annot=True表示需要显示数值标签，fmt="d"表示标签采用整数格式。
14 sns.heatmap(cm_rf, annot=True, fmt="d")
15 
16 # 为图表和子图添加横纵坐标轴的标签。
17 label_aux.set_xlabel('Predicted Quality')
18 label_aux.set_ylabel('True Quality')

 1 #计算线性回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_lr中。
 2 RMSE_lr = sqrt(mean_squared_error(y_test, y_prediction_lr))
 3 
 4 #打印输出新改进的线性回归模型的RMSE。
 5 print("新改进的线性回归模型在测试集上的RMSE为：" + str(RMSE_lr) + "\n")
 6 
 7 #计算决策树回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_dt中。
 8 RMSE_dt = sqrt(mean_squared_error(y_test, y_prediction_dt))
 9 
10 #打印输出新改进的决策树回归模型的RMSE。
11 print("新改进的决策树回归模型在测试集上的RMSE为：" + str(RMSE_dt) + "\n")
12 
13 #计算随机森林回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_rf中。
14 RMSE_rf = sqrt(mean_squared_error(y_test, y_prediction_rf))
15 
16 #打印输出新改进的随机森林回归模型的RMSE。
17 print("新改进的随机森林回归模型在测试集上的RMSE为：" + str(RMSE_rf) + "\n")

 1 # 忽略警告信息
 2 warnings.filterwarnings('ignore')
 3 
 4 # 创建一个 PrettyTable 表格对象
 5 ptbl = PrettyTable()
 6 
 7 # 设置表格列名
 8 ptbl.field_names = ["Regressor Model", "Precision", "Recall", "F1Score"]
 9 
10 # 添加线性回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
11 ptbl.add_row(["Linear", 
12               precision_score(y_test, y_prediction_lr, average='weighted'), # 计算测试集上的 Precision
13               recall_score(y_test, y_prediction_lr, average='weighted'),    # 计算测试集上的 Recall
14               f1_score(y_test, y_prediction_lr, average='weighted')        # 计算测试集上的 F1 Score
15              ])
16 
17 # 添加决策树回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
18 ptbl.add_row(["Decision Tree", 
19               precision_score(y_test, y_prediction_dt, average='weighted'), # 计算测试集上的 Precision
20               recall_score(y_test, y_prediction_dt, average='weighted'),    # 计算测试集上的 Recall
21               f1_score(y_test, y_prediction_dt, average='weighted')        # 计算测试集上的 F1 Score
22              ])
23 
24 # 添加随机森林回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
25 ptbl.add_row(["Random Forest", 
26               precision_score(y_test, y_prediction_rf, average='weighted'), # 计算测试集上的 Precision
27               recall_score(y_test, y_prediction_rf, average='weighted'),    # 计算测试集上的 Recall
28               f1_score(y_test, y_prediction_rf, average='weighted')        # 计算测试集上的 F1 Score
29              ])
30 
31 # 输出表格
32 print(ptbl)

  1 import numpy as np  # 导入处理数值计算的库
  2   import warnings  # 用于处理警告信息
  3   import pandas as pd  # 导入处理数据的库
  4   import matplotlib.pyplot as plt  # 导入可视化绘图的库
  5   import seaborn as sns  # 导入更高级的可视化绘图库
  6   from sklearn.model_selection import train_test_split  # 导入拆分训练集和测试集的方法
  7   from sklearn.linear_model import LinearRegression  # 导入线性回归的方法
  8   from sklearn.metrics import mean_squared_error  # 导入均方误差的方法
  9   from sklearn.metrics import accuracy_score  # 导入准确率得分的方法
 10  from sklearn.metrics import f1_score, confusion_matrix, accuracy_score, recall_score, precision_score  # 导入用于分类问题评估性能的方法
 11  from sklearn.preprocessing import PolynomialFeatures  # 导入处理多项式特征的方法
 12  from sklearn.metrics import mean_squared_error  # 导入均方误差的方法
 13  from sklearn.tree import DecisionTreeRegressor  # 导入决策树回归器的方法
 14  from sklearn.ensemble import RandomForestRegressor  # 导入随机森林回归器的方法
 15  from sklearn import linear_model  # 导入线性模型库
 16  from math import sqrt  # 导入计算平方根的函数
 17  from prettytable import PrettyTable  # 导入绘制ascii表格的库
18
19
 18 #使用 pandas 中的 read_csv 函数读取 csv 文件
 19  df = pd.read_csv("winequality-red.csv")
 20  #使用 DataFrame 中的 head() 函数来查看数据的前 10 行
 21  df.head(10)
 22  df.shape #使用 df.shape 查看数据集的维度，即行数和列数。
 23 #将数据集中所有列名中的空格替换为下划线。
 24  df.columns = df.columns.str.replace(' ', '_')
 25  # 使用 df.info() 查看每列的数据类型和非空数量。
 26  # 使用 df.isnull().sum() 查看每列缺失值的数量。
 27  df.info()
 28  df.isnull().sum()
 29  #使用 Seaborn 库的 countplot 函数，展示数据集中每个品质评分对应的红酒质量
 30  sns.countplot(df['quality']) 
 31  
 32  #输出每种品质评分在数据集中的红酒质量
 33  df['quality'].value_counts() 
 34  df.corr()['quality'] #计算数据集中各个特征与“quality”列之间的相关系数，返回一个Series类型的对象。
 35  sort_values(ascending=False) #将上述Series对象中的值按照从大到小的顺序排序，生成一个有序的Series类型的对象。
 36  print(correlations) #输出排序后的结果。
 37 correlations.plot(kind='bar')#绘制按特征与品质相关系数从大到小排列的条形图  
 38 plt.figure(figsize=(10,6)) # 设置画布大小为 10*6 英寸
 39  sns.heatmap(df.corr(), annot=True, fmt='.0%') # 使用 Seaborn 可视化库绘制热力图
 40   print(abs(correlations) > 0.2)#计算各特征与“quality”特征之间的相关系数，然后返回一个布尔型DataFrame对象，其中每个元素表示该位置的相关系数绝对值是否大于0.2。
 41  # 使用Seaborn库的boxplot函数，绘制箱线图
 42  bp = sns.boxplot(x='quality',y='alcohol', data=df)
 43  
 44  # 设置图表标题
 45  bp.set(title="Alcohol Percent in Different Quality Wines")
 46 
 47  # 选择质量等级在5或6之间的葡萄酒数据
 48  df_quality_five_six = df.loc[(df['quality'] >= 5) & (df['quality'] <= 6)]
 49  # 统计质量等级为5和6的葡萄酒数量
 50  df_quality_five_six['quality'].value_counts()
 51 
 52  # 计算质量等级在5或6之间的葡萄酒数据中各属性与质量等级之间的相关性，并根据相关性从大到小进行排序
 53  correlations_subset = df_quality_five_six.corr()['quality'].sort_values(ascending=False)
 54  
 55  # 输出各属性与质量等级之间的相关性结果
 56  print(correlations_subset)
 57 
 58  # 使用seaborn库中的boxplot函数绘制质量等级与二氧化硫含量（“sulphates”）之间的箱线图
 59  bp = sns.boxplot(x='quality',y='sulphates', data=df)
 60  # 设置图表标题为“不同质量等级葡萄酒中的二氧化硫含量”
 61  bp.set(title="Sulphates in Different Quality Wines")
 62  # 使用seaborn库中的boxplot函数绘制质量等级与柠檬酸含量（“citric_acid”）之间的箱线图
 63  bp = sns.boxplot(x='quality',y='citric_acid', data=df)
 64  # 设置图表标题为“不同质量等级葡萄酒中的柠檬酸含量”
 65  bp.set(title="Citric Acid in Different Quality Wines")
 66
 67  # 使用seaborn库中的boxplot函数绘制质量等级与挥发性酸含量（“volatile_acidity”）之间的箱线图
 68  bp = sns.boxplot(x='quality',y='volatile_acidity', data=df)
 69  # 设置图表标题为“不同质量等级葡萄酒中的乙酸存在情况”
 70  bp.set(title="Acetic Acid Presence in Different Quality Wines")
 71 
 72   # 复制DataFrame对象df到新的对象df_aux
 73   df_aux = df.copy() 
 74   # 使用.replace()函数将3和4替换为“low”，5和6替换为“med”，7和8替换为“high”，并将结果直接更新到df_aux的“quality”列中
 75   df_aux['quality'].replace([3,4],['low','low'],inplace=True)
 76   df_aux['quality'].replace([5,6],['med','med'],inplace=True)
 77   df_aux['quality'].replace([7,8],['high','high'],inplace=True)
 78   # 使用Seaborn库中的countplot函数绘制质量等级计数图
 79  sns.countplot(df_aux['quality'])
 80 
 81   # 需要绘制直方图的特征列列表
 82   flistt = ['alcohol','sulphates','citric_acid','volatile_acidity']
 83   
 84   # 根据不同质量等级将数据分为三个子集
 85   low = df_aux[df_aux['quality'] == 'low']
 86   medium = df_aux[df_aux['quality'] == 'med']
 87   high = df_aux[df_aux['quality'] == 'high']
 88   
 89   # 更改字体大小
 90  plt.rcParams.update({'font.size': 8})
 91  
 92  # 创建2x2的4个子图
 93  plot, graphs = plt.subplots(nrows= 2, ncols= 2, figsize=(12,6))
 94  graphs = graphs.flatten()
 95  
 96  # 循环绘制4个特征的直方图
 97  for i, graph in enumerate(graphs):
 98      graph.figure
 99      
100      # 计算每个直方图的bin宽度
101      binwidth= (max(df_aux[flistt[i]]) - min(df_aux[flistt[i]]))/30
102      bins = np.arange(min(df[flistt[i]]), max(df_aux[flistt[i]]) + binwidth, binwidth)
103      
104      # 将三个子集的数据分别添加到直方图中，设置透明度、标签和颜色，并绘制标准化后的直方图
105      graph.hist([low[flistt[i]],medium[flistt[i]],high[flistt[i]]], bins=bins, alpha=0.6, normed=True, label=['Low','Medium','High'], color=['red','green','blue'])
106      
107      # 添加图例到右上角
108      graph.legend(loc='upper right')
109      
110      # 设置子图标题
111      graph.set_title(flistt[i])
112  # 自适应调整子图布局
113  plt.tight_layout()
114  #从相关系数矩阵中选择绝对值大于0.2的相关系数，以查找与目标列（此处为quality）强相关的列。
115  correlations[abs(correlations) > 0.2]
116 # 从数据框中选择4个特征列作为自变量，将“quality”列作为因变量。
117  X = df.loc[:,['alcohol','sulphates','citric_acid','volatile_acidity']]
118  Y = df.iloc[:,11]
119  
120  # 将数据划分为训练集和测试集，并使用线性回归模型进行拟合和预测。
121  
122 # 此处采用70%的数据作为训练集，其余30%作为测试集，设置随机种子为42，以确保每次运行时产生相同的结果。
123 X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.3, random_state=42)
124 
125   # 构建线性回归模型，并对模型进行训练和预测。
126   regressor = LinearRegression()
127   regressor.fit(X_train, y_train)
128   y_prediction_lr = regressor.predict(X_test)
129   y_prediction_lr = np.round(y_prediction_lr)
130   # 对模型的预测结果进行可视化展示。
131   plt.scatter(y_test,y_prediction_lr)
132   plt.title("Prediction Using Linear Regression")
133   plt.xlabel("Real Quality")
134  plt.ylabel("Predicted")
135  plt.show()
136 
137 
138   # 使用混淆矩阵展示线性回归模型的分类效果。
139   # 首先，计算模型预测结果的混淆矩阵。
140   cm_linear_regression = confusion_matrix(y_test,y_prediction_lr)
141   
142   # 将混淆矩阵转换为数据框，并设置标签和格式。
143   cm_lr = pd.DataFrame(cm_linear_regression,
144                        index = ['3','4','5','6','7','8'], 
145                        columns = ['3','4','5','6','7','8'])
146   sns.heatmap(cm_lr,annot=True,fmt="d")
147  
148  # 设置横纵坐标的标签。
149  label_aux = plt.subplot()
150  label_aux.set_xlabel('Predicted Quality')
151  label_aux.set_ylabel('True Quality')
152 
153 
154 
155   # 构建决策树回归模型，并对模型进行训练和预测。
156   regressor = DecisionTreeRegressor()
157  regressor.fit(X_train, y_train)
158   y_prediction_dt = regressor.predict(X_test)
159   y_prediction_dt = np.round(y_prediction_dt)
160   
161   # 对模型的预测结果进行可视化展示。
162   plt.scatter(y_test,y_prediction_dt)
163   plt.title("Prediction Using Decision Tree Regression")
164  plt.xlabel("Real Quality")
165  plt.ylabel("Predicted")
166  plt.show()
167 
168 
169 
170   # 构建决策树回归模型并对模型进行预测后，使用混淆矩阵展示其分类效果。
171   # 首先，计算模型预测结果的混淆矩阵。
172   cm_decision_tree_regression = confusion_matrix(y_test,y_prediction_dt)
173  
174   # 将混淆矩阵转换为数据框，并设置标签和格式。
175   cm_dt = pd.DataFrame(cm_decision_tree_regression,
176                        index = ['3','4','5','6','7','8'], 
177                        columns = ['3','4','5','6','7','8'])
178   sns.heatmap(cm_dt,annot=True,fmt="d")
179  
180  # 设置横纵坐标的标签。
181  label_aux = plt.subplot()
182  label_aux.set_xlabel('Predicted Quality')
183  label_aux.set_ylabel('True Quality')
184   # 构建随机森林回归模型，并对模型进行训练和预测。
185   regressor = RandomForestRegressor(n_estimators=10,random_state = 42)
186   regressor.fit(X_train, y_train)
187   y_prediction_rf = regressor.predict(X_test)
188   y_prediction_rf = np.round(y_prediction_rf)
189   
190   # 对模型的预测结果进行可视化展示。
191   plt.scatter(y_test,y_prediction_rf)
192  plt.title("Prediction Using Random Forest Regression")
193  plt.xlabel("Real Quality")
194  plt.ylabel("Predicted")
195  plt.show()
196 
197 
198 
199   # 对随机森林回归模型的预测结果进行混淆矩阵展示。
200   label_aux = plt.subplot()
201   cm_random_forest_regression = confusion_matrix(y_test,y_prediction_rf)
202   cm_rf = pd.DataFrame(cm_random_forest_regression,
203   index = ['3','4','5','6','7','8'], 
204   columns = ['3','4','5','6','7','8'])
205   sns.heatmap(cm_rf,annot=True,fmt="d")
206   
207   # 设置横纵坐标的标签。
208  label_aux.set_xlabel('Predicted Quality')
209  label_aux.set_ylabel('True Quality')
210 
211  # 计算线性回归模型的RMSE并输出。
212  RMSE = sqrt(mean_squared_error(y_test, y_prediction_lr))
213  print(RMSE)
214 # 计算决策树回归模型的RMSE并输出。
215  RMSE = sqrt(mean_squared_error(y_test, y_prediction_dt))
216  print(RMSE)
217  # 计算随机森林回归模型的RMSE并输出。
218  
219  RMSE = sqrt(mean_squared_error(y_test, y_prediction_rf))
220  
221  print(RMSE)
222 # 定义函数，将回归模型预测结果与真实值之间相差1的样本的预测值调整为真实值。
223   def one_accuracy(predicted, true):
224      i = 0
225       for x,y in zip(predicted,true):
226           if(abs(x-y)==1):
227               predicted[i] = y
228          i = i + 1
229   
230   # 分别对线性回归、决策树回归和随机森林回归模型的预测结果进行一次精度修正。
231  one_accuracy(y_prediction_lr, y_test)
232  one_accuracy(y_prediction_dt, y_test)
233  one_accuracy(y_prediction_rf, y_test)
234  
235  # 展示线性回归模型在测试集上的混淆矩阵。
236  label_aux = plt.subplot()
237  cm_linear_regression = confusion_matrix(y_test,y_prediction_lr)
238  cm_lr = pd.DataFrame(cm_linear_regression,
239                       index = ['3','4','5','6','7','8'], 
240                     columns = ['3','4','5','6','7','8'])
241  sns.heatmap(cm_lr,annot=True,fmt="d")
242  label_aux.set_xlabel('Predicted Quality');label_aux.set_ylabel('True Quality');
243   # 创建一个新的图表或子图，并将其赋值给变量label_aux。
244   label_aux = plt.subplot()
245   
246   # 计算决策树回归模型在测试集上的混淆矩阵，将结果赋值给变量cm_decision_tree_regression。
247   cm_decision_tree_regression = confusion_matrix(y_test, y_prediction_dt)
248   
249   # 创建一个以质量等级为标签的DataFrame，将混淆矩阵作为数据，行索引和列索引均使用质量等级。
251  cm_dt = pd.DataFrame(cm_decision_tree_regression,
252     index=['3', '4', '5', '6', '7', '8'],
253    columns=['3', '4', '5', '6', '7', '8'])
254 
255  # 使用sns.heatmap()函数绘制混淆矩阵的热图，其中annot=True表示需要显示数值标签，fmt="d"表示标签采用整数格式。
256  sns.heatmap(cm_dt, annot=True, fmt="d")
257 
258  # 为图表和子图添加横纵坐标轴的标签。
259  label_aux.set_xlabel('Predicted Quality')
260  label_aux.set_ylabel('True Quality')
261 
262  # 创建一个新的图表或子图，并将其赋值给变量label_aux。
263  label_aux = plt.subplot()
264  
265  # 计算随机森林回归模型在测试集上的混淆矩阵，将结果赋值给变量cm_random_forest_regression。
266  cm_random_forest_regression = confusion_matrix(y_test, y_prediction_rf)
267  
268  # 创建一个以质量等级为标签的DataFrame，将混淆矩阵作为数据，行索引和列索引均使用质量等级。
269   cm_rf = pd.DataFrame(cm_random_forest_regression,
270                      index=['3', '4', '5', '6', '7', '8'],
271                      columns=['3', '4', '5', '6', '7', '8'])
272 
273  # 使用sns.heatmap()函数绘制混淆矩阵的热图，其中annot=True表示需要显示数值标签，fmt="d"表示标签采用整数格式。
274  sns.heatmap(cm_rf, annot=True, fmt="d")
275  
276 # 为图表和子图添加横纵坐标轴的标签。
277 label_aux.set_xlabel('Predicted Quality')
278  label_aux.set_ylabel('True Quality')
279 #计算线性回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_lr中。
280   RMSE_lr = sqrt(mean_squared_error(y_test, y_prediction_lr))
281  
282   #打印输出新改进的线性回归模型的RMSE。
283   print("新改进的线性回归模型在测试集上的RMSE为：" + str(RMSE_lr) + "\n")
284   
285   #计算决策树回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_dt中。
286   RMSE_dt = sqrt(mean_squared_error(y_test, y_prediction_dt))
287   
288  #打印输出新改进的决策树回归模型的RMSE。
289  print("新改进的决策树回归模型在测试集上的RMSE为：" + str(RMSE_dt) + "\n")
290  
291  #计算随机森林回归模型在测试集上的均方根误差（RMSE），并将结果保存到变量RMSE_rf中。
292  RMSE_rf = sqrt(mean_squared_error(y_test, y_prediction_rf))
293  
294  #打印输出新改进的随机森林回归模型的RMSE。
295  print("新改进的随机森林回归模型在测试集上的RMSE为：" + str(RMSE_rf) + "\n")
296  
297 
298   # 忽略警告信息
299   warnings.filterwarnings('ignore')
300   
301   # 创建一个 PrettyTable 表格对象
302   ptbl = PrettyTable()
303   
304   # 设置表格列名
305   ptbl.field_names = ["Regressor Model", "Precision", "Recall", "F1Score"]
306   
307  # 添加线性回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
308  ptbl.add_row(["Linear", 
309                precision_score(y_test, y_prediction_lr, average='weighted'), # 计算测试集上的 Precision
310                recall_score(y_test, y_prediction_lr, average='weighted'),    # 计算测试集上的 Recall
311               f1_score(y_test, y_prediction_lr, average='weighted')        # 计算测试集上的 F1 Score
312               ])
313  
314  # 添加决策树回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
315 ptbl.add_row(["Decision Tree", 
316                precision_score(y_test, y_prediction_dt, average='weighted'), # 计算测试集上的 Precision
317                recall_score(y_test, y_prediction_dt, average='weighted'),    # 计算测试集上的 Recall
318                f1_score(y_test, y_prediction_dt, average='weighted')        # 计算测试集上的 F1 Score
319               ])
320  
321  # 添加随机森林回归模型在测试集上的 Precision、Recall 和 F1 Score 指标
322  ptbl.add_row(["Random Forest", 
323                precision_score(y_test, y_prediction_rf, average='weighted'), # 计算测试集上的 Precision
324                recall_score(y_test, y_prediction_rf, average='weighted'),    # 计算测试集上的 Recall
325                f1_score(y_test, y_prediction_rf, average='weighted')        # 计算测试集上的 F1 Score
326               ])
327  
328  # 输出表格
329  print(ptbl)