GBDT+LR算法入门理解

CTR估计也就是广告点击率预估，计算广告训练与平滑思想说明了是用LR算法对于预测的有效性。LR（Logistic Regression）是广义线性模型，与传统线性模型相比，LR通过Logit变换将函数值映射到0~1区间，映射后的函数就是CTR的预估值。LR模型十分适合并行化，因此对于大数据的训练十分有效。但是对于线性模型而言，学习能力是有限的，因此需要大量的特征工程预先分析出有效的特征或者是特征组合，从而去间接的增强LR的非线性学习能力。

特征组合，是通过特征的一些线性叠加或者非线性叠加得到一个新的特征，可以有效的提高分类效果。常见的特征组合方式有笛卡尔积方式。为了降低人工组合特征的工作量，FaceBook提出了一个自动特征提取的方式GBDT+LR。

最近在看 GBDT + LR 相关知识，从facebook发表的一篇论文（https://pdfs.semanticscholar.org/daf9/ed5dc6c6bad5367d7fd8561527da30e9b8dd.pdf）开始的。大意就是利用gdbt模型的叶子节点作为lr模型的输入，起到了自动组合特征，简化lr特征工程的作用（如下图）。

GBDT是梯度提升决策树，首先会构造一个决策树，首先在已有的模型和实际样本输出的残差上再构造一颗决策树，不断地进行迭代。每一次迭代都会产生一个增益较大的分类特征，因此GBDT树有多少个叶子节点，得到的特征空间就有多大，并将该特征作为LR模型的输入。

核心问题
（1）建树采用ensemble决策树？
一棵树的区分性是具有一定的限制的，但是多棵树可以获取多个具有区分度的特征组合，而且GBDT的每一棵树都会学习前面的树的不足。

（2）建树算法为什么采用GBDT而不是RF?
对于GBDT而言，前面的树，特征分裂主要体现在对多数样本的具有区分度的特征；后面的树，主要体现的是经过前面n棵树，残差依然比较大的少数样本。优先选用在整体上具有区分度的特征，再选用针对少数样本有区分度的特征。

 

#!/usr/bin python
#-*- coding:utf-8 -*-
 
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import (RandomTreesEmbedding, RandomForestClassifier,
                              GradientBoostingClassifier)
from sklearn.preprocessing import OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_curve, roc_auc_score
from sklearn.pipeline import make_pipeline
import xgboost as xgb
from xgboost.sklearn import XGBClassifier
 
np.random.seed(10)
n_estimator = 10
 
X, y = make_classification(n_samples=80000)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)
#To avoid overfitting
X_train, X_train_lr, y_train, y_train_lr = train_test_split(X_train, y_train, test_size=0.5)
 
def RandomForestLR():
	rf = RandomForestClassifier(max_depth=3, n_estimators=n_estimator)
	rf_enc = OneHotEncoder()
	rf_lr = LogisticRegression()
	rf.fit(X_train, y_train)
	rf_enc.fit(rf.apply(X_train))
	rf_lr.fit(rf_enc.transform(rf.apply(X_train_lr)), y_train_lr)
	y_pred_rf_lr = rf_lr.predict_proba(rf_enc.transform(rf.apply(X_test)))[:, 1]
	fpr_rf_lr, tpr_rf_lr, _ = roc_curve(y_test, y_pred_rf_lr)
	auc = roc_auc_score(y_test, y_pred_rf_lr)
	print("RF+LR:", auc)
	return fpr_rf_lr, tpr_rf_lr
 
def GdbtLR():
	grd = GradientBoostingClassifier(n_estimators=n_estimator)
	grd_enc = OneHotEncoder()
	grd_lr = LogisticRegression()
	grd.fit(X_train, y_train)
	grd_enc.fit(grd.apply(X_train)[:, :, 0])
	grd_lr.fit(grd_enc.transform(grd.apply(X_train_lr)[:, :, 0]), y_train_lr)
	y_pred_grd_lr = grd_lr.predict_proba(grd_enc.transform(grd.apply(X_test)[:, :, 0]))[:, 1]
	fpr_grd_lr, tpr_grd_lr, _ = roc_curve(y_test, y_pred_grd_lr)
	auc = roc_auc_score(y_test, y_pred_grd_lr) 
	print("GDBT+LR:", auc)
	return fpr_grd_lr, tpr_grd_lr
 
