一、GBDT+LR简介
协同过滤和矩阵分解存在的劣势就是仅利用了用户与物品相互行为信息进行推荐， 忽视了用户自身特征， 物品自身特征以及上下文信息等，导致生成的结果往往会比较片面。
2014年由Facebook提出的GBDT+LR模型， 该模型利用GBDT自动进行特征筛选和组合， 进而生成新的离散特征向量， 再把该特征向量当做LR模型的输入， 来产生最后的预测结果， 该模型能够综合利用用户、物品和上下文等多种不同的特征， 生成较为全面的推荐结果， 在CTR点击率预估场景下使用较为广泛。
二、逻辑回归模型
逻辑回归模型非常重要， 在推荐领域里面， 相比于传统的协同过滤， 逻辑回归模型能够综合利用用户、物品、上下文等多种不同的特征生成较为“全面”的推荐结果， 关于逻辑回归的更多细节， 可以参考下面给出的链接，这里只介绍比较重要的一些细节和在推荐中的应用。
逻辑回归是在线性回归的基础上加了一个 Sigmoid 函数（非线形）映射，使得逻辑回归成为了一个优秀的分类算法， 学习逻辑回归模型， 首先应该记住一句话：逻辑回归假设数据服从伯努利分布,通过极大化似然函数的方法，运用梯度下降来求解参数，来达到将数据二分类的目的。
相比于协同过滤和矩阵分解利用用户的物品“相似度”进行推荐， 逻辑回归模型将问题看成了一个分类问题， 通过预测正样本的概率对物品进行排序。这里的正样本可以是用户“点击”了某个商品或者“观看”了某个视频， 均是推荐系统希望用户产生的“正反馈”行为， 因此逻辑回归模型将推荐问题转化成了一个点击率预估问题。而点击率预测就是一个典型的二分类， 正好适合逻辑回归进行处理， 那么逻辑回归是如何做推荐的呢？ 过程如下：
将用户年龄、性别、物品属性、物品描述、当前时间、当前地点等特征转成数值型向量
确定逻辑回归的优化目标，比如把点击率预测转换成二分类问题， 这样就可以得到分类问题常用的损失作为目标， 训练模型
在预测的时候， 将特征向量输入模型产生预测， 得到用户“点击”物品的概率
利用点击概率对候选物品排序， 得到推荐列表
推断过程可以用下图来表示：
这里的关键就是每个特征的权重参数w ww， 我们一般是使用梯度下降的方式， 首先会先随机初始化参数w ww， 然后将特征向量（也就是我们上面数值化出来的特征）输入到模型， 就会通过计算得到模型的预测概率， 然后通过对目标函数求导得到每个w ww的梯度， 然后进行更新w ww
这里的目标函数长下面这样：
这样通过若干次迭代， 就可以得到最终的w ww了， 关于这些公式的推导，可以参考下面给出的文章链接， 下面我们分析一下逻辑回归模型的优缺点。
优点：
LR模型形式简单，可解释性好，从特征的权重可以看到不同的特征对最后结果的影响。
训练时便于并行化，在预测时只需要对特征进行线性加权，所以性能比较好，往往适合处理海量id类特征，用id类特征有一个很重要的好处，就是防止信息损失（相对于范化的 CTR 特征），对于头部资源会有更细致的描述
资源占用小,尤其是内存。在实际的工程应用中只需要存储权重比较大的特征及特征对应的权重。
方便输出结果调整。逻辑回归可以很方便的得到最后的分类结果，因为输出的是每个样本的概率分数，我们可以很容易的对这些概率分数进行cutoff，也就是划分阈值(大于某个阈值的是一类，小于某个阈值的是一类)
当然， 逻辑回归模型也有一定的局限性
表达能力不强， 无法进行特征交叉， 特征筛选等一系列“高级“操作（这些工作都得人工来干， 这样就需要一定的经验， 否则会走一些弯路）， 因此可能造成信息的损失
准确率并不是很高。因为这毕竟是一个线性模型加了个sigmoid， 形式非常的简单(非常类似线性模型)，很难去拟合数据的真实分布
处理非线性数据较麻烦。逻辑回归在不引入其他方法的情况下，只能处理线性可分的数据， 如果想处理非线性， 首先对连续特征的处理需要先进行离散化（离散化的目的是为了引入非线性），如上文所说，人工分桶的方式会引入多种问题。
LR 需要进行人工特征组合，这就需要开发者有非常丰富的领域经验，才能不走弯路。这样的模型迁移起来比较困难，换一个领域又需要重新进行大量的特征工程。
所以如何自动发现有效的特征、特征组合，弥补人工经验不足，缩短LR特征实验周期，是亟需解决的问题， 而GBDT模型， 正好可以自动发现特征并进行有效组合
三、GBDT模型
GBDT全称梯度提升决策树，在传统机器学习算法里面是对真实分布拟合的最好的几种算法之一，在前几年深度学习还没有大行其道之前，gbdt在各种竞赛是大放异彩。原因大概有几个，一是效果确实挺不错。二是即可以用于分类也可以用于回归。三是可以筛选特征， 所以这个模型依然是一个非常重要的模型。
GBDT是通过采用加法模型(即基函数的线性组合），以及不断减小训练过程产生的误差来达到将数据分类或者回归的算法， 其训练过程如下：
gbdt通过多轮迭代， 每轮迭代会产生一个弱分类器， 每个分类器在上一轮分类器的残差基础上进行训练。 gbdt对弱分类器的要求一般是足够简单， 并且低方差高偏差。 因为训练的过程是通过降低偏差来不断提高最终分类器的精度。 由于上述高偏差和简单的要求，每个分类回归树的深度不会很深。最终的总分类器是将每轮训练得到的弱分类器加权求和得到的（也就是加法模型）。
GBDT的伪代码
关于GBDT的详细细节，依然是可以参考下面给出的链接。这里想分析一下GBDT如何来进行二分类的，因为注意gbdt 每轮的训练是在上一轮的训练的残差基础之上进行训练的， 而这里的残差指的就是当前模型的负梯度值， 这个就要求每轮迭代的时候，弱分类器的输出的结果相减是有意义的， 而gbdt 无论用于分类还是回归一直都是使用的CART 回归树， 那么既然是回归树， 是如何进行二分类问题的呢？
GBDT 来解决二分类问题和解决回归问题的本质是一样的，都是通过不断构建决策树的方式，使预测结果一步步的接近目标值， 但是二分类问题和回归问题的损失函数是不同的， 关于GBDT在回归问题上的树的生成过程， 损失函数和迭代原理可以参考给出的链接， 回归问题中一般使用的是平方损失， 而二分类问题中， GBDT和逻辑回归一样， 使用的下面这个：
下面我们具体来看GBDT的生成过程， 构建分类GBDT的步骤有两个：
3.1 初始化GBDT
和回归问题一样， 分类 GBDT 的初始状态也只有一个叶子节点，该节点为所有样本的初始预测值，如下：
上式里面， F FF代表GBDT模型， F 0 F_0F
0
是模型的初识状态， 该式子的意思是找到一个γ \gammaγ，使所有样本的 Loss 最小，在这里及下文中，γ \gammaγ都表示节点的输出，即叶子节点， 且它是一个 l o g ( η i ) log(\eta_i)log(η
i
) 形式的值(回归值)，在初始状态，γ = F 0 \gamma =F_0γ=F
0
。
下面看例子(该例子来自下面的第二个链接)， 假设我们有下面3条样本：
此处使用m − 1 m-1m−1棵树的模型， 计算每个样本的残差r i m r_{im}r
im
, 就是上面的y i − p i y_i-piy
i
−pi, 于是例子中， 每个样本的残差：
2. 使用回归树来拟合r i m r_{im}r
im
这里的i ii表示样本，回归树的建立过程可以参考下面的链接文章，简单的说就是遍历每个特征， 每个特征下遍历每个取值， 计算分裂后两组数据的平方损失， 找到最小的那个划分节点。 假如我们产生的第2棵决策树如下：
3. 对于每个叶子节点j jj, 计算最佳残差拟合值
这样， 通过多次循环迭代， 就可以得到一个比较强的学习器F m ( x ) F_m(x)F
m
(x)
下面分析一下GBDT的优缺点：
我们可以把树的生成过程理解成自动进行多维度的特征组合的过程，从根结点到叶子节点上的整个路径(多个特征值判断)，才能最终决定一棵树的预测值， 另外，对于连续型特征的处理，GBDT 可以拆分出一个临界阈值，比如大于 0.027 走左子树，小于等于 0.027（或者 default 值）走右子树，这样很好的规避了人工离散化的问题。这样就非常轻松的解决了逻辑回归那里自动发现特征并进行有效组合的问题， 这也是GBDT的优势所在。
但是GBDT也会有一些局限性， 对于海量的 id 类特征，GBDT 由于树的深度和棵树限制（防止过拟合），不能有效的存储；另外海量特征在也会存在性能瓶颈，当 GBDT 的 one hot 特征大于 10 万维时，就必须做分布式的训练才能保证不爆内存。所以 GBDT 通常配合少量的反馈 CTR 特征来表达，这样虽然具有一定的范化能力，但是同时会有信息损失，对于头部资源不能有效的表达。
所以， 我们发现其实GBDT和LR的优缺点可以进行互补。
四、GBDT+LR模型
2014年， Facebook提出了一种利用GBDT自动进行特征筛选和组合， 进而生成新的离散特征向量， 再把该特征向量当做LR模型的输入， 来产生最后的预测结果， 这就是著名的GBDT+LR模型了。GBDT+LR 使用最广泛的场景是CTR点击率预估，即预测当给用户推送的广告会不会被用户点击（二分类问题）。
有了上面的铺垫， 这个模型解释起来就比较容易了， 模型的总体结构长下面这样：
4.1 训练阶段
训练时，GBDT 建树的过程相当于自动进行的特征组合和离散化，然后从根结点到叶子节点的这条路径就可以看成是不同特征进行的特征组合，用叶子节点可以唯一的表示这条路径，并作为一个离散特征传入 LR 进行二次训练。
比如上图中， 有两棵树，x为一条输入样本，遍历两棵树后，x样本分别落到两颗树的叶子节点上，每个叶子节点对应LR一维特征，那么通过遍历树，就得到了该样本对应的所有LR特征。构造的新特征向量是取值0/1的。 比如左树有三个叶子节点，右树有两个叶子节点，最终的特征即为五维的向量。对于输入x，假设他落在左树第二个节点，编码[0,1,0]，落在右树第二个节点则编码[0,1]，所以整体的编码为[0,1,0,0,1]，这类编码作为特征，输入到线性分类模型（LR or FM）中进行分类。
4.2 预测阶段
预测时，会先走 GBDT 的每棵树，得到某个叶子节点对应的一个离散特征(即一组特征组合)，然后把该特征以 one-hot 形式传入 LR 进行线性加权预测。
4.3 几个关键点
通过GBDT进行特征组合之后得到的离散向量是和训练数据的原特征一块作为逻辑回归的输入， 而不仅仅全是这种离散特征
建树的时候用ensemble建树的原因就是一棵树的表达能力很弱，不足以表达多个有区分性的特征组合，多棵树的表达能力更强一些。GBDT每棵树都在学习前面棵树尚存的不足，迭代多少次就会生成多少棵树。
RF也是多棵树，但从效果上有实践证明不如GBDT。且GBDT前面的树，特征分裂主要体现对多数样本有区分度的特征；后面的树，主要体现的是经过前N颗树，残差仍然较大的少数样本。优先选用在整体上有区分度的特征，再选用针对少数样本有区分度的特征，思路更加合理，这应该也是用GBDT的原因。
在CRT预估中， GBDT一般会建立两类树(非ID特征建一类， ID类特征建一类)， AD，ID类特征在CTR预估中是非常重要的特征，直接将AD，ID作为feature进行建树不可行，故考虑为每个AD，ID建GBDT树。
非ID类树：不以细粒度的ID建树，此类树作为base，即便曝光少的广告、广告主，仍可以通过此类树得到有区分性的特征、特征组合
ID类树：以细粒度 的ID建一类树，用于发现曝光充分的ID对应有区分性的特征、特征组合
五、用于回归时的GBDT
DT－Decision Tree决策树，GB是Gradient Boosting，是一种学习策略，GBDT的含义就是用Gradient Boosting的策略训练出来的DT模型。
模型的结果是一组回归分类树组合(CART Tree Ensemble)： T1,…, Tk 。其中 Tj 学习的是之前 （j - 1） 棵树预测结果的残差。
这种思想就像准备考试前的复习，先做一遍习题册，然后把做错的题目挑出来，在做一次，然后把做错的题目挑出来在做一次，经过反复多轮训练，取得最好的成绩。
5.1 函数空间的优化问题
【练习】当样本i ii计算得到的残差r i = 0 r_i=0r
i
=0时，本例中的函数在w = 0 w=0w=0处不可导，请问当前轮应当如何处理模型输出？
【答】不可做梯度下降，直接取h m ∗ ( X i ) = 0 h_m^{*}(X_i)=0h
m
∗
(X
i
)=0。
根据在零点处的梯度下降可知：
w i ∗ = 0 − ∂ L ∂ w ∣ w = 0 = − 1 2 ∣ r i ∣ s i g n ( r i )
w∗i=0−∂L∂w∣∣∣w=0=−12|ri|−−−√sign(ri)
wi∗=0−∂L∂w|w=0=−12|ri|sign(ri)
5.2 调节学习率环节过拟合
为了缓解模型的过拟合现象，我们需要引入学习率参数η \etaη来控制每轮的学习速度，即获得了由w ∗ \textbf{w}^*w
∗
拟合的第m棵树h ∗ h^*h
∗
后，当前轮的输出结果为
上述的结果与先前的梯度下降结果完全一致，事实上这两种观点在本质上没有任何区别，只是损失函数本身进行了平移，下图展示了它们之间的联系。
GBDT的特征重要性：
在sklearn实现的GBDT中，特征重要性的计算方式与随机森林相同，即利用相对信息增益来度量单棵树上的各特征特征重要性，再通过对所有树产出的重要性得分进行简单平均来作为最终的特征重要性。
六、用于分类时的GBDT
CART树能够同时处理分类问题和回归问题，但是对于多棵CART进行分类任务的集成时，我们并不能将树的预测结果直接进行类别加和。
在GBDT中，我们仍然使用回归树来处理分类问题。
6.1 GBDT拟合的对象和流程
对于K KK分类问题，我们假设得到了K KK个得分F 1 i , . . . , F K i F_{1i},...,F_{Ki}F
1i
,...,F
Ki
来代表样本i ii属于对应类别的相对可能性，那么在进行Softmax归一化后，就能够得到该样本属于这些类别的概率大小。其中，属于类别k的概率即为
【练习】请验证多分类负梯度的结果。
【练习】请验证二分类负梯度的结果。
【练习】设二分类数据集中正样本比例为10 % 10\%10%，请计算模型的初始参数F ( 0 ) F^{(0)}F
(0)
。
6.2 单调约束（Monotonic Constraints）
有时我们会对某个特征或某些特征如何影响模型的输出有先验的知识，例如每天投入在学习的有效时间上越长就越有可能在考试中取得好的成绩，即有效学习时间长度和考试分数是一种单调增的约束关系。许多GBDT的实现（sklearn中的Histogram-Based GBDT、XGBoost和LightGBM）都提供了单调约束的参数选项，有关其在内部的实现原理可以参考本文。
七、作业
7.1 GBDT和梯度下降的联系
GBDT使用梯度提升（Gradient Boosting）作为训练方法，而在逻辑回归或者 神经网络的训练过程中往往采用梯度下降（Gradient Descent）作为训练方法。
两者都是在每一轮迭代中，利用损失函数相对于模型的负梯度方向的信息来对当前模型进行更新：
（1）只不过在梯度下降中，模型是以参数化形式表示，从而模型的更新等价于参数的更新。
（2）在梯度提升中，模型并不需要进行参数化表示，而是直接定义在函数空间中，从而大大扩展了可以使用的模型种类。
7.2 GBDT用于分类问题的算法流程。
7.3 为什么使用集成的决策树？ 为什么使用GBDT构建决策树而不是随机森林？
GBDT是boosting的， 随机森林是Bagging的，回顾task3说的基分类器的错误 = 偏差 + 方差。
Boosting通过逐步聚集基分类器分错的样本，减少集成分类器的偏差；Bagging通过分而治之的策略，通过对训练样本多次采用，综合决策多个训练出来的模型，来减少集成分类器的方差。
7.4 面对高维稀疏类特征的时候(比如ID类特征)， 逻辑回归一般要比GBDT这种非线性模型好， 为什么
逻辑回归的优点：
LR模型形式简单，可解释性好，从特征的权重可以看到不同的特征对最后结果的影响。
训练时便于并行化，在预测时只需要对特征进行线性加权，所以性能比较好，往往适合处理海量id类特征，用id类特征有一个很重要的好处，就是防止信息损失（相对于范化的 CTR 特征），对于头部资源会有更细致的描述
资源占用小,尤其是内存。在实际的工程应用中只需要存储权重比较大的特征及特征对应的权重。
方便输出结果调整。逻辑回归可以很方便的得到最后的分类结果，因为输出的是每个样本的概率分数，我们可以很容易的对这些概率分数进行cutoff，也就是划分阈值(大于某个阈值的是一类，小于某个阈值的是一类)
from sklearn.tree import DecisionTreeRegressor as DT from sklearn.datasets import make_classification from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split import numpy as np class GBDTClassifier: def __init__(self, max_depth=4, n_estimator=1000, lr=0.2): self.max_depth = max_depth self.n_estimator = n_estimator self.lr = lr self.booster = [] self.best_round = None def record_score(self, y_train, y_val, train_predict, val_predict, i): train_predict = np.exp(train_predict) / (1 + np.exp(train_predict)) val_predict = np.exp(val_predict) / (1 + np.exp(val_predict)) auc_val = roc_auc_score(y_val, val_predict) if (i+1)%10==0: auc_train = roc_auc_score(y_train, train_predict) print("第%d轮\t训练集： %.4f\t" "验证集： %.4f"%(i+1, auc_train, auc_val)) return auc_val def fit(self, X, y): X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=0.25, random_state=0) train_predict, val_predict = 0, 0 # 按照二分类比例的初始化公式计算 fit_val = np.log(y_train.mean() / (1 - y_train.mean())) next_fit_val = np.full(X_train.shape[0], fit_val) last_val_score = - np.infty for i in range(self.n_estimator): cur_booster = DT(max_depth=self.max_depth) cur_booster.fit(X_train, next_fit_val) train_predict += cur_booster.predict(X_train) * self.lr val_predict += cur_booster.predict(X_val) * self.lr next_fit_val = y_train - np.exp( train_predict) / (1 + np.exp(train_predict)) self.booster.append(cur_booster) cur_val_score = self.record_score( y_train, y_val, train_predict, val_predict, i) if cur_val_score < last_val_score: self.best_round = i print("\n训练结束！最佳轮数为%d"%(i+1)) break last_val_score = cur_val_score def predict(self, X): cur_predict = 0 for i in range(self.best_round): cur_predict += self.lr * self.booster[i].predict(X) return np.exp(cur_predict) / (1 + np.exp(cur_predict)) if __name__ == "__main__": X, y = make_classification( n_samples=10000, n_features=50, n_informative=20, random_state=1) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=0) model = GBDTClassifier() model.fit(X_train, y_train) prediction = model.predict(X_test) auc = roc_auc_score(y_test, prediction) print("\n测试集的AUC为 %.4f"%(auc))
得到的结果为：
第10轮 训练集： 0.9269 验证集： 0.8911 第20轮 训练集： 0.9474 验证集： 0.9129 第30轮 训练集： 0.9578 验证集： 0.9238 第40轮 训练集： 0.9645 验证集： 0.9322 第50轮 训练集： 0.9699 验证集： 0.9383 第60轮 训练集： 0.9744 验证集： 0.9443 第70轮 训练集： 0.9776 验证集： 0.9480 第80轮 训练集： 0.9801 验证集： 0.9517 第90轮 训练集： 0.9820 验证集： 0.9539 第100轮 训练集： 0.9840 验证集： 0.9568 第110轮 训练集： 0.9854 验证集： 0.9584 第120轮 训练集： 0.9868 验证集： 0.9598 训练结束！最佳轮数为121 测试集的AUC为 0.9634
7.6 实现GBDT的回归树
from sklearn.tree import DecisionTreeRegressor as DT from sklearn.datasets import make_regression from sklearn.metrics import mean_absolute_error from sklearn.model_selection import train_test_split import numpy as np class GBDTRegressor: def __init__(self, max_depth=4, n_estimator=1000, lr=0.2): self.max_depth = max_depth self.n_estimator = n_estimator self.lr = lr self.booster = [] self.best_round = None def record_score(self, y_train, y_val, train_predict, val_predict, i): mse_val = mean_absolute_error(y_val, val_predict) if (i+1)%10==0: mse_train = mean_absolute_error(y_train, train_predict) print("第%d轮\t训练集： %.4f\t" "验证集： %.4f"%(i+1, mse_train, mse_val)) return mse_val def fit(self, X, y): # 在数据集中划分训练集和验证集 X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=0.25, random_state=0) train_predict, val_predict = 0, 0 next_fit_val = np.full(X_train.shape[0], np.median(y_train)) # 为early_stop做记录准备 last_val_score = np.infty for i in range(self.n_estimator): cur_booster = DT(max_depth=self.max_depth) cur_booster.fit(X_train, next_fit_val) train_predict += cur_booster.predict(X_train) * self.lr val_predict += cur_booster.predict(X_val) * self.lr # 平方损失为((y - (F_{m-1} + w)^2)/2，若记残差为r # 即为((r - w)^2)/2，此时关于w在0点处的负梯度求得恰好为r # 因此拟合的值就是y_train - train_predict next_fit_val = y_train - train_predict self.booster.append(cur_booster) cur_val_score = self.record_score( y_train, y_val, train_predict, val_predict, i) if cur_val_score > last_val_score: self.best_round = i print("\n训练结束！最佳轮数为%d"%(i+1)) break last_val_score = cur_val_score def predict(self, X): cur_predict = 0 # 在最佳验证集得分的轮数停止，防止过拟合 for i in range(self.best_round): cur_predict += self.lr * self.booster[i].predict(X) return cur_predict if __name__ == "__main__": X, y = make_regression( n_samples=10000, n_features=50, n_informative=20, random_state=1) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=0) model = GBDTRegressor() model.fit(X_train, y_train) prediction = model.predict(X_test) mse = mean_absolute_error(y_test, prediction) print("\n测试集的MSE为 %.4f"%(mse))
得到的结果为：
第10轮 训练集： 125.5180 验证集： 134.8806 第20轮 训练集： 89.8797 验证集： 104.4727 第30轮 训练集： 68.7123 验证集： 87.0258 第40轮 训练集： 54.8424 验证集： 75.9678 第50轮 训练集： 45.2828 验证集： 68.2107 第60轮 训练集： 38.8341 验证集： 62.9527 第70轮 训练集： 34.1962 验证集： 58.9250 第80轮 训练集： 30.8356 验证集： 56.0184 第90轮 训练集： 28.4778 验证集： 54.0267 第100轮 训练集： 26.7017 验证集： 52.5821 第110轮 训练集： 25.0525 验证集： 51.2764 第120轮 训练集： 23.8643 验证集： 50.3764 第130轮 训练集： 22.9112 验证集： 49.5915 第140轮 训练集： 22.0003 验证集： 49.0042 训练结束！最佳轮数为144 测试集的MSE为 51.1359
7.7 GBDT的优缺点
（1）优点
（1）预测阶段的计算速度快，树与树之间可并行化计算。
（2）在分布稠密的数据集上，泛化能力和表达能力都很好。
（3）采用决策树作为弱分类器使得GBDT模型具有较好的解释性和鲁棒性， 能够自动发现特征间的高阶关系，并且也不需要对数据进行特殊的预处理如归一化等。
（2）缺点
（1）GBDT在高维稀疏的数据集上，表现不如支持向量机或者神经网络。
（2）GBDT在处理文本分类特征问题上，相对其他模型的优势不如它在处理 数值特征时明显。
（3）训练过程需要串行训练，只能在决策树内部采用一些局部并行的手段提 高训练速度。
7.8 GBDT多分类
from sklearn.tree import DecisionTreeRegressor as DT from sklearn.datasets import make_classification from sklearn.metrics import roc_auc_score from sklearn.model_selection import train_test_split import numpy as np def one_hot(y): res = np.zeros((y.size, y.max()+1)) res[np.arange(y.size), y] = 1 return res class GBDTMultiClassifier: def __init__(self, max_depth=4, n_estimator=1000, lr=0.2): self.max_depth = max_depth self.n_estimator = n_estimator self.lr = lr self.booster = [] self.n_classes = None self.best_round = None def get_init_val(self, y): init_val = [] y = np.argmax(y, axis=1) for c in range(self.n_classes): init_val.append(np.log((y==c).mean())) return np.full((y.shape[0], self.n_classes), init_val) def record_score(self, y_train, y_val, train_predict, val_predict, i): train_predict = np.exp(train_predict) / np.exp( train_predict).sum(1).reshape(-1, 1) val_predict = np.exp(val_predict) / np.exp( val_predict).sum(1).reshape(-1, 1) auc_val = roc_auc_score(y_val, val_predict) if (i+1)%10==0: auc_train = roc_auc_score(y_train, train_predict) print("第%d轮\t训练集： %.4f\t" "验证集： %.4f"%(i+1, auc_train, auc_val)) return auc_val def fit(self, X, y): X_train, X_val, y_train, y_val = train_test_split( X, y, test_size=0.25, random_state=0) self.n_classes = y.shape[1] train_predict = np.zeros((X_train.shape[0], self.n_classes)) val_predict = np.zeros((X_val.shape[0], self.n_classes)) next_fit_val = self.get_init_val(y_train) last_val_score = - np.infty for i in range(self.n_estimator): last_train = train_predict.copy() self.booster.append([]) for m in range(self.n_classes): cur_booster = DT(max_depth=self.max_depth) cur_booster.fit(X_train, next_fit_val[:, m]) train_predict[:, m] += cur_booster.predict(X_train) * self.lr val_predict[:, m] += cur_booster.predict(X_val) * self.lr next_fit_val[:, m] = y_train[:, m] - np.exp( last_train[:, m]) / np.exp(last_train).sum(1) self.booster[-1].append(cur_booster) cur_val_score = self.record_score( y_train, y_val, train_predict, val_predict, i) if cur_val_score < last_val_score: self.best_round = i print("\n训练结束！最佳轮数为%d"%(i+1)) break last_val_score = cur_val_score def predict(self, X): cur_predict = np.zeros((X.shape[0], self.n_classes)) for i in range(self.best_round): for m in range(self.n_classes): cur_predict[:, m] += self.lr * self.booster[i][m].predict(X) return np.exp(cur_predict) / np.exp(cur_predict).sum(1).reshape(-1, 1) if __name__ == "__main__": X, y = make_classification( n_samples=10000, n_features=50, n_informative=20, n_classes=3, random_state=1) y = one_hot(y) X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.25, random_state=0) model = GBDTMultiClassifier() model.fit(X_train, y_train) prediction = model.predict(X_test) auc = roc_auc_score(y_test, prediction) print("\n测试集的AUC为 %.4f"%(auc))
