当前位置:首页>排行榜>一百棵小树叠起来,为什么比一棵大树强

一百棵小树叠起来,为什么比一棵大树强

  • 更新时间 2026-11-14 23:00:33
一百棵小树叠起来,为什么比一棵大树强

摘要:单棵树只能画台阶,一百棵树能把正弦曲线追到误差 0.34。这篇从零写一个 GBDT,把残差、负梯度、学习率、对数损失这几个概念全用代码跑出来,顺便回答一个老问题:为什么三十棵深度 3 的小树,能打赢一棵深度 10 的大树。

前阵子帮朋友的公司面人,我出了一道 GBDT 的题。

面试里问 GBDT,十个候选人九个能背出"拟合负梯度"。

再往下问一句:为什么负梯度就等于残差?换成分类任务,残差还能用吗?

能答上来的,不到两个。

这事挺典型。GBDT 的概念不难,难在"为什么这么设计"。你把这三个字拆开看:Gradient Boosting Decision Tree,梯度、提升、决策树。每个词都对应一个具体的设计决策,串起来才讲得通。

这篇我打算用最笨的办法讲:一行一行把 GBDT 写出来,然后在数据上跑,看它怎么一轮一轮把误差磨掉。

👇 先从一个反直觉的现象开始。

01 为什么小树反而更强

先做个对比。

一棵深度 10 的树,能把训练集拟合到几乎零误差。它的叶子多,规则细,每个叶子可能只装了几条样本。

但这样的树拿去做预测,往往不如三十棵深度 3 的树加起来。

原因在偏差和方差。

深度 10 的树,偏差极低,方差极高。训练集里的一点噪声,都会被它当成规律记下来。换个样本,叶子里的均值就变了,预测跟着抖。

深度 3 的树,偏差高一些,方差低。它只能切八片,表达不了太复杂的形状,但也记不住噪声。

单棵用不行,那就多棵。问题是怎么把多棵加起来还有意义?

随机森林的办法是并行:每棵树独立看一部分样本和特征,最后投票。它降的是方差。

GBDT 的办法是串行:每棵树专门修正前面所有树犯的错。它降的是偏差。

一句话区分:随机森林是"一群专家各看各的,投票";GBDT 是"一个学生做题,老师专挑错题讲"。

这里有个反例值得记住。

前几年有个团队为了让模型更准,把树深度从 4 调到 12,树的数量从 200 加到 800。训练集 AUC 干到 0.93,测试集只有 0.71,比原来的浅层模型还差。

他们以为是数据不够,又去补了三年的样本。结果训练集 0.94,测试集 0.72。

问题不在数据量,在模型复杂度。深度 12 的树有四千多个叶子,平均每个叶子装不到 30 条样本,这已经是在记样本了。

后来把深度调回 4,只留 300 棵树,测试集回到 0.78。

02 GBDT 到底在学什么

假设你要预测一个人的年收入。

第一版模型很简单:所有人都预测平均值,10 万。这一步的误差,就是每个人的实际收入减去 10 万。

第二版模型不看收入了,它看"误差"。它要回答的问题是:什么样的人,实际收入比 10 万高?高多少?

比如它学到"硕士学历的人,比平均高 3 万"。于是第二版预测变成 10 万加 3 万。

剩下的误差还有。第三版继续学:在"硕士且在一线城市"这群人里,还差多少?

一轮一轮下去,误差越来越小。

这就是 Boosting 的直觉:不要求每棵树都对,只要求每棵树把当前的错补一点。

写成公式就是加法模型。最终预测是所有树的输出加起来,乘上学习率,加上初始值。

而"每棵树学什么",严格来说学的不是残差,是损失函数的负梯度。

对平方损失,负梯度正好等于残差,所以两个说法在这个场景下是一回事。换成别的损失,就不一样了。

这是理解 GBDT 最关键的一步:残差只是负梯度的特例。

03 为什么负梯度正好等于残差

这一步值得动手算一遍,算完就再也不会忘。

平方损失长这样:L 等于二分之一乘以预测减真实值的平方。

对预测值 F 求导,导数就是 F 减 y。

梯度下降的意思是,沿着导数反方向走一小步。所以"应该往哪个方向修正",就是 y 减 F。

而 y 减 F,正好就是残差的定义。

所以对平方损失来说,"拟合负梯度"和"拟合残差"是同一件事,只是换了个说法。

换成对数损失,就不一样了。

