Python打卡Day11 常见的调参方式
核心知识：
1. 模型 = 算法 + 实例化设置的外参（超参数）+训练得到的内参
2. 只要调参就需要考2次
所以如果不做交叉验证，就需要划分验证集和测试集，但是很多调参方法中都默认有交叉验证，所以实际中可以省去划分验证集和测试集的步骤
基线模型（基准模型）: 首先运行一个使用默认参数的模型，记录其性能作为比较的基准。
超参数调整
数据1. 网格搜索 (GridSearchCV):
- 需要定义参数的网格（param_grid），包含所有你想要尝试的特定值的列表。它会尝试网格中所有可能的参数组合。
- 缺点: 计算成本非常高，参数和值的数量稍多，组合数就会呈指数级增长（维度灾难）。因此，网格通常设置得比较小或集中在认为最优参数可能存在的区域（可能基于随机搜索的初步结果）。
2. 随机搜索 (RandomizedSearchCV):（实战中很少用到）
- 需要定义参数的分布，而不是固定的列表。这是它与网格搜索的主要区别，它不会尝试所有组合，而是在指定次数内随机采样。通常，用相对较少的迭代次数（如 50-100）就能找到相当好的参数。
- 对于给定的计算预算，随机搜索通常比网格搜索更有效，尤其是在高维参数空间中。
3. 贝叶斯优化 (BayesSearchCV from skopt):
- 需要定义参数的搜索空间，与随机搜索类似，当搜索空间非常大时，它通常比网格搜索和随机搜索更有效。
- 核心优势: 它不是随机选择下一个点，而是根据先前评估的结果建立一个概率模型（通常是高斯过程），预测哪些参数组合可能产生更好的结果，并据此选择下一个评估点。这使得它在寻找最优解方面通常比随机搜索更高效（用更少的迭代次数达到相似或更好的性能），特别是当模型训练（单次评估）非常耗时的时候。
正常情况下，计算资源够用网格，计算资源不够用贝叶斯优化，不用随机搜索
time库的计时模块，方便后人查看代码运行时长
数据预处理
import pandas as pd
import pandas as pd #用于数据处理和分析，可处理表格数据。
import numpy as np #用于数值计算，提供了高效的数组操作。
import matplotlib.pyplot as plt #用于绘制各种类型的图表
import seaborn as sns #基于matplotlib的高级绘图库，能绘制更美观的统计图形。
# 设置中文字体（解决中文显示问题）
plt.rcParams['font.sans-serif'] = ['SimHei'] # Windows系统常用黑体字体
plt.rcParams['axes.unicode_minus'] = False # 正常显示负号
data = pd.read_excel('data.xlsx') #读取数据
# 先筛选字符串变量
discrete_features = data.select_dtypes(include=['object']).columns.tolist()
# Home Ownership 标签编码
home_ownership_mapping = {
'Own Home': 1,
'Rent': 2,
'Have Mortgage': 3,
'Home Mortgage': 4
}
data['Home Ownership'] = data['Home Ownership'].map(home_ownership_mapping)
# Years in current job 标签编码
years_in_job_mapping = {
'< 1 year': 1,
'1 year': 2,
'2 years': 3,
'3 years': 4,
'4 years': 5,
'5 years': 6,
'6 years': 7,
'7 years': 8,
'8 years': 9,
'9 years': 10,
'10+ years': 11
}
data['Years in current job'] = data['Years in current job'].map(years_in_job_mapping)
# Purpose 独热编码，记得需要将bool类型转换为数值
data = pd.get_dummies(data, columns=['Purpose'])
data2 = pd.read_excel('data.xlsx') #读取数据
# data2 = pd.read_csv("data.csv") # 重新读取数据，用来做列名对比
list_final = [] # 新建一个空列表，用于存放独热编码后新增的特征名
for i in data.columns:
if i not in data2.columns:
list_final.append(i) # 这里打印出来的就是独热编码后的特征名
for i in list_final:
data[i] = data[i].astype(int) # 这里的i就是独热编码后的特征名
# Term 0 - 1 映射
term_mapping = {
'Short Term': 0,
'Long Term': 1
}
data['Term'] = data['Term'].map(term_mapping)
data.rename(columns={'Term': 'Long Term'}, inplace=True) # 重命名列
continuous_features = data.select_dtypes(include=['int64', 'float64']).columns.tolist() #把筛选出来的列名转换成列表
# 连续特征用中位数补全
for feature in continuous_features:
mode_value = data[feature].mode()[0] #获取该列的众数。
data[feature].fillna(mode_value, inplace=True) #用众数填充该列的缺失值，inplace=True表示直接在原数据上修改。
# 划分训练集、验证集和测试集，因为需要考2次
# 这里演示一下如何2次划分数据集，因为这个函数只能划分一次，所以需要调用两次才能划分出训练集、验证集和测试集。
from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1) # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:1:1划分训练集、验证集和测试集
X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.2, random_state=42) # 80%训练集，20%临时集
X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42) # 50%验证集，50%测试集
# X_train, y_train (80%)
# X_val, y_val (10%)
# X_test, y_test (10%)
print("Data shapes:")
print("X_train:", X_train.shape)
print("y_train:", y_train.shape)
print("X_val:", X_val.shape)
print("y_val:", y_val.shape)
print("X_test:", X_test.shape)
print("y_test:", y_test.shape)
# 最开始也说了 很多调参函数自带交叉验证，甚至是必选的参数，你如果想要不交叉反而实现起来会麻烦很多
# 所以这里我们还是只划分一次数据集
from sklearn.model_selection import train_test_split
X = data.drop(['Credit Default'], axis=1) # 特征，axis=1表示按列删除
y = data['Credit Default'] # 标签
# 按照8:2划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) # 80%训练集，20%测试集
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.neighbors import KNeighborsClassifier
import warnings
warnings.filterwarnings("ignore")基准模型
# --- 2. LightGBM模型 ---
print("--- 2. 默认参数LightGBM (训练集 -> 测试集) ---")
import time
start_time = time.time()
import lightgbm as lgb
lgb_model = lgb.LGBMClassifier(random_state=42)
lgb_model.fit(X_train, y_train)
lgb_pred = lgb_model.predict(X_test)
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认LightGBM 在测试集上的分类报告：")
print(classification_report(y_test, lgb_pred))
print("默认LightGBM 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, lgb_pred))
# --- 3. KNN模型 ---
print("--- 3. 默认参数KNN (训练集 -> 测试集) ---")
start_time = time.time()
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
# KNN需要特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
knn_model = KNeighborsClassifier()
knn_model.fit(X_train_scaled, y_train)
knn_pred = knn_model.predict(X_test_scaled)
end_time = time.time()
print(f"训练与预测耗时: {end_time - start_time:.4f} 秒")
print("\n默认KNN 在测试集上的分类报告：")
print(classification_report(y_test, knn_pred))
print("默认KNN 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, knn_pred))
--- 2. 默认参数LightGBM (训练集 -> 测试集) ---
训练与预测耗时: 0.1314 秒
默认LightGBM 在测试集上的分类报告：
precision recall f1-score support
0 0.78 0.94 0.85 1059
1 0.70 0.36 0.47 441
accuracy 0.77 1500
macro avg 0.74 0.65 0.66 1500
weighted avg 0.75 0.77 0.74 1500
默认LightGBM 在测试集上的混淆矩阵：
[[992 67]
[284 157]]
--- 3. 默认参数KNN (训练集 -> 测试集) ---
训练与预测耗时: 0.2075 秒
默认KNN 在测试集上的分类报告：
precision recall f1-score support
0 0.77 0.88 0.82 1059
1 0.56 0.36 0.44 441
accuracy 0.73 1500
macro avg 0.66 0.62 0.63 1500
weighted avg 0.71 0.73 0.71 1500
默认KNN 在测试集上的混淆矩阵：
[[934 125]
[283 158]]
网格搜索lightgbm
# --- 2. 网格搜索优化LightGBM ---
print("\n--- 2. 网格搜索优化LightGBM (训练集 -> 测试集) ---")
from sklearn.model_selection import GridSearchCV
import lightgbm as lgb
# 定义要搜索的参数网格
param_grid = {
'n_estimators': [50, 100, 200],
'learning_rate': [0.01, 0.1, 0.2],
'max_depth': [-1, 10, 20], # LightGBM中-1表示无限制
'num_leaves': [31, 50, 100]
}
# 创建网格搜索对象
grid_search = GridSearchCV(
estimator=lgb.LGBMClassifier(random_state=42),
param_grid=param_grid,
cv=5,
n_jobs=-1,
scoring='accuracy'
)
start_time = time.time()
# 在训练集上进行网格搜索
grid_search.fit(X_train, y_train)
end_time = time.time()
print(f"网格搜索耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", grid_search.best_params_)
# 使用最佳参数的模型进行预测
best_model = grid_search.best_estimator_
best_pred = best_model.predict(X_test)
print("\n网格搜索优化后的LightGBM 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("网格搜索优化后的LightGBM 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))
--- 2. 网格搜索优化LightGBM (训练集 -> 测试集) ---
网格搜索耗时: 363.9410 秒
最佳参数: {'learning_rate': 0.01, 'max_depth': -1, 'n_estimators': 100, 'num_leaves': 50}网格搜索优化后的LightGBM 在测试集上的分类报告：
precision recall f1-score support0 0.76 0.99 0.86 1059
1 0.87 0.24 0.37 441accuracy 0.77 1500
macro avg 0.81 0.61 0.61 1500
weighted avg 0.79 0.77 0.71 1500网格搜索优化后的LightGBM 在测试集上的混淆矩阵：
[[1044 15]
[ 337 104]]
网格搜索KNN
# --- 3. 网格搜索优化KNN ---
print("\n--- 3. 网格搜索优化KNN (训练集 -> 测试集) ---")
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
# 特征标准化（KNN对特征尺度敏感）
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 定义要搜索的参数网格
param_grid = {
'n_neighbors': [3, 5, 7, 9, 11], # K值
'weights': ['uniform', 'distance'], # 权重计算方式
'p': [1, 2] # 距离度量方式（1=曼哈顿距离，2=欧氏距离）
}
# 创建网格搜索对象
grid_search = GridSearchCV(
estimator=KNeighborsClassifier(),
param_grid=param_grid,
cv=5,
n_jobs=-1,
scoring='accuracy'
)
start_time = time.time()
# 在标准化的训练集上进行网格搜索
grid_search.fit(X_train_scaled, y_train)
end_time = time.time()
print(f"网格搜索耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", grid_search.best_params_)
# 使用最佳参数的模型进行预测
best_model = grid_search.best_estimator_
best_pred = best_model.predict(X_test_scaled)
print("\n网格搜索优化后的KNN 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("网格搜索优化后的KNN 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))
--- 3. 网格搜索优化KNN (训练集 -> 测试集) ---
网格搜索耗时: 1.3023 秒
最佳参数: {'n_neighbors': 11, 'p': 2, 'weights': 'distance'}
网格搜索优化后的KNN 在测试集上的分类报告：
precision recall f1-score support
0 0.76 0.93 0.84 1059
1 0.64 0.31 0.42 441
accuracy 0.75 1500
macro avg 0.70 0.62 0.63 1500
weighted avg 0.73 0.75 0.71 1500
网格搜索优化后的KNN 在测试集上的混淆矩阵：
[[983 76]
[304 137]]
贝叶斯优化lightgbm
# --- 2. 贝叶斯优化LightGBM ---
print("\n--- 2. 贝叶斯优化LightGBM (训练集 -> 测试集) ---")
from skopt import BayesSearchCV
from skopt.space import Integer, Real
import lightgbm as lgb
from sklearn.metrics import classification_report, confusion_matrix
import time
# 定义要搜索的参数空间
search_space = {
'n_estimators': Integer(50, 200),
'learning_rate': Real(0.01, 0.2, 'log-uniform'), # 学习率通常用对数均匀分布
'max_depth': Integer(5, 20),
'num_leaves': Integer(31, 100),
'min_child_samples': Integer(5, 20)
}
# 创建贝叶斯优化搜索对象
bayes_search = BayesSearchCV(
estimator=lgb.LGBMClassifier(random_state=42),
search_spaces=search_space,
n_iter=32, # 迭代次数，可根据需要调整
cv=5, # 5折交叉验证
n_jobs=-1,
scoring='accuracy'
)
start_time = time.time()
# 在训练集上进行贝叶斯优化搜索
bayes_search.fit(X_train, y_train)
end_time = time.time()
print(f"贝叶斯优化耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", bayes_search.best_params_)
# 使用最佳参数的模型进行预测
best_model = bayes_search.best_estimator_
best_pred = best_model.predict(X_test)
print("\n贝叶斯优化后的LightGBM 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("贝叶斯优化后的LightGBM 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))
--- 2. 贝叶斯优化LightGBM (训练集 -> 测试集) ---
贝叶斯优化耗时: 105.6435 秒
最佳参数: OrderedDict([('learning_rate', 0.0554438906650061), ('max_depth', 5), ('min_child_samples', 10), ('n_estimators', 110), ('num_leaves', 67)])
贝叶斯优化后的LightGBM 在测试集上的分类报告：
precision recall f1-score support
0 0.77 0.97 0.86 1059
1 0.82 0.28 0.42 441
accuracy 0.77 1500
macro avg 0.79 0.63 0.64 1500
weighted avg 0.78 0.77 0.73 1500
贝叶斯优化后的LightGBM 在测试集上的混淆矩阵：
[[1032 27]
[ 316 125]]
贝叶斯优化KNN
# --- 3. 贝叶斯优化KNN ---
print("\n--- 3. 贝叶斯优化KNN (训练集 -> 测试集) ---")
from skopt import BayesSearchCV
from skopt.space import Integer, Categorical
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
import time
# KNN需要特征标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 定义要搜索的参数空间
search_space = {
'n_neighbors': Integer(3, 11), # K值范围
'weights': Categorical(['uniform', 'distance']), # 权重类型
'p': Integer(1, 2) # 距离度量（1=曼哈顿距离，2=欧氏距离）
}
# 创建贝叶斯优化搜索对象
bayes_search = BayesSearchCV(
estimator=KNeighborsClassifier(),
search_spaces=search_space,
n_iter=16, # KNN参数较少，可适当减少迭代次数
cv=5, # 5折交叉验证
n_jobs=-1,
scoring='accuracy'
)
start_time = time.time()
# 在标准化后的训练集上进行贝叶斯优化搜索
bayes_search.fit(X_train_scaled, y_train)
end_time = time.time()
print(f"贝叶斯优化耗时: {end_time - start_time:.4f} 秒")
print("最佳参数: ", bayes_search.best_params_)
# 使用最佳参数的模型进行预测
best_model = bayes_search.best_estimator_
best_pred = best_model.predict(X_test_scaled)
print("\n贝叶斯优化后的KNN 在测试集上的分类报告：")
print(classification_report(y_test, best_pred))
print("贝叶斯优化后的KNN 在测试集上的混淆矩阵：")
print(confusion_matrix(y_test, best_pred))
--- 3. 贝叶斯优化KNN (训练集 -> 测试集) ---
贝叶斯优化耗时: 10.8179 秒
最佳参数: OrderedDict([('n_neighbors', 10), ('p', 1), ('weights', 'uniform')])
贝叶斯优化后的KNN 在测试集上的分类报告：
precision recall f1-score support
0 0.75 0.96 0.85 1059
1 0.73 0.25 0.37 441
accuracy 0.75 1500
macro avg 0.74 0.61 0.61 1500
weighted avg 0.75 0.75 0.71 1500
贝叶斯优化后的KNN 在测试集上的混淆矩阵：
[[1018 41]
[ 331 110]]
LightGBM在默认参数下表现最佳（准确率77%，F1 0.74），优于KNN（准确率73%，F1 0.71）
优化后提升有限，网格搜索/贝叶斯优化仅微调指标
LightGBM训练速度快（0.13s）但优化耗时长（网格搜索364s），KNN优化效率高（网格搜索仅1.3s）
@浙大疏锦行