GBDT原理与Sklearn源码分析-分类篇

最新推荐文章于 2022-11-21 12:02:07 发布
最新推荐文章于 2022-11-21 12:02:07 发布
阅读量1.5k 收藏 4
点赞数
分类专栏： 人工智能 文章标签： GBDT

摘要：

继上一篇文章，介绍完回归任务下的GBDT后，这篇文章将介绍在分类任务下的GBDT，大家将可以看到，对于回归和分类，其实GBDT过程简直就是一模一样的。如果说最大的不同的话，那就是在于由于loss function不同而引起的初始化不同、叶子节点取值不同。

正文：

GB的一些基本原理都已经在上文中介绍了，下面直接进入正题。
下面是分类任务的GBDT算法过程，其中选用的loss function是logloss。
L(yi,Fm(xi))=yilogpi+(1−yi)log(1−pi)L(yi,Fm(xi))=yilogpi+(1−yi)log(1−pi)。
其中pi=11+e(−Fm(xi))pi=11+e(−Fm(xi))

这里简单推导一下logloss通常化简后的式子：
L(yi,Fm(xi))=−{yilogpi+(1−yi)log(1−pi)}L(yi,Fm(xi))=−{yilogpi+(1−yi)log(1−pi)}
（先不带入负号）
带入pipi=>yilog(11+e(−Fm(xi)))+(1−yi)log(e(−Fm(xi))1+e(−Fm(xi)))yilog(11+e(−Fm(xi)))+(1−yi)log(e(−Fm(xi))1+e(−Fm(xi)))
=>−yilog(1+e(−Fm(xi)))+(1−yi){log(e(−Fm(xi)))−log(1+e(−Fm(xi)))}−yilog(1+e(−Fm(xi)))+(1−yi){log(e(−Fm(xi)))−log(1+e(−Fm(xi)))}
=>−yilog(1+e(−Fm(xi)))+log(e(−Fm(xi)))−log(1+e(−Fm(xi)))−yilog(e(−Fm(xi)))+yilog(1+e(−Fm(xi)))−yilog(1+e(−Fm(xi)))+log(e(−Fm(xi)))−log(1+e(−Fm(xi)))−yilog(e(−Fm(xi)))+yilog(1+e(−Fm(xi)))
=>yiFm(xi)−log(1+eFm(xi))yiFm(xi)−log(1+eFm(xi))
最后加上负号可以得：
L(yi,Fm(xi))=−{yilogpi+(1−yi)log(1−pi)}=−{yiFm(xi)−log(1+eFm(xi))}L(yi,Fm(xi))=−{yilogpi+(1−yi)log(1−pi)}=−{yiFm(xi)−log(1+eFm(xi))}

Algorithm 3:BinomiaDeviance_TreeBoost____________________________________F0(x)=0.5∗log(∑Ni=1yi∑Ni=1(1−yi))From=1 to M do:       yi~=−[∂L(yi,F(xi))∂F(xi)]F(x)=Fm−1(x)=yi−11+e(−Fm−1(xi))       {Rjm}J1=J−terminal node tree({y~i,xi}N1)       γjm=∑xi∈Rjmy~i∑xi∈Rjm(yi−y~i)∗(1−yi+y~i)       Fm(x)=Fm−1(x)+∑j=1JγjmI(x∈Rjm)Algorithm 3:BinomiaDeviance_TreeBoost____________________________________F0(x)=0.5∗log(∑i=1Nyi∑i=1N(1−yi))From=1 to M do:       yi~=−[∂L(yi,F(xi))∂F(xi)]F(x)=Fm−1(x)=yi−11+e(−Fm−1(xi))       {Rjm}1J=J−terminal node tree({y~i,xi}1N)       γjm=∑xi∈Rjmy~i∑xi∈Rjm(yi−y~i)∗(1−yi+y~i)       Fm(x)=Fm−1(x)+∑j=1JγjmI(x∈Rjm)

算法3就是GBDT用于分类任务时，loss funcion选用logloss的算法流程。
可以看到，和回归任务是一样的，并没有什么特殊的处理环节。
（其实在sklearn源码里面，虽然回归任务的模型定义是GradientBoostingRegressor()而分类任务是GradientBoostingClassifier()，但是这两者区分开来是为了方便用户使用，最终两者都是共同继承BaseGradientBoosting()，算法3这些流程都是在BaseGradientBoosting()完成的，GradientBoostingRegressor()、GradientBoostingClassifier()只是完成一些学习器参数配置的任务）