对数损失对 F 求导,导数等于预测概率减真实标签。它长得像残差,但残的是概率空间,不是标签空间。

一个正样本,当前预测概率 0.3,那么梯度是 0.3 减 1,等于负 0.7。模型会把这个人的分数往上推。

一个负样本,预测概率 0.3,梯度是 0.3 减 0,等于正的 0.3。模型往下推。

注意,两个样本的预测都是 0.3,但推力方向完全相反,大小也不同。这就是对数损失和平方损失的区别:它是按"当前预测错得有多离谱"来分配力度的。

预测 0.5 的样本,推力 0.5;预测 0.9 的正样本,推力只有 0.1,因为已经差不多了。

这种"错得越多推得越狠"的性质,正是分类任务需要的。

04 先把一棵回归树写出来

树的本质是一串 if-else。

每个内部节点选一个特征、一个阈值,把样本劈成两半。劈到叶子,就输出一个值。

回归树的输出值是叶子里的均值。选切点的标准是:劈完之后,两边的平方误差之和最小。

下面这段代码实现了回归树和 GBDT 的主体。为了看清过程,用一维数据。

# -*- coding: utf-8 -*-"""从零实现 GBDT 回归:一棵树拟合残差,一百棵树叠起来。"""import numpy as nprng = np.random.default_rng(7)n = 800x = np.sort(rng.uniform(0, 10, n))y = np.sin(x) + 0.25 * x + rng.normal(0, 0.35, n)class RegTree:    """最小二乘回归树,每次选让 SSE 下降最多的切点"""    def __init__(self, depth=3, min_leaf=20):        self.depth, self.min_leaf = depth, min_leaf    def fit(self, x, y):        self.x, self.y = x, y        self.root = self._build(np.arange(len(x)), 0)        return self    def _build(self, idx, d):        if d >= self.depth or len(idx) < 2 * self.min_leaf:            return ("leaf", self.y[idx].mean())        best = None        for t in np.quantile(self.x[idx], np.linspace(0.1, 0.9, 19)):            left = idx[self.x[idx] <= t]            right = idx[self.x[idx] > t]            if len(left) < self.min_leaf or len(right) < self.min_leaf:                continue            sse = ((self.y[left] - self.y[left].mean()) ** 2).sum() + \                  ((self.y[right] - self.y[right].mean()) ** 2).sum()            if best is None or sse < best[0]:                best = (sse, t, left, right)        if best is None:            return ("leaf", self.y[idx].mean())        _, t, left, right = best        return ("node", t, self._build(left, d + 1), self._build(right, d + 1))    def predict(self, x):        return np.array([self._one(self.root, v) for v in x])    def _one(self, node, v):        while node[0] == "node":            node = node[2] if v <= node[1] else node[3]        return node[1]def gbdt(x, y, lr=0.1, rounds=100, depth=3):    f = np.full(len(y), y.mean())    trees = []    for _ in range(rounds):        r = y - f                      # 残差就是平方损失的负梯度        t = RegTree(depth).fit(x, r)        f += lr * t.predict(x)        trees.append(t)    return f, treesdef rmse(a, b):    return float(np.sqrt(((a - b) ** 2).mean()))if __name__ == "__main__":    print(f"数据 {n} 条,目标函数 y = sin(x) + 0.25x + 噪声")    print(f"用均值猜:RMSE {rmse(y, np.full(n, y.mean())):.3f}")    for k in (1, 5, 10, 30, 100):        pred, _ = gbdt(x, y, lr=0.1, rounds=k)        print(f"  {k:>3} 棵树  RMSE {rmse(y, pred):.3f}")    pred, trees = gbdt(x, y, lr=0.1, rounds=100)    print(f"\n100 棵树之后的残差标准差:{np.std(y - pred):.3f}(原始 {np.std(y):.3f})")

代码不长,但几个点值得说。

第一,切点用分位数撒了 19 个候选,没有暴力遍历所有可能值。真实工程里也是这么做的,几百万条数据不可能每个值都试一遍。

第二,r = y - f 这一行就是全部的秘密。拟合目标不是 y,是残差。

第三,每棵树都很浅,深度 3,最多 8 个叶子。它只负责补一小块。

跑出来的结果:

