2.机器学习-回归模型-非线性模型

一.决策树回归

1.决策树的核心参数:

(1)树的生长与分裂

参数名	默认值	作用
criterion	"squared_error"	分裂节点的评估标准： - "squared_error"：均方误差（MSE）。 - "friedman_mse"：改进的均方误差。 - "absolute_error"：平均绝对误差（MAE）。
splitter	"best"	分裂策略： - "best"：选择最佳分裂点。 - "random"：随机选择分裂点。
max_depth	None	树的最大深度。若为 None，则节点会一直分裂，直到所有叶子节点纯净或达到 min_samples_split。
min_samples_split	2	分裂内部节点所需的最小样本数。若样本数少于该值，则不再分裂。
min_samples_leaf	1	叶节点所需的最小样本数。若某次分裂导致叶子节点样本数小于该值，则放弃分裂。
max_features	None	寻找最佳分裂时考虑的最大特征数： - None：使用所有特征。 - "sqrt"：取特征数的平方根。 - "log2"：取特征数的对数。 - 整数：直接指定特征数。 - 浮点数：取特征数的百分比。

(2)随机性与剪枝

参数名	默认值	作用
random_state	None	随机种子，用于控制随机性（如 splitter="random" 时的随机分裂）。设置固定值可复现结果。
min_impurity_decrease	0.0	若某次分裂导致不纯度减少量小于该值，则放弃分裂。
ccp_alpha	0.0	用于最小化成本复杂度剪枝的复杂度参数。值越大，剪枝越强。

2.完整代码

#1.导入必备的库
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy import stats
from sklearn.model_selection import train_test_split, cross_val_score, KFold
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import GridSearchCV#2.设置显示选项
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
pd.set_option('display.max_rows', None)    #显示最大行数
pd.set_option('display.max_columns', None)  #显示最大列数
pd.set_option('display.max_colwidth', None)  #显示的最大列宽
pd.set_option('display.width', None)  #显示的最宽度
#3.导入数据
data=pd.read_excel("信用评分卡模型.xlsx")
#4.数据预处理
#4.1使用均值填写缺失值
print("缺失值统计:\n",data.isnull().sum())
data=data.apply(lambda col:col.fillna(col.mean()),axis=0)
#4.2处理异常值
numeric_data = data.select_dtypes(include=[np.number])
z_scores = np.abs(stats.zscore(data.select_dtypes(include=[np.number])))  # 仅对数值型数据计算 Z-score
threshold = 3  # Z-score 阈值 3个标准差
outliers = (z_scores > threshold).any(axis=1)  # 检测异常值
print("检测到的异常值行索引:\n", data[outliers].index.tolist())  # 输出异常值的行索引
print(data[outliers])
data = data[~outliers]  # 移除异常值
x=data.drop("信用评分",axis=1)
y=data["信用评分"]
#4.3将数据划分为训练集与测试集
X_train, X_test, y_train, y_test = train_test_split(x,y,test_size=0.3,random_state=0)
#4.4创建标准化训练测试集与训练集
scaler=StandardScaler()
x_train=scaler.fit_transform(X_train)
x_test=scaler.transform(X_test)#5建立模型(网格搜索)
model = DecisionTreeRegressor(random_state=42)
cv=KFold(n_splits=5, random_state=42, shuffle=True)
param_grid = {'max_depth': [3, 5, 7, None],'min_samples_split': [2, 5, 10],'min_samples_leaf': [1, 2, 4],'max_features': ['sqrt', 'log2', None]
}
grid_search = GridSearchCV(estimator=model,param_grid=param_grid,cv=cv,scoring='neg_mean_squared_error'
)
grid_search.fit(x_train, y_train)
best_model = grid_search.best_estimator_
print("Best Model:\n", best_model)
y_pred = best_model.predict(x_test)
#5.1模型评估
print("MSE:", mean_squared_error(y_test, y_pred))
print("R² Score:", r2_score(y_test, y_pred))
cv_scores=cross_val_score(best_model, x_train, y_train, cv=cv,scoring='neg_mean_squared_error')
print(f"5折交叉验证负MSE: {np.mean(cv_scores):.4f} (±{np.std(cv_scores):.4f})")
#5.1模型特征重要性(可用于特征选择)
feature_importances = pd.DataFrame(best_model.feature_importances_, index=x.columns)
feature_importances = feature_importances.sort_values(by=0,ascending=False)
print("\n特征重要性:")
print(feature_importances)
#6.可视化
plt.figure(figsize=(10, 6))
feature_importances.plot(kind='barh')
plt.title("特征重要性")
plt.xlabel("重要性")
plt.ylabel("特征")
plt.show()
"""
方法2:随机搜索
param_dist = {'max_depth': randint(3, 20),'min_samples_split': randint(2, 20),'min_samples_leaf': randint(1, 10)
}
random_search = RandomizedSearchCV(model, param_dist, n_iter=100, cv=5)
"""