实践

下面同样以一个简单的数据集来大致的介绍一下GBDT的过程。

xixi12345678910
yiyi0001100011

参数配置：
1. 以logloss为损失函数
2. 以MSE为分裂准则
3. 树的深度为1
4. 学习率为0.1

算法3的第一步，初始化。
F0(x)=log(∑Ni=1yi∑Ni=1(1−yi))=log(46)=−0.4054F0(x)=log(∑i=1Nyi∑i=1N(1−yi))=log(46)=−0.4054

拟合第一颗树(m=1m=1)
计算负梯度值：
yi~=−[∂L(yi,F(xi))∂F(xi)]F(x)=Fm−1(x)=yi−11+e(−Fm−1(xi))=yi−11+e(−F0(xi))yi~=−[∂L(yi,F(xi))∂F(xi)]F(x)=Fm−1(x)=yi−11+e(−Fm−1(xi))=yi−11+e(−F0(xi))

比如计算第一个样本(i=1i=1)有：
y1~=0−11+e(0.4054)=−0.400y1~=0−11+e(0.4054)=−0.400
同样地，其他计算后如下表：

xixi12345678910
y~iy~i-0.4-0.4-0.40.60.6-0.4-0.4-0.40.60.6

接着，我们需要以y~iy~i为目标，拟合一颗树。
拟合树的过程上篇文章已经详细介绍了，这里就不再累述了。拟合完后结果如下：
这里写图片描述

可以得出建好树之后叶子节点的区域：
R11R11为xi<=8xi<=8，R21R21为xi>8xi>8
下面计算可以叶子节点的值γjmγjm
由公式：γjm=∑xi∈Rjmy~i∑xi∈Rjm(yi−y~i)∗(1−yi+y~i)γjm=∑xi∈Rjmy~i∑xi∈Rjm(yi−y~i)∗(1−yi+y~i)
对于区域R11R11有如下：
∑xi∈R11y~i=(y~1+y~2+y~3+y~4+y~5+y~6+y~7+y~8)=−1.2∑xi∈R11y~i=(y~1+y~2+y~3+y~4+y~5+y~6+y~7+y~8)=−1.2
∑xi∈R11(yi−y~i)∗(1−yi+y~i)=(y1−y~1)∗(1−y1+y~1)+(y2−y~2)∗(1−y2+y~2)+(y3−y~3)∗(1−y3+y~3)+(y4−y~4)∗(1−y4+y~4)+(y5−y~5)∗(1−y5+y~5)+(y6−y~6)∗(1−y6+y~6)+(y7−y~7)∗(1−y7+y~7)+(y8−y~8)∗(1−y8+y~8)+(y9−y~9)∗(1−y9+y~9)=1.92∑xi∈R11(yi−y~i)∗(1−yi+y~i)=(y1−y~1)∗(1−y1+y~1)+(y2−y~2)∗(1−y2+y~2)+(y3−y~3)∗(1−y3+y~3)+(y4−y~4)∗(1−y4+y~4)+(y5−y~5)∗(1−y5+y~5)+(y6−y~6)∗(1−y6+y~6)+(y7−y~7)∗(1−y7+y~7)+(y8−y~8)∗(1−y8+y~8)+(y9−y~9)∗(1−y9+y~9)=1.92

对于区域R21R21有如下：
∑xi∈R21y~i=(y~9+y~10)=1.2∑xi∈R21y~i=(y~9+y~10)=1.2
∑xi∈R21(yi−y~i)∗(1−yi+y~i)=(y9−y~9)∗(1−y9+y~9)+(y10−y~10)∗(1−y10+y~10)=0.48∑xi∈R21(yi−y~i)∗(1−yi+y~i)=(y9−y~9)∗(1−y9+y~9)+(y10−y~10)∗(1−y10+y~10)=0.48

故最后可以得到两个叶子节点的值：
γ11=−1.21.92=−0.625γ11=−1.21.92=−0.625、γ21=1.20.480=2.5γ21=1.20.480=2.5