数据 800 条,目标函数 y = sin(x) + 0.25x + 噪声用均值猜:RMSE 1.036    1 棵树  RMSE 0.949    5 棵树  RMSE 0.690   10 棵树  RMSE 0.509   30 棵树  RMSE 0.358  100 棵树  RMSE 0.344100 棵树之后的残差标准差:0.344(原始 1.036)

注意两个数。原始数据的标准差是 1.036,一百棵树之后残差标准差 0.344。

而我加进去的噪声,标准差正好是 0.35。

也就是说,模型已经把能学的都学到了,剩下的 0.344 全是噪声,再练也降不下去。

这张图能看清叠加的过程。

浅蓝色是一条树,它是阶梯状的,只有 8 个台阶,形状勉强对但很粗。

橙色是十棵树,台阶变细了,已经能看出正弦的走势,但在波峰处明显偏低。

深蓝色是一百棵,几乎贴着真实函数(红色虚线)走。

这就是 Boosting 的视觉解释:每棵树贡献一小段修正,累加起来逼近真实形状。

05 学习率:慢就是快

上面代码里有个参数 lr,学习率,我设的是 0.1。

它的作用是把每棵树的输出打个折。树说"这里应该加 3",模型只加 0.3。

为什么打折?因为每棵树都是在当前残差上拟合的,它一定会过拟合一点。全额加上去,错误也被放大。

打折之后,需要更多轮才能收敛,但每一轮都更稳。

这个参数和树的数量是一对,必须一起调。

# -*- coding: utf-8 -*-"""学习率和树数量怎么配:四档学习率,各跑 200 棵树。"""import numpy as npfrom block1 import RegTree, rmserng = np.random.default_rng(2026)n = 1200x = rng.uniform(0, 10, n)y = np.sin(x) + 0.25 * x + rng.normal(0, 0.35, n)idx = rng.permutation(n)tr, te = idx[:900], idx[900:]print("学习率  最优树数  最优测试RMSE  第200棵测试RMSE")for lr in (0.05, 0.1, 0.3, 1.0):    f_tr = np.full(len(tr), y[tr].mean())    f_te = np.full(len(te), y[tr].mean())    curve = []    for m in range(200):        r = y[tr] - f_tr        t = RegTree(depth=3).fit(x[tr], r)        f_tr += lr * t.predict(x[tr])        f_te += lr * t.predict(x[te])        curve.append(rmse(y[te], f_te))    best = int(np.argmin(curve)) + 1    print(f"{lr:5.2f}   {best:>7}   {min(curve):>11.3f}   {curve[-1]:>12.3f}")

输出:

学习率  最优树数  最优测试RMSE  第200棵测试RMSE 0.05       100         0.359          0.364 0.10        49         0.359          0.367 0.30        24         0.362          0.373 1.00         5         0.376          0.393

这张表信息量很大。

学习率 0.05,要 100 棵树才到最优,最优 RMSE 0.359。学习率 1.0,5 棵树就到最优了,但最优只有 0.376,而且跑到 200 棵时涨到 0.393,明显过拟合。

也就是说,学习率小,最终效果略好,代价是训练慢。

学习率大,收敛快,但精度差,且更容易在后期变差。

工程上的经验是:学习率取 0.05 到 0.1,树的数量用早停法定。

早停怎么做?留一个验证集,每加一棵树算一次验证集指标,连续 N 轮不提升就停。N 一般取 30 到 50。

图上看得很清楚:学习率 0.3 和 1.0 的曲线,在第 30 棵之后基本是平的,甚至微微上翘。这时候再加树,只是在拟合噪声。

早停的实现有个细节容易错:不能每加一棵树就判断一次,否则曲线抖一下就触发停止。

正确做法是记录历史最优值,同时记一个计数器。每次验证指标比历史最优好,计数器清零并更新最优;否则计数器加一。计数器达到阈值才真停。

还有一个更隐蔽的坑:早停用的验证集,不能跟最终评估用的是同一份。

有些团队只有一份验证集,既用来早停,又用来报指标。这样报出来的指标是偏乐观的,因为模型已经在这份数据上做过选择。

三个数据集,训练、验证、测试,各干各的事。数据量实在不够,至少保证早停和最终评估分开。

还有个现象值得一提。四条曲线最后都收敛到 0.35 附近,也就是噪声水平。这说明在合适的参数下,GBDT 不会把噪声学进去太多,它的上限就是数据本身的信息量。

06 从回归到分类:残差不能用了

上面都是回归。换到分类,问题来了。

