Jiahong的个人博客

凡事预则立不预则废


  • Home

  • Tags

  • Archives

  • Search

ML——GBDT-梯度提升树-推导过程

Posted on 2018-03-15

本文介绍梯度提升树(族)的推导过程,包括传统的GBDT,XGBoost等


参数空间的优化

  • 参数空间中我们使用梯度下降法(一阶导数)和牛顿迭代法(二阶导数)来优化
  • 关于无约束参数优化方法参考无约束参数优化方法

从参数空间优化到函数空间的优化

  • 函数空间中我们使用GBDT(一阶导数)和XGBoost(二阶导数)来优化
  • 函数空间的优化完全类比参数空间的优化

Boosting是一种加法模型

加法模型:additive training
$$
\begin{align}
F(x) = \sum_{t=0}^{T}f_{t}(x)
\end{align}
$$

  • 上式中\(f_{t}(x)\)为基分类器, 我们通常采用回归树[Friedman 1999] 和逻辑回归
    [Friedman 2000]
  • 树模型的优缺点可以参考ML——DT-决策树

GBDT算法原理

这里只原论文中的Gradient Boosting Tree算法
Friedman于论文”GreedyFunctionApproximation…”中最早 出GBDT

模型\(F\)的加法定义:

$$
\begin{align}
F(x) &= \sum_{t=0}^{T}\alpha_{t} h_{t}(x;w_{t}) \\
&= \sum_{t=0}^{T} f_{t}(x;w_{t})
\end{align}
$$

  • 其中, \(x\)为输入样本, \(h_{t}\)为分类回归树, \(w_{t}\)是树\(h_{t}\)的参数, \(\alpha_{t}\)是树\(h_{t}\)的权重

损失函数的定义

$$
\begin{align}
F^{\star} = \arg\max_{F}\sum_{i=1}^{N}L(y_{i}, F(x_{i};w))
\end{align}
$$

  • 其中,\(N\)为样本数量,所有样本的损失总和为总的损失函数
  • 最小化损失函数即可得到最优模型

