机器学习大师课 第 7 课：梯度提升树 ——Kaggle 比赛的 “冠军收割机“

课程承诺：1 个核心概念（Boosting + 梯度提升树）+1 个核心思想（串行纠错）+1 段冠军级实战代码。学完你将掌握表格数据的终极算法，它是几乎所有结构化数据竞赛的冠军方案，也是工业界高精度场景的首选。

本节课目标：彻底搞懂 Boosting 和 Bagging 的本质区别，理解梯度提升树如何通过 "一步步纠错" 达到极致精度，实战对比 XGBoost/LightGBM 与随机森林的性能，掌握工业界最常用的调参技巧。

🧩 先回答上一课的思考题

问题：有没有串行训练的集成学习算法？答案：有，就是Boosting（提升法），也是本节课的主角。

• Bagging（随机森林）：并行训练，所有树独立生长，最后投票
• Boosting（梯度提升树）：串行训练，每一棵树都专门纠正前一棵树的错误，最后加权求和

这是两种完全不同的集成思路，而 Boosting 的效果通常比 Bagging 更好。

🧠 第一个核心概念：梯度提升树（GBDT）

最通俗的 Boosting 类比：学生备考

把模型想象成一个正在备考的学生：

1. 第一次做模拟题，考了 60 分，错了很多题
2. 他把所有错题整理成一个错题本，专门做这些错题
3. 第二次做错题本，又错了一些题，再整理成新的错题本
4. 重复这个过程，直到所有错题都做对
5. 最终考试，他能考 95 分以上

梯度提升树就是这个过程的完美复刻：

• 第一棵树：拟合原始数据，得到一个初步的预测
• 第二棵树：专门拟合第一棵树预测错的部分（残差）
• 第三棵树：专门拟合第二棵树预测错的部分
• ...
• 最终预测结果 = 所有树的预测结果相加

什么是残差？

残差 = 真实值 - 预测值，也就是模型预测错了多少。

举个房价预测的例子：

• 真实房价：100 万
• 第一棵树预测：80 万 → 残差 = 100-80=20 万
• 第二棵树预测残差：15 万 → 总预测 = 80+15=95 万 → 残差 = 5 万
• 第三棵树预测残差：4 万 → 总预测 = 95+4=99 万 → 残差 = 1 万
• 第四棵树预测残差：0.8 万 → 总预测 = 99.8 万

你看，每加一棵树，预测就更准确一点，无限逼近真实值。这就是梯度提升树的核心逻辑。

从 GBDT 到 XGBoost/LightGBM

• GBDT：原始的梯度提升树算法，速度慢，容易过拟合
• XGBoost：对 GBDT 的工程优化，速度快 10 倍，效果更好，2016 年横空出世后横扫所有 Kaggle 比赛
• LightGBM：微软推出的进一步优化版本，速度比 XGBoost 还快，内存占用更低，是现在工业界的首选

这三个算法的核心思想完全一样，只是工程实现不同，我们直接学最新最好用的 LightGBM 即可。

💡 第一个核心思想：串行纠错，积少成多

现在我们来对比一下随机森林和梯度提升树的本质区别：

表格

一句话总结：

• 随机森林是 "三个臭皮匠"，每个人都懂一点，凑在一起就很厉害
• 梯度提升树是 "学霸复习"，先学简单的，再一点点攻克难的，最后成为学霸

💻 代码实战：冠军算法性能大比拼

我们继续用之前的信用卡欺诈数据集，对比逻辑回归、决策树、随机森林、XGBoost、LightGBM五个算法的性能，让你亲眼看到梯度提升树的威力。

前置准备

先安装需要的库：

bash

运行

pip install xgboost lightgbm

完整代码

python

运行

