排序层-传统模型-2014：GBDT+LR模型【“首次”实现特征工程自动化，实现端到端训练】【①用GBDT构建特征工程；②利用LR预估CTR；这2步骤是独立训练的】

深碍√TFBOYSˉ_ 2023-10-02 13:31 12阅读 0赞

[《原始论文：Practical Lessons from Predicting Clicks on Ads at Facebook》][Practical Lessons from Predicting Clicks on Ads at Facebook]

## 一、概述 ##

FFM模型采用引入特征域的方式增强了模型的特征交叉能力，但无论如何, FFM只能做二阶的特征交叉，如果继续提高特征交叉的维度，会不可避免地产生 组合爆炸和计算复杂度过高的问题。那么，有没有其他方法可以有效地处理高维 特征组合和筛选的问题呢？ 2014年，Facebook提出了基于GBDT+LR组合模型 的解决方案。

GBDT+LR 使用最广泛的场景是CTR点击率预估，即预测当给用户推送的广告会不会被用户点击。

协同过滤和矩阵分解存在的劣势就是仅利用了用户与物品相互行为信息进行推荐，忽视了用户自身特征，物品自身特征以及上下文信息等，导致生成的结果往往会比较片面。

而GBDT+LR模型是2014年由Facebook提出的，该模型利用GBDT自动进行特征筛选和组合，进而生成新的离散特征向量，再把该特征向量当做LR模型的输入，来产生最后的预测结果，该模型能够综合利用用户、物品和上下文等多种不同的特征，生成较为全面的推荐结果，在CTR点击率预估场景下使用较为广泛。

简而言之，Facebook提出了一种利用GBDT自动进行特征筛选和组合，进而生成新的离散特征向量，再把该特征向量当作LR模型输入，预估CTR的模型结 构。  
![在这里插入图片描述][7d3a1bdba84c4270b3e16ea0eef3d23b.png_pic_center]  
需要强调的是以下两步骤是独立训练的，所以不存在如何将LR的梯度回传到GBDT这类复杂的问题。：

*  用GBDT构建特征工程；
 *  利用LR预估CTR；

## 二、GBDT模型 ##

### 1、什么是GBDT模型 ###

集成学习是一种协同多个“个体学习器”完成任务的学习方法，其原理是使用某种方式将多个学习器进行集成，以此获得比单一学习器更优越的泛化性能。梯度提升决策树(Gradient Boosting Decison Tree,GBDT) 由Friedman于1999年提出，是一种Boost类集成学习算法。其核心思想是通过多轮迭代产生多个弱分类器,在每一次迭代后计算损失函数的负梯度，将其作为残差的近似值。在GBDT分类模型中，一般使用CART回归树作为基学习器，每个分类器的训练都是基于上一轮分类器预测结果的残差，以串行的方式向残差减小的方向进行梯度迭代，最后将每个弱分类器得到的结果进行加权求和得到最终的分类器。

GBDT全称梯度提升决策树，在传统机器学习算法里面是对真实分布拟合的最好的几种算法之一，在前几年深度学习还没有大行其道之前，GBDT在各种竞赛是大放异彩。原因大概有几个，一是效果确实挺不错，二是即可以用于分类也可以用于回归，三是可以筛选特征， 所以这个模型依然是一个非常重要的模型。