分类的标签是 0 和 1。残差是 0 减 0.3 等于负 0.3,这个数没有意义,因为它不是"差多少",而是"差在哪个方向"。

所以分类必须换损失函数,通常用对数损失,也就是逻辑回归那个损失。

换了损失,负梯度就不等于残差了。

对数损失对 F 的负梯度是 y 减 p,p 是当前预测的违约概率。这个形式看着像残差,但它残的是"概率",不是标签。

还有一处更关键:叶子输出值不能再用均值了。

回归里叶子输出均值,是因为平方损失的最优解就是均值。对数损失下,最优解是"梯度和除以二阶导之和",也就是牛顿法的一步。

所以完整的 GBDT 分类,每个叶子要算两个量:一阶导的和、二阶导的和,然后相除。

这就是 XGBoost 里那个 gain 公式的来源。它不是拍脑袋想出来的,是二阶泰勒展开的结果。

下面这段代码用四个特征做二分类,从头实现一遍。

# -*- coding: utf-8 -*-"""GBDT 做二分类:用对数损失的梯度,叶子值用牛顿步长。"""import numpy as nprng = np.random.default_rng(3)n = 4000income = rng.normal(12000, 4000, n).clip(2000, 60000)dti = rng.beta(2.2, 3.0, n) * 1.2delinq = np.clip(rng.poisson(0.5, n), 0, 6)inq = np.clip(rng.poisson(1.8, n), 0, 12)z = (-3.1 - 0.00004 * income + 2.6 * dti + 0.55 * delinq     + 0.12 * inq + 0.8 * (dti > 0.55) - 0.6 * (income > 20000))y = (rng.random(n) < 1 / (1 + np.exp(-z))).astype(float)X = np.column_stack([income / 10000, dti, delinq, inq])names = ["收入", "负债收入比", "历史逾期", "查询次数"]print(f"样本 {n},坏账率 {y.mean()*100:.2f}%")def build(X, g, h, idx, depth, min_leaf, cols):    """返回树节点;gain 用二阶泰勒展开"""    if depth == 0 or len(idx) < 2 * min_leaf:        return ("leaf", -g[idx].sum() / (h[idx].sum() + 1e-6))    G, H = g[idx].sum(), h[idx].sum()    best = None    for c in cols:        for t in np.quantile(X[idx, c], np.linspace(0.2, 0.8, 9)):            l = idx[X[idx, c] <= t]            r = idx[X[idx, c] > t]            if len(l) < min_leaf or len(r) < min_leaf:                continue            gain = (g[l].sum() ** 2 / (h[l].sum() + 1e-6) +                    g[r].sum() ** 2 / (h[r].sum() + 1e-6) -                    G ** 2 / (H + 1e-6))            if best is None or gain > best[0]:                best = (gain, c, t, l, r)    if best is None:        return ("leaf", -G / (H + 1e-6))    _, c, t, l, r = best    return ("node", c, t,            build(X, g, h, l, depth - 1, min_leaf, cols),            build(X, g, h, r, depth - 1, min_leaf, cols))def apply(node, X, i=0):    while node[0] == "node":        node = node[3] if X[i, node[1]] <= node[2] else node[4]    return node[1]def fit_gbdt(X, y, rounds=100, lr=0.1, depth=3, min_leaf=40):    p0 = y.mean()    F = np.full(len(y), np.log(p0 / (1 - p0)))    for _ in range(rounds):        p = 1 / (1 + np.exp(-np.clip(F, -30, 30)))        g, h = p - y, p * (1 - p)          # 一阶导、二阶导        cols = rng.choice(X.shape[1], max(1, int(X.shape[1] * 0.8)), replace=False)        tree = build(X, g, h, np.arange(len(y)), depth, min_leaf, cols)        F += lr * np.array([apply(tree, X, i) for i in range(len(y))])    return Fdef auc(y, s):    order = np.argsort(s)    rank = np.empty(len(s))    rank[order] = np.arange(1, len(s) + 1)    pos = y == 1    return (rank[pos].sum() - pos.sum() * (pos.sum() + 1) / 2) / (pos.sum() * (~pos).sum())if __name__ == "__main__":    for k in (1, 10, 100):        F = fit_gbdt(X, y, rounds=k)        print(f"{k:>3} 棵树  AUC {auc(y, F):.4f}")    F = fit_gbdt(X, y, rounds=100)    print(f"\n集成后分数范围 {F.min():.2f} ~ {F.max():.2f},"          f"对应违约概率 {1/(1+np.exp(-F.min())):.3f} ~ {1/(1+np.exp(-F.max())):.3f}")

