本文通过分析20年成绩数据，使用线性回归、岭回归、鲁棒回归、支持向量回归、最近邻回归、决策树回归和神经网络回归七种算法预测课程C、D、E，并进行性能评估。数据预处理包括缺失值处理和归一化。结果显示，决策树回归在多个预测任务中表现最优，而最近邻回归在某些任务中也有良好表现。
链接：https://pan.baidu.com/s/1AUgPuexOliPo-qD5BD2cXA
提取码：0chv
本项目使用到的数据集如上 分为data1.csv、sorce.csv
1.问题描述
某学校为提高教学和思想工作水平，希望能够对学生的学习成绩进行预测，从而提前发现学生的学业问题。为了实现这一目标，该学校整理了20年的成绩数据的五门课程的成绩，其中第一学期课程两门，分别为A和B；第二学期两门课程，分别为C和D；第三学期一门课程E。数据存放于data1.csv文件中（因为输入需要归一化、输出不需要归一化处理，所以我们使用了两个文件分别赋予两个变量，以便预测），各字段的含义如下：
现在，需要根据该学校提供的数据，对数据进行分析，并尝试找到预测课程C 、D、E的模型，并对预测模型的性能进行分析。
2.方法要求
a)分析该数据集的数据缺失情况；
b)分析该数据集不同年份各门课程的描述性统计量，并进行比对分析；
c)对该数据集进行数据清洗，处理缺失值；
d)对该数据集进行归一化；
e)要求分别利用sklearn提供的线性回归（Linear Regression）、岭回归（Ridge Regression）、鲁棒回归（使用Huber Regression）、支持向量回归（SVR）、最近邻回归（Nearest Neighbors Regression）、决策树回归（Decision Trees）、神经网络回归（Neural Network Regression）共七种回归算法实现对成绩的预测。
f)并对训练出的七种回归器进行性能评估，利用测试集计算七种回归器的四项性能指标：解释方差（Explained Variance）、平均绝对误差（MAE，Mean Absolute Error）、平均平方误差（MSE，Mean Squared Error）和中位绝对误差（MedAE，Median Absolute Error）。
代码实现
1. 数据分析
# 导入包
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# 查看当前运行代码所在路径（以便存入数据）
import os
print(os.path.abspath('.'))`
# 加载数据
df = pd.read_csv('data1.csv')
yuce = pd.read_csv('score.csv')
# 查看数据集的大小
df.shape
# 分析该数据集不同年份各门课程的描述性统计量，并进行比对分析
df.info()
# 查看成绩A的基本信息（其他特征类似）
yearcount = len(pd.unique(df.year))
minyear = min(df.year)
maxyear = max(df['year'])
print(yearcount,minyear,maxyear)
# 查看每个年份对应的数据个数
pd.value_counts(df.year)
运行结果：
#使用data.isnull().sum()查看数据缺失情况
df.isnull().sum()
得出 id 、year 无缺失值；score_A、score_B、score_C、score_D、score_E 的 缺失值分别为 473、527、641、716、188。
2.数据预处理**
2.1数据清洗
考虑到学生成绩的实际意义，我们不能将缺失的数据删除，故采用均值插补对缺失值进行处理。我们使用data[‘score_i’]=data[‘score_i’].fillna(data[‘score_i’].mean())对成绩的缺失值进行处理。
df['score_A']=df['score_A'].fillna(df['score_A'].mean())
df['score_B']=df['score_B'].fillna(df['score_B'].mean())
df['score_C']=df['score_C'].fillna(df['score_C'].mean())
df['score_D']=df['score_D'].fillna(df['score_D'].mean())
df['score_E']=df['score_E'].fillna(df['score_E'].mean())
yuce['score_A']=yuce['score_A'].fillna(yuce['score_A'].mean())
yuce['score_B']=yuce['score_B'].fillna(yuce['score_B'].mean())
yuce['score_C']=yuce['score_C'].fillna(yuce['score_C'].mean())
yuce['score_D']=yuce['score_D'].fillna(yuce['score_D'].mean())
yuce['score_E']=yuce['score_E'].fillna(yuce['score_E'].mean())
#查看均值对缺失值处理后的结果
yuce.isnull().sum()
得出所有属性都无缺失值。
2.2 数据归一化
我们对缺失值处理后的特征进行归一化，以保证数据之间的可比性，消除指标间量纲不同所带来的误差。
由于我们要分别利用score_A、score_B；score_A、score_B、score_C；score_A、score_B、score_C、score_D预测成绩C、D、E，且只考虑对特征进行归一化处理，故我们创建两个数据集对其中一组data进行归一化处理（作为输入特征），另一组保留原始的数据（作为输出特征）。
我们使用最大最小归一化preprocessing.MinMaxScaler()
这种方法的缺陷就是当有新数据加入时，可能导致max，min的变化，需要重新定义。
#数据归一化处理
for i in list(['score_A','score_B','score_C','score_D','score_E']):
Max=np.max(df[i])
Min=np.min(df[i])
df[i]=(df[i]-Min)/(Max-Min)
#查看归一化后的属性值
print(df.score_C)
3.七种回归算法对成绩的预测以及模型性能评估
3.1七种回归算法
①线性回归和岭回归
线性回归采用普通的最小二乘法对自变量和因变量之间的线性关系进行分析，岭回归即改良的最小二乘估计法。当自变量之间存在多重共线性时，有
此时回归系数的估计值会很不稳定，而接近奇异的程度比接近奇异的程度小的多，即岭回归系数。
我们使用sklearn.linear_model导入LinearRegression（线性回归）、Ridge（岭回归），考虑到岭回归的正则化力度，k=0.5和1分别进行训练。
②鲁棒回归
鲁棒回归解决的是数据分布存在大量离群值的情况。鲁棒回归算法可以免疫离群值的影响，捕获了主要的数据分布规律。
我们使用sklearn.linear_model导入HuberRegressor进行鲁棒回归模型的训练。
③支持向量回归
支持向量回归使得靠拟合出的直线距离超平面最远的样本点之间的间隔最大。
我们使用sklearn.svm导入SVR进行支持向量回归模型的训练
④最近邻回归
我们使用sklearn.neighbors 导入KNeighborsRegressor进行最近邻回归的训练，根据weights参数的不同，分为初始化平均回归的KNN回归器（weights=’uniform’）和初始化距离加权回归的KNN回归器（weights=’distance’）。
⑤决策树回归
我们使用sklearn.tree导入DecisionTreeRegressor()进行决策树回归模型的训练及预测。
⑥神经网络回归
我们使用sklearn.neural_network导入MLPRegressor进行神经网络回归模型的训练及预测，采用两层神经网络，每层4个节点，激活函数为’relu’函数，adam优化器，学习率的初始值为0.001，最大迭代次数为5000。
3.2性能评估的四项指标
我们使用sklearn.metrics分别导入explained_variance_score（解释方差）、mean_absolute_error（平均绝对误差）、mean_squared_error（平均平方误差）、median_absolute_error（中位绝对误差）来评估回归模型。
①解释方差
最好的可能值为1.0，越低表示越差。
解释回归模型的方差得分，其值取值范围是[0,1]，越接近于1说明自变量越能解释因变量的方差变化，值越小说明效果越差。
②平均绝对误差
用于评估预测结果和真实数据集的接近程度，其值越小说明拟合效果越好。
③平均平方误差
该指标计算的是拟合数据和原始数据对应样本点的误差的平方和的均值，其值越小说明拟合效果越好。
④中位绝对误差
此方法非常适合含有离群点的数据集
3.3模型训练
训练过程代码流程如图所示。
#导入包
from sklearn.metrics import explained_variance_score # 解释方差.
from sklearn.metrics import mean_absolute_error # 平均绝对误差
from sklearn.metrics import mean_squared_error # 平均平方误差
from sklearn.metrics import median_absolute_error # 中位绝对误差
#预测任务分别用成绩A、B预测C；用成绩A、B、C预测D；用成绩A、B、C、D预测E
#因为输入需要归一化、输出不需要归一化处理，所以我们使用了两个文件分别赋予两个变量
#准备数据
xC=[df['score_A'],df['score_B']];yC=yuce['score_C']
xC=np.array(xC);yC=np.array(yC)
xC=xC.T;yC=yC.T
xC.shape #输出(86220, 2)
xD=[df['score_A'],df['score_B'],df['score_C']];yD=yuce['score_D']
xD=np.array(xD);yD=np.array(yD)
xD=xD.T;yD=yD.T
xD.shape #输出(86220, 3)
xE=[df['score_A'],df['score_B'],df['score_C'],df['score_D']];yE=yuce['score_E']
xE=np.array(xE);yE=np.array(yE)
xE=xE.T;yE=yE.T
xE.shape #输出(86220, 4)
#分割数据集
from sklearn.model_selection import train_test_split
#random_state 是随机数种子
#这里的random_state就是为了保证程序每次运行都分割一样的训练集和测试集。否则，同样的算法模型在不同的训练集和测试集上的效果不一样。
#当你用sklearn分割完测试集和训练集，确定模型和初始参数以后，你会发现程序每运行一次，都会得到不同的准确率，无法调参。这个时候就是因为没有加random_state。加上以后就可以调参了。
xC_train,xC_test,yC_train,yC_test = train_test_split(xC, yC, test_size=0.3)
xD_train,xD_test,yD_train,yD_test = train_test_split(xD, yD, test_size=0.3)
xE_train,xE_test,yE_train,yE_test = train_test_split(xE, yE, test_size=0.3)
print(yC_test) #输出[78. 77. 70. ... 82. 56. 74.]
#模型训练
# 1.线性回归
from sklearn.linear_model import LinearRegression
model_linear_regressionC = LinearRegression()
model_linear_regressionD = LinearRegression()
model_linear_regressionE = LinearRegression()
model_linear_regressionC.fit(xC_train,yC_train)
yC1_pred = model_linear_regressionC.predict(xC_test)
linregC1=explained_variance_score(yC_test,yC1_pred)
linregC2=mean_absolute_error(yC_test,yC1_pred)
linregC3=mean_squared_error(yC_test,yC1_pred)
linregC4=median_absolute_error(yC_test,yC1_pred)
model_linear_regressionD.fit(xD_train,yD_train)
yD1_pred = model_linear_regressionD.predict(xD_test)
linregD1=explained_variance_score(yD_test,yD1_pred)
linregD2=mean_absolute_error(yD_test,yD1_pred)
linregD3=mean_squared_error(yD_test,yD1_pred)
linregD4=median_absolute_error(yD_test,yD1_pred)
model_linear_regressionE.fit(xE_train,yE_train)
yE1_pred = model_linear_regressionE.predict(xE_test)
linregE1=explained_variance_score(yE_test,yE1_pred)
linregE2=mean_absolute_error(yE_test,yE1_pred)
linregE3=mean_squared_error(yE_test,yE1_pred)
linregE4=median_absolute_error(yE_test,yE1_pred)
print(linregC1,linregC2,linregC3,linregC4)
print(linregD1,linregD2,linregD3,linregD4)
print(linregE1,linregE2,linregE3,linregE4)
# 2.岭回归（Ridge Regression）
from sklearn.linear_model import Ridge
model_RidgeC = Ridge(alpha=2.0) #alpha表示正则化力度
model_RidgeD = Ridge(alpha=2.0)
model_RidgeE = Ridge(alpha=2.0)
model_RidgeC.fit(xC_train,yC_train)
yC2_pred = model_RidgeC.predict(xC_test)
ridregC1=explained_variance_score(yC_test,yC2_pred)
ridregC2=mean_absolute_error(yC_test,yC2_pred)
ridregC3=mean_squared_error(yC_test,yC2_pred)
ridregC4=median_absolute_error(yC_test,yC2_pred)
model_RidgeD.fit(xD_train,yD_train)
yD2_pred = model_RidgeD.predict(xD_test)
ridregD1=explained_variance_score(yD_test,yD2_pred)
ridregD2=mean_absolute_error(yD_test,yD2_pred)
ridregD3=mean_squared_error(yD_test,yD2_pred)
ridregD4=median_absolute_error(yD_test,yD2_pred)
model_RidgeE.fit(xE_train,yE_train)
yE2_pred = model_RidgeE.predict(xE_test)
ridregE1=explained_variance_score(yE_test,yE2_pred)
ridregE2=mean_absolute_error(yE_test,yE2_pred)
ridregE3=mean_squared_error(yE_test,yE2_pred)
ridregE4=median_absolute_error(yE_test,yE2_pred)
print(ridregC1,ridregC2,ridregC3,ridregC4)
print(ridregD1,ridregD2,ridregD3,ridregD4)
print(ridregE1,ridregE2,ridregE3,ridregE4)
# 3.鲁棒回归（使用Huber Regression）
from sklearn.linear_model import HuberRegressor
model_huber_regressorC = HuberRegressor()
model_huber_regressorD = HuberRegressor()
model_huber_regressorE = HuberRegressor()
model_huber_regressorC.fit(xC_train,yC_train)
yC3_pred = model_huber_regressorC.predict(xC_test)
hubregC1=explained_variance_score(yC_test,yC3_pred)
hubregC2=mean_absolute_error(yC_test,yC3_pred)
hubregC3=mean_squared_error(yC_test,yC3_pred)
hubregC4=median_absolute_error(yC_test,yC3_pred)
model_huber_regressorD.fit(xD_train,yD_train)
yD3_pred = model_huber_regressorD.predict(xD_test)
hubregD1=explained_variance_score(yD_test,yD3_pred)
hubregD2=mean_absolute_error(yD_test,yD3_pred)
hubregD3=mean_squared_error(yD_test,yD3_pred)
hubregD4=median_absolute_error(yD_test,yD3_pred)
model_huber_regressorE.fit(xE_train,yE_train)
yE3_pred = model_huber_regressorE.predict(xE_test)
hubregE1=explained_variance_score(yE_test,yE3_pred)
hubregE2=mean_absolute_error(yE_test,yE3_pred)
hubregE3=mean_squared_error(yE_test,yE3_pred)
hubregE4=median_absolute_error(yE_test,yE3_pred)
print(hubregC1,hubregC2,hubregC3,hubregC4)
print(hubregD1,hubregD2,hubregD3,hubregD4)
print(hubregE1,hubregE2,hubregE3,hubregE4)
#4.支持向量回归（SVR）
from sklearn import svm
model_svmC = svm.SVR()
model_svmD = svm.SVR()
model_svmE = svm.SVR()
model_svmC.fit(xC_train,yC_train)
yC4_pred = model_svmC.predict(xC_test)
svmC1=explained_variance_score(yC_test,yC4_pred)
svmC2=mean_absolute_error(yC_test,yC4_pred)
svmC3=mean_squared_error(yC_test,yC4_pred)
svmC4=median_absolute_error(yC_test,yC4_pred)
model_svmD.fit(xD_train,yD_train)
yD4_pred = model_svmD.predict(xD_test)
svmD1=explained_variance_score(yD_test,yD4_pred)
svmD2=mean_absolute_error(yD_test,yD4_pred)
svmD3=mean_squared_error(yD_test,yD4_pred)
svmD4=median_absolute_error(yD_test,yD4_pred)
model_svmE.fit(xE_train,yE_train)
yE4_pred = model_svmE.predict(xE_test)
svmE1=explained_variance_score(yE_test,yE4_pred)
svmE2=mean_absolute_error(yE_test,yE4_pred)
svmE3=mean_squared_error(yE_test,yE4_pred)
svmE4=median_absolute_error(yE_test,yE4_pred)
print(svmC1,svmC2,svmC3,svmC4)
print(svmD1,svmD2,svmD3,svmD4)
print(svmE1,svmE2,svmE3,svmE4)
# 5.最近邻回归（Nearest Neighbors Regression）
from sklearn import neighbors
model_k_neighborC = neighbors.KNeighborsRegressor(weights='uniform')
model_k_neighborD = neighbors.KNeighborsRegressor(weights='uniform')
model_k_neighborE = neighbors.KNeighborsRegressor(weights='uniform')
model_k_neighborC.fit(xC_train,yC_train)
yC5_pred = model_k_neighborC.predict(xC_test)
knnC1=explained_variance_score(yC_test,yC5_pred)
knnC2=mean_absolute_error(yC_test,yC5_pred)
knnC3=mean_squared_error(yC_test,yC5_pred)
knnC4=median_absolute_error(yC_test,yC5_pred)
model_k_neighborD.fit(xD_train,yD_train)
yD5_pred = model_k_neighborD.predict(xD_test)
knnD1=explained_variance_score(yD_test,yD5_pred)
knnD2=mean_absolute_error(yD_test,yD5_pred)
knnD3=mean_squared_error(yD_test,yD5_pred)
knnD4=median_absolute_error(yD_test,yD5_pred)
model_k_neighborE.fit(xE_train,yE_train)
yE5_pred = model_k_neighborE.predict(xE_test)
knnE1=explained_variance_score(yE_test,yE5_pred)
knnE2=mean_absolute_error(yE_test,yE5_pred)
knnE3=mean_squared_error(yE_test,yE5_pred)
knnE4=median_absolute_error(yE_test,yE5_pred)
print(knnC1,knnC2,knnC3,knnC4)
print(knnD1,knnD2,knnD3,knnD4)
print(knnE1,knnE2,knnE3,knnE4)
# 6.决策树回归（Decision Trees）
from sklearn import tree
model_decision_tree_regressionC = tree.DecisionTreeRegressor()
model_decision_tree_regressionD = tree.DecisionTreeRegressor()
model_decision_tree_regressionE = tree.DecisionTreeRegressor()
model_decision_tree_regressionC.fit(xC_train,yC_train)
yC6_pred = model_decision_tree_regressionC.predict(xC_test)
dtC1=explained_variance_score(yC_test,yC6_pred)
dtC2=mean_absolute_error(yC_test,yC6_pred)
dtC3=mean_squared_error(yC_test,yC6_pred)
dtC4=median_absolute_error(yC_test,yC6_pred)
model_decision_tree_regressionD.fit(xD_train,yD_train)
yD6_pred = model_decision_tree_regressionD.predict(xD_test)
dtD1=explained_variance_score(yD_test,yD6_pred)
dtD2=mean_absolute_error(yD_test,yD6_pred)
dtD3=mean_squared_error(yD_test,yD6_pred)
dtD4=median_absolute_error(yD_test,yD6_pred)
model_decision_tree_regressionE.fit(xE_train,yE_train)
yE6_pred = model_decision_tree_regressionE.predict(xE_test)
dtE1=explained_variance_score(yE_test,yE6_pred)
dtE2=mean_absolute_error(yE_test,yE6_pred)
dtE3=mean_squared_error(yE_test,yE6_pred)
dtE4=median_absolute_error(yE_test,yE6_pred)
print(dtC1,dtC2,dtC3,dtC4)
print(dtD1,dtD2,dtD3,dtD4)
print(dtE1,dtE2,dtE3,dtE4)
# 7.神经网络回归（Neural Network Regression）
from sklearn.neural_network import MLPRegressor
model_mlpC = MLPRegressor(hidden_layer_sizes=(4,8),activation='relu',solver='adam', alpha=0.001, batch_size='auto',
learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=5000, shuffle=True,
random_state=1, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True,
early_stopping=False, beta_1=0.9, beta_2=0.999,epsilon=1e-08)
model_mlpD = MLPRegressor(hidden_layer_sizes=(4,8),activation='relu',solver='adam', alpha=0.001, batch_size='auto',
learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=5000, shuffle=True,
random_state=1, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True,
early_stopping=False, beta_1=0.9, beta_2=0.999,epsilon=1e-08)
model_mlpE = MLPRegressor(hidden_layer_sizes=(4,8),activation='relu',solver='adam', alpha=0.01, batch_size='auto',
learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=5000, shuffle=True,
random_state=1, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True,
early_stopping=False, beta_1=0.9, beta_2=0.999,epsilon=1e-08)
model_mlpC.fit(xC_train,yC_train)
yC7_pred = model_mlpC.predict(xC_test)
nnrC1=explained_variance_score(yC_test,yC7_pred)
nnrC2=mean_absolute_error(yC_test,yC7_pred)
nnrC3=mean_squared_error(yC_test,yC7_pred)
nnrC4=median_absolute_error(yC_test,yC7_pred)
model_mlpD.fit(xD_train,yD_train)
yD7_pred = model_mlpD.predict(xD_test)
nnrD1=explained_variance_score(yD_test,yD7_pred)
nnrD2=mean_absolute_error(yD_test,yD7_pred)
nnrD3=mean_squared_error(yD_test,yD7_pred)
nnrD4=median_absolute_error(yD_test,yD7_pred)
model_mlpE.fit(xE_train,yE_train)
yE7_pred = model_mlpE.predict(xE_test)
nnrE1=explained_variance_score(yE_test,yE7_pred)
nnrE2=mean_absolute_error(yE_test,yE7_pred)
nnrE3=mean_squared_error(yE_test,yE7_pred)
nnrE4=median_absolute_error(yE_test,yE7_pred)
print(nnrC1,nnrC2,nnrC3,nnrC4)
print(nnrD1,nnrD2,nnrD3,nnrD4)
print(nnrE1,nnrE2,nnrE3,nnrE4)
#结果可视化（其一）
x = np.linspace(40, 100, 100)
y = x
axes = plt.gca()
axes.set_xlim([40, 100])
axes.set_ylim([40, 100])
plt.plot(x, y, color="blue", linewidth=1.0, linestyle="-")
plt.scatter(yE_test, yE7_pred, alpha=0.4, label='yuce')
plt.xlabel("init_E")
plt.ylabel("pred_E")
plt.title("qijiajing181294-scoreEyuce-Neural Network Regression")
plt.show()
3.4结果分析
①误差分析
对于划分数据集，显然划分训练集：测试集=8:2 比 7:3 的拟合效果更佳，故我 们选取 8:2 的划分集进行成绩预测和误差分析。 由上面分析可得，解释方差越大，均方误差越小，模型预测效果越好。 对于成绩 C，决策树回归拟合效果最好，其次是支持向量回归，拟合效果最差的 是最近邻回归。 对于成绩 D，决策树回归拟合效果最好，其次是最近邻回归，拟合效果最差的是 线性回归/岭回归/鲁棒性回归。 对于成绩 E，最近邻回归拟合效果最好，其次是决策树回归，再其次是支持向量 回归。
②预测结果可视化（图为成绩E，成绩C、D的预测可用上面画图语句画出）
成绩 C、D、E 的预测可视化均呈现较好的趋势，每种成绩预测的最佳模型效果与 误差分析结果相吻合。 对于线性回归/岭回归/鲁棒回归的可视化结果，可以得出成绩 A、B 与成绩 C 的 线性关系较弱；成绩 A、B、C 与成绩 D 的线性关系较强；成绩 A、B、C、D 与成 绩 E 的线性关系最强。 整体而言，对于整个回归模型，成绩 C 的预测最为不准，成绩 E 的预测最准确。 说明成绩 A、B 与成绩 C 有较弱的相关关系；成绩 A、B、C、D 与成绩 D 有较强的 相关关系。其中最近邻回归、决策树在预测成绩 E 效果上最好。
③综合分析
根据上述误差分析和预测可视化结果，可初步得出以下结论：
a.线性回归/岭回归/鲁棒回归并没有展示出很好的拟合效果，故我们猜测成绩之 间的线性相关性一般，也许存在非线性关系。且三种回归的误差类似，故成绩 A、 B、C、D 之间几乎不存在多重共线性，异常值和离散值较少，原始数据较为合理。
b.在成绩C、D、E的预测中线性回归和岭回归结果的四项性能指标很接近，故我们可以认为成绩A、B、C、D之间几乎没有多重共线性。但线性回归并没有表现出较强的优越性，可能是因为数据之间的线性关系不明显，故模型对非线性数据拟合效果不好。
c.最近邻回归在成绩 C 的预测中展示出相对较差的拟合效果，而在成绩 C、D 的 预测中展示出较好的拟合效果。
d.鲁棒回归没有体现出明显的优势，故我们初步判定数据不存在大量离群值时，数据的生成分布较为合理。
e.决策树回归的性能指标在三个成绩的预测中体现的性能指标都较出色、有相对较大的可解释方差、相对较小的误差。相比于神经网络的黑盒模型，决策树在逻辑上可以得到很好的解释。
f.最近邻回归在预测成绩D、E表现出的拟合效果较好，而预测成绩C时表现出的拟合效果相对不佳。
g.对于同一个回归模型，成绩E的预测效果>成绩D的预测效果>成绩C的预测效果，可得出成绩E与成绩A、B、C、D的相关性最强，成绩C与成绩A、B的相关性最弱。
h.支持向量回归在三种预测模型中拟合较好，但运行程序花费时间也相对最长。
i.决策树在三个成绩预测中均展示出较好的拟合效果，这也符合决策树的产生过程，易于理解。 d.神经网络在三种预测中的拟合效果并不出色，我们设计模型的参数有待改进。
4863
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