GBDT是通过采用加法模型(即基函数的线性组合），以及不断减小训练过程产生的误差来达到将数据分类或者回归的算法， 其训练过程如下：  
![在这里插入图片描述][ab2fa3a932e54c2ebab0be2cdc587e16.png_pic_center]  
![在这里插入图片描述][0708a5b99ec94c128b20f03ea2f46970.png_pic_center]  
GBDT是由多棵回归树组成的树林，后一棵树以前面树林的结果与真实结果 的残差为拟合目标。每棵树生成的过程是一棵标准的回归树生成过程，

因此回归 树中每个节点的分裂是一个自然的特征选择的过程，而多层节点的结构则对特征 进行了有效的自动组合，也就非常高效地解决了过去棘手的特征选择和特征组合 的问题。

### 2、GBDT进行特征转换的过程 ###

利用训练集训练好GBDT模型之后,就可以利用该模型完成从原始特征向量 到新的离散型特征向量的转化。具体过程如下。

一个训练样本在输入GBDT的某一子树后，会根据每个节点的规则最终落入 某一叶子节点，把该叶子节点置为1 ,其他叶子节点置为0 , 所有叶子节点组成 的向量即形成了该棵树的特征向量，把 GBDT所有子树的特征向量连接起来，即 形成了后续LR模型输入的离散型特征向量。

举例来说，如图2-17所示，GBDT由三棵子树构成，每棵子树有4 个叶子 节点，输入一个训练样本后，其先后落入“子树1” 的第3 个叶节点中，那么特 征向量就是［0,0,1,0］ , “子树2” 的 箪 1个叶节点，特征向量为［1,0,0,0］ , “子树3” 的第4 个叶节点，特征向量为［0,0,0,1］ , 最后连接所有特征向量，形成最终的特 征向量［0,0,1,0,1,0,0,0,0,0,0,1］ 。

![在这里插入图片描述][c0d648b71c69423c9de4f2add9f20391.png_pic_center]  
事实上，决策树的深度决定了特征交叉的阶数。如果决策树的深度为4 , 则 通过3 次节点分裂，最终的叶节点实际上是进行三阶特征组合后的结果，如此强 的特征组合能力显然是FM系的模型不具备的。

但 GBDT容易产生过拟合，以及 GBDT的特征转换方式实际上丢失了大量特征的数值信息，因此不能简单地说 GBDT的特征交叉能力强，效果就比FFM好，在模型的选择和调试上，永远都 是多种因素综合作用的结果。

## 二、LR模型 ##

逻辑回归算法(Logistics Regression,LR) 是一种基于回归分析的分类算法。LR算法与线性回归算法非常相似，然而线性回归能够处理的是数值问题，而LR算法则是使用sigmoid函数将线性回归的分析结果转换为概率值。LR算法是最简单和最快速的分类模型之一，在具有线性分离边界的数据集上表现良好，其表达式为  
![在这里插入图片描述][bf4f1054769d4a538861e58960b4314d.png_pic_center]  
逻辑回归模型非常重要，在推荐领域里面，相比于传统的协同过滤，逻辑回归模型能够综合利用用户、物品、上下文等多种不同的特征生成较为“全面”的推荐结果，关于逻辑回归的更多细节，可以参考下面给出的链接，这里只介绍比较重要的一些细节和在推荐中的应用。

逻辑回归是在线性回归的基础上加了一个 Sigmoid 函数（非线形）映射，使得逻辑回归成为了一个优秀的分类算法， 学习逻辑回归模型，首先应该记住一句话：逻辑回归假设数据服从伯努利分布,通过极大化似然函数的方法，运用梯度下降来求解参数，来达到将数据二分类的目的。

相比于协同过滤和矩阵分解利用用户的物品“相似度”进行推荐， 逻辑回归模型将问题看成了一个分类问题，通过预测正样本的概率对物品进行排序。这里的正样本可以是用户“点击”了某个商品或者“观看”了某个视频，均是推荐系统希望用户产生的“正反馈”行为， 因此逻辑回归模型将推荐问题转化成了一个点击率预估问题。而点击率预测就是一个典型的二分类， 正好适合逻辑回归进行处理，那么逻辑回归是如何做推荐的呢？

过程如下：

1.  将用户年龄、性别、物品属性、物品描述、当前时间、当前地点等特征转成数值型向量
2.  确定逻辑回归的优化目标，比如把点击率预测转换成二分类问题， 这样就可以得到分类问题常用的损失作为目标，训练模型
3.  在预测的时候，将特征向量输入模型产生预测， 得到用户“点击”物品的概率
4.  利用点击概率对候选物品排序，得到推荐列表

推断过程可以用下图来表示：  
![在这里插入图片描述][4731aabf2d9a493499df305287631755.png_pic_center]

优点：

1.  LR模型形式简单，可解释性好，从特征的权重可以看到不同的特征对最后结果的影响。
2.  训练时便于并行化，在预测时只需要对特征进行线性加权，所以性能比较好，往往适合处理海量id类特征，用id类特征有一个很重要的好处，就是防止信息损失（相对于范化的 CTR 特征），对于头部资源会有更细致的描述
3.  资源占用小,尤其是内存。在实际的工程应用中只需要存储权重比较大的特征及特征对应的权重。
4.  方便输出结果调整。逻辑回归可以很方便的得到最后的分类结果，因为输出的是每个样本的概率分数，我们可以很容易的对这些概率分数进行cutoff，也就是划分阈值(大于某个阈值的是一类，小于某个阈值的是一类)

当然， 逻辑回归模型也有一定的局限性：

1.  表达能力不强， 无法进行特征交叉， 特征筛选等一系列“高级“操作（这些工作都得人工来干， 这样就需要一定的经验， 否则会走一些弯路）， 因此可能造成信息的损失
2.  准确率并不是很高。因为这毕竟是一个线性模型加了个sigmoid， 形式非常的简单(非常类似线性模型)，很难去拟合数据的真实分布
3.  处理非线性数据较麻烦。逻辑回归在不引入其他方法的情况下，只能处理线性可分的数据， 如果想处理非线性， 首先对连续特征的处理需要先进行离散化（离散化的目的是为了引入非线性），如上文所说，人工分桶的方式会引入多种问题。
4.  LR 需要进行人工特征组合，这就需要开发者有非常丰富的领域经验，才能不走弯路。这样的模型迁移起来比较困难，换一个领域又需要重新进行大量的特征工程。

所以如何自动发现有效的特征、特征组合，弥补人工经验不足，缩短LR特征实验周期，是亟需解决的问题， 而GBDT模型， 正好可以自动发现特征并进行有效组合

所以， 我们发现其实GBDT和LR的优缺点可以进行互补。

## 三、GBDT+LR模型 ##

LR算法属于线性模型，模型简单，计算开销小且易并行化，能够处理海量的数据，但缺点是只在具有良好线性关系的数据集上有效，其学习能力有限，对特征选取要求高，容易造成欠拟合。因此，需要有效的特征工程来生成有区分度的特征，从而产生良好的分类效果。早在2014年He等就提出了通过GBDT模型生产新特征来解决LR的特征工程问题，将其应用于广告点击率的评估。GBDT算法以Boost算法为基础，每次迭代都会生成一棵新树，该特点正好可以用来挖掘有区分度的新特征，避免复杂的人工成本。

GBDT+LR 使用最广泛的场景是**CTR点击率预估，即预测当给用户推送的广告会不会被用户点击**。

GBDT-LR融合模型的训练过程如图所示，其具体步骤如下:

1.  利用原始训练集训练GBDT模型构造—系列的决策树，组成一个强分类器。
2.  利用训练好的GBDT模型对原始数据进行预测时，不以分类概率作为输出，而是以模型中每棵树的预测值所属叶结点的位置为新特征提取特征值，形成新的数据。
3.  对新数据进行One-hot编码，也就是将样本输出所属叶结点的位置标记为1，得到每个样本的位置标记向量W。所有样本的输出会组成一个标记每棵决策树输出的叶结点位置的稀疏矩阵。
4.  将该W作为新的训练数据供LR模型进行训练。

GBDT-LR模型训练示意图：  
![在这里插入图片描述][5488027c9e45430a9d0d88e6af994dc7.png_pic_center]  
有了上面的铺垫， 这个模型解释起来就比较容易了， 模型的总体结构长下面这样：  
![在这里插入图片描述][dbb1ff6dcc964273a661d0f6d2324d52.png_pic_center]  
训练时，GBDT 建树的过程相当于自动进行的特征组合和离散化，然后从根结点到叶子节点的这条路径就可以看成是不同特征进行的特征组合，用叶子节点可以唯一的表示这条路径，并作为一个离散特征传入 LR 进行二次训练。

比如上图中， 有两棵树， x x x 为一条输入样本，遍历两棵树后， x x x 样本分别落到两颗树的叶子节点上，每个叶子节点对应LR一维特征，那么通过遍历树，就得到了该样本对应的所有LR特征。构造的新特征向量是取值0/1的。 比如左树有三个叶子节点，右树有两个叶子节点，最终的特征即为五维的向量。对于输入x，假设他落在左树第二个节点，编码\[0,1,0\]，落在右树第二个节点则编码\[0,1\]，所以整体的编码为\[0,1,0,0,1\]，这类编码作为特征，输入到线性分类模型（LR or FM）中进行分类。

预测时，会先走 GBDT 的每棵树，得到某个叶子节点对应的一个离散特征(即一组特征组合)，然后把该特征以 one-hot 形式传入 LR 进行线性加权预测。

这个方案应该比较简单了， 下面有几个关键的点我们需要了解：

1.  通过GBDT进行特征组合之后得到的离散向量是和训练数据的原特征一块作为逻辑回归的输入， 而不仅仅全是这种离散特征。
2.  建树的时候用ensemble建树的原因就是一棵树的表达能力很弱，不足以表达多个有区分性的特征组合，多棵树的表达能力更强一些。GBDT每棵树都在学习前面棵树尚存的不足，迭代多少次就会生成多少棵树。
3.  RF也是多棵树，但从效果上有实践证明不如GBDT。且GBDT前面的树，特征分裂主要体现对多数样本有区分度的特征；后面的树，主要体现的是经过前N颗树，残差仍然较大的少数样本。优先选用在整体上有区分度的特征，再选用针对少数样本有区分度的特征，思路更加合理，这应该也是用GBDT的原因。
4.  在CRT预估中， GBDT一般会建立两类树(非ID特征建一类， ID类特征建一类)， AD，ID类特征在CTR预估中是非常重要的特征，直接将AD，ID作为feature进行建树不可行，故考虑为每个AD，ID建GBDT树。
    
     *  非ID类树：不以细粒度的ID建树，此类树作为base，即便曝光少的广告、广告主，仍可以通过此类树得到有区分性的特征、特征组合
     *  ID类树：以细粒度 的ID建一类树，用于发现曝光充分的ID对应有区分性的特征、特征组合

### GBDT+LR组合模型开后的特征工程新趋势 ###

GBDT+LR组合模型对于推荐系统领域的重要性在于，它大大推进了特征工 程模型化这一重要趋势。在 GBDT+LR组合模型出现之前，特征工程的主要解决 方法有两个：一是进行人工的或半人工的特征组合和特征筛选；二是通过改造目 标函数，改进模型结构，增加特征交叉项的方式增强特征组合能力。但这两种方 法都有弊端，第一种方法对算法工程师的经验和精力投入要求较高；第二种方法 则要求从根本上改变模型结构，对模型设计能力的要求较高。

GBDT+LR组合模型的提出，意味着特征工程可以完全交由一个独立的模型 来完成，模型的输入可以是原始的特征向量，不必在特征工程上投入过多的人工 筛选和模型设计的精力，实现真正的端到端( End to End ) 训练。

广义上讲，深度学习模型通过各类网络结构、Embedding层等方法完成特征 工程的自动化，都是GBDT+LR开启的特征工程模型化这一趋势的延续。

## 四、编程实践 ##

下面我们通过kaggle上的一个ctr预测的比赛来看一下GBDT+LR模型部分的编程实践， [数据来源][Link 1]。

我们回顾一下上面的模型架构， 首先是要训练GBDT模型， GBDT的实现一般可以使用xgboost， 或者lightgbm。训练完了GBDT模型之后， 我们需要预测出每个样本落在了哪棵树上的哪个节点上， 然后通过one-hot就会得到一些新的离散特征， 这和原来的特征进行合并组成新的数据集， 然后作为逻辑回归的输入，最后通过逻辑回归模型得到结果。

根据上面的步骤， 我们看看代码如何实现：

假设我们已经有了处理好的数据xtrain, ytrain。

### 1、训练GBDT模型 ###

GBDT模型的搭建我们可以通过XGBOOST， lightgbm等进行构建。比如：

gbm = lgb.LGBMRegressor(objective='binary',
                                subsample= 0.8,
                                min_child_weight= 0.5,
                                colsample_bytree= 0.7,
                                num_leaves=100,
                                max_depth = 12,
                                learning_rate=0.05,
                                n_estimators=10,
                                )
    
    gbm.fit(x_train, y_train,
            eval_set = [(x_train, y_train), (x_val, y_val)],
            eval_names = ['train', 'val'],
            eval_metric = 'binary_logloss',
            # early_stopping_rounds = 100,
            )

### 2、特征转换并构建新的数据集 ###

通过上面我们建立好了一个GBDT模型， 我们接下来要用它来预测出样本会落在每棵树的哪个叶子节点上， 为后面的离散特征构建做准备， 由于不是用GBDT预测结果而是预测训练数据在每棵树上的具体位置， 就需要用到下面的语句：

model = gbm.booster_            # 获取到建立的树
    
    # 每个样本落在每个树的位置 ， 下面两个是矩阵  (样本个数, 树的棵树)  ， 每一个数字代表某个样本落在了某个数的哪个叶子节点
    gbdt_feats_train = model.predict(train, pred_leaf = True)
    gbdt_feats_test = model.predict(test, pred_leaf = True)
    
    # 把上面的矩阵转成新的样本-特征的形式， 与原有的数据集合并
    gbdt_feats_name = ['gbdt_leaf_' + str(i) for i in range(gbdt_feats_train.shape[1])]
    df_train_gbdt_feats = pd.DataFrame(gbdt_feats_train, columns = gbdt_feats_name) 
    df_test_gbdt_feats = pd.DataFrame(gbdt_feats_test, columns = gbdt_feats_name)
    
    # 构造新数据集
    train = pd.concat([train, df_train_gbdt_feats], axis = 1)
    test = pd.concat([test, df_test_gbdt_feats], axis = 1)
    train_len = train.shape[0]
    data = pd.concat([train, test])

### 3、离散特征的独热编码，并划分数据集 ###

# 新数据的新特征进行独热编码
    for col in gbdt_feats_name:
        onehot_feats = pd.get_dummies(data[col], prefix = col)
        data.drop([col], axis = 1, inplace = True)
        data = pd.concat([data, onehot_feats], axis = 1)
        
     # 划分数据集
    train = data[: train_len]
    test = data[train_len:]
      
    x_train, x_val, y_train, y_val = train_test_split(train, target, test_size = 0.3, random_state = 2018)

### 4、训练逻辑回归模型作最后的预测 ###

# 新数据的新特征进行读入编码
    for col in gbdt_feats_name:
        onehot_feats = pd.get_dummies(data[col], prefix = col)
        data.drop([col], axis = 1, inplace = True)
        data = pd.concat([data, onehot_feats], axis = 1)
        
     # 划分数据集
    train = data[: train_len]
    test = data[train_len:]
      
    x_train, x_val, y_train, y_val = train_test_split(train, target, test_size = 0.3, random_state = 2018)

上面我们就完成了GBDT+LR模型的基本训练步骤， 具体详细的代码看实战部分

### 5、完整代码 ###

GBDT\_LR.py

# Description：
    # 这个笔记本要做一个GBDT+LR的demon，基于kaggle上的一个比赛数据集, 下载链接：[http://labs.criteo.com/2014/02/kaggle-display-advertising-challenge-dataset/](http://labs.criteo.com/2014/02/kaggle-display-advertising-challenge-dataset/) 数据集介绍：
    # 这是criteo-Display Advertising Challenge比赛的部分数据集， 里面有train.csv和test.csv两个文件：
    # * train.csv： 训练集由Criteo 7天内的部分流量组成。每一行对应一个由Criteo提供的显示广告。为了减少数据集的大小，正(点击)和负(未点击)的例子都以不同的比例进行了抽样。示例是按时间顺序排列的
    # * test.csv: 测试集的计算方法与训练集相同，只是针对训练期之后一天的事件
    
    # 字段说明：
    # * Label： 目标变量， 0表示未点击， 1表示点击
    # * l1-l13: 13列的数值特征， 大部分是计数特征
    # * C1-C26: 26列分类特征， 为了达到匿名的目的， 这些特征的值离散成了32位的数据表示
    
    # 这个比赛的任务就是：开发预测广告点击率(CTR)的模型。给定一个用户和他正在访问的页面，预测他点击给定广告的概率是多少？比赛的地址链接：[https://www.kaggle.com/c/criteo-display-ad-challenge/overview](https://www.kaggle.com/c/criteo-display-ad-challenge/overview)
    # <br><br>
    # 下面基于GBDT+LR模型完后这个任务。
    
    # 数据导入与简单处理
    import numpy as np
    import pandas as pd
    
    from sklearn.linear_model import LogisticRegression
    from sklearn.model_selection import train_test_split
    import lightgbm as lgb
    from sklearn.preprocessing import MinMaxScaler, OneHotEncoder, LabelEncoder
    from sklearn.metrics import log_loss
    import gc
    from scipy import sparse
    import warnings
    warnings.filterwarnings('ignore')
    
    """数据读取与预处理"""
    # 数据读取
    path = 'data/'
    df_train = pd.read_csv(path + 'kaggle_train.csv')
    df_test = pd.read_csv(path + 'kaggle_test.csv')
    
    # 简单的数据预处理
    # 去掉id列， 把测试集和训练集合并， 填充缺失值
    df_train.drop(['Id'], axis=1, inplace=True)
    df_test.drop(['Id'], axis=1, inplace=True)
    
    df_test['Label'] = -1
    
    data = pd.concat([df_train, df_test])
    data.fillna(-1, inplace=True)
    
    """下面把特征列分开处理"""
    continuous_fea = ['I'+str(i+1) for i in range(13)]
    category_fea = ['C'+str(i+1) for i in range(26)]
    
    # 建模
    # 下面训练三个模型对数据进行预测， 分别是LR模型， GBDT模型和两者的组合模型， 然后分别观察它们的预测效果， 对于不同的模型， 特征会有不同的处理方式如下：
    # 1. 逻辑回归模型： 连续特征要归一化处理， 离散特征需要one-hot处理
    # 2. GBDT模型： 树模型连续特征不需要归一化处理， 但是离散特征需要one-hot处理
    # 3. LR+GBDT模型： 由于LR使用的特征是GBDT的输出， 原数据依然是GBDT进行处理交叉， 所以只需要离散特征one-hot处理
    
    
    # 下面就通过函数的方式建立三个模型， 并进行训练
    # 逻辑回归建模
    def lr_model(data, category_fea, continuous_fea):
        # 连续特征归一化
        scaler = MinMaxScaler()
        for col in continuous_fea:
            data[col] = scaler.fit_transform(data[col].values.reshape(-1, 1))
        
        # 离散特征one-hot编码
        for col in category_fea:
            onehot_feats = pd.get_dummies(data[col], prefix=col)
            data.drop([col], axis=1, inplace=True)
            data = pd.concat([data, onehot_feats], axis=1)
        
        # 把训练集和测试集分开
        train = data[data['Label'] != -1]
        target = train.pop('Label')
        test = data[data['Label'] == -1]
        test.drop(['Label'], axis=1, inplace=True)
        
        # 划分数据集
        x_train, x_val, y_train, y_val = train_test_split(train, target, test_size=0.2, random_state=2020)
        
        # 建立模型
        lr = LogisticRegression()
        lr.fit(x_train, y_train)
        tr_logloss = log_loss(y_train, lr.predict_proba(x_train)[:, 1])   # −(ylog(p)+(1−y)log(1−p)) log_loss
        val_logloss = log_loss(y_val, lr.predict_proba(x_val)[:, 1])
        print('tr_logloss: ', tr_logloss)
        print('val_logloss: ', val_logloss)
        
        # 模型预测
        y_pred = lr.predict_proba(test)[:, 1]  # predict_proba 返回n行k列的矩阵，第i行第j列上的数值是模型预测第i个预测样本为某个标签的概率, 这里的1表示点击的概率
        print('predict: ', y_pred[:10]) # 这里看前10个， 预测为点击的概率
    
    
    # GBDT 建模
    def gbdt_model(data, category_fea, continuous_fea):
        
        # 离散特征one-hot编码
        for col in category_fea:
            onehot_feats = pd.get_dummies(data[col], prefix=col)
            data.drop([col], axis=1, inplace=True)
            data = pd.concat([data, onehot_feats], axis=1)
        
        # 训练集和测试集分开
        train = data[data['Label'] != -1]
        target = train.pop('Label')
        test = data[data['Label'] == -1]
        test.drop(['Label'], axis=1, inplace=True)
        
        # 划分数据集
        x_train, x_val, y_train, y_val = train_test_split(train, target, test_size=0.2, random_state=2020)
        
        # 建模
        gbm = lgb.LGBMClassifier(boosting_type='gbdt',  # 这里用gbdt
                                 objective='binary', 
                                 subsample=0.8,
                                 min_child_weight=0.5, 
                                 colsample_bytree=0.7,
                                 num_leaves=100,
                                 max_depth=12,
                                 learning_rate=0.01,
                                 n_estimators=10000
                                )
        gbm.fit(x_train, y_train, 
                eval_set=[(x_train, y_train), (x_val, y_val)], 
                eval_names=['train', 'val'],
                eval_metric='binary_logloss',
                early_stopping_rounds=100,
               )
        
        tr_logloss = log_loss(y_train, gbm.predict_proba(x_train)[:, 1])   # −(ylog(p)+(1−y)log(1−p)) log_loss
        val_logloss = log_loss(y_val, gbm.predict_proba(x_val)[:, 1])
        print('tr_logloss: ', tr_logloss)
        print('val_logloss: ', val_logloss)
        
        # 模型预测
        y_pred = gbm.predict_proba(test)[:, 1]  # predict_proba 返回n行k列的矩阵，第i行第j列上的数值是模型预测第i个预测样本为某个标签的概率, 这里的1表示点击的概率
        print('predict: ', y_pred[:10])  # 这里看前10个， 预测为点击的概率
    
    
    # LR + GBDT建模
    # 下面就是把上面两个模型进行组合， GBDT负责对各个特征进行交叉和组合， 把原始特征向量转换为新的离散型特征向量， 然后在使用逻辑回归模型
    def gbdt_lr_model(data, category_feature, continuous_feature):  # 0.43616
        # 离散特征one-hot编码
        for col in category_feature:
            onehot_feats = pd.get_dummies(data[col], prefix=col)
            data.drop([col], axis=1, inplace=True)
            data = pd.concat([data, onehot_feats], axis=1)
    
        train = data[data['Label'] != -1]
        target = train.pop('Label')
        test = data[data['Label'] == -1]
        test.drop(['Label'], axis=1, inplace=True)
    
        # 划分数据集
        x_train, x_val, y_train, y_val = train_test_split(train, target, test_size=0.2, random_state=2020)
    
        gbm = lgb.LGBMClassifier(objective='binary',
                                subsample=0.8,
                                min_child_weight=0.5,
                                colsample_bytree=0.7,
                                num_leaves=100,
                                max_depth=12,
                                learning_rate=0.01,
                                n_estimators=1000,
                                 )
    
        gbm.fit(x_train, y_train,
                eval_set=[(x_train, y_train), (x_val, y_val)],
                eval_names=['train', 'val'],
                eval_metric='binary_logloss',
                early_stopping_rounds=100,
                )
        
        model = gbm.booster_
    
        gbdt_feats_train = model.predict(train, pred_leaf=True)
        gbdt_feats_test = model.predict(test, pred_leaf=True)
        gbdt_feats_name = ['gbdt_leaf_' + str(i) for i in range(gbdt_feats_train.shape[1])]
        df_train_gbdt_feats = pd.DataFrame(gbdt_feats_train, columns=gbdt_feats_name)
        df_test_gbdt_feats = pd.DataFrame(gbdt_feats_test, columns=gbdt_feats_name)
    
        train = pd.concat([train, df_train_gbdt_feats], axis=1)
        test = pd.concat([test, df_test_gbdt_feats], axis=1)
        train_len = train.shape[0]
        data = pd.concat([train, test])
        del train
        del test
        gc.collect()
    
        # 连续特征归一化
        scaler = MinMaxScaler()
        for col in continuous_feature:
            data[col] = scaler.fit_transform(data[col].values.reshape(-1, 1))
    
        for col in gbdt_feats_name:
            onehot_feats = pd.get_dummies(data[col], prefix = col)
            data.drop([col], axis = 1, inplace = True)
            data = pd.concat([data, onehot_feats], axis = 1)
    
        train = data[: train_len]
        test = data[train_len:]
        del data
        gc.collect()
    
        x_train, x_val, y_train, y_val = train_test_split(train, target, test_size = 0.3, random_state = 2018)
    
        
        lr = LogisticRegression()
        lr.fit(x_train, y_train)
        tr_logloss = log_loss(y_train, lr.predict_proba(x_train)[:, 1])
        print('tr-logloss: ', tr_logloss)
        val_logloss = log_loss(y_val, lr.predict_proba(x_val)[:, 1])
        print('val-logloss: ', val_logloss)
        y_pred = lr.predict_proba(test)[:, 1]
        print(y_pred[:10])
    
    # 训练和预测lr模型
    lr_model(data.copy(), category_fea, continuous_fea)
    
    # 模型训练和预测GBDT模型
    gbdt_model(data.copy(), category_fea, continuous_fea)
    
    # 训练和预测GBDT+LR模型
    gbdt_lr_model(data.copy(), category_fea, continuous_fea)

结果：  
![在这里插入图片描述][e2a28ab1e7a849d2b0a274797101a965.png_pic_center]  
![在这里插入图片描述][e4d4d72be54346dc8d0326af9f9ab0b3.png_pic_center]

--------------------

参考资料：  
[推荐系统入门（五）：GBDT+LR（附代码）][GBDT_LR]  
[CTR预估模型FM、FFM、DeepFM][CTR_FM_FFM_DeepFM]  
[GBDT+LR算法解析及Python实现][GBDT_LR_Python]  
[GBDT+LR 原理及代码实现][GBDT_LR 1]  
[广告点击率(CTR)预测经典模型 GBDT + LR 理解与实践（附数据 + 代码）][CTR_ GBDT _ LR _ _]  
[GitHub：zxxwin/GBDT\_LR][Link 1]

[Practical Lessons from Predicting Clicks on Ads at Facebook]: https://dl.acm.org/doi/abs/10.1145/2648584.2648589
[7d3a1bdba84c4270b3e16ea0eef3d23b.png_pic_center]: https://img-blog.csdnimg.cn/7d3a1bdba84c4270b3e16ea0eef3d23b.png#pic_center
[ab2fa3a932e54c2ebab0be2cdc587e16.png_pic_center]: https://img-blog.csdnimg.cn/ab2fa3a932e54c2ebab0be2cdc587e16.png#pic_center
[0708a5b99ec94c128b20f03ea2f46970.png_pic_center]: https://img-blog.csdnimg.cn/0708a5b99ec94c128b20f03ea2f46970.png#pic_center
[c0d648b71c69423c9de4f2add9f20391.png_pic_center]: https://img-blog.csdnimg.cn/c0d648b71c69423c9de4f2add9f20391.png#pic_center
[bf4f1054769d4a538861e58960b4314d.png_pic_center]: https://img-blog.csdnimg.cn/bf4f1054769d4a538861e58960b4314d.png#pic_center
[4731aabf2d9a493499df305287631755.png_pic_center]: https://img-blog.csdnimg.cn/4731aabf2d9a493499df305287631755.png#pic_center
[5488027c9e45430a9d0d88e6af994dc7.png_pic_center]: https://img-blog.csdnimg.cn/5488027c9e45430a9d0d88e6af994dc7.png#pic_center
[dbb1ff6dcc964273a661d0f6d2324d52.png_pic_center]: https://img-blog.csdnimg.cn/dbb1ff6dcc964273a661d0f6d2324d52.png#pic_center
[Link 1]: https://github.com/zxxwin/GBDT_LR
[e2a28ab1e7a849d2b0a274797101a965.png_pic_center]: https://img-blog.csdnimg.cn/e2a28ab1e7a849d2b0a274797101a965.png#pic_center
[e4d4d72be54346dc8d0326af9f9ab0b3.png_pic_center]: https://img-blog.csdnimg.cn/e4d4d72be54346dc8d0326af9f9ab0b3.png#pic_center
[GBDT_LR]: https://blog.csdn.net/weixin_42691585/article/details/109337381
[CTR_FM_FFM_DeepFM]: https://www.biaodianfu.com/ctr-fm-ffm-deepfm.html
[GBDT_LR_Python]: https://www.cnblogs.com/wkang/p/9657032.html
[GBDT_LR 1]: https://wangguisen.blog.csdn.net/article/details/112756687
[CTR_ GBDT _ LR _ _]: https://blog.csdn.net/VariableX/article/details/107385704