机器学习 scikit-learn7 - 预测贷款用户是否会逾期 - 网络搜索交叉验证

最新推荐文章于 2022-09-07 23:07:27 发布

DataScience

最新推荐文章于 2022-09-07 23:07:27 发布

阅读量424

点赞数

CC 4.0 BY-SA版权

分类专栏： Machine Learning 机器学习

本文链接：https://blog.youkuaiyun.com/q370835062/article/details/84436945

Machine Learning 同时被 2 个专栏收录

37 篇文章

订阅专栏

机器学习

14 篇文章

订阅专栏

本文详细介绍使用网格搜索(GridSearchCV)寻找机器学习模型最优参数的过程，并对比不同模型如逻辑回归、SVM、决策树、XGBoost及LightGBM的表现。同时，文章深入探讨K折交叉验证的效果，对比网络搜索得出的分数，揭示模型性能评估的重要性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1 说明

在做逻辑回归的最初就有尝试做网络搜索，找到最佳的特征组合
代码链接： https://github.com/spareribs/kaggleSpareribs/blob/master/Overdue/ml/code/sklearn_gcv.py

2 代码使用方法

sklearn_gcv.py 默认使用Logistic Regression 做示例

【必须】先执行 features 中的 base.py 先把数据处理好 [PS:需要根据实际情况修改]
【按需修改】修改 clf_name 需要训练的模型，param_grid 模型参数组合，scoring模型评分方式
【必须】再通过 code 中的 sklearn_gcv.py 搜索模型的最佳配置

3 核心代码说明

3.1 使用网络搜索获得最优的参数

clf：网络搜索的模型
param_grid：模型支持的参数
scoring：模型评分方式
grid.best_params_：网络搜索等到的最佳分数
grid.best_score_：最佳模型得到的最优结果

3.1.1 逻辑回归

clf_name = "lr"
clf = clfs[clf_name]

param_grid = {
    'C': [0.05, 0.1, 0.5, 1.5],
    'penalty': ['l1', 'l2'],
    'tol': [1e-4, 1e-5, 1e-6]
}

grid = GridSearchCV(clf, param_grid, scoring='f1')
grid.fit(x_train, y_train)

print("最优参数：{0}".format(grid.best_params_))
print("最好的分数{0}".format(grid.best_score_))

输出的最优参数

f1_micro
最优参数：{'C': 0.1, 'penalty': 'l1', 'tol': 0.0001}
最好的分数0.794278502313841
------------------------------
f1
最优参数：{'C': 0.5, 'penalty': 'l1', 'tol': 0.0001}
最好的分数0.45478870333462207

3.1.2 SVM

clf_name = "svm"
clf = clfs[clf_name]

param_grid = {
    'C': [0.05, 0.1, 0.5, 1.5],
    'penalty': ['l2'],
    'dual': [True]
}

grid = GridSearchCV(clf, param_grid, scoring='f1')
grid.fit(x_train, y_train)

print("最优参数：{0}".format(grid.best_params_))
print("最好的分数{0}".format(grid.best_score_))

输出的最优参数

f1_micro
最优参数：{'C': 0.05, 'dual': True, 'penalty': 'l2'}
最好的分数0.7900715187210771
------------------------------
f1
最优参数：{'C': 1.5, 'dual': True, 'penalty': 'l2'}
最好的分数0.430947628589009

3.1.3 决策树

clf_name = "rf"
clf = clfs[clf_name]

param_grid = {
    'criterion': ['gini'],
    'n_estimators': range(10, 71, 10),
    'max_depth': range(5, 10),
    'class_weight': ['balanced', None]
}

grid = GridSearchCV(clf, param_grid, scoring='f1')
grid.fit(x_train, y_train)

print("最优参数：{0}".format(grid.best_params_))
print("最好的分数{0}".format(grid.best_score_))

输出的最优参数

f1_micro
最优参数：{'class_weight': None, 'criterion': 'gini', 'max_depth': 9, 'n_estimators': 40}
最好的分数0.792175010517459
------------------------------
f1
最优参数：{'class_weight': 'balanced', 'criterion': 'gini', 'max_depth': 6, 'n_estimators': 60}
最好的分数0.5639910319567408

3.1.4 xgb

clf_name = "xgb"
clf = clfs[clf_name]

param_grid = {
    'max_depth': [3, 10, 30, 50],
    'learning_rate': [0.05, 0.1, 0.16],
    'n_estimators': [50, 100, 500],
    "learning_rate": [0.05, 0.1, 0.16]
}

grid = GridSearchCV(clf, param_grid, scoring='f1')
grid.fit(x_train, y_train)

print("最优参数：{0}".format(grid.best_params_))
print("最好的分数{0}".format(grid.best_score_))

输出的最优参数

f1_micro
最优参数：{'learning_rate': 0.1, 'max_depth': 3, 'n_estimators': 50}
最好的分数0.7997475809844342
------------------------------
f1
最优参数：{'learning_rate': 0.16, 'max_depth': 3, 'n_estimators': 100}
最好的分数0.4787024291359792

3.1.5 lgb

clf_name = "lgb"
clf = clfs[clf_name]

param_grid = {
    'boosting_type': ['gbdt'],
    "max_depth": [5, 10, 15],
    "learning_rate": [0.01, 0.05, 0.1],
    "num_leaves": [30, 90, 120],
    'n_estimators': [100, 200, 250]
}

grid = GridSearchCV(clf, param_grid, scoring='f1')
grid.fit(x_train, y_train)

print("最优参数：{0}".format(grid.best_params_))
print("最好的分数{0}".format(grid.best_score_))

输出的最优参数

