最近读了一篇GBDT+LR实现推荐系统的文章，准备实践一下，但是所有讲这种方式的文章都没有放数据集，所以我从头开始整理了一遍思路，并且找了Kaggle上一个比赛的数据集进行实现。

1 背景

CTR预估是工业界十分常见的一个问题，Click Through Rate指的是推送给某个顾客的商品是否会被点击，推送给顾客会最大概率被点击的商品无疑会提高盈利能力。
在CTR预估问题的发展初期，使用最多的方法就是逻辑回归(LR)，LR使用了Sigmoid变换将函数值映射到0~1区间，映射后的函数值就是CTR的预估值。
LR属于线性模型，容易并行化，可以轻松处理上亿条数据，但是学习能力十分有限，需要大量的特征工程来增加模型的学习能力。但大量的特征工程耗时耗力同时并不一定会带来效果提升。因此，如何自动发现有效的特征、特征组合，弥补人工经验不足，缩短LR特征实验周期，是亟需解决的问题。

Facebook 2014年的文章介绍了通过GBDT解决LR的特征组合问题，随后Kaggle竞赛也有实践此思路，GBDT与LR融合开始引起了业界关注。
在介绍这个模型之前，我们先来介绍两个问题：
1）为什么要使用集成的决策树模型，而不是单棵的决策树模型：一棵树的表达能力很弱，不足以表达多个有区分性的特征组合，多棵树的表达能力更强一些。可以更好的发现有效的特征和特征组合
2）为什么建树采用GBDT而非RF：RF也是多棵树，但从效果上有实践证明不如GBDT。且GBDT前面的树，特征分裂主要体现对多数样本有区分度的特征；后面的树，主要体现的是经过前N颗树，残差仍然较大的少数样本。优先选用在整体上有区分度的特征，再选用针对少数样本有区分度的特征，思路更加合理，这应该也是用GBDT的原因。

2 GBDT + LR

这两种方法的融合主要流程如下图所示

GBDT + LR

对于输入的样本，他的特征是向量 x ，用GBDT的方法构造两颗树，第 1 棵树有3个叶子节点，第二棵树有两个叶子节点。
假设x 进入第1棵树落入3个叶子节点中的第1个叶子，进入第2棵树落入2个叶子节点的第2个叶子，在这里我们构造新的特征。第1棵树有3个叶子，构造一个向量U1=[0, 0 ,0]，样本x落到第1个叶子，把向量U1的第一个位置变为1，其余位置仍然是0，即U1=[1, 0, 0]。第2棵树有2个叶子，构造向量U2=[0, 0]，样本x落到第2个叶子，把第二个位置的值变为1，即U2=[1, 0]。接下来把 U1 和 U2 串联起来变为 [1, 0, 0, 1, 0]。这样就得到了转化后的特征向量。
接下来就是将转化后的特征向量用LR训练。

3 实践

在这里用的是 lightgbm 这个包，安装也很方便，打开conda命令行，conda install lightgbm。
所有要导入的包如下

import lightgbm as lgb
import numpy as np
import pandas as pd
from sklearn import preprocessing
from sklearn.linear_model import LogisticRegression

3.1 数据集

这里用到的数据集是kaggle:avazu-ctr-prediction，训练集下载下来大概有1.2GB，解压后6GB，因为电脑内存不够后面训练的过程中出现MemoryError，所以我切分了1w条数据，下载链接小数据集提取码：6gr9 实现时选择前8k作为训练集，后2k为测试集。

数据集字段：

id: ad identifier
click: 0/1 for non-click/click
hour: format is YYMMDDHH, so 14091123 means 23:00 on Sept. 11, 2014 UTC.
C1 -- anonymized categorical variable
banner_pos
site_id
site_domain
site_category
app_id
app_domain
app_category
device_id
device_ip
device_model
device_type
device_conn_type
C14-C21 -- anonymized categorical variables

因为本文只是做一个demo，所以不进行特征工程，只选择部分属性

cols = ['C1', 'banner_pos',  'site_domain',  .....'app_id', 'C14','C15', 'C16']

读取数据集

df_train = pd.read_csv(r"D:\Kaggle_CTR\train.csv")
cols = ['C1','banner_pos', 'site_domain',  'site_id', 'site_category','app_id', 'app_category',  'device_type',  'device_conn_type', 'C14', 'C15','C16']

cols_all = ['id']
cols_all.extend(cols)
#print(df_train.head(10))

y = df['click']  
y_train = y.iloc[:-2000] # training label
y_test = y.iloc[-2000:]  # testing label

X = df[cols_all[1:]]  # training dataset