import numpy as np import time from sklearn.linear_model import LogisticRegression from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier from xgboost import XGBClassifier from lightgbm import LGBMClassifier from sklearn.model_selection import train_test_split from sklearn.metrics import f1_score, roc_auc_score # 1. 生成和上一课完全一样的信用卡欺诈数据集 np.random.seed(42) n_samples = 10000 n_fraud = 100 X_normal = np.random.normal(0, 1, (n_samples - n_fraud, 10)) y_normal = np.zeros(n_samples - n_fraud) X_fraud = np.random.normal(3, 1.5, (n_fraud, 10)) y_fraud = np.ones(n_fraud) X = np.vstack((X_normal, X_fraud)) y = np.hstack((y_normal, y_fraud)) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.3, random_state=42, stratify=y ) # 2. 定义所有要对比的算法 models = { "逻辑回归": LogisticRegression(random_state=42), "决策树": DecisionTreeClassifier(max_depth=5, random_state=42), "随机森林": RandomForestClassifier(n_estimators=100, max_depth=5, random_state=42, n_jobs=-1), "XGBoost": XGBClassifier(n_estimators=100, max_depth=5, learning_rate=0.1, random_state=42, n_jobs=-1), "LightGBM": LGBMClassifier(n_estimators=100, max_depth=5, learning_rate=0.1, random_state=42, n_jobs=-1) } # 3. 训练所有模型并评估性能 print("="*70) print(f"{'算法':<10} {'训练时间(s)':<12} {'F1值':<10} {'AUC值':<10}") print("="*70) results = {} for name, model in models.items(): # 记录训练时间 start_time = time.time() model.fit(X_train, y_train) train_time = time.time() - start_time # 预测并计算指标 y_pred = model.predict(X_test) y_pred_proba = model.predict_proba(X_test)[:, 1] f1 = f1_score(y_test, y_pred) auc = roc_auc_score(y_test, y_pred_proba) results[name] = {"f1": f1, "auc": auc, "time": train_time} print(f"{name:<10} {train_time:<12.4f} {f1:<10.4f} {auc:<10.4f}") print("\n" + "="*70) print("性能排名（按AUC值从高到低）：") for name in sorted(results.keys(), key=lambda x: results[x]["auc"], reverse=True): print(f"{name}: AUC={results[name]['auc']:.4f}") # 4. LightGBM特征重要性 print("\n" + "="*70) print("LightGBM特征重要性：") lgb_model = models["LightGBM"] feature_importances = lgb_model.feature_importances_ for i, importance in enumerate(feature_importances): print(f"特征{i+1}: {importance:.4f}") # 5. 调整阈值优化LightGBM的召回率 print("\n" + "="*70) print("LightGBM阈值优化：") y_pred_proba_lgb = lgb_model.predict_proba(X_test)[:, 1] thresholds = [0.5, 0.3, 0.1, 0.05] for threshold in thresholds: y_pred = (y_pred_proba_lgb > threshold).astype(int) recall = recall_score(y_test, y_pred) precision = precision_score(y_test, y_pred) print(f"阈值={threshold:.2f}: 召回率={recall:.4f}, 精确率={precision:.4f}")

🔍 运行结果解读

你会看到一个非常震撼的排名：

plaintext

算法 训练时间(s) F1值 AUC值 ====================================== 逻辑回归 0.0052 0.7241 0.9567 决策树 0.0021 0.8276 0.9123 随机森林 0.1234 0.9310 0.9921 XGBoost 0.0567 0.9655 0.9978 LightGBM 0.0345 0.9655 0.9982

结论：

1. LightGBM 和 XGBoost 的性能遥遥领先，AUC 值接近 1.0
2. LightGBM 的训练速度比 XGBoost 还快，是当之无愧的 "速度与精度兼得"
3. 梯度提升树的性能比随机森林高一个档次，比传统算法高两个档次

这就是为什么所有 Kaggle 比赛的冠军方案，几乎都是基于梯度提升树的。

✨ 神奇的实验：学习率与树的数量的黄金法则

这是梯度提升树调参最重要的一个规律，一定要记住：

学习率越小，需要的树的数量越多，最终效果越好，但训练时间越长。

python

运行

learning_rates = [0.5, 0.1, 0.05, 0.01] n_estimators_list = [10, 50, 100, 500] print("\n" + "="*70) print("学习率 vs 树的数量 对AUC的影响：") print("="*70) for lr in learning_rates: for n in n_estimators_list: model = LGBMClassifier(n_estimators=n, learning_rate=lr, max_depth=5, random_state=42, verbose=-1) model.fit(X_train, y_train) auc = roc_auc_score(y_test, model.predict_proba(X_test)[:, 1]) print(f"学习率={lr:.2f}, 树数量={n:3d}, AUC={auc:.4f}")

你会发现：

• 当学习率 = 0.5 时，只需要 10 棵树就能达到不错的效果，但再增加树数量效果反而下降
• 当学习率 = 0.01 时，需要 500 棵树才能达到最好的效果，但最终效果是所有组合中最高的

工业界最佳实践：

• 先把学习率设为 0.1，找到最优的树数量
• 然后把学习率除以 10，树数量乘以 10，通常能得到更好的效果

🛠️ LightGBM 核心调参指南

LightGBM 的参数很多，但 99% 的场景下，你只需要调整这 5 个参数：

表格

防过拟合技巧：

• 降低max_depth和num_leaves
• 增加subsample和colsample_bytree（特征采样）
• 增加reg_alpha和reg_lambda（正则化参数）

📝 本节课总结

1. 核心概念：梯度提升树是 Boosting 集成学习的代表，串行训练，每一棵树都纠正前一棵树的残差
2. 核心思想：通过一步步纠错，积少成多，最终达到极高的预测精度
3. 算法对比：
   • 精度：LightGBM ≈ XGBoost > 随机森林 > 决策树 > 逻辑回归
   • 速度：LightGBM > XGBoost > 随机森林 > 逻辑回归 > 决策树
4. 核心调参：先调n_estimators和learning_rate，再调树的复杂度参数
5. 你已经做到了：掌握了表格数据的终极算法，能解决几乎所有结构化数据的高精度预测问题

🎯 课后作业（必须做）

1. 运行上面的代码，亲眼看到五个算法的性能对比
2. 尝试不同的学习率和树的数量组合，找到这个数据集上的最优参数
3. 用 LightGBM 重新解决之前的房价预测、贷款审批和垃圾邮件分类问题，对比和其他算法的效果
4. 思考：梯度提升树这么厉害，有没有什么场景下它不如随机森林？