f1_micro
最优参数：{'boosting_type': 'gbdt', 'learning_rate': 0.01, 'max_depth': 5, 'n_estimators': 250, 'num_leaves': 90}
最好的分数0.7940681531342028
------------------------------
f1
最优参数：{'boosting_type': 'gbdt', 'learning_rate': 0.1, 'max_depth': 10, 'n_estimators': 100, 'num_leaves': 30}
最好的分数0.4780571062731863

3.2 K折交叉验证

使用模型的最优参数, 进行交叉验证, 输出结果

print(u"[Info]: K次训练开始...")
preds = []
i = 0
my_splits = 5
skf = StratifiedKFold(n_splits=my_splits, random_state=1)
score_sum = 0
for train_idx, vali_idx in skf.split(x_train, y_train):
    i = i+1
    t_start = time.time()
    """获取训练集和验证集"""
    f_train_x = x_train[train_idx]
    f_train_y = y_train[train_idx]
    f_vali_x = x_train[vali_idx]
    f_vali_y = y_train[vali_idx]

    """训练分类器"""
    clf_name = "svm"
    clf = clfs[clf_name]
    clf.fit(f_train_x, f_train_y)

    """
    3 在验证集上评估模型
    """
    if status_vali:
        print("=" * 20)
        pre_vali = clf.predict(f_vali_x)
        score_vali = f1_score(y_true=f_vali_y, y_pred=pre_vali)
        print("第{}折， 验证集分数：{}".format(i, score_vali))
        score_sum += score_vali
        score_mean = score_sum / i
        print("第{}折后， 验证集分平均分数：{}".format(i, score_mean))
        t_end = time.time()

3.2.1 逻辑回归

[Info]: K次训练开始...
====================
第1折， 验证集分数：0.4902506963788301
第1折后， 验证集分平均分数：0.4902506963788301
====================
第2折， 验证集分数：0.40816326530612246
第2折后， 验证集分平均分数：0.4492069808424763
====================
第3折， 验证集分数：0.4045584045584046
第3折后， 验证集分平均分数：0.4343241220811191
====================
第4折， 验证集分数：0.4593837535014006
第4折后， 验证集分平均分数：0.4405890299361894
====================
第5折， 验证集分数：0.4542772861356933
第5折后， 验证集分平均分数：0.4433266811760902

很神奇，比在网络搜素的分数相差太多了

3.2.2 SVM

[Info]: K次训练开始...
====================
第1折， 验证集分数：0.45014245014245013
第1折后， 验证集分平均分数：0.45014245014245013
====================
第2折， 验证集分数：0.40816326530612246
第2折后， 验证集分平均分数：0.4291528577242863
====================
第3折， 验证集分数：0.4034582132564841
第3折后， 验证集分平均分数：0.42058797623501887
====================
第4折， 验证集分数：0.4495677233429395
第4折后， 验证集分平均分数：0.427832913011999
====================
第5折， 验证集分数：0.4047619047619047
第5折后， 验证集分平均分数：0.42321871136198014

3.2.3 决策树

[Info]: K次训练开始...
====================
第1折， 验证集分数：0.4119402985074626
第1折后， 验证集分平均分数：0.4119402985074626
====================
第2折， 验证集分数：0.3902439024390243
第2折后， 验证集分平均分数：0.40109210047324345
====================
第3折， 验证集分数：0.3205128205128205
第3折后， 验证集分平均分数：0.3742323404864358
====================
第4折， 验证集分数：0.4144144144144144
第4折后， 验证集分平均分数：0.3842778589684304
====================
第5折， 验证集分数：0.3975155279503106
第5折后， 验证集分平均分数：0.3869253927648065

3.2.4 xgb

[Info]: K次训练开始...
====================
第1折， 验证集分数：0.46760563380281694
第1折后， 验证集分平均分数：0.46760563380281694
====================
第2折， 验证集分数：0.4297994269340974
第2折后， 验证集分平均分数：0.4487025303684572
====================
第3折， 验证集分数：0.4632768361581921
第3折后， 验证集分平均分数：0.4535606322983688
====================
第4折， 验证集分数：0.45633802816901414
第4折后， 验证集分平均分数：0.45425498126603014
====================
第5折， 验证集分数：0.46629213483146065
第5折后， 验证集分平均分数：0.4566624119791163

3.2.5 lgb

[Info]: K次训练开始...
====================
第1折， 验证集分数：0.4873949579831933
第1折后， 验证集分平均分数：0.4873949579831933
====================
第2折， 验证集分数：0.3976608187134504
第2折后， 验证集分平均分数：0.44252788834832185
====================
第3折， 验证集分数：0.3941176470588235
第3折后， 验证集分平均分数：0.4263911412518224
====================
第4折， 验证集分数：0.4482758620689655
第4折后， 验证集分平均分数：0.4318623214561082
====================
第5折， 验证集分数：0.4367816091954023
第5折后， 验证集分平均分数：0.432846179003967

4 问题

问题1：如果 param_grid 里面的参数存在冲突的情况改如何处理
例如SVM

param_grid = {
    'C': [0.05, 0.1, 0.5, 1.5],
    'penalty': ['l2','l1'],
    'dual': [True]
}

问题2：很神奇，交叉验证比在网络搜素的分数相差太多了网络搜索和交叉验证用的不是同一个标准？ f1_micro是多分类的吗？

grid = GridSearchCV(clf, param_grid, scoring='f1_micro')  设置  分数 大概在0.8左右
grid = GridSearchCV(clf, param_grid, scoring='f1') 设置 分数 大概在0.5左右
查询 scoring 的配置，发现默认值是None~~ 查了代码，发现也没有用的信息，提示我们去查阅 multimetric_grid_search ，先记下来，后续再看看

在这里插入图片描述