def Xgboost():
	xgboost = xgb.XGBClassifier(nthread=4, learning_rate=0.08,\
			n_estimators=50, max_depth=5, gamma=0, subsample=0.9, colsample_bytree=0.5)
	xgboost.fit(X_train, y_train)
	y_xgboost_test = xgboost.predict_proba(X_test)[:, 1]
	fpr_xgboost, tpr_xgboost, _ = roc_curve(y_test, y_xgboost_test)
	auc = roc_auc_score(y_test, y_xgboost_test)
	print("Xgboost:", auc)
	return fpr_xgboost, tpr_xgboost
 
def Lr():
	lm = LogisticRegression(n_jobs=4, C=0.1, penalty='l1')
	lm.fit(X_train, y_train)
	y_lr_test = lm.predict_proba(X_test)[:, 1]
	fpr_lr, tpr_lr, _ = roc_curve(y_test, y_lr_test)
	auc = roc_auc_score(y_test, y_lr_test)
	print("LR:", auc)
	return fpr_lr, tpr_lr
 
def XgboostLr():
	xgboost = xgb.XGBClassifier(nthread=4, learning_rate=0.08,\
	                            n_estimators=50, max_depth=5, gamma=0, subsample=0.9, colsample_bytree=0.5)
	xgb_enc = OneHotEncoder()
	xgb_lr = LogisticRegression(n_jobs=4, C=0.1, penalty='l1')
	xgboost.fit(X_train, y_train)
 
	xgb_enc.fit(xgboost.apply(X_train)[:, :])
	xgb_lr.fit(xgb_enc.transform(xgboost.apply(X_train_lr)[:, :]), y_train_lr)
	y_xgb_lr_test = xgb_lr.predict_proba(xgb_enc.transform(xgboost.apply(X_test)[:,:]))[:, 1]
	fpr_xgb_lr, tpr_xgb_lr, _ = roc_curve(y_test, y_xgb_lr_test)
	auc = roc_auc_score(y_test, y_xgb_lr_test)
	print("Xgboost + LR:", auc)
	return fpr_xgb_lr, tpr_xgb_lr
 
if __name__ == '__main__':
	fpr_rf_lr, tpr_rf_lr = RandomForestLR()
	fpr_grd_lr, tpr_grd_lr = GdbtLR()
	fpr_xgboost, tpr_xgboost = Xgboost()
	fpr_lr, tpr_lr = Lr()
	fpr_xgb_lr, tpr_xgb_lr = XgboostLr()
 
	plt.figure(1)
	plt.plot([0, 1], [0, 1], 'k--')
	plt.plot(fpr_rf_lr, tpr_rf_lr, label='RF + LR')
	plt.plot(fpr_grd_lr, tpr_grd_lr, label='GBT + LR')
	plt.plot(fpr_xgboost, tpr_xgboost, label='XGB')
	plt.plot(fpr_lr, tpr_lr, label='LR')
	plt.plot(fpr_xgb_lr, tpr_xgb_lr, label='XGB + LR')
	plt.xlabel('False positive rate')
	plt.ylabel('True positive rate')
	plt.title('ROC curve')
	plt.legend(loc='best')
	plt.show()
 
	plt.figure(2)
	plt.xlim(0, 0.2)
	plt.ylim(0.8, 1)
	plt.plot([0, 1], [0, 1], 'k--')
	plt.plot(fpr_rf_lr, tpr_rf_lr, label='RF + LR')
	plt.plot(fpr_grd_lr, tpr_grd_lr, label='GBT + LR')
	plt.plot(fpr_xgboost, tpr_xgboost, label='XGB')
	plt.plot(fpr_lr, tpr_lr, label='LR')
	plt.plot(fpr_xgb_lr, tpr_xgb_lr, label='XGB + LR')
	plt.xlabel('False positive rate')
	plt.ylabel('True positive rate')
	plt.title('ROC curve (zoomed in at top left)')
	plt.legend(loc='best')
	plt.show()

参考：

1、GBDT+LR算法进行特征扩增https://blog.csdn.net/twt520ly/article/details/79769705

2、xgboost/gdbt/randomforest + lr入门实践https://blog.csdn.net/asdfghjkl1993/article/details/78606268

3、CTR预估中GBDT与LR融合方案https://blog.csdn.net/lilyth_lilyth/article/details/48032119

4、Feature transformations with ensembles of trees