输出:

样本 4000,坏账率 23.65%  1 棵树  AUC 0.7415 10 棵树  AUC 0.7661100 棵树  AUC 0.7879集成后分数范围 -4.03 ~ 1.97,对应违约概率 0.017 ~ 0.878

三件事值得说。

第一,单棵树的 AUC 就有 0.74。树模型天生擅长找非线性和交互,一棵树就能吃掉大部分信号。

第二,从 1 棵到 100 棵,AUC 从 0.7415 涨到 0.7879,涨了 4.6 个点。这个提升幅度在真实项目里很典型:GBDT 相对单棵树,通常能提 3 到 6 个点。

第三,分数分布那张图,好客户集中在左边,坏客户往右拖了一条长尾。中间有一大块重叠区,那就是模型分不清的部分。风控的所有策略,本质上都是在这个重叠区里做取舍。

07 和随机森林到底差在哪

这两个模型经常被放在一起比,其实定位完全不同。

随机森林是 Bagging。每棵树用自助采样的一份数据,特征也随机抽一部分。树与树之间独立,可以并行训练。最后平均或投票。

它的核心作用是降方差。单棵树容易受样本扰动,平均一百棵就稳了。

GBDT 是 Boosting。每棵树依赖前面的结果,必须串行。它的核心作用是降偏差。

所以适用场景不一样。

数据噪声大、单棵树严重过拟合的时候,随机森林更省心,几乎不用调参。

追求极致精度、愿意花时间调参的时候,GBDT 通常更强。这也是为什么 Kaggle 上的表格赛题,GBDT 系(XGBoost、LightGBM、CatBoost)长期霸榜。

还有一点常被忽略:GBDT 对异常值更敏感。因为它在拟合残差,一个极端的 y 会产生一个巨大的残差,后面的树都会去追这个点。随机森林里,这个点只影响一部分树,还被平均掉了。

08 实践里真正要调的参数

理论讲完,说说调参。

树的数量和学习率是一对,前面说过了。经验是学习率固定 0.05 到 0.1,用早停定树数。

树的深度。风控场景常用 3 到 5。太深容易过拟合,也不利于解释。营销场景可以到 6 到 8,因为要抓更细的交互。

叶子最小样本数。这个参数比深度更直接影响过拟合。我一般设成总样本的 0.5% 到 1%,比如 10 万条数据设 500 到 1000。

行采样和列采样。每棵树随机用 70% 到 80% 的样本和特征。这两个参数能显著提升泛化,还能加速训练。

正则项。XGBoost 里的 lambda 和 alpha,控制叶子输出的惩罚。数据量小的时候调大一点,能明显抑制过拟合。

调参顺序我一般是这样:先定学习率和树数(早停),再调深度和叶子最小样本,最后微调采样比例和正则。

不要一上来就网格搜索所有参数,那是浪费时间。每个参数的作用方向搞清楚,手动调几轮就差不多了。

还有一个容易被忽略的点:早停用的那份验证集,必须按时间切,不能随机抽。

随机抽的话,验证集和训练集是同一段时间的同一批客户,模型在这上面表现好,只说明它记住了这批人的特征分布。真实上线面对的是下一批客户,早停点在随机验证集上选出来的树数,通常偏多,过拟合就藏在这多出来的几十棵树里。

按时间切也有代价,样本变少,指标更抖。所以我的做法是留最后两到三个月做验证,宁可抖一点,也要它真实。

09 特征重要性到底在说什么

模型跑完,业务第一个问题永远是:哪个变量最重要。

GBDT 能给出答案,但答案有三种口径,含义完全不同。

第一种,分裂次数。这个特征在所有树里被用来切了多少次。简单,但偏向取值多的连续变量,因为连续变量可切的位置多。

第二种,增益。每次用这个特征切分,带来的损失下降累加起来。这个更合理,因为它衡量的是"切了之后模型好了多少"。

第三种,置换重要性。把这一列随机打乱,看模型指标掉多少。掉得越多,说明这个特征越重要。

三种口径排出来的顺序,经常不一样。我一般看第二种和第三种,两个都高才算真的重要。

更麻烦的是共线性。