决策树回归（DecisionTreeRegressor）与决策树分类（DecisionTreeClassifier）在 代码结构上类似，但 关键参数、模型目标和输出结果 有本质区别。以下是详细对比和代码示例：

---

1. 核心区别

特性	决策树回归 (DecisionTreeRegressor)	决策树分类 (DecisionTreeClassifier)
任务类型	回归（预测连续值，如房价、销售额）	分类（预测离散类别，如是否离职、垃圾邮件识别）
分裂标准	criterion='mse'（均方误差）或 'mae'（平均绝对误差）	criterion='gini'（基尼不纯度）或 'entropy'（信息增益）
输出结果	连续值（浮点数）	离散类别（整数或字符串标签）
叶子节点值	目标变量的平均值	类别的概率分布（多数投票）
评估指标	MSE、R² 等回归指标	准确率、F1-Score、AUC-ROC 等分类指标

二.随机森林回归

1.核心参数

(1)树的数量与构建

参数名	默认值	作用
n_estimators	100	随机森林中树的数量。树越多，模型越稳定，但计算成本越高。
criterion	"squared_error"	分裂节点的评估标准： - "squared_error"：均方误差（MSE）。 - "absolute_error"：平均绝对误差（MAE）。
max_depth	None	树的最大深度。若为 None，则节点会一直分裂，直到所有叶子节点纯净或达到 min_samples_split。
min_samples_split	2	分裂内部节点所需的最小样本数。若样本数少于该值，则不再分裂。
min_samples_leaf	1	叶节点所需的最小样本数。若某次分裂导致叶子节点样本数小于该值，则放弃分裂。
max_features	"auto"	寻找最佳分裂时考虑的最大特征数： - "auto" 或 "sqrt"：取特征数的平方根。 - "log2"：取特征数的对数。 - 整数：直接指定特征数。 - 浮点数：取特征数的百分比。

---

(2)随机性与鲁棒性

参数名	默认值	作用
random_state	None	随机种子，用于控制随机性（如样本和特征的随机选择）。设置固定值可复现结果。
bootstrap	True	是否使用 Bootstrap 采样（有放回随机采样）。若为 False，则使用整个数据集构建每棵树。
oob_score	False	是否使用袋外样本（Out-of-Bag, OOB）评估模型性能。需 bootstrap=True。
max_samples	None	若 bootstrap=True，指定每棵树的训练样本数（整数或浮点数比例）。

---

(3)并行计算与性能

参数名	默认值	作用
n_jobs	None	并行计算使用的 CPU 核心数： - None：使用 1 个核心。 - -1：使用所有核心。
verbose	0	控制训练过程中的日志输出： - 0：不输出。 - 1：输出进度。 - >1：更详细输出。
warm_start	False	若为 True，则复用之前训练的模型，继续添加新的树（用于增量训练）。

---

2.其他参数

参数名	默认值	作用
ccp_alpha	0.0	用于最小化成本复杂度剪枝的复杂度参数。值越大，剪枝越强。
min_impurity_decrease	0.0	若某次分裂导致不纯度减少量小于该值，则放弃分裂。
min_weight_fraction_leaf	0.0	叶节点所需的最小样本权重比例（与 min_samples_leaf 类似，但基于权重）。

3.完整代码 