pandas读取的‘site_id'等是object对象，需要将其转化为字符串，进而用LabelEncoder转化为类别。

# label encode
lbl = preprocessing.LabelEncoder()
X['site_domain'] = lbl.fit_transform(X['site_domain'].astype(str))#将提示的包含错误数据类型这一列进行转换
X['site_id'] = lbl.fit_transform(X['site_id'].astype(str))
X['site_category'] = lbl.fit_transform(X['site_category'].astype(str))
X['app_id'] = lbl.fit_transform(X['app_id'].astype(str))
X['app_category'] = lbl.fit_transform(X['app_category'].astype(str))

X_train = X.iloc[:-2000]
X_test = X.iloc[-2000:]  # testing dataset

3.2 训练LGB

使用lgb时要先将数据集转化为lgb的数据集，指定好参数后再进行训练。

# create dataset for lightgbm
lgb_train = lgb.Dataset(X_train, y_train)
lgb_eval = lgb.Dataset(X_test, y_test, reference=lgb_train)

params = {
    'task': 'train',
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': {'binary_logloss'},
    'num_leaves': 64,
    'num_trees': 100,
    'learning_rate': 0.01,
    'feature_fraction': 0.9,
    'bagging_fraction': 0.8,
    'bagging_freq': 5,
    'verbose': 0
}

# number of leaves,will be used in feature transformation
num_leaf = 64

print('Start training...')
# train
gbm = lgb.train(params,
                lgb_train,
                num_boost_round=100,
                valid_sets=lgb_train)

训练100轮的结果是[100] training's binary_logloss: 0.408675。

3.3 用lgb转化特征向量

用训练好的lgb模型预测训练集，观察其落在哪些叶子节点上。

y_pred_train = gbm.predict(X_train, pred_leaf=True)

观察y_pred_train的形状

In[181]:  y_pred_train.shape
Out[181]: (8000, 100)

共有8000个样本，100棵树（在上面的参数中 num_trees=100),观察第 1 个样本y_pred_train[0]的前10个值：

In[182]:  y_pred_train[0][:10]
Out[182]: array([31, 29, 29, 32, 38, 46, 35, 36, 36, 42])

其中第一个数 31 表示这个样本落到了第一颗树的 31 叶子节点，29 表示落到了第二棵树的 29 叶子节点，注意31 、29表示节点编号，从0开始到63。

将叶子节点编号转化为OneHot编码

# train data
transformed_training_matrix = np.zeros([len(y_pred_train), len(y_pred_train[0]) * num_leaf],dtype=np.int64)  # N * num_tress * num_leafs
for i in range(0, len(y_pred_train)):
    temp = np.arange(len(y_pred_train[0])) * num_leaf + np.array(y_pred_train[i])
    transformed_training_matrix[i][temp] += 1

# test data
transformed_testing_matrix = np.zeros([len(y_pred_test), len(y_pred_test[0]) * num_leaf], dtype=np.int64)
for i in range(0, len(y_pred_test)):
    temp = np.arange(len(y_pred_test[0])) * num_leaf + np.array(y_pred_test[i])
    transformed_testing_matrix[i][temp] += 1

3.4 LR

lm = LogisticRegression(penalty='l2',C=0.05)
lm.fit(transformed_training_matrix,y_train) 
y_pred_lr_test = lm.predict_proba(transformed_testing_matrix)

3.5 结果评估

在Kaggle指明的评价指标是NE(Normalized Cross-Entropy)

NE公式

NE = (-1) / len(y_pred_lr_test) * sum(((1+y_test)/2 * np.log(y_pred_lr_test[:,1]) +  (1-y_test)/2 * np.log(1 - y_pred_lr_test[:,1])))
print("Normalized Cross Entropy " + str(NE))

在我这里计算出来的的NE结果是1.27958508822，这其实是一个很差的结果，在比赛上想取得好成绩最重要的就是特征工程，即组合原始特征、计算新特征等工作，特征工程决定算法结果的上界。

4 总结

GBDT+LR只是对历史的记忆，并不是真正适合现在的大多数业务数据，现在的业务数据是大量离散特征导致的高维度离散数据。而树模型对这样的离散特征，是不能很好处理的，因为这容易导致过拟合。

代码下载：链接提取码：1nh2
写作本文是为了整理GBDT+LR的思路和工程实现，主要工作都是来自 石晓文的学习日记，在他的博客里有很多推荐系统不同实现方式的文章。
参考资料：推荐系统遇上深度学习(十)--GBDT+LR融合方案实战

GBDT+LR CTR预估-Kaggle实例[有数据集]