假设"月收入"和"年收入"同时在模型里,它们几乎等价。树会随机选其中一个切分,结果两个的重要性都被摊薄,各占一半。你看到的是"两个都不重要",实际是"两个都很重要,但重复了"。

处理办法是先把高度相关的变量合并,或者只留一个。

还有一个常见误解:重要性高不等于业务上重要。

有些特征重要性很高,但它是个代理变量。比如"手机号归属地"可能只是间接代表了客群结构。这类特征在模型里有效,但业务没法据此做动作,也不能写进策略。

我的建议是:重要性用来排排查顺序,不用来写结论。真正要下结论,还得做单变量分析加业务访谈。

10 几个容易踩的坑

第一个,特征泄漏。

GBDT 特别擅长利用泄漏的特征。你只要不小心把一个"未来信息"放进去,它会立刻抓住,AUC 能冲到 0.95,然后上线就废。这类事故我见过不止一次,尤其是把"逾期天数"这种贷后变量误当成贷前特征。

第二个,类别特征直接喂进去。

不做编码直接扔给树,树会按数值大小切,把"北京、上海、广州"当成 1、2、3 排序,切出毫无意义的规则。要么做目标编码,要么用 LightGBM 那种原生支持类别特征的实现。

第三个,拿 GBDT 做评分卡。

GBDT 的分数不单调,也不可加。你没法跟审批人说"这个客户因为年龄扣了 15 分"。真要做评分卡,还是得回到逻辑回归加 WOE。

第四个,忽视跨期验证。

随机划分训练测试集,AUC 0.85,上线三个月掉到 0.72。表格数据的分布漂移比图像文本严重得多,时间外采样验证是必须的,不能只做随机划分。

第五个,只调参不做特征工程。

见过一些团队,把调参当成主要工作,网格搜索跑了三天,AUC 从 0.782 调到 0.786,很高兴。

同一时间,另一个团队加了一个"近三个月查询次数"的特征,AUC 直接到 0.81。

树模型对特征质量极其敏感。特征里没有的信息,参数调破了也变不出来。调参的收益通常在千分位,好特征的收益在百分位。

第六个,把特征重要性当成因果。

GBDT 的特征重要性只说明"这个特征被用来切分了,且带来了增益",不说明它导致了结果。两个高度相关的特征,重要性会随机分给其中一个,看起来像是一个有用一个没用,其实是共线的。

11 一个真实项目里的选择

去年接触过一个消费贷的申请评分项目,样本 8 万条,坏账率 4.2%。

他们原来用的是逻辑回归加 WOE,KS 0.38。业务想要更高,问能不能上 GBDT。

我先跑了一版 LightGBM,深度 4,500 棵树,学习率 0.05,KS 到 0.46。提升很明显。

但问题来了:模型过不了合规。

合规的要求是"每个客户的拒绝理由要能说清楚"。逻辑回归能给出"因为负债收入比超过 0.6,扣 20 分",GBDT 给不出来。

我们试了几种折中方案。

第一种,用 GBDT 做特征筛选,把重要性高的变量挑出来,再进逻辑回归。KS 回到 0.41,比原来高 3 个点,可解释性保住了。

第二种,用 GBDT 的叶子编号做特征,再套一个逻辑回归。这在业内叫 GBDT 加 LR,KS 0.43,解释性打了折扣但还能接受。

第三种,双模型并行。GBDT 跑在后台做监控和额度建议,逻辑回归跑在前台做审批决策。KS 前台还是 0.38,但后台能提前发现异常客群。

最后落地的是第一种加第三种。

这个案例想说的是:模型选型不是比谁的 AUC 高,是在精度、解释性、合规成本之间找平衡点。GBDT 在纯精度上几乎总是赢,但它赢的那几个点,有时候换不来上线许可。

写在最后

三句话。

第一,GBDT 的本质是加法模型加前向分步。每棵树学的是当前损失的负梯度,平方损失下它恰好等于残差。

第二,学习率和树数必须一起看。学习率小最终更准但更慢,早停是最实用的定树数方法。

第三,分类任务不能用残差,要用对数损失的梯度加牛顿叶子值。这一步是很多人背概念时跳过的地方,也是 XGBoost 那些公式的真正来源。

如果你想动手,建议先把我上面那三十行回归树跑一遍,把深度改成 1、2、5,看拟合曲线怎么变。比看十篇文章都管用。

觉得有用点个赞,转给正在调参的同学。

本文内容为本人学习共享,仅供参考。

随机文章