最后通过Fm(x)=Fm−1(x)+∑Jj=1γjmI(x∈Rjm)Fm(x)=Fm−1(x)+∑j=1JγjmI(x∈Rjm)更新F1(x)F1(x)，需要注意的是，这里同样也用shrinkage，即乘一个学习率ηη，具体表现为：
Fm(x)=Fm−1(x)+η∗∑Jj=1γjmI(x∈Rjm)Fm(x)=Fm−1(x)+η∗∑j=1JγjmI(x∈Rjm)。

以计算x1x1为例：
F1(x1)=F0(x1)+0.1∗(−0.625)=−0.4054−0.0625=−0.4679F1(x1)=F0(x1)+0.1∗(−0.625)=−0.4054−0.0625=−0.4679
其他计算完毕后如下表供参考：

xixi12345678910
F1(xi)F1(xi)-0.46796511-0.46796511-0.46796511-0.46796511-0.46796511-0.46796511-0.46796511-0.46796511-0.15546511-0.15546511

至此，第一颗树已经训练完成。可以再次看到其训练过程和回归基本没有区别。

下面简单提一下拟合第二颗树(m=2)m=2)

计算负梯度值：
比如对于x1x1有：
=>y~1=y1−11+e(−F1(x1))=0−0.38509=−0.38509y~1=y1−11+e(−F1(x1))=0−0.38509=−0.38509
其他同理，可得下表：

xixi12345678910
y~iy~i-0.38509799-0.38509799-0.385097990.614902010.61490201-0.38509799-0.38509799-0.385097990.538788180.53878818

之后也是以新的y~iy~i为目标拟合一颗回归树后计算叶子节点的区间和叶子节点的值。

关于预测

当只有2颗树的时候，其预测过程也是和下面这个图一样
这里写图片描述

相比于回归任务，分类任务需把要最后累加的结果Fm(x)Fm(x)转成概率。（其实Fm(x)Fm(x)可以理解成一个得分）。具体来说：
对于采用logloss作为损失函数的情况下，pi=11+e(−Fm(xi))pi=11+e(−Fm(xi))。
对于采用指数损失作为损失函数的情况下，pi=11+e(−2Fm(xi))pi=11+e(−2Fm(xi))。
当然这里的pipi指的是正样本的概率。

这里再详细一点，比如对于上面例子，当我们拟合完第二颗树后，计算F2(x)F2(x)可有有下表：

xixi12345678910
F2(xi)F2(xi)-0.52501722-0.52501722-0.52501722-0.52501722-0.52501722-0.52501722-0.52501722-0.525017220.061355010.06135501

此时计算相应的概率值有：
F2(x)F2(x)可有有下表：

xixi12345678910
pipi0.371679790.371679790.371679790.371679790.371679790.371679790.371679790.371679790.515333940.51533394