#1.导入必备的库
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from scipy import stats
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, KFold
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler
#2.设置显示选项
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
pd.set_option('display.max_rows', None)    #显示最大行数
pd.set_option('display.max_columns', None)  #显示最大列数
pd.set_option('display.max_colwidth', None)  #显示的最大列宽
pd.set_option('display.width', None)  #显示的最宽度
#3.导入数据
data=pd.read_excel("信用评分卡模型.xlsx")
#4.数据预处理
#4.1使用均值填写缺失值
print("缺失值统计:\n",data.isnull().sum())
data=data.apply(lambda col:col.fillna(col.mean()),axis=0)
#4.2处理异常值
numeric_data = data.select_dtypes(include=[np.number])
z_scores = np.abs(stats.zscore(data.select_dtypes(include=[np.number])))  # 仅对数值型数据计算 Z-score
threshold = 3  # Z-score 阈值 3个标准差
outliers = (z_scores > threshold).any(axis=1)  # 检测异常值
print("检测到的异常值行索引:\n", data[outliers].index.tolist())  # 输出异常值的行索引
print(data[outliers])
data = data[~outliers]  # 移除异常值
X=data.drop("信用评分",axis=1)
y=data["信用评分"]
#4.3将数据划分为训练集与测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=0)
#4.4创建标准化训练测试集与训练集
scaler=StandardScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)
#5.建立模型
Model = RandomForestRegressor(criterion='squared_error',  # 分裂标准（MSE）min_samples_leaf=2,         # 叶节点所需的最小样本数bootstrap=True,             # 使用 Bootstrap 采样oob_score=True,             # 使用袋外样本评估模型性能random_state=42,              # 固定随机种子n_jobs=-1,                  # 使用所有 CPU 核心# verbose=1                   # 输出训练进度
)
#5.1参数调优:网格搜索(数据量大时使用随机搜索)
cv = KFold(n_splits=5, shuffle=True, random_state=42)
param_grid = {'n_estimators': [50, 100, 200],     # 树的数量'max_depth': [None, 5, 10],         # 树的最大深度'min_samples_split': [2, 5],        # 分裂内部节点所需的最小样本数'max_features': ['sqrt', 'log2']    # 每棵树分裂时考虑的特征数
}
grid_search = GridSearchCV(estimator=Model,param_grid=param_grid,cv = cv,  # 5折交叉验证scoring='neg_mean_squared_error',  # 负均方误差（越大越好）n_jobs=-1,  # 使用所有CPU核心
)
grid_search.fit(X_train, y_train)
print("最佳参数组合:", grid_search.best_params_)
best_model = grid_search.best_estimator_
#5.2模型评估
cv_scores = cross_val_score(best_model, X_train, y_train,cv=cv, scoring='neg_mean_squared_error')
print(f"交叉验证 MSE: {-np.mean(cv_scores):.4f} (±{np.std(cv_scores):.4f})")
y_pred = best_model.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f"测试集 MSE: {mse:.4f}")
print(f"测试集 R²: {r2:.4f}")
#5.3模型特征重要性
feature_importances = pd.DataFrame(best_model.feature_importances_, index=X.columns)
feature_importances = feature_importances.sort_values(by=0,ascending=False)
print("\n特征重要性:")
print(feature_importances)
#6.可视化
plt.figure()
feature_importances.plot(kind='barh')
plt.title("Feature Importances")
plt.show()

三.支持向量回归

1、核心参数

(1). 模型类型与核函数

参数名	默认值	作用
kernel	'rbf'	指定核函数类型： - 'linear'：线性核。 - 'poly'：多项式核。 - 'rbf'：径向基函数（高斯）核。 - 'sigmoid'：Sigmoid 核。 - 自定义核函数（通过 callable 对象）。
degree	3	多项式核的阶数（仅当 kernel='poly' 时有效）。
gamma	'scale'	核函数的系数： - 'scale'：1/(n_features×Var(X))1/(n_features×Var(X))。 - 'auto'：1/n_features1/n_features。 - 浮点数：直接指定值。
coef0	0.0	核函数中的独立项（仅对 kernel='poly' 和 kernel='sigmoid' 有效）。

(2). 正则化与误差容忍

参数名	默认值	作用
C	1.0	正则化参数，控制对误差的惩罚程度。值越大，模型越倾向于拟合训练数据。
epsilon	0.1	ϵϵ-不敏感损失函数的阈值，控制对误差的容忍程度。

(3). 优化与计算

参数名	默认值	作用
tol	1e-3	优化算法的停止条件（误差容忍度）。
max_iter	-1	最大迭代次数。若为 -1，则无限制。
shrinking	True	是否使用启发式收缩（shrinking heuristic）加速训练。
cache_size	200	核函数缓存大小（单位：MB）。

(4). 多线程与随机性

参数名	默认值	作用
verbose	False	是否输出训练过程的详细信息。
random_state	None	随机种子，用于控制随机性（如数据打乱）。

---

2、参数调优建议

(1). 核函数选择

• 线性核（kernel='linear'）：适合线性可分的数据。

• RBF 核（kernel='rbf'）：适合非线性数据，是默认选择。