最优模型的求解

  • 直接列举所有可能的树——NP难问题
  • 所以GBDT算法使用贪心法, 迭代求局部最优解
  • 详细的Gradient Boosting Tree迭代过程如下
  • 上面的推导中
    • 2.1中:\(\tilde{y}_{i}\)是当前的损失函数\(L(y_{i}, F(x_{i})\)关于当前函数\(F(x)\)(模型)在\(F(x)=F_{t-1}(x)\)处的负梯度(每个样本都有一个负梯度)
      • 这个损失函数在使用不同回归方法时时定义各不相同
      • 原始论文中提到两个损失函数定义,根据损失函数的不同,对应的归回方法不同: 最小二乘归回或者最小绝对误差回归
    • 2.2中:\(w^{\star}\)是指能够拟合当前负梯度的树\(h_{t}(x;w^{\star})\)的最佳参数,这里我们认为最佳参数就是最小二乘的最佳参数,实际上这个地方可以使用其他测拟合标准(这个标准是拟合当前负梯度的拟合标准,与后面的损失函数\(L(y, F(x;w))\)无关),只是这里最小二乘是最简单也是最自然的选择
      • 原始论文中这里使用的基函数是\(\beta h(x;w)\),其中\(\beta\)是当前基函数\(h(x;w)\)的权重,这里我认为直接使用\(h(x;w)\)作为基函数即可,权重\(\beta\)会自动被基函数学到的(可能原始论文中\(h(x;w)\)指的是简单的基函数,是不含权重学习功能的)
      • 但是需要注意的是,如果我们使用的基分类器是逻辑回归,那么这里每个基分类器的结果都是在[0-1]之间的数,是需要前面的\(\beta\)的
      • 这里我们推导的时候假定了基分类器是回归树,所以不需要使用 \(\beta\)
    • 2.3中:由于\(w^{\star}\)只能保证当前树\(h_{t}(x;w^{\star})\)是能拟合负梯度的,不能保证把当前这棵树添加到模型中时模型的损失函数是最小的,所以我们加了一个步长参数\(\rho\),用来表示得到当前树的最优权重
      • 损失函数是平方损失函数时,这里的参数为\(\rho\)就是1,无需计算
    • 2.4中:将当前树的最优树(包括权重)一起加入到模型中

不同损失函数和基函数对应不同的算法

上述式子中推导用到的基函数为树模型,实际使用中也可以使用逻辑回归模型[Friedman 2000]等基函数
本小节将介绍不同损失函数或者基函数带来的不同算法

  • 注意:包括Adaboost和GBDT在内Boosting框架中,基函数(基分类器)都不能使用线性模型
    • 理解: Boosting框架本质上是一个加法模型,是对多个基函数的线性组合,得到更优的分类器,可以证明线性模型的线性组合还是线性模型,如果Boosting框架中使用线性模型,那么我们最终得到的分类器也是线性模型,这就局限了我们的整体模型的表达能力
最小二乘回归(损失函数)

Least-Squares Regression

损失函数定义
  • 此时损失函数定义为
    $$
    \begin{align}
    L(y,F(x)) = \frac{1}{2}(y-F(x))^{2}
    \end{align}
    $$
进一步理解推导过程
  • 2.1中\(\tilde{y}_{i}=y_{i}-F_{t-1}(x_{i})\),这里直接对损失函数求导即可的到
    $$
    \begin{align}
    \tilde{y_{i}} &= -\left [\frac{\partial L(y,F(x_{i}))}{\partial F(x_{i})}\right ]_{F(x) = F_{t-1}(x)} \\
    &= -\left [\frac{\partial L(y,F_{t-1}(x_{i}))}{\partial F_{t-1}(x_{i})}\right ] \\
    &= -\left [\frac{\partial \frac{1}{2}(y_{i}-F_{t-1}(x_{i}))^{2}}{\partial F_{t-1}(x_{i})}\right ] \\
    &= 2 \cdot -\frac{1}{2}(y_{i}-F_{t-1}(x_{i})) \cdot -1 \\
    &= y_{i}-F_{t-1}(x_{i})
    \end{align}
    $$
  • 2.2中正常拟合(使用线性回归和CART回归树均可)
  • 2.3中基函数的权重\(\rho^{\star}\)是常数1,推导如下
    $$
    \begin{align}
    L(y,F_{t}(x)) &= \sum_{i=1}^{N}L(y_{i}, F_{t}(x_{i})) \\
    &= \frac{1}{2}\sum_{i=1}^{N}((y_{i}-F_{t}(x_{i}))^{2}) \\
    &= \frac{1}{2}\sum_{i=1}^{N}((y_{i}-F_{t-1}(x_{i}) - h_{t}(x_{i};w))^{2}) \\
    &= \frac{1}{2}\sum_{i=1}^{N}((\tilde{y}_{i}-h_{t}(x_{i};w))^{2}) \\
    \end{align}
    $$
  • 显然,这个式子和2.2中拟合目标完全相同(只差着2倍常数权重),所以2.2中得到的最优基函数\(h_{t}(x;w^{\star})\)就是2.3中使得模型损失函数\(L(y,F_{t}(x))\)最小的最优基函数,无需添加任何的权重系数
最小绝对偏差回归(损失函数)

Least Absolute Deviation Regression, LAD

损失函数定义
  • 此时损失函数定义为
    $$
    \begin{align}
    L(y,F(x)) = |y-F(x)|
    \end{align}
    $$
进一步理解推导过程
  • 2.1中\(\tilde{y}_{i}=sign(y_{i}-F_{t-1}(x_{i}))\)
    • 绝对值的导数就是1或者-1,当
      $$y_{i}-F_{t-1}(x_{i}) > 0$$
    • 对损失函数求导得到-1,负梯度为1
    • 同理得到,当
      $$y_{i}-F_{t-1}(x_{i}) > 0$$
    • 对损失函数求导得到1,负梯度为-1
    • 总结得到负梯度为
      $$\tilde{y}_{i}=sign(y_{i}-F_{t-1}(x_{i}))$$
  • 2.2中正常拟合(使用线性回归和CART回归树均可)
  • 2.3中基函数的权重\(\rho^{\star}\)不再是常数,推导如下
  • 待更新*
    $$
    \begin{align}
    待更新
    \end{align}
    $$
回归树(基函数)

Regression Trees

  • 传统GBDT中原始论文使用树回归,论文见Firedman 1999,后来作者提出可以使用逻辑回归,论文见Friedman 2000
  • 回归树和逻辑回归的优缺点比较
    • 树模型优点:
      • 可解释性强
      • 可处理混合类型特征(混合类型特征指的是数值型和类别型均可处理)
      • 具有伸缩不变性(无需特征归一化: 神经网络和逻辑回归都需要,逻辑回归中是为了保证随机梯度下降的方向正确,速度快)
      • 可自然的处理缺失值, C4.5树处理缺失值默认使用的方法是先用未缺失样本计算信息增益确定分裂结点,然后将缺失值的每个样本按照权重(当前叶子节点未缺失样本数量 / 未缺失样本总数)分配到各个结点
      • 对异常点鲁棒(不用去除异常点,LR不具有这个优点)
      • 有特征选择的作用
      • 可扩展性强,容易并行(并行是最好的,用来解释为什么XGBoost等都用树模型)
    • 树模型缺点:
      • 缺乏平滑性(回归预测时输出值只能输出若干种数值,而不是连续的数值,所以不平滑[不平滑即离散])
      • 不适合处理高维稀疏数据(当数据量太少时,非常容易过拟合,树的深度太深,从而模型变得太复杂)

传统GDBT与XGBoost的比较

  • 参考博客: ML——XGBoost-vs-传统GBDT

ML——GBDT-梯度提升树-概念性总结

Posted on 2018-03-15

GBDT(GradientBoostingDecisionTree), 梯度提升树
GBDT泛指所有梯度提升树,包括XGBoost(XGBoost是GBDT的变种),平时为了进行区分,GBDT特指“Greedy Function Approximation:A Gradient Boosting Machine”(GBDT论文原文)提出的算法,只利用了一阶导数信息(XGBoost利用了二阶导数信息)
*梯度的数学定义:函数上升最快的方向

参考论文:Greedy Function Approximation: A Gradient Boosting Machine
一篇很详细的论文阅读笔记:GBM Paper Reading

引用一个常见的通俗例子:GBDT的思想可以用一个通俗的例子解释,假如有个人30岁,我们首先用20岁去拟合,发现损失有10岁,这时我们用6岁去拟合剩下的损失,发现差距还有4岁,第三轮我们用3岁拟合剩下的差距,差距就只有一岁了(残差作为下一轮拟合的数据的理解)。如果我们的迭代轮数还没有完,可以继续迭代下面,每一轮迭代,拟合的岁数误差都会减小,最终预测时使用他们的结果


五种简称

  • 各种简称,都是同一种算法:
    • GBDT(Gradient Boosting Decision Tree)
    • MART(Multiple Additive Regression Tree)
    • GBT(Gradient Boosting Tree)
    • GTB(Gradient Tree Boosting)
    • GBRT(Gradient Boosting Regression Tree)

模型原理

核心

  • 使用CART作为基础模型(GDBT只能使用CART,不能使用其他树C4.5和ID3等), 后来作者提出也可以使用逻辑回归模型
  • 每棵树学习的是前一棵树的残差(预测值与真实值的差)[这里是当损失函数是均方误差(平方损失, square loss)时可直接使用残差,其他类似的学习算法中若]
  • 残差 = 真实值 - 预测值

与AdaBoost不同

  • AdaBoost是通过利用前一轮弱学习器的误差率来更新训练集的权重

    • 增大分类错误的样本权重,从而使得样本更加关注上一步中分类错误的样本
  • GBDT是通过学习上一轮学习器的残差来实现对真实结果的不断逼近

    • 上一步中预测越接近真实结果的样本,残差越接近0,下一轮中对该样本的关注度越低
    • 上一步中预测越不接近真实结果的样本,残差越大,下一轮中对该样本的关注度越高
  • GBDT的弱学习器只能使用CART回归树,只能用回归树这一点与AdaBoost和RF均不同

    • 因为我们的目标是拟合上一若学习器的残差
    • 而残差往往是数值,不是类别,所以只能使用回归树CART

GBDT分类

二分类
  • GBDT实现二分类时可以每轮迭代直接用一个模型去学残差
  • 此时类别可编码为一个一维向量,取值0或1
多分类
  • GBDT实现多分类时每轮使用一个模型不够了,因为三个模型时使用1,2,3编码显然是不科学的,类别之间不应该有这种数值大小关系
  • 此时三分类模型的类别可编码为一个三维向量,每一维的取值为0或1
  • 在每一轮迭代时,为每个类训练一个CART树,每棵CART树是相互独立的
  • 然后每个模型每轮分别学习当前特征的残差
  • 每个模型都会用到所有的样本
    • 比如一个标记为标记为类别2的样本(x, y=2)
    • 编码为(x, [0,1,0])
    • 对于CART1和CART3(类别1和类别3的CART树)来说,该样本对应输入为(x, y=0)
    • 对于CART2(类别2CART树)来说,该样本对应输入为(x, y=1)
  • 可以理解为把一个三分类问题转化成了3个二分类问题解决了
  • 最后预测时
    • 给定一个未标记样本
    • 每个类对应的模型(每个类的模型个数是该类上模型的迭代次数)都对应给出该类的打分
    • 最后选择分数最高的一个类为最终分类即可

GDBT + LR

  • 为什么在广告CTR预估中, GDBT+LR能够提升效果?
    • 和LR对比: 线性模型
    • 和GBDT对比:

GBDT和神经网络的优劣

深度神经网络

  • 通过不同层级和类型的网络可以对时空信息建模
  • 适合图像, 声音, 文字等带有时序特质的数据

GBDT

  • 基于树模型的GBDT则能很好地处理表格数据
  • 模型的可解释性
  • 输入数据的不变性(几乎不用格式化数据)
  • 更易于调参等特质更适合数值型数据

ML——RF

Posted on 2018-03-15

随机森林是一种集成学习(Ensemble)方法,属于集成学习中的Bagging族,是一种典型的Bagging方法


随机森林

训练

  • 假设训练集总大小为N,特征总数为K
  • 有放回抽样N个训练样本
    • 说明:这种有放回的抽样技术又称为自助法(Bootstrap)重采样技术
  • 随机从所有特征中选取k个特征(k一般远小于总特征数K)
  • 用bootstrap采样的结果(N个样本)和k个特征训练一棵决策树(训练时不剪枝,每棵树都尽可能生长)
  • 重复上述三个步骤:bootstrap采样和训练新的决策树,直到生成m棵决策树
  • 将m棵决策树组合成随机森林

预测

  • 对于一个确定的未标记样本
  • 经过每一棵决策树预测
  • 投票产生结果,确定最终分类

优点

  • 避免过拟合(bootstrap采样[随机]和随机选择部分特征)
  • 便于处理高维度的数据
  • 对高维度的数据无需做特征选择,全部保留也无所谓
  • 可并行计算
  • 模型实现简单

缺点

  • 模型训练多棵树,所以训练时间长
  • 预测时经过多棵树,预测时间长

参数

  • 决策树类型: 三种(ID3,C4.5,CART)均可选,默认均分的三种算法混合到一起
    • 决策树详细信息可参考ML——DT
  • 树的数量m:
    • n_estimators
    • int i: n_estimators = i
    • 默认为10
  • 特征个数k(以Sklearn库为例):
    • max_features = k
    • int i: k = i
    • float f: k = f * K
    • sqrt: k = sqrt(K)
    • log2: k = log2(K)
    • None: k = K
    • Sklearn.ensemble.RandomRorestClassifier默认是”auto”,也就是sqrt(K)
  • 树的深度:
    • max_depth
    • 单棵树的深度
    • 默认是None,不做限制
    • int i: 指定树的深度为i
  • 叶子节点最小样本数:
    • int i: min_samples_leaf = i
    • float f: min_samples_leaf = f * N
    • 默认为1

问题: 随机森林的随机体现在哪里?

  • 个人理解
    • 体现在每棵树的训练样本随机,有放回采样(自助法(Bootstrap)重采样技术)
    • 体现在每棵树的训练样本的特征随机, 对每棵树而言,随机从K个特征中选取k个特征,当前树的每个叶节点分裂时只能从这k个特征中选择

RS——CTR-CVR的预估模型

Posted on 2018-03-12

本文主要广告计算领域用于CTR,CVR预估的模型


计算广告领域的术语

一些术语

  • CPA(Cost Per Action):
    • 一种广告计费模式
    • 按照行为(Action)来计费
    • 这里的行为可以是注册,咨询,放入购入车等
  • CPC(Cost Per Click)
    • 一种广告计费模式
    • 按照点击(Click)次数

衡量指标

  • 点击率CTR(click-through rate), 又名点击通过率:
    $$CTR = \frac{Count_{click}}{Count_{show}} $$
    • 分母是广告的实际展示次数
    • 分子是广告的实际点击次数
  • 转化率CVR(conversion rate), 一种CPA衡量指标
    $$CVR= \frac{Count_{conversion}}{Count_{click}}$$
    • 分母是广告的实际点击次数
    • 分子是广告的转化次数,不同场景对转化成功的定义不同,比如手机号码注册用户为一次有效转化,那么这里CVR统计的就是所有点击了广告的人中有多少进行了实际的手机号注册

预估CTR,CVR的模型

人工特征工程+LR

  • 人工提取当前广告的特征
  • LR模型预估用户是否会点击该广告或者注册该网站(二分类)

GBDT+LR

  • 参考博客: https://www.jianshu.com/p/96173f2c2fb4
  • Facebook paper中的一个例子
    • 图中的GBDT只包含两棵树,实际上使用时可包含更多
    • LR的特征数量(样本维度)就是所有树的叶节点树,样本落到当前叶节点则,当前叶节点对应的特征值为1,否则为0
    • 用于LR训练的特征维度共num_trees * num_leaves(也就是所有树叶节点的总数)
    • 由于有多棵树,每个原始样本在每棵树都会落到一个叶节点上,所以得到的新样本中可能有很多个特征值为1
    • 实践中原始输出时可能维度是树的棵数,每个数表示当前树中样本落到第几个叶节点上,对每棵树分别使用OneHot编码即可的到上面的 (num_trees * num_leaves) 维数据

FM

  • 参考博客RS——FM-因子分解机

FFM

  • 参考博客RS——FMM模型

ML——XGBoost-推导过程

Posted on 2018-02-18

XGBoost,全称: Extreme Gradient Boosting


概述

  • CART回归树是XGBoost的基分类器

XGBoost模型推导(假设回归树的结构确定)

模型\(F\)的加法定义:

$$
\begin{align}
F(x;w) = \sum_{k=0}^{K} f_{k}(x;w_{k})
\end{align}
$$

  • 其中, \(x\)为输入样本, \(f_{k}\)为分类回归树,可以是分类回归树空间中的任意一棵树, \(w_{k}\)是树\(f_{k}\)的参数

定义损失函数

$$
\begin{align}
L^{t} &= \sum_{i=1}^{n}l(y_{i},\hat{y}_{i}^{t}) + \Omega(f_{t}) \\
&= \sum_{i=1}^{n}l(y_{i},\hat{y}_{i}^{t-1} + f_{t}(x_{i})) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2
\end{align}
$$

  • \(L^{t}\): 第 \(t\) 轮迭代的损失函数
  • \(l(y_{i},\hat{y}_{i}^{t})\) 表示单个样本的损失函数定义
  • \(\hat{y}_{i}^{t} = \hat{y}_{i}^{t-1} + f_{t}(x_{i})\) 表示第 \(t\) 轮 \(x_{i}\) 样本的预测值
    • 加法模型: 第 \(t\) 轮预测值 = 第 \(t-1\) 轮预测值 + 第 \(t\) 棵(轮)决策树的预测值
  • \(\Omega(f_{t})\) 表示正则项
    • \(n\) 表示样本的个数
    • \(T\) 表示叶子结点的个数
    • \(w_{j}\) 表示叶节点分数, 即任意样本落到第 \(t\) 棵(轮)决策树的第 \(j\) 叶子结点时的预测值(可称为第 \(t\) 棵(轮)决策树的第 \(j\) 叶子结点的预测值)
    • \(\gamma\)和\(\lambda\)都是正则项参数

第 \(t\) 轮训练的目标

  • 找到一个最优的分类器 \(f_t^{\star}(x)\), 满足
    $$
    \begin{align}
    f_t^{\star}(x) &= \arg\max_{f_t(x)}L^{t} \\
    &= \arg\max_{f_t(x)}\left(\sum_{i=1}^{n}l(y_{i},\hat{y}_{i}^{t}) + \Omega(f_{t})\right) \\
    &= \arg\max_{f_t(x)}\left(\sum_{i=1}^{n}l(y_{i},\hat{y}_{i}^{t-1} + f_{t}(x_{i})) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2 \right)
    \end{align}
    $$

最小化损失函数推导

损失函数二阶泰勒展开

  • 回忆传统泰勒展开:
    $$
    \begin{aligned}
    f(x) &= f(x_0) + f’(x_0)(x-x_0) + \frac{f’’(x_0)}{2!}(x-x_0)^2 + \cdots + \frac{f^{(n)}(x_0)}{n!}(x-x_0)^n \\
    & = \sum\limits_{n=0}^{\infty}\frac{f^{(n)}x_0}{n!}(x - x_0)^n
    \end{aligned}
    $$

  • 二阶泰勒展开公式
    $$
    \begin{align}
    f(x+\Delta x) \approx f(x) + f’(x)\Delta x + \frac{1}{2}f’’(x)\Delta x^2
    \end{align}
    $$

  • 在我们的场景中,令

    • \(x = \hat{y}_{i}^{t-1}\)
    • \(\Delta x = f_{t}(x_{i})\)
  • 则有对单个样本能得到
    $$
    \begin{align}
    l(y_{i},\hat{y}_{i}^{t-1} + f_{t}(x_{i})) \approx l(y_i,\hat{y}_i^{t-1}) + l’(y_i,\hat{y}_i^{t-1})f_t(x_i) + \frac{1}{2}l’’(y_i,\hat{y}_i^{t-1})f_t^2(x_i)
    \end{align}
    $$

    • \(l’(y_i,\hat{y}_i^{t-1})\) 是 \(l(y_i,\hat{y}_i)\) 对 \(\hat{y}_i\) 的一阶导数在 \(\hat{y}_i = \hat{y}_i^{t-1}\) 处的值
    • \(l’’(y_i,\hat{y}_i^{t-1})\) 是 \(l(y_i,\hat{y}_i)\) 对 \(\hat{y}_i\) 的二阶导数在 \(\hat{y}_i = \hat{y}_i^{t-1}\) 处的值
  • 我们第 \(t\) 轮的目标是找到一个最优的分类器 \(f_t^{\star}(x)\)最小化损失函数 \(L^{t}\)
    $$
    \begin{align}
    L^{t} \approx \sum_{i=1}^{n}\left(l(y_i,\hat{y}_i^{t-1}) + l’(y_i,\hat{y}_i^{t-1})f_t(x_i) + \frac{1}{2}l’’(y_i,\hat{y}_i^{t-1})f_t^2(x_i)\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2
    \end{align}
    $$

  • 显然上面式子中的 \(l(y_i,\hat{y}_i^{t-1})\) 与 \(f_t(x_i)\) 无关,可以移除,于是有
    $$
    \begin{align}
    L^{t} \approx \sum_{i=1}^{n}\left(l’(y_i,\hat{y}_i^{t-1})f_t(x_i) + \frac{1}{2}l’’(y_i,\hat{y}_i^{t-1})f_t^2(x_i)\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2
    \end{align}
    $$

  • 令:

    • \(g_i = l’(y_i,\hat{y}_i^{t-1})\) 为 \(l(y_i,\hat{y}_i)\) 对 \(\hat{y}_i\) 的一阶导数在 \(\hat{y}_i = \hat{y}_i^{t-1}\) 处的值
    • \(h_i = l’’(y_i,\hat{y}_i^{t-1})\) 是 \(l(y_i,\hat{y}_i)\) 对 \(\hat{y}_i\) 的二阶导数在 \(\hat{y}_i = \hat{y}_i^{t-1}\) 处的值
  • 则有:
    $$
    \begin{align}
    L^{t} \approx \sum_{i=1}^{n}\left(g_if_t(x_i) + \frac{1}{2}h_if_t^2(x_i)\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2
    \end{align}
    $$

  • 做一个重要的转换:
    $$f_t(x_i) = w_j, \quad s.t. \ x_i \in I_j$$

    • 上面的式子前半部分成立的条件是 \(x_i\) 落在叶子结点 \(j\) 上
    • 我们将条件\(x_i\) 落在叶子结点 \(j\) 上表示为 \(\ x_i \in I_j\)
  • 于是: 我们可以将前面对样本的累加变成对叶子结点的累加
    $$
    \begin{align}
    L^{t} &\approx \sum_{j=1}^{T}\left((\sum_{i \in I_j}g_i)w_j + \frac{1}{2}(\sum_{i \in I_j}h_i)w_j^2\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2 \\
    &\approx \sum_{j=1}^{T}\left((\sum_{i \in I_j}g_i)w_j + \frac{1}{2}(\sum_{i \in I_j}h_i + \lambda)w_j^2\right) + \gamma T
    \end{align}
    $$

  • 令:

    • \(G_j = \sum_{i \in I_j}g_i\)
    • \(H_j = \sum_{i \in I_j}h_i\)
  • 则有
    $$
    \begin{align}
    L^{t} \approx \sum_{j=1}^{T}\left(G_jw_j + \frac{1}{2}(H_j + \lambda)w_j^2\right) + \gamma T
    \end{align}
    $$

  • \(L^t\) 对 \(w_j\) 求偏导有
    $$
    \begin{align}
    \frac{\partial L^{t}}{\partial w_j} = G_j + (H_j + \lambda)w_j
    \end{align}
    $$

  • 令导数 \(\frac{\partial L^{t}}{\partial w_j} = 0\) 可得
    $$
    \begin{align}
    w_j^{\star} = -\frac{G_j}{H_j+\lambda}
    \end{align}
    $$

  • 同时
    $$
    \begin{align}
    L^{\star^t} &\approx min(L^t) \\
    &\approx \sum_{j=1}^{T}\left(G_j\cdot (-\frac{G_j}{H_j+\lambda}) + \frac{1}{2}(H_j + \lambda)\cdot(-\frac{G_j}{H_j+\lambda})^2\right) + \gamma T \\
    &\approx -\frac{1}{2}\sum_{j=1}^{T}\left(\frac{G_j^2}{H_j+\lambda}\right) + \gamma T
    \end{align}
    $$

  • 目标函数的计算示例: 目标分数越小越好

结论

  • 在第 \(t\) 轮回归树的结构确定后,我们得到的最优叶节点分数与结构无关 \(w_j^{\star} = -\frac{G_j}{H_j+\lambda}\)
  • 最小损失与第 \(t\) 轮回归树的结构的复杂度(叶节点数量)相关
  • 我们还需要确定第 \(t\) 轮回归树的结构

回归树的结构确定

普通决策树树结构的确定

  • 详细情况可参考: ML——DT-决策树
ID3
  • 最大化信息增益来选择分裂特征
C4.5
  • 最大化信息增益比来选择分裂特征
CART
分类树
  • 最小化基尼指数来选择分裂特征
回归树
  • 最小化平方误差来选择分裂特征

XGBoost结点分裂前后的信息增益

  • 信息增益应该与前面的损失函数相关, 损失越小越好
  • 原始损失函数为
    $$
    \begin{align}
    L^{\star^t} \approx -\frac{1}{2}\sum_{j=1}^{T}\left(\frac{G_j^2}{H_j+\lambda}\right) + \gamma T
    \end{align}
    $$
  • 显然,要使得损失函数最小,我们需要使得下面的式子最大:
    $$
    \begin{align}
    \frac{G_j^2}{H_j+\lambda}
    \end{align}
    $$
  • 一个结点分裂后的信息为
    $$
    \begin{align}
    \frac{G_L^2}{H_L+\lambda} + \frac{G_R^2}{H_R+\lambda}
    \end{align}
    $$
    • 左子树的信息 + 右子树的信息
  • 一个结点分裂前信息为
    $$
    \begin{align}
    \frac{(G_L + G_R)^2}{H_L+ H_R + \lambda}
    \end{align}
    $$
  • 从而我们定义一个结点分列前后的信息增益为:
    $$
    \begin{align}
    Gain = \frac{G_L^2}{H_L+ \lambda} + \frac{G_R^2}{H_R+ \lambda} - \frac{(G_L + G_R)^2}{H_L+ H_R + \lambda} - \gamma
    \end{align}
    $$
    • Gain 越大说明当前结点的当前分裂方式越好
    • 其中 \(\gamma\) 是一个超参数用于防止过拟合,可以理解为有两层含义:
      • 用于对叶节点数目进行控制
      • 用于增大分裂前后Gain的阈值
      • 事实上 \(\gamma\) 不是凭空来的,开始的定义中 \(\gamma\) 就是L1正则化(叶节点数量)的系数, 这里分裂后叶节点数量多了1个, 我们希望树的叶节点越少越好(模型越简单越好),而这个的信息增益越大越好, 所以减去 \(\gamma\) 值,防止结点分裂得太多
      • 对于每个特征的每个分裂点, \(\gamma\) 值都相同,所以 \(\gamma\) 值对特征和分裂点的选择没有影响,只是影响了某个结点是否能够被分裂(信息增益太小或者为负时我们可以选择不分裂)

XGBoost树节点分裂

精确分裂算法
  • 单个叶节点精确计算信息增益分裂流程(特征和特征分裂取值的选择, 假设一共m个特征)
    • 注意: 每次只对叶节点分裂,已经分裂了的就不是叶节点了,不能二次分裂
    • 原图来自: https://www.cnblogs.com/massquantity/p/9794480.html
近似分裂算法
  • 将每个特征的取值划分为多个分位点
  • 每次考察特征时值考察分位点,减少计算复杂度
  • 其他的步骤与前面的精确分裂算法相同,包括分数计算和选择最大分数等
分桶策略与GBDT的不同
  • 传统的GBDT分桶时每个样本的权重都是相同的
  • XGBoost中每个样本的权重为损失函数在该样本点的二阶导数(对不同的样本,计算得到的损失函数的二阶导数是不同的), 这里优点AdaBoost的思想,重点关注某些样本的感觉
  • 这里影响的是划分点的位置(我们划分划分点[桶]时都是均匀划分样本到桶里面,当不同样本的权重不同时,每个桶里面的样本数量可能会不同)
  • 下图是一个示例
  • 详细推导解释,为什么选择损失函数在当前样本的二阶导数作为权重?
    $$
    \begin{align}
    L^{t} &\approx \sum_{i=1}^{n}\left(g_if_t(x_i) + \frac{1}{2}h_if_t^2(x_i)\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2 \\
    &\approx \sum_{i=1}^{n}\frac{1}{2}h_i\left(2\frac{g_i}{h_i}f_t(x_i) + f_t^2(x_i)\right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2 \\
    &\approx \sum_{i=1}^{n}\frac{1}{2}h_i\left(f_t(x_i) - \frac{g_i}{h_i}\right)^2 + \sum_{i=1}^{n}\left ( \frac{g_i^2}{2h_i} - 2g_if_t(x_i) \right) + \gamma T + \frac{1}{2}\lambda \sum_{j=1}^{T}w_{j}^2 \\
    \end{align}
    $$
    • 上面的式子中第二项在原文中用constant来表示,可以被看成某种正则项
    • 第一项是一个平方误差表达式,样本 \(x_i\) 对应的输出值为 \(\frac{g_i}{h_i}\), 而样本权重就是 \(h_i\)
    • 权重代表概率,概率越大说明该点出现的次数或者该点附近的值出现的次数就越多.
  • XGBoost分桶流程
    • [待更新]

XGBoost整棵树分裂流程

  • 初始化\(f^0(x)\)
  • for t=1 to M:
    • 计算损失函数对每个训练样本点的一阶导数 \(g_i\) ,二阶导数 \(h_i\)
    • 递归对叶子节点运用树分裂算法生成一颗决策树 \(f^t(x)\),
      • (这一步包括叶子节点的分数 \(w_j\) 也都确定下来)
      • (这一步可以使用近似分裂算法加快训练速度)
    • 把新生成的决策树加入到模型中, \(\hat{y}^t = \hat{y}^{t-1} + f_m(x)\)

传统GDBT与XGBoost的比较

  • 参考博客: ML——XGBoost-vs-传统GBDT

DL——BN-LN-IN-GN-LRN-WN

Posted on 2018-02-17

本文介绍各种不同的Normalization方法

  • BN: Batch Normalization
  • LN: Layer Normalization
  • IN: Instance Normalization
  • GN: Group Normalization
  • LRN: Local Response Normalization
  • WN: Weight Normalization

Normalization总体介绍

  • BN,LN,IN的归一化的步骤都是使用下面的公式:
    $$
    \begin{align}
    u &= \frac{1}{m}\sum_{k\in S}x_k \\
    \sigma &= \sqrt{\frac{1}{m}\sum_{k\in S}(x_k-u) + \epsilon} \\
    \hat{x} &= \frac{1}{\sigma}(x-u) \\
    y &= \gamma \hat{x} + \beta
    \end{align}
    $$
    • \(u\) 为均值
    • \(\sigma\) 为标准差
    • \(\gamma\) 和 \(beta\) 是可以训练的参数
    • \(\epsilon\) 是平滑因子, 防止分母为0
    • BN,LN,IN三种不同的归一化方法, 对应的数据集 \(S\)不同
      • BN对同一批数据进行归一化, 不管其他神经元, 只针对某个神经元的Mini Batch个样本输出值做归一化
      • LN对同一个样本的同一层输出进行归一化, 不依赖其他样本, 每次只依赖当前样本本身

BN

Batch Normalization

  • 对一批数据实行归一化
  • 对某个具体的神经元的Mini Batch个样本输出做归一化, 与其他神经元的输出无关
  • 代码:
    1
    2
    3
    4
    mu = np.mean(x,axis=0)
    sigma2 = np.var(x,axis=0)
    x_hat = (x-mu)/np.sqrt(sigma2+eps)
    out = gamma*x_hat + beta

LN

Layer Normalization

  • 对单个训练样本的同一层所有神经元的输入做归一化
  • 与其他样本无关

BN的作用和说明

  • Batch Normalization把网络每一层的输出Y固定在一个变化范围的作用
  • BN都能显著提高训练速度
  • BN可以解决梯度消失问题
    • 归一化操作将每一层的输出从饱和区拉到了非饱和区(导数),从而解决了梯度消失问题
  • 普通的优化器加上BN后效果堪比Adam
    $$ ReLU + Adam \approx ReLU + SGD + BN$$
  • 如果对于具有分布极不平衡的二分类测试任务, 不要使用BN
  • BN一定程度上有归一化作用
    • BN本身就能提高网络模型的泛化能力
    • 使用BN后,不用太依赖Dropout, L2正则化等,可以将L2正则化的参数变小一点

WN

Weight Normalization

  • 对参数做归一化
  • 与数据无关

总结

BN和WN对比

  • BN是对对一个mini batch的数据在同一个神经元计算均值和方差
  • WN对网络的网络权值 W 进行归一化(L2归一化)

BN和LN对比

  • BN高度依赖于mini-batch的大小,实际使用中会对mini-Batch大小进行约束,不适合类似在线学习(mini-batch为1)情况;
  • BN不适用于RNN网络中normalize操作:
    • BN实际使用时需要计算并且保存某一层神经网络mini-batch的均值和方差等统计信息,对于对一个固定深度的前向神经网络(DNN,CNN)使用BN,很方便;
    • 但对于RNN来说,sequence的长度是不一致的,换句话说RNN的深度不是固定的,不同的time-step需要保存不同的statics特征,可能存在一个特殊sequence比其的sequence长很多,这样training时,计算很麻烦
  • 但LN可以有效解决上面这两个问题
  • LN适用于LSTM的加速,但用于CNN加速时并没有取得比BN更好的效果

PyTorch——关于Variable类和Tensor类的类型判断

Posted on 2018-02-07

问题描述

requires_grad=True

等价于requires_grad=a, a为任意非0整数,不能为浮点数
浮点数会报错: TypeError: integer argument expected, got float

  • 测试代码

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    import torch
    from torch.autograd import Variable

    tensor = torch.ones(1)
    variable = Variable(tensor, requires_grad=True)
    print(tensor)
    print(variable)
    print("type1: ", type(tensor), type(variable))
    print(tensor.data)
    print(variable.data)
    print("type2: ", type(tensor.data), type(variable.data))
    print(tensor.data.numpy())
    print(variable.data.numpy())
    print("type3: ", type(tensor.data.numpy()), type(variable.data.numpy()))
    print(tensor.numpy())
    print(variable.numpy())
    print("type4: ", type(tensor.numpy()), type(variable.numpy()))

    # Output:
    tensor([1.])
    tensor([1.], requires_grad=True)
    ('type1: ', <class 'torch.Tensor'>, <class 'torch.Tensor'>)
    tensor([1.])
    tensor([1.])
    ('type2: ', <class 'torch.Tensor'>, <class 'torch.Tensor'>)
    [1.]
    [1.]
    ('type3: ', <type 'numpy.ndarray'>, <type 'numpy.ndarray'>)
    [1.]
    Traceback (most recent call last):
    File "/home/jiahong/JupyterWorkspace/test.py", line 16, in <module>
    print(variable.numpy())
    RuntimeError: Can't call numpy() on Variable that requires grad. Use var.detach().numpy() instead.
  • 从上面的测试用例可以看出:

    • Variable和Tensor在判断类型时都是torch.Tensor
      • type(tensor) == type(variable) == torch.Tensor
    • 几乎所有操作都相同
      • tensor.data == variable.data
      • tensor.data.numpy() == varible.data.numpy()
    • 直接输出变量结果不相同
      • tensor输出时没有requires_grad=True
      • variable输出时有requires_grad=True
    • variable不能直接调用函数variable.numpy(),会报异常
      • 异常描述为: 当前Variable变量要求requires grad,也就是requires_grad属性为真时,变量不能直接使用

requires_grad=False

等价于requires_grad=0
不等价于requires_grad=None, None会报错: TypeError: an integer is required

  • 测试代码:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    import torch
    from torch.autograd import Variable

    tensor = torch.ones(1)
    variable = Variable(tensor, requires_grad=False)
    print(tensor)
    print(variable)
    print("type1: ", type(tensor), type(variable))
    print(tensor.data)
    print(variable.data)
    print("type2: ", type(tensor.data), type(variable.data))
    print(tensor.data.numpy())
    print(variable.data.numpy())
    print("type3: ", type(tensor.data.numpy()), type(variable.data.numpy()))
    print(tensor.numpy())
    print(variable.numpy())
    print("type4: ", type(tensor.numpy()), type(variable.numpy()))

    # Output:
    tensor([1.])
    tensor([1.])
    ('type1: ', <class 'torch.Tensor'>, <class 'torch.Tensor'>)
    tensor([1.])
    tensor([1.])
    ('type2: ', <class 'torch.Tensor'>, <class 'torch.Tensor'>)
    [1.]
    [1.]
    ('type3: ', <type 'numpy.ndarray'>, <type 'numpy.ndarray'>)
    [1.]
    [1.]
    ('type4: ', <type 'numpy.ndarray'>, <type 'numpy.ndarray'>)
  • 从上面的测试用例可以看出:

    • 当variable变量的requires_grad=False时,variable完全退化为tensor
      • 直接输出变量时没有requires_grad=False属性
      • 可以直接使用variable.numpy()函数

Variable的三种等价定义

下面三种定义的Variable类型变量varible等价

  • requires_grad=False

    1
    variable = Variable(tensor, requires_grad=False)
  • 没有requires_grad参数

    1
    variable = Variable(tensor)
  • requires_grad=True,然后variable = variable.detach()

    1
    2
    variable = Variable(tensor, requires_grad=True)
    variable = variable.detach()
  • 上面三种定义都等价于原始的tensor

    • 这里的等价并未经过详细测试,但是至少以下方面等价:
      • 自身类型相同type, 类型为torch.Tensor
      • 可以调用属性.data,类型为torch.Tensor
      • 可以调用.grad,只不过都为None
      • 直接输出对象完全相同,都不包含requires_grad=True属性
      • 可以调用相同的函数.numpy(), 类型为numpy.ndarray
      • 可以调用相同的函数.data.numpy(), 类型为numpy.ndarray

DL——Attention

Posted on 2018-02-04

本文主要介绍Attention的原理和变种

  • 参考博客(其中有些错误,本文已经修正): https://zhuanlan.zhihu.com/p/47063917
  • 参考论文: An Introductory Survey on Attention Mechanisms in NLP Problems
  • 强烈推荐一篇写得非常好的动画讲解: 基于Attention的Seq2Seq可视化神经机器翻译机
  • 另一篇不错的Attention和Transformer讲解自然语言处理中的自注意力机制(Self-Attention Mechanism)

RNN的局限: Encoder-Decoder模型

  • RNN 结构
  • Encoder-Decoder结构

Attention机制的引入

  • Attention机制的根本优势在于对不同的
  • 引入Attention前后的Encoder和Decoder对比图
    • 使用 Attention 前: \(\vec{h_{t}^{out}} = f(\vec{h_{t-1}^{out}},\vec{y_{t-1}})\)
    • 使用 Attention 后: \(\vec{h_{t}^{out}} = f(\vec{h_{t-1}^{out}},\vec{y_{t-1}}, \vec{c_{t}})\)
      • \(\vec{c_{t}} = q(\vec{h_{1}^{in}}, \dots, \vec{h_{T}^{in}})\)
      • \(q\) 是个多层的运算,有多重不同实现,详情参考后面的讲解
  • 动态图理解 Attention 机制
* 图中线条越清晰说明对当前结点的影响越大,不清晰说明影响较小
  • 进一步看结构图
  • 上图中Encoder使用的是双层双向的RNN
    • 第一层倒序从后\(X_T\)到前\(X_1\)生成, 反方向编码器
    • 第二层正序从前\(X_1\)到后\(X_T\)生成, 正方向编码器
    • 二者combine为一个更高维度的向量, 这个更高维度的向量整个作为Encoder的隐藏层
  • 流程说明:
    • 利用 RNN 结构得到 Encoder中的 Hidden State (\(\vec{h_1}, \vec{h_2},\dots, \vec{h_T}\))
    • 假设当前 Decoder 的Hidden State 是 \(\vec{s_{t-1}}\), 计算每一个 \(\vec{h_j}\) 与当前输入位置的关联性 \(e_{ij} = a(\vec{s_{t-1}}, \vec{h_j})\), 得到向量 \(\vec{e_t} = (a(\vec{s_{t-1}}, \vec{h_1}), \dots, a(\vec{s_{t-1}}, \vec{h_T})) \)
      • 这里的 \(a\) 是相关性的(函数)运算符, 常用的可以用向量内积(点成),加权点乘等
        • 内积点乘: \(e_{tj} = \vec{s_{t-1}}^T\cdot\vec{h_j}\)
        • 加权点乘: \(e_{tj} = \vec{s_{t-1}}^TW\vec{h_j}\) (一般使用这个)
        • 更复杂的: \(e_{tj} = \vec{v}^Ttanh(W_1\vec{s_{t-1}}^T + W_2\vec{h_j})\)
    • 对 \(\vec{e_t}\) 进行 softmax 操作,将其归一化得到 Attention 的分布, \(\vec{\alpha_t} = softmax(\vec{e_t})\)
    • 利用 \(\vec{\alpha_t}\), 我们可以进行加权求和得到相应的上下文向量(context verctor) \(\vec{c_t} = \sum_{j=1}^T\alpha_{tj}\vec{h_j}\)
    • 计算 Decoder 的下一个 Hidden State \(\vec{s_t} = f_h(\vec{s_{t-1}}, \vec{y_{j-1}}, \vec{c_t})\)

Attention的变种

这里的总结参考博客Attention

  • 基于强化学习的注意力机制:选择性的Attend输入的某个部分
  • 全局&局部注意力机制:其中,局部注意力机制可以选择性的Attend输入的某些部分
  • 多维度注意力机制:捕获不同特征空间中的Attention特征。
  • 多源注意力机制:Attend到多种源语言语句
  • 层次化注意力机制:word->sentence->document
  • 注意力之上嵌一个注意力:和层次化Attention有点像。
  • 多跳注意力机制:和前面两种有点像,但是做法不太一样。且借助残差连接等机制,可以使用更深的网络构造多跳Attention。使得模型在得到下一个注意力时,能够考虑到之前的已经注意过的词。
  • 使用拷贝机制的注意力机制:在生成式Attention基础上,添加具备拷贝输入源语句某部分子序列的能力。
  • 基于记忆的注意力机制:把Attention抽象成Query,Key,Value三者之间的交互;引入先验构造记忆库。
  • 自注意力机制:自己和自己做attention(这里的自己只每个文档自身),使得每个位置的词都有全局的语义信息,有利于建立长依赖关系。

广义的Attention机制

参考博客: https://www.sohu.com/a/226596189_500659

  • Attention的本质:
    • 一个Attention函数可以被描述为一个把查询(Query)和键-值(Key-Value)对集合变换成输出(Attention Value)的映射
    • 简单的讲就是一个把 (Query,[Key-Value]s) 映射成一个 Attention Value (输出)
    • An attention function can be described as Mapping aquery and a set of key-value pairs to an output
  • 表示成数学公式如下
  • 如上图所示,在计算 Attention 时主要分为三步
    • 第一步是将 Query 和每个 Key 进行相似度计算得到权重,常用的相似度函数有点积,拼接,感知机等
    • 第二步一般是使用一个 Softmax 函数对这些权重进行归一化
    • 第三步将权重和相应的键值 Value 进行加权求和得到最后的 Attention
  • Attention过程还可以大致分为两步理解:
      1. 将Query和Key经过相似度计算(某种数学运算)的结果通过 Softmax 激活函数激活得到上文所说的权重得分布 \(\vec{\alpha} = (\alpha_1\dots \alpha_n)\)
        • 变换一般包括
          • 点乘(Dot): \(f(Q,K_i) = Q^TK_i\)
          • 加权点乘(General): \(f(Q,K_i) = Q^TW_{\alpha}K_i\), \(W_{\alpha}\) 对不同的 \(\alpha_i\)
          • 拼接(Concat): \(f(Q,K_i) = W[Q^T;K_i]\)
          • 感知机(Perceptorn): \(f(Q,K) = \boldsymbol{v}^T tanh(W_Q, UK_i)\)
        • Query和Key在不同任务中是不同的东西
          • 在阅读理解中: Query指的是问题,Key指的是文档
          • 在简单的文本分类中: Query和Key可以是同一个句子(这也就是Self Attention), 也就是句子自己和自己做两个词之间的相似度计算的到权重分布
      1. 将权重分布 \(\vec{\alpha} = (\alpha_1\dots \alpha_n)\) 对Value做加权求和得到最终的特征表示
        • 在当前NLP任务中, 基本上 Key == Value
        • 阅读理解任务中, Value指的就是前面的Key, 是文档
        • 简单文本分类中, Value指句子
        • 在 Self Attention 机制中, 由于之前提到过, Query == Key, 所以有Key == Value == Query
          • 输入一个句子,那么里面的每个词都要和该句子中的所有词进行 Attention 计算, 然后Softmax得到当前句子中每个词的权重,进而对句子中的词求和, 输出当前句子在当前模型中的Attention表示(Attention Value), 即$$\boldsymbol{Y_{AttentionOutput}} = Self Attention(\boldsymbol{Q},\boldsymbol{K},\boldsymbol{V}) = Attention(\boldsymbol{X},\boldsymbol{X},\boldsymbol{X})$$

Attention研究发展趋势

DL——MLP及其BP算法

Posted on 2018-02-04

多层感知机(Multi-Layer Perception, MLP)及其BP(Back Propagation)算法


多层感知机

  • 图示如下

BP算法

推导

以一维输出(二分类)为例

详细流程

  • 动图

References

References:

  • http://galaxy.agh.edu.pl/~vlsi/AI/backp_t_en/backprop.html
  • https://www.cnblogs.com/ooon/p/5577241.html
  • https://blog.csdn.net/guotong1988/article/details/52096724

DL——DeepFM

Posted on 2018-02-04

文本介绍DeepFM的理论和实现

  • 原始论文: DeepFM: A Factorization-Machine based Neural Network for CTR Prediction, IJCAI 2017
  • 参考博客: https://www.jianshu.com/p/6f1c2643d31b

回顾特征组合的问题

传统解决方案

  • FM: (Factorization Machines, FM)因子分解机
  • FMM: (Field Factorization Machines, FFM)
存在问题
  • 只能二阶特征组合,无法做到高阶特征组合
    • 理论上来讲FM经过简单的拓展后可以组合高阶特征,但是那样的话参数会爆炸增加,所以实际上使用时一般只是二阶特征.

DNN建模高阶组合特征

优点
  • 理论上DNN建模高阶组合特征是可行的
缺点
  • 由于离散特征中我们使用One-Hot编码,会导致输入维度增加,网络参数很多
解决方案
  • 利用FFM中的思想,特征分为不同的Field
  • 基本思想是从One-Hot编码换成Dense Vector
  • 进一步加上两个全连接层(隐藏层),让刚刚学到的Dense Vector进行组合,于是得到高阶组合特征
  • 此时,高阶和低阶的特征体现在隐藏层中,我们希望把低阶特征组合单独建模,然后融合高阶特征组合
  • 将DNN与FM进行一个合理的融合
  • 二者的融合分两种方式: 串行结构和并行结构

DeepFM

  • 是一种并行化的解决方案

  • 包含 FM 和 DNN 两个部分, FM 负责低阶组合特征的提取,DNN 负责高阶组合特征的提取,两部分共享同样的输入

  • DeepFM的预测结果可以表示为如下的形式
    $$\hat{y} = sigmoid(y_{FM} + y_{DNN})$$

FM部分

  • 输出如下
    $$ y(x) = w_0+ \sum_{i=1}^n w_i x_i + \sum_{i=1}^n \sum_{j=i+1}^n w_{ij} x_i x_j $$

DNN部分

  • DNN部分是一个前馈神经网络
  • 与图像语音的区别:
    • 图像语音输入为连续且密集的
    • CTR中使用的一般是稀疏的
  • 在进入隐藏层之前,使用一个嵌入层(DenseEmbeddings): 将高维稀疏输入向量压缩为低维稠密向量
1…151617…20
Joe Zhou

Joe Zhou

世界上只有一种真正的英雄主义,那就是在认清生活真相之后依然热爱生活。 ——罗曼·罗兰

195 posts
38 tags
GitHub E-Mail
© 2024 Joe Zhou
Powered by Hexo
|
Theme — NexT.Gemini v5.1.4