(表中的概率为正样本的概率，即yi=1yi=1的概率）

Sklearn源码简单分析

写在前面：Sklearn源码分析后面有时间有添加一些内容，下面先简单了解GDBT分类的核心代码。

当loss function选用logloss时，对应的是sklearn里面的loss=’deviance’。
计算负梯度、初始化、更新叶子节点、转成概率都在一个名叫BinomialDeviance()的类中。

class BinomialDeviance(ClassificationLossFunction):
    """Binomial deviance loss function for binary classification.

    Binary classification is a special case; here, we only need to
    fit one tree instead of ``n_classes`` trees.
    """
    def __init__(self, n_classes):
        if n_classes != 2:
            raise ValueError("{0:s} requires 2 classes.".format(
                self.__class__.__name__))
        # we only need to fit one tree for binary clf.
        super(BinomialDeviance, self).__init__(1)

    def init_estimator(self):
        return LogOddsEstimator()

    def __call__(self, y, pred, sample_weight=None):
        """Compute the deviance (= 2 * negative log-likelihood). """
        # logaddexp(0, v) == log(1.0 + exp(v))
        pred = pred.ravel()
        if sample_weight is None:
            return -2.0 * np.mean((y * pred) - np.logaddexp(0.0, pred))
        else:
            return (-2.0 / sample_weight.sum() *
                    np.sum(sample_weight * ((y * pred) - np.logaddexp(0.0, pred))))

    def negative_gradient(self, y, pred, **kargs):
        """Compute the residual (= negative gradient). """
        return y - expit(pred.ravel())

    def _update_terminal_region(self, tree, terminal_regions, leaf, X, y,
                                residual, pred, sample_weight):
        """Make a single Newton-Raphson step.

        our node estimate is given by:

            sum(w * (y - prob)) / sum(w * prob * (1 - prob))

        we take advantage that: y - prob = residual
        """
        terminal_region = np.where(terminal_regions == leaf)[0]
        residual = residual.take(terminal_region, axis=0)
        y = y.take(terminal_region, axis=0)
        sample_weight = sample_weight.take(terminal_region, axis=0)

        numerator = np.sum(sample_weight * residual)
        denominator = np.sum(sample_weight * (y - residual) * (1 - y + residual))
        # prevents overflow and division by zero
        if abs(denominator) < 1e-150:
            tree.value[leaf, 0, 0] = 0.0
        else:
            tree.value[leaf, 0, 0] = numerator / denominator

    def _score_to_proba(self, score):
        proba = np.ones((score.shape[0], 2), dtype=np.float64)
        proba[:, 1] = expit(score.ravel())
        proba[:, 0] -= proba[:, 1]
        return proba

    def _score_to_decision(self, score):
        proba = self._score_to_proba(score)
        return np.argmax(proba, axis=1)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

下面这是用于计算负梯度值。注意的函数expit就是11+e−x11+e−x
代码中的y_pred或者pred表达的就是Fm−1(x)Fm−1(x)

    def negative_gradient(self, y, pred, **kargs):
        """Compute the residual (= negative gradient). """
        return y - expit(pred.ravel())
  • 1
  • 2
  • 3

更新叶子节点，关键在于计算numerator和denominator。
另外代码里的residual代表的是负梯度值。

    def _update_terminal_region(self, tree, terminal_regions, leaf, X, y,
                                residual, pred, sample_weight):
        """Make a single Newton-Raphson step.

        our node estimate is given by:

            sum(w * (y - prob)) / sum(w * prob * (1 - prob))

        we take advantage that: y - prob = residual
        """
        terminal_region = np.where(terminal_regions == leaf)[0]
        residual = residual.take(terminal_region, axis=0)
        y = y.take(terminal_region, axis=0)
        sample_weight = sample_weight.take(terminal_region, axis=0)

        numerator = np.sum(sample_weight * residual)
        denominator = np.sum(sample_weight * (y - residual) * (1 - y + residual))
        # prevents overflow and division by zero
        if abs(denominator) < 1e-150:
            tree.value[leaf, 0, 0] = 0.0
        else:
            tree.value[leaf, 0, 0] = numerator / denominator
  • 1
  • 2
  • 3
  • 4
  • 5

初始化的类：

class LogOddsEstimator(object):
    """An estimator predicting the log odds ratio."""
    scale = 1.0

    def fit(self, X, y, sample_weight=None):
        # pre-cond: pos, neg are encoded as 1, 0
        if sample_weight is None:
            pos = np.sum(y)
            neg = y.shape[0] - pos
        else:
            pos = np.sum(sample_weight * y)
            neg = np.sum(sample_weight * (1 - y))

        if neg == 0 or pos == 0:
            raise ValueError('y contains non binary labels.')
        self.prior = self.scale * np.log(pos / neg)

    def predict(self, X):
        check_is_fitted(self, 'prior')

        y = np.empty((X.shape[0], 1), dtype=np.float64)
        y.fill(self.prior)
        return y
  • 1
  • 2

其中，下面这个用于初始化，可以看到有一个因子self.scale，这是由于在Sklearn里提供两种loss function用于分类，一种是logloss，一种是指数损失，两者的初始化仅仅只是在系数上不同，前者是1.0,后者是0.5。

    def fit(self, X, y, sample_weight=None):
        # pre-cond: pos, neg are encoded as 1, 0
        if sample_weight is None:
            pos = np.sum(y)
            neg = y.shape[0] - pos
        else:
            pos = np.sum(sample_weight * y)
            neg = np.sum(sample_weight * (1 - y))

        if neg == 0 or pos == 0:
            raise ValueError('y contains non binary labels.')
        self.prior = self.scale * np.log(pos / neg)
  • 1

最后是转化成概率，这里有个细节，就是正样本的概率是放在第2列（从1数起）。

    def _score_to_proba(self, score):
        proba = np.ones((score.shape[0], 2), dtype=np.float64)
        proba[:, 1] = expit(score.ravel())
        proba[:, 0] -= proba[:, 1]
        return proba

总结

至此，GBDT用于回归和分类的两种情况都已经说明完毕，欠缺的可能是源码部分说的不够深入，由于最近时间的关系没办法做到太深入，所以后面找时间会把代码再深入的分析后补充在这。

对于多分类问题也需要单独讨论详细请看文章。

参考资料

http://docplayer.net/21448572-Generalized-boosted-models-a-guide-to-the-gbm-package.html（各种loss function的推导结果）
http://xueshu.baidu.com/s?wd=paperuri%3A%28ab7165108163edc94b30781e51819e0c%29&filter=sc_long_sign&sc_ks_para=q%3DGreedy%20function%20approximation%3A%20A%20gradient%20boosting%20machine.&sc_us=13783016239361402484&tn=SE_baiduxueshu_c1gjeupa&ie=utf-8 （本文主要参考的超级著名论文 greedy function approximation: a gradient boosting machine）

hai008007
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
loss 加权_Multi-Similarity Loss使用通用对加权进行深度度量学习-CVPR2019
weixin_39695672的博客
12-21 735
《Multi-Similarity Loss with General Pair Weighting for Deep Metric Learning》原文Multi-Similarity Loss with General Pair Weighting for Deep Metric Learning​openaccess.thecvf.comcodehttps://github. com/Ma...
GBDT用于分类
h2728677716的博客
03-14 979
思想介绍： 类似于逻辑回归，FM模型用于分类模型，用一个线性模型或者 包含交叉项的非线性模型去拟合所谓的对数几率, 即在逻辑回归公式推导过程中通过广义线性回归,θtX去拟合了对数几率。 GBDT是用了F(x)去拟合了对数几率。用公式表达就是。 做法： 我们先训练一颗小树拟合对数几率，如果拟合的不够好就在来训练一棵小树再去拟合对数几率，以此类推，把所有的小树加和在一起得到F(x)在做二分类的时候就是我们总体的对数几率，带到sigmoid函数里面去，就能得到属于正例的概率有多大。 求梯度 ..
XGBoost、LightGBM的详细对比介绍
weixin_30894583的博客
04-14 423
sklearn集成方法 集成方法的目的是结合一些基于某些算法训练得到的基学习器来改进其泛化能力和鲁棒性(相对单个的基学习器而言)主流的两种做法分别是： bagging 基本思想 独立的训练一些基学习器(一般倾向于强大而复杂的模型比如完全生长的决策树)，然后综合他们的预测结果，通常集成模型的效果会优于基学习器，因为模型的方差有所降低。 常见变体(按照样本采样方式的不同划分) Past...
回归和分类损失函数（MSE、MAE、Huber、Exponential、Deviance、Hinge）
十里清风
05-06 5609
指数损失和二项偏差损失 给定样本x\boldsymbol xx，类别y∈{−1,+1}y\in\{-1,+1\}y∈{−1,+1}，类别另一种表示y′=(y+1)/2∈{0,1}y'=(y+1)/2\in\{0,1\}y′=(y+1)/2∈{0,1}. 二项偏差（Binomial Deviance）的类1概率为 p(x)=P(y=1∣x)=exp⁡(f(x))exp⁡(−f(x))+exp⁡(f(...
sklearn实现GBDT算法（分类）
HRMEMEDA的博客
11-14 5265
阿喽哈~小天才们，今天我们聊一聊GBDT上一篇文章我们详细地说了GBDT算法原理，包括为什么拟合负梯度、负梯度为何可以替代残差、二分类GBDT算法公式和实例演算，感兴趣的童鞋请移步具体算法公式啥的这里就不赘述啦，大家就自行学习理解叭，我们今天主要是说如何使用sklearn包来实现GBDT以及简单的调参演示，话不多说上代码~
GBDT原理与Sklearn源码分析-回归篇
热门推荐
SCUT_Sam
01-28 3万+
摘要： 本文将非常详细的介绍GBDT（Gradient Boosting Decision Tree）的原理以及Sklearn里面具体是如何实现一个GBDT的。本次内容将分为两篇文章，一篇是GBDT用于回归，一篇是GBDT用于分类任务。虽然两者其实本质是一样的，只是loss function不同，但是分成两篇可以帮助更好的对比理解。 注意：本文前半部分是GBDT原理的一个概述，后半步是skle...
GBDT.zip_GBDT_sklearn_分类算法_提升树_梯度提升决策树
09-21
- `sklearn.ensemble.GradientBoostingClassifier`和`sklearn.ensemble.GradientBoostingRegressor`是`sklearn`中实现GBDT的两个主要类，分别用于分类和回归任务。 - 参数包括`n_estimators`（决策树的数量）、`...
大白话GBDT算法-通俗理解GBDT原理
06-21
第三个模块通过剖析分类和回归损失函数来讲解GBDT在分类和回归方面的应用。 第四个模块通过手动方式一步步拆解讲解GBDT回归，二分类，多分类的过程，还原真实迭代流程。 第五个模块通过真实案例讲解GBDT的工作中所用...
一个案例搞定GBDT原理分析.pdf
08-10
**梯度提升决策树（Gradient Boosting Decision Tree, GBDT）**是一种强大的机器学习算法，广泛应用于分类和回归任务。它通过迭代地构建多个决策树，并将它们的预测结果组合起来，形成一个强预测模型。下面我们将...
gbdt回归源码matlab-curry:咖喱
06-03
gbdt回归源码matlab CS74：预测篮球统计数据 依赖关系 MATLAB R2014a 运行pip install scrapy进行安装 数据 所有数据都包含在data目录中。 数据全部来自basketball-reference.com。 我们使用了从 1979-80 赛季...
gbdt-rs:MesaTEE GBDT-RS
05-05
支持的任务支持训练和推理的任务线性回归：使用SquaredError和LAD损失类型二进制分类（标记为1和-1）：使用LogLikelyhood损失类型与xgboost的兼容性目前，MesaTEE GBDT-RS支持使用xgboost训练的模型进行推断。...
机器学习算法[8]--集成方法之GBDT原理详解及sklearn实现
Gthan
07-07 1431
对机器学习算法-GBDT进行总结，包括原理详解和sklearn的实现
GBDT 梯度提升树（Gradient Boosting Decision Tree）长篇全解
qq_49183286的博客
11-21 5494
GBDT梯度提升树
【sklearn】GBDT（Gradient Boosting Decision Tree） - 预测在网具有单卡转合约倾向的客户
秋天
10-09 3407
本文主要完成如下内容 简单介绍GBDT； 介绍sklearn中GBDT算法（GradientBoostingClassifier）的参数； 介绍使用pandas模块分析训练数据的方法； 介绍使用网格搜索对GBDT调参的方法技巧； GBDT介绍 GBDT全称梯度下降树，可以用于分类（做二分类效果还可以，做多分类效果不好）、回归（适合做回归）问题，也可以筛选特征。本次使用GBDT解决分类、特...
sklearn GBDT源码阅读
using namespace 数学工具构造器;
01-27 374
class LeastSquaresError(RegressionLossFunction): def init_estimator(self): return DummyRegressor(strategy='mean') def __call__(self, y, raw_predictions, sample_weight=None): return (1 / sample_weight.sum() * np.sum( sam
GBDT训练分类器时，残差是如何计算的？
mmc2015的专栏
09-01 8511
大家都知道，对于回归任务，GBDT的loss=(y-pred)^2，因此残差residual=2*(y-pred)很容易理解。 那么，GBDT做分类任务时，残差是怎样的呢？？？ Gradient Boosting attempts to solve this minimization problem numerically via steepest descent， The st
深度度量学习（DML）中pair-based方法中的loss
weixin_43480312的博客
04-30 1455
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入
基于贝叶斯网络BO-Transformer-BiLSTM实现负荷数据回归预测附matlab代码.rar
最新发布
07-27
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
梯度提升机(GBDT)原理与应用
这篇原始论文深入探讨了GBDT的数学基础和算法实现，对于想要深入理解GBDT工作原理的读者，它是不可或缺的参考资料。通过阅读论文，我们可以了解GBDT如何通过迭代优化和决策树集成来达到高效、稳健的预测效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值