• 多项式核（kernel='poly'）：适合多项式特征交互较强的数据。

• Sigmoid 核（kernel='sigmoid'）：适合特定类型的非线性数据。

(2). 正则化参数 C

• 小值（如 0.1）：模型更简单，可能欠拟合。

• 大值（如 100）：模型更复杂，可能过拟合。

(3). ϵϵ 参数

• 小值（如 0.01）：对误差容忍度低，模型更精确，但可能过拟合。

• 大值（如 0.5）：对误差容忍度高，模型更鲁棒，但可能欠拟合。

(4). gamma 参数

• 小值（如 0.01）：核函数影响范围大，模型更平滑。

• 大值（如 10）：核函数影响范围小，模型更复杂。

3.完整代码

#1.导入必备的库
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from scipy import stats
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, KFold
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVR#2.设置显示选项
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
pd.set_option('display.max_rows', None)    #显示最大行数
pd.set_option('display.max_columns', None)  #显示最大列数
pd.set_option('display.max_colwidth', None)  #显示的最大列宽
pd.set_option('display.width', None)  #显示的最宽度
#3.导入数据
data=pd.read_excel("信用评分卡模型.xlsx")
#4.数据预处理
#4.1使用均值填写缺失值
print("缺失值统计:\n",data.isnull().sum())
data=data.apply(lambda col:col.fillna(col.mean()),axis=0)
#4.2处理异常值
numeric_data = data.select_dtypes(include=[np.number])
z_scores = np.abs(stats.zscore(data.select_dtypes(include=[np.number])))  # 仅对数值型数据计算 Z-score
threshold = 3  # Z-score 阈值 3个标准差
outliers = (z_scores > threshold).any(axis=1)  # 检测异常值
print("检测到的异常值行索引:\n", data[outliers].index.tolist())  # 输出异常值的行索引
print(data[outliers])
data = data[~outliers]  # 移除异常值
X=data.drop("信用评分",axis=1)
y=data["信用评分"]
#4.3将数据划分为训练集与测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=0)
#4.4创建标准化训练测试集与训练集
scaler=StandardScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)# 初始化 SVR 模型
model = SVR(kernel='rbf')
cv=KFold(n_splits=5,random_state=10,shuffle=True)
param_grid = {'C': [0.1, 1, 10],'epsilon': [0.01, 0.1, 0.5],'gamma': ['scale', 'auto', 0.1, 1]
}
grid_search = GridSearchCV(estimator=model,param_grid=param_grid,cv=cv,scoring='neg_mean_squared_error',n_jobs=-1
)
grid_search.fit(X_train, y_train)
print("最佳参数组合:", grid_search.best_params_)
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
cv_scores = cross_val_score(best_model, X_train, y_train,cv=cv, scoring='neg_mean_squared_error')
print(f"交叉验证 MSE: {-np.mean(cv_scores):.4f} (±{np.std(cv_scores):.4f})")
print("测试集 MSE:", mean_squared_error(y_test, y_pred))
print("测试集 R² Score:", r2_score(y_test, y_pred))
#可视化
plt.scatter(y_test, y_pred)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'k--', lw=2)
plt.xlabel("实际值")
plt.ylabel("预测值")
plt.title("实际值 vs 预测值")
plt.show()

四.K近邻回归

1、KNN 回归的核心参数

(1). 模型参数

参数名	默认值	作用
n_neighbors	5	最近邻的数量 kk。
weights	'uniform'	权重函数： - 'uniform'：所有最近邻样本的权重相等。 - 'distance'：权重与距离成反比。
algorithm	'auto'	计算最近邻的算法： - 'auto'：自动选择最佳算法。 - 'ball_tree'：使用 BallTree 算法。 - 'kd_tree'：使用 KDTree 算法。 - 'brute'：暴力搜索。
leaf_size	30	BallTree 或 KDTree 的叶子节点大小，影响树的构建和查询效率。
p	2	闵可夫斯基距离的参数 pp： - p=1：曼哈顿距离。 - p=2：欧氏距离。
metric	'minkowski'	距离度量函数，支持自定义函数。

(2). 计算与性能

参数名	默认值	作用
n_jobs	None	并行计算使用的 CPU 核心数： - None：使用 1 个核心。 - -1：使用所有核心。

完整代码 

#1.导入必备的库
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from scipy import stats
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, KFold
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import StandardScaler#2.设置显示选项
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
pd.set_option('display.max_rows', None)    #显示最大行数
pd.set_option('display.max_columns', None)  #显示最大列数
pd.set_option('display.max_colwidth', None)  #显示的最大列宽
pd.set_option('display.width', None)  #显示的最宽度
#3.导入数据
data=pd.read_excel("信用评分卡模型.xlsx")
#4.数据预处理
#4.1使用均值填写缺失值
print("缺失值统计:\n",data.isnull().sum())
data=data.apply(lambda col:col.fillna(col.mean()),axis=0)
#4.2处理异常值
numeric_data = data.select_dtypes(include=[np.number])
z_scores = np.abs(stats.zscore(data.select_dtypes(include=[np.number])))  # 仅对数值型数据计算 Z-score
threshold = 3  # Z-score 阈值 3个标准差
outliers = (z_scores > threshold).any(axis=1)  # 检测异常值
print("检测到的异常值行索引:\n", data[outliers].index.tolist())  # 输出异常值的行索引
print(data[outliers])
data = data[~outliers]  # 移除异常值
X=data.drop("信用评分",axis=1)
y=data["信用评分"]
#4.3将数据划分为训练集与测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=0)
#4.4创建标准化训练测试集与训练集
scaler=StandardScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)#建立模型
model = KNeighborsRegressor(n_neighbors=5)
cv=KFold(n_splits=5,random_state=10,shuffle=True)
# 参数网格
param_grid = {'n_neighbors': [3, 5, 7],'weights': ['uniform', 'distance'],'p': [1, 2]
}
grid_search = GridSearchCV(estimator=model,param_grid=param_grid,cv=5,scoring='neg_mean_squared_error',n_jobs=-1
)
grid_search.fit(X_train, y_train)
print("最佳参数组合:", grid_search.best_params_)
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
cv_scores = cross_val_score(best_model, X_train, y_train,cv=cv, scoring='neg_mean_squared_error')
print(f"交叉验证 MSE: {-np.mean(cv_scores):.4f} (±{np.std(cv_scores):.4f})")
print("测试集 MSE:", mean_squared_error(y_test, y_pred))
print("测试集 R² Score:", r2_score(y_test, y_pred))

五.梯度提升回归

1. 模型参数

参数名	默认值	作用
n_estimators	100	弱学习器的数量（即迭代次数）。
learning_rate	0.1	学习率，控制每一步的贡献程度。较小的学习率需要更多的弱学习器。
max_depth	3	每个弱学习器（决策树）的最大深度。
min_samples_split	2	分裂内部节点所需的最小样本数。
min_samples_leaf	1	叶节点所需的最小样本数。
max_features	None	寻找最佳分裂时考虑的最大特征数： - None：使用所有特征。 - 'sqrt'：取特征数的平方根。 - 'log2'：取特征数的对数。 - 整数：直接指定特征数。 - 浮点数：取特征数的百分比。
loss	'squared_error'	损失函数： - 'squared_error'：均方误差。 - 'absolute_error'：平均绝对误差。 - 'huber'：结合均方误差和平均绝对误差。
subsample	1.0	每步训练时使用的样本比例（随机梯度提升）。

2. 正则化与优化

参数名	默认值	作用
alpha	0.9	Huber 损失函数的分位数参数（仅当 loss='huber' 时有效）。
init	None	初始模型（如均值模型）。
random_state	None	随机种子，用于控制随机性（如样本和特征的随机选择）。
validation_fraction	0.1	用于早期停止的验证集比例（仅当 n_iter_no_change 有效时使用）。
n_iter_no_change	None	如果验证集性能在指定迭代次数内未提升，则提前停止训练。

3. 计算与性能

参数名	默认值	作用
verbose	0	控制训练过程中的日志输出： - 0：不输出。 - 1：输出进度。 - >1：更详细输出。
warm_start	False	若为 True，则复用之前训练的模型，继续添加新的弱学习器。
n_jobs	None	并行计算使用的 CPU 核心数： - None：使用 1 个核心。 - -1：使用所有核心。

4.完整代码 

#1.导入必备的库
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
from scipy import stats
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, KFold
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.neighbors import KNeighborsRegressor
from sklearn.preprocessing import StandardScaler#2.设置显示选项
plt.rcParams['font.sans-serif'] = ['SimHei']
plt.rcParams['axes.unicode_minus'] = False
pd.set_option('display.max_rows', None)    #显示最大行数
pd.set_option('display.max_columns', None)  #显示最大列数
pd.set_option('display.max_colwidth', None)  #显示的最大列宽
pd.set_option('display.width', None)  #显示的最宽度
#3.导入数据
data=pd.read_excel("信用评分卡模型.xlsx")
#4.数据预处理
#4.1使用均值填写缺失值
print("缺失值统计:\n",data.isnull().sum())
data=data.apply(lambda col:col.fillna(col.mean()),axis=0)
#4.2处理异常值
numeric_data = data.select_dtypes(include=[np.number])
z_scores = np.abs(stats.zscore(data.select_dtypes(include=[np.number])))  # 仅对数值型数据计算 Z-score
threshold = 3  # Z-score 阈值 3个标准差
outliers = (z_scores > threshold).any(axis=1)  # 检测异常值
print("检测到的异常值行索引:\n", data[outliers].index.tolist())  # 输出异常值的行索引
print(data[outliers])
data = data[~outliers]  # 移除异常值
X=data.drop("信用评分",axis=1)
y=data["信用评分"]
#4.3将数据划分为训练集与测试集
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=0)
#4.4创建标准化训练测试集与训练集
scaler=StandardScaler()
X_train=scaler.fit_transform(X_train)
X_test=scaler.transform(X_test)
#建立模型
model = GradientBoostingRegressor(n_estimators=100, learning_rate=0.1, max_depth=3, random_state=42)
cv=KFold(n_splits=5, random_state=42, shuffle=True)
# 参数网格
param_grid = {'n_estimators': [50, 100, 200],'learning_rate': [0.01, 0.1, 0.2],'max_depth': [3, 5, 7]
}
# 网格搜索
grid_search = GridSearchCV(estimator=model,param_grid=param_grid,cv=cv,scoring='neg_mean_squared_error',n_jobs=-1
)
grid_search.fit(X_train, y_train)
print("最佳参数组合:", grid_search.best_params_)
best_model = grid_search.best_estimator_
y_pred = best_model.predict(X_test)
print("测试集 MSE:", mean_squared_error(y_test, y_pred))
print("测试集 R² Score:", r2_score(y_test, y_pred))
cv_scores = cross_val_score(best_model, X_train, y_train, cv=cv, scoring='neg_mean_squared_error')
print(f"5折交叉验证负MSE: {np.mean(cv_scores):.4f} (±{np.std(cv_scores):.4f})")

六、网格搜索中的scoring参数

1.回归任务常用评分指标

评分指标名称	Scikit-learn 参数名	说明
负均方误差（Negative Mean Squared Error）	'neg_mean_squared_error'	均方误差（MSE）的负值，数值越大（越接近 0）表示模型性能越好。
均方误差（Mean Squared Error）	'neg_mean_squared_error' 的绝对值	均方误差的原始值，数值越小表示模型性能越好。
均方根误差（Root Mean Squared Error）	自定义（基于 mean_squared_error）	均方误差的平方根，与目标变量量纲一致。
负平均绝对误差（Negative Mean Absolute Error）	'neg_mean_absolute_error'	平均绝对误差（MAE）的负值，数值越大（越接近 0）表示模型性能越好。
R² 分数（R-squared）	'r2'	取值范围 [−∞,1][−∞,1]，越接近 1 表示模型性能越好。
解释方差分数（Explained Variance Score）	'explained_variance'	取值范围 [0,1][0,1]，越接近 1 表示模型性能越好。

---

2.分类任务常用评分指标

评分指标名称	Scikit-learn 参数名	说明
准确率（Accuracy）	'accuracy'	分类正确的样本比例。
精确率（Precision）	'precision'	正类预测正确的比例（针对二分类或多分类）。
召回率（Recall）	'recall'	正类样本中被正确预测的比例（针对二分类或多分类）。
F1 分数（F1 Score）	'f1'	精确率和召回率的调和平均值。
ROC AUC 分数（ROC AUC Score）	'roc_auc'	ROC 曲线下面积，适用于二分类任务。
对数损失（Log Loss）	'neg_log_loss'	对数损失的负值，数值越大（越接近 0）表示模型性能越好。

---

3.聚类任务常用评分指标

评分指标名称	Scikit-learn 参数名	说明
轮廓系数（Silhouette Score）	'silhouette'	衡量聚类效果的指标，取值范围 [−1,1][−1,1]，越接近 1 表示聚类效果越好。
调整兰德指数（Adjusted Rand Index）	'adjusted_rand_score'	衡量聚类与真实标签的一致性，取值范围 [−1,1][−1,1]，越接近 1 表示一致性越好。