论文1：《Chinese Spelling Error Detection and Correction Based on Language Model, Pronunciation, and Shape》[1, Yu, 2013]
论文提供了一种准确较高、召回较低的纠错方法。

1. Character级别 n-gram language model。
2. 拼音和字形召回候选
3. 词典过滤掉部分无效候选
4. 取最高语言模型打分
5. 高于既定阈值则认为是替换候选

系统流程图：

各步骤展开，具体简述如下：

1. 判断何处有输入错误，两种方式：
   a. 使用正向反向的character级别的ngram语言模型，对每个位置进行打分，得分低的地方标记为待纠错片段。
   b. 切词切出独立的字符。
   这里的ngram语言模型为5-gram，为了避免过多召回，阈值设定较为严苛。通过语言模型判断出的可疑位置将与上下文组合进行词典查词。
2. 召回：上一步词典过滤出的最终可疑词进行同音字和形近字的召回。召回候选与前后近邻组合为词进行词典查词过滤出有效候选。
3. 打分：候选中语言模型最高分，且得分大于阈值，则胜出。

论文2：《Guest Editorial: Special Issue on Chinese as a Foreign Language》[2, Lee, 2015]
论文为纠错综述文章，提了6篇文章，逐一拆解如下：

1. 《A Unified Framework for Chinese Spelling Correction》[3]提出基于隐马尔科夫和排序模型的纠错框架，配合基于规则的模型进行汉字纠错，其数据集为CLP-2014-CSC
2. 《A Study on Chinese Spelling Check Using Confusion Sets and N-gram Statistics》[4]通过说文解字和四角码扩大候选集合(Confusion Sets)，结合N-gram统计进行拼写纠错。
3. 《Automatically Detecting Syntactic Errors in Sentences Written by Learners of Chinese as a Foreign Language》[5]介绍了一种通过自动生成和手工规则来发现中文语法问题，提出了KNGED算法来发现语法错误。其数据集为NLP-TEA CFL(Chinese as Foreign Language)。
4. 《Automatic Classification of the “De” Word Usage for Chinese as a Foreign Language》[6]聚焦在”De”音的三个常用字{的，地，得}的形态句法，提出LEM 2算法用于规则生成，基于规则进行{的，地，得}的错别字分类识别。
5. 《The Error Analysis of “Le”Based on “Chinese Learner Written Corpus”》以“华语学习者语料库”为本的”了”字句错误分析。“了”为中文常见的时貌标记和句尾虚词，但其表动作完成的语义，可能使华语学习者将其泛化为过去时标记，而成为学习难点。文章以”台师大华语学习者语料库”为本，分析初级A2和中级B1英语母语者学习”了”字句时的使用情形和偏误类型，有以下发现：
   1. 初级A2和中级B1学习者都较难掌握作为时貌标记的”了”，这类问题最常见，而较容易掌握作为句尾虚词的”了2”。
   2. 不论初级A2或中级B1都有”了”过度泛化的情况。
   3. 此二级学习者在“了2”及“了1+2”的使用上，皆多为冗余偏误。对于外国人学习教学应先由简到繁，介绍“了2”和相关句型，再介绍”了”和相关句型。
6. 《Cross-Linguistic Error Types of Misused Chinese Based on Learners》基于东京大学语言学习者的语料库”Full Moon”，详细地研究了常见汉语学习者在书写时容易犯的错误，对错误类型进行了语言学角度的分类和定义。文章对日美两国学习者在学习时不同的量词使用错误进行了分析。

论文3：《Chinese Spelling Checker Based on Statistical Machine Translation》[8, Chiu, 2013]
文章综合使用了基于统计和基于规则的方法，规则召回的可能出错的位置通过统计翻译模型进行二次确认。作者将纠错视为一项翻译任务，即结合替换概率以及语言模型，将错误的句子翻译成正确的句子。
作者将纠错分三个阶段：

1. 切词：降低候选的搜索空间
2. 错误识别，找到可能错误的位置.(例如，两个以上的单字含更多错误。不过，这方法会受到切词粒度的影响，作者引入正确的web单字语言模型，甄别真实输入错误，即切词+使用词典+语料库语言模型方式进行错误判断。)
3. 召回候选，错误纠正。召回候选使用引文[9, liu, 2011]的混淆集合(confusion set)。错误纠正套用SMT框架，定义翻译概率为： $$p(error|candi) = lo{g_{10}}\left( {{{freq\left( {error \to candi} \right)} \over {freq\left( {error \to candi} \right) - freq\left( {candi} \right)}}*\gamma } \right)$$ 公式按我的理解换了表述方式，其中${freq\left( {error \to candi} \right)}$表示替换为候选的次数，${freq\left( {candi} \right)}$表示为候选的次数。$\gamma $ 表示音频召回和字形召回的权重算子。解码的时候综合考虑翻译概率和语言模型，纠错比翻译任务少了排序一项。

文章未考虑删词和多词情况，作者建议的其他额外特征有：新词发现、POS、专名、ngram作为确认边界的词典。

论文4：《Chinese Word Spelling Correction Based on Rule Induction》[10, yeh, 2014]
前置介绍E-Hownet为词库小组于2003年起开始建构繁体知识图谱。按下述系统流程图，分训练部分和测试部分。训练部分为了得到测试部分所需词典，加上同音词典和形近词典一共有三个词典。训练的流程分四个部分：

1. 输入预处理，去除空格和圆括号等无关符号。
2. 切词，标记POS。
3. 规则衍生出候选词典，根据训练数据上下文及形似词典组合，在E-Hownet找到最佳词，形成候选词典。
   测试阶段分为：
4. 输入预处理，去除空格和圆括号等无关符号。
5. 切词，标记POS。
6. 判断是否错误（若干规则）
   a. 组合两个字以上的词（token），如果不在E-Hownet和训练集词典中(?)。
   b. 四个字的词(token)过一次形近词典和音近词典、E-Hownet，如果没找到，则认为该位置的词不正确。
   c. 通过pos规则找到“的、地、得”问题
   d. 组合连续两个单字词(token)，连接起来作为一个错词。
   得到错误位置后，将其替换为音近或者形近字，保留存在于E-Hownet和训练集词典中的词。
7. 多个候选以E-Hownet中下标小的为最佳。

论文5：《Understanding Error Correction and its Role as Part of the Communication Channel in Environments composed of Self-Integrating Systems》[12, lodwich, 2016]
这篇文章介绍了纠错在通讯系统里的重要性，篇幅较长60+。跟文本纠错有关的章节在2.4节”Error Correction in high-level languages”， 里面有句话颇有共鸣：“Error correction for high-level languages can demand a large amount of a priori knowledge which is usually too large to be provided as additional information by the sender and hence is provided directly to the receiver’s knowledge pool”。纠错是重资源依赖型，资源可以引申为与应用场景相关的先验信息。纠错如果需要继续深入，突破口应该在灵活多变的架构上，而不是万能纠错。

论文6：《Using Higher-level Linguistic Knowledge for Speech Recognition Error Correction in a Spoken Q/A Dialog》[13, jeong, 2004]
在对话系统中的中文纠错文章较少，这篇文章是韩国学者写的，对中文也有一定参考价值。耦合语音输入场景，作者在本文提出了基于音节的纠错模型。传统纠错常用的noisy channel模型，给定观测序列$O = {o_1},{o_2},...,{o_n}$，找到最佳的正确结果序列$W = {w_1},{w_2},...,{w_3}$。在语音识别纠错应用中，观测序列为语音识别模型输出的文本序列，我们需要找到用户在对应场景下想表达的正确结果。根据贝叶斯公式推导得：
$$\hat W = \arg \mathop {\max }\limits_W P\left( {W|O} \right) = \arg \mathop {\max }\limits_W P\left( W \right)P\left( {O|W} \right)$$
其中两项分别为语言模型$P\left( W \right)$和channel model$P\left( {O|W} \right)$。语言模型的一阶马尔可夫模型可以表达成：
$$P\left( W \right) = \mathop \prod \limits_i P\left( {{w_i}|{w_{1,i - 1}}} \right)$$
如果简单假设给定，结果序列的channel model的条件概率可以表达成：
$$P\left( {O|W} \right) = \prod\limits_i {P\left( {{o_i}|{w_i}} \right)} $$
这个假设太强，以至于无法处理如下”1对多”和”多对1”的两种情形。
。
作者通过简化统计翻译模型IBM-Model-4利用了前一个位置的观察${{o_{i-1}}}$和输出结果${{w_{i-1}}}$，这部分最初工作来自(15, Brown, 1990)。
前面介绍了基于字的noisy channel model，韩语是表音文字，每个字可以根据其构成拼读出来，不需要另外单独的拼音系统，如果将字级别粒度进一步细化成音节级别，可以降低数据稀疏的问题。语音识别的输出序列由$W = {w_1},{w_2},...,{w_3}$替换为$S = {s_1},{s_2},...,{s_n}$，公式改造如下：
$$\hat W = \arg \mathop {\max }\limits_W P\left( {W|S} \right)$$
类似地，应用贝叶斯法则，在条件概率公式中引入音节的中间变量，进一步分解：
$$P\left( {w|s} \right) = {{P\left( {s|w} \right)P\left( w \right)} \over {P\left( s \right)}} \propto {P\left( {s|w} \right)P\left( w \right)} = \left( {\sum\limits_x {P\left( {s|x} \right)P\left( {x|w} \right)} } \right)P\left( w \right)$$
公式和原文略有不同原文公式最后为约等号$\approx P\left( {s|x} \right)P\left( {x|w} \right)P\left( w \right)$，感觉有点问题。最终公式形态为：
$$\hat W = \arg \mathop {\max }\limits_W P\left( W \right)P\left( {X|W} \right)P\left( {S|X} \right)$$
这个式子类似于语音识别里的隐马尔可夫模型。$P\left( {S|X} \right)$为声学模型，而$P\left( {X|W} \right)$为发音词典。在实验中作者用了2个字节的二阶马尔科夫模型。
简介文章中整体纠错流程：

1. 语义级别纠错：使用Lexico-Semantic Pattern(LSP)[16, Jung, 2003] (LSP将query抽象为词法模板，类似POSTAG工作，举例 “Recretion coach”->”%hobby @position”)。通过预先收集的(话术)模板数据库进行语义级别纠错，在相同的LSP标签下找到数据库里面编辑距离最相似的候选，将语义级别LSP标签错误进行替换。
2. 词汇级别纠错：对于LSP标签错误和词汇错误情况，通过前文介绍的基于音节的noisy channel model进行召回，并以动态规划方法进行动态求解。

论文7 《A hybrid approach to automatic Chinese text checking and error correction》[19, Ren, 2001]
作者在这篇论文里面提出使用规则+统计进行错误识别

1. 规则，例如：中文语法中“数词+量词+名词”。通过语法规则进行错误识别。
2. 统计
   a. 词频
   b. 相邻词之间的共现矩阵，例如“百度搜索”， “百度”和“搜索”共现
   c. 相邻字之间的共现矩阵，例如“网盘”， “网”和“盘”共现
   d. 相邻词内部的相邻字，例如“百度搜索”， “度”和“搜”
   e. 字词位置关系。例如字位于词的第N个位置，也能提供很强的统计信息，约有1200个汉字只出现在词第一位，3008个汉字只会出现在第二个。

论文8 《Neural Language Correction with Character-Based Attention》[20, zhang, 2016]
这篇文章介绍NN在英文纠错里面的应用，简介如下：

1. 作者使用了金字塔结构的GRU-RNN训练了一个纠错场景下的encoder decoder网络，解码过程使用了attention机制。
2. 接着采用beam search算法，结合传统Ngram语言模型模型，进行最佳结果序列选择。
3. 得到结果序列以后，再采用一个多层感知机分类器对纠错位置进行是否为正确纠错的判断。多层感知机使用编辑距离相关特征和词向量特征，其中词向量特征为GloVe训练出的100维向量。

[1] Yu J, Li Z. Chinese Spelling Error Detection and Correction Based on Language Model, Pronunciation, and Shape[C]// Cips-Sighan Joint Conference on Chinese Language Processing. 2014:220-223. （注：资源：形近词典，音近词典来自Yeh et al. 2013）
[2] Lee L H, Yu L C, Chang L P. Guest Editorial: Special Issue on Chinese as a Foreign Language[J]. 中文計算語言學期刊, 2015, 20:i-vi.
[3] Zhang S, Xiong J, Hou J, et al. HANSpeller++: A Unified Framework for Chinese Spelling Correction[C]// Eighth Sighan Workshop on Chinese Language Processing. 2015.
[4] Chuan-Jie Lin and Wei-Cheng Chu (2015). “A Study on Chinese Spelling Check Using Confusion Sets and N-gram Statistics,” International Journal of Computational Linguistics and Chinese Language Processing, to be appeared.
[5] Chang T H, Sung Y T, Hong J F. Automatically Detecting Syntactic Errors in Sentences Written by Learners of Chinese as a Foreign Language[J]. 中文計算語言學期刊, 2015, 20.
[6] Yeh J F, Yeh C K. Automatic Classification of the “De” Word Usage for Chinese as a Foreign Language[J]. 中文計算語言學期刊, 2015, 20.
[7] Mochizuki K, Sano H, Shen Y M, et al. Cross-Linguistic Error Types of Misused Chinese Based on Learners[J]. 中文計算語言學期刊, 2015, 20.
[8] Hsun-wen Chiu, Jian-cheng Wu, Jason S. Chang, Chinese Spelling Checker Based on Statistical Machine Translation, colling 2013, 2013
[9] Chao-Lin Liu, Min-Hua Lai, Kan-Wen Tien, Yi-Hsuan Chuang, Shih-Hung Wu, ＆ Chia-Ying Lee (2011). Visually and phonologically similar characters in incorrect Chinese words: Analyses, identification, and applications. ACM Trans. Asian Lang, Inform. Process. 10, 2, Article 10, pages 39, June 2011.
[10] Yeh J F, Lu Y Y, Lee C H, et al. Chinese Word Spelling Correction Based on Rule Induction[C] // Cips-Sighan Joint Conference on Chinese Language Processing. 2014:139-145.
[11] JF Yeh，SF Li，MR Wu，WY Chen，MC Su Chinese Word Spelling Correction Based on N-gram Ranked Inverted Index List, In Six International Joint Conference on Natural Language Processing, 2013
[12] Lodwich A. Understanding Error Correction and its Role as Part of the Communication Channel in Environments composed of Self-Integrating Systems[J]. 2016.
[13] Jeong M, Kim B, Lee G G. Using higher-level linguistic knowledge for speech recognition error correction in a spoken Q/A dialog[C]// Hlt-Naacl Special Workshop on Higher-Level Linguistic Information for Speech Processing. 2004:48–55.
[14] Wang X, Li L. An N-gram based Chinese syllable evaluation approach for speech recognition error detection[C]// International Conference on Natural Language Processing and Knowledge Engineering, 2009. Nlp-Ke. IEEE, 2009:1-6.
[15] Voll K, Atkins S, Forster B. Improving the utility of speech recognition through error detection.[J]. Journal of Digital Imaging, 2008, 21(4):371.
[16] P. F. Brown, J. Cocke, S. A. Della Pietra, V. J. Della Pietra, F. Jelinek, J. D. Lafferty, R. L. Mercer, and P. S. Roossin. 1990. A Statistical Approach to Machine Translation. Computational Linguistics, 16(2):79-85
[17] Hanmin Jung, Gary Geunbae Lee, Wonseug Choi, KyungKoo Min, and Jungyun Seo. 2003. Multilingual question answering with high portability on relational databases. IEICE transactions on information and systems, E-86D(2):306-315.
[18] Lin C J, Chen S H. NTOU Chinese Grammar Checker for CGED Shared Task[C]// The Workshop on Natural Language Processing Techniques for Educational Applications. 2015:15-19. 作者根据语言模型定义了错误识别函数，使用svm判断出错位置。
[19] Ren F, Shi H, Zhou Q. A hybrid approach to automatic Chinese text checking and error correction[C]// IEEE International Conference on Systems, Man, and Cybernetics. IEEE, 2001:1693-1698 vol.3.
[20] Xie Z, Avati A, Arivazhagan N, et al. Neural Language Correction with Character-Based Attention[J]. 2016.

论文TODO List：
Correcting Chinese Spelling Errors with Word Lattice Decoding
Spelling checking using conditional random fields with feature induction for secondary language learners
Improving the Utility of Speech Recognition Through Error Detection
A METHODOLOGY OF ERROR DETECTION: IMPROVING SPEECH RECOGNITION IN RADIOLOGY
DIRECTED AUTOMATIC SPEECH TRANSCRIPTION ERROR CORRECTION USING BIDIRECTIONAL LSTM
A rule based Chinese spelling and grammar detection system utility. 2012.

（注：//历年举办纠错大会SIGHAN workshop自IJCNLP 2013年开始。）
后续会整理出一些ctr和online learning 相关的笔记

Motivation

1.1 internal convariate shit
传统的浅层学习模型，如单层的logistic regression, SVMs以及2层结构的FMs等模型，每次更新参数均从稳定的训练数据上拟合. 深度学习因其多层结构，浅层输出作为下一层输入.除了梯度消失问题外，在学习过程中，每层网络的参数不断更新，导致下一层输入的分布不断变化. 因而无法跟浅层模型一样，每次都在稳定的数据上学习参数. 除了降低学习率外，还要初始化一组良好的参数，调得一手好参.
1.2 为什么要初始化一组良好的参数
学习过UFLDL或者做过图像实验的同学会发现对数据进行预处理，例如PCA Whitening或者简单的z-score都是可以加速收敛的.
首先图像数据是局部高度相关的，并且个维度上的数据取值在[0,255]之间. 简化到2维，图像数据仅会落到第一象限，如下图:

图片来自happynear的博客²
假设激活函数为ReLu$f(x) = \text{max}(Wx + b)$, 如果不通过精心设计或者fine-tune，而随机初始化$W$, 学习的前期阶段很可能是图中的绿色虚线，需要经过长时间的迭代才能收敛到紫色虚线，得到一个好的拟合结果。
如果对数据做预处理，例如z-score/PCA whitening等线性变化，映射到0均值单位方差的平移后空间里，那么收敛效果会有显著提升。因为减去均值后，数据能分散到各个象限；更进一步的，对数据做去相关操作，提高收敛效率.
1.3 为什么做的是线性变换而不能做非线性变换呢？
Batch Normalization是数据层面的改进，要保留数据的原貌，即保留特征的非线性关系.

Normalization via Mini-Batch Statistics

前向反馈时，在每个Batch中，从特征维度上计算出mini-batch和mini-batch variance之后完成normalization.
理想情况下，均值和方差应该是在整个数据集上计算的，然而不能穿越得到unseen data，因此，退而求其次，用Batch中统计的均值和方差作为整个数据集的估计.
完成normalization之后算法似乎该结束了，但是如果把特征都normalize到$\cal{N}(0,1)$，那么因为特征只在激活函数上线性区域上激活，会降低特征的表达能力. 如下图虚线和Sigmoid曲线的重叠的部分.

容易混淆的是，Hinton老爷子曾在公开课Neural Networks for Machine Learning³里提到神经网络的weight应该初始化在$\cal{N}(0,1)$附近，防止梯度消失.

但是，如果使用PReLU或者ELU等激活函数，是不会有这个问题的!

针对上述问题，在算法结束之前，作者对normalization之后的数据$\hat{x_i}$设置了两个参数$\gamma$和$\beta$. 很显然如果$\gamma=\sqrt{\sigma^2_{\beta}}$,$\beta=\mu_{\beta}$，那么对$x_i$ scale
and shift之后的$y_i$就还原成$x_i$了. 至于是否需要对$y_i$进行还原，由构建好的模型自动从训练数据中学习决定， learning from data.

反向传播时，SGD也在Batch中计算，梯度公式很简单，请大家停下10分钟，在白纸上推导一遍，保证清楚理解链式法则计算梯度的思路. 这很重要，因为目前所有的学习算法都是基于链式法则的反向传播.

Implementation in Caffe

笔者接下来介绍Batch Normalization在Caffe中的实现.

实际应用中，$\mu_{\beta}$和$\sigma^2_{\beta}$通常是在训练集上计算，测试的时候直接使用训练时计算得到的值. 此外，Batch Normalization Layer的backward pass实际并没有被调用，因此笔者仅分析forward pass部分的代码.

首先Batch Normalization在proto中默认参数配置如下:

1
2
3
4
5
6
7
8
9
10
11

message BatchNormParameter {
    // If false, accumulate global mean/variance values via a moving average. If
    // true, use those accumulated values instead of computing mean/variance
    // across the batch.
    optional bool use_global_stats = 1;
    // How much does the moving average decay each iteration?
    optional float moving_average_fraction = 2 [default = .999];
    // Small value to add to the variance estimate so that we don't divide by
    // zero.
    optional float eps = 3 [default = 1e-5];
}

因为一些历史原因(可能是scale and shift只对使用sigmoid作为激活函数有效), Caffe的normalize step 和scale and shift step至今不在同一个layer中实现, 导致很多人在使用的时候经常出现不知道该怎么用或者这么用对不对的问题. 笔者建议参考ResNet⁴，并建议在BatchNorm中不显示配置batch_norm_param，而是有代码运行时自动判断是否use_global_stats，此外不建议做scale and shift step，因为sigmoid function效果通常是很差的，导致更多的是一开始就选择PReLu等激活函数:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

layer {
	bottom: "conv1"
	top: "conv1"
	name: "bn_conv1"
	type: "BatchNorm"
	// 不建议配置batch_norm_param. 
	batch_norm_param {
		use_global_stats: true
	}
} 
layer {
	bottom: "conv1"
	top: "conv1"
	name: "scale_conv1"
	type: "Scale"
	scale_param {
		bias_term: true
	}
}

详细代码走读参见笔者的github.

总结

本文首先解释了Batch Normalization的motivation以及该方法为什么work. 接着对算法内容进行详解，给出并建议读者朋友们动手在白纸上推导反向传播计算$\mu_{\beta}$和$\sigma^2_{\beta}$的梯度公式. 最后在github上提供了一份Caffe的bn代码走读.

欢迎并鼓励对本文和github上代码走读有不同见解的朋友们留言或者联系本站站长!

参考文献

1. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift
2. 《Batch Normalization Accelerating Deep Network Training by Reducing Internal Covariate Shift》阅读笔记与实现
3. Neural Networks for Machine Learning
4. ResNet-152-deploy

作者微博：@ryyen

基于聚类的分布表示(clusteringbased word representation)

这类方法通过聚类将词和类的标签建立关联，关联关系可以是确定性也可以是概率表示，用这种方式构建词与其上下文之间的关系。相关工作有(Brown, 1992)[10], (Ney, 1993)[35], (Niesler, 1998)[36]。布朗聚类(Brown, 1992)[10]是一种层级聚类方法，聚类结果为每个词的多层类别体系。可以根据两个词的公共类别判断这两个词的语义相似度。

基于矩阵的分布表示(distributional representation)

构建一个“词-上下文”矩阵，从矩阵中获取词的表示。在“词-上下文”矩阵中，每行对应一个词，每列表示一种不同的上下文，矩阵中的每个元素对应相关词和上下文的共现次数。
a. 矩阵构造
b. 矩阵元素值的确定
c. 降维技术将高维稀疏的向量压缩成低维稠密
典型如Latent Semantic Analysis (LSA) 的做法，构造word-doc矩阵，TF-IDF为每个元素的值。使用SVD分解，得到词的低维表达(Deerwester, 1990)[37] (Bellegarda, 1997)[34]。介绍两份比较近的工作：

• GloVe(Pennington, 2014)[27]，GloVe 模型是一种对“词-词”矩阵进行分解从而得到词表示的方法。矩阵第$i$行第$j$列的值为词$v_i$与词$v_j$ 在语料中的共现次数$x_{ij}$ 的对数。在矩阵分解步骤，GloVe 模型借鉴了LSA (Deerwester,1990)[31]，在计算重构误差时，只考虑共现次数非零的矩阵元素，同时对矩阵中的行和列加入了偏移项，根据共现词频对重构误差进行调权。文章论述了基于矩阵分解方法和skip-gram/ivLBL型优化目标相似，代码开源在：github，主页链接：paper。关于矩阵分解和神经网络方法之间关系的更多讨论可以参看(Omer Levy, 2014)[25], (Li Y, 2015)[26]
• FOREST(Yogatama, 2014)[32]， FOREST模型和GloVe不同，”词-词”矩阵第$i$行第$j$列的元素为词$v_i$与词$v_j$的互信息，将互信息矩阵分解为基矩阵和词的表示矩阵的乘积，在目标函数中，对表示矩阵的每一个维度，引入结构化正则化项。使用在线词典学习方法进行求解。

基于神经网络的分布表示(distributed representation)

神经网络词向量表示技术通过神经网络技术对上下文，以及上下文与目标词之间的关系进行建模，这类方法的最大优势在于可以表示复杂的上下文。
发展轨迹：

• 神经网络求解二元语言模型 (徐伟,2000)[13]
• Neural Network Language Model (Yoshua Bengio, 2001, 2003)[14,15]
  • Hierarchical NNLM(Bengio, 2005)[39]
• Log-Bilinear Language Model (Mnih & Hinton, 2007)[16]
  • Hierarchical LBL(Mnih, 2008)[17] {注：Hierarchical Softmax}
  • vector LBL / inverse vector LBL(Mnih, 2013)[18] {注：Skip-gram, 噪声比估算NCE}
• C & W model(Collobert & Weston, 2008)[21] {注：pair-wise negative sampling}
• CBOW & Skip-gram model(Mikolov,2013)[22]， (Mikolov, 2013)[23]

接下来按时序介绍下上面几篇文章：

1. (徐伟, 2000)[13]提出使用单层全联通神经网络处理语言模型，对词的bigram语言模型进行建模，最小化混淆度的log似然为目标，输入为每个词的one-hot表示，输出为给定当前词其他词的概率，通过softmax进行归一化输出值。
2. (Bengio, 2001, 2003][14,15]提出同时训练神经网络语言模型和词向量的方法。简介下[15, Bengio, 2003]的工作，将词表示为m维的特征向量，将语言模型表示为词向量的概率函数，同时学习词的特征向量和概率函数的参数。网络结构如下图：
   
   绿色虚线表示输入x有直连到softmax层，Bengio模型中这部分是可选的，因此也有其他地方的图是略掉这条虚线。直连边能让模型学习到词的权重更多，加快收敛速度。如果去除直连的话，通过隐层能学习到较多的泛化。由于激活函数和归一化部分计算耗时，论文里讨论了两种建立在异步更新权重的并行方法：共享内存的多处理器并行和网络并行。
3. (Bengio, 2005)[39]提出了Hierarchical NNLM，通过词义之间的关系启发式的构建二叉树，代替归一化计算，将训练速度提升200倍。构建树的启发来自(Goodman, 2001)[40]，将计算条件概率转为为一系列子分类概率的乘积，对于子分类问题，每一个分支，Bengio使用同一个分类器进行决策，由于分类的需求使得每一个叶子节点需要具备类别意义，很自然地引入了WordNet词之间的关系启发式地构建叶子节点。
4. (Mnih & Hinton, 2007)[16]用RBM建模LM，提出了三个模型，分别是Factored RBM, Temporal Factored RBM和Log-Bilinear Language Model。 语言模型结构如下图：
   其中$ v_i $为词的index向量，$R$为特征向量表，二者相乘可得到第$i$个词的向量表达。$h$为隐层。a). 左边模型结构实线部分为Factored RBM，结合虚线框部分构成Temporal Factored RBM，虚线框表示$h_{t-1}$，b). 右边结构为Log-Bilinear Language Model。能量表达式中去除了隐层，简化网络结构，提升训练速度。三个模型都是通过Constrastiv Divergence算法(Hinton, 2002)[38]进行训练。
5. (Mnih & Hinton, 2008)[17]在(Bengio, 2005)[39]的结构化NNLM启发下对LBL进行改进，提出了Hierarchical LBL。为了降低计算复杂性，限制对上下文Context的关系矩阵为对角矩阵，这种简化相当于直接进行两个向量内积。有别于引入WordNet资源，Mnih提出另一种思路建立词的二叉树结构，随机初始化二叉树，训练得到初始词向量。从根节点开始迭代使用高斯混合模型(K=2)进行聚类，为不同的词选择不同的分支。实验效果上看这种启发式建树的方式能明显提高LM的效果。
6. (Collobert &Weston, 2008)[21]尝试使用一套框架完成多项任务，训练LM任务通过随机替换当前词的方式构造负例，得到判别式语言模型同时产出词向量，判别式语言模型无需进行输出概率归一化，加快了计算速度，并尝试了将语言模型结合其他序列标注任务(NER, POS, Semantic Role Labeling)同时训练的方式，各个任务共享词的向量表达。后续在这个基础上提出了SENNA model(Collobert, 2011)[28]。下图为多任务训练示意图。
   
7. (Mikolov, 2013)[22]提出了CBOW(Continuous Bag Of words)和skipgram模型，CBOW使用窗口上下文作为输入，预测当前词。skipgram使用当前词作为输入，预测窗口范围内的其他词，精简了隐层，计算效率大为提高。下图为CBOW和skipgram网络结构图：
   
8. (Mnih & Kavukcuoglu, 2013)[18] 受Mikolov启发，在log-Bilinear Language Model基础上将矩阵运算简化为向量运算得到vector log-Bilinear Model(vLBL)，进一步简化上下文的表达为简单求和等价于CBOW，借鉴skipgram的思想：使用当前词预测上下文，得到inverse vector log-Bilinear Model(ivLBL)，目标函数采用Noise-contrastive estimation(Gutmann, 2012)[42]，代替原预测目标词的概率，加快了算法的收敛。在速度上比CBOW和skipgram有了进一步改善。
9. (Mikolov, 2013)[23] 在skipgram基础上尝试了NCE，并进一步简化NCE至Negative Sampling。训练过程中引入了采样(subsampling)来减轻无意义的高频词对词向量学习带来的影响。引入短语识别，解决先前词向量训练单位为unigram导致专名被打散的问题。这些特性同样可以用在CBOW模型。

上面罗列了近些年词向量技术发展的比较重要的文章，希望能帮助读者了解对词向量的发展过程。近两年也有一些比较好的工作，
a). 通过在目标函数中，引入词典中词义关系（同义词、词的上下位）进行联合训练(Yu M, 2014)[46]。
b). 引入双语语料，在不同语种的语料无监督得到词向量，利用不同语料间词对的关系进行典型相关分析(canonical correction analysis)，将词向量映射到一个新的空间(Faruqui, 2014)[47]。
c). 在各模型得到的词向量基础上，引入词典资源进行增强(Faruqui M, 2014)[43]。
d). 将网络结构转为局部线性结构学习节点的embedding，根据转化方式可以分为深度优先版本DeepWalk(Perozzi, 2014)[44]，广度优先版本LINE(Tang, 2015)[45]。
e). 进一步，在学习网络结构embedding的基础上引入了半监督学习，并给出了transductive框架（DeepWalk&LINE）和inductive框架。(Yang Z, 2016)[46].

如何衡量词向量的语言学特性，来博士的毕业论文(2016)[1]总结了8个评价指标

• 词义相关性(ws): WordSim353数据集，词对语义打分。
• 同义词检测(tfl): TOEFL数据集，80个单选题。准确率评价
• 单词语义类比(sem): 9000个问题。queen-king+man=women。准确率
• 单词句法类比(syn): 1W个问题。dancing-dance+predict=predicting。准确率
  词向量用作特征
• 基于平均词向量的文本分类(avg): IMDB数据集，Logistic分类。准确率评价
• 命名实体识别(ner): CoNLL03数据集，作为现有系统的额外特征。F1值
  词向量用作神经网络模型的初始值
• 基于卷积的文本分类(cnn): 斯坦福情感树库数据集，词向量不固定。准确率
• 词性标注(pos): 华尔街日报数据集，Collobert等人提出的NN。准确率

论文中对各模型进行了横向实验比较，推荐阅读。

word2vec源码及扩展

作者 Tomas Mikolov (Linked In) 目前在facebook
word2vec: 下载地址, 更新日志
笔者对核心代码word2vec.c进行了注释（按：可能是市面上最详lao细dao的注释），增加了两个小工具，见【github仓库】，txt2bin(明文转二进制)和distance_search（递归查找近邻向量）。

[更多扩展]对word2vec的具体实现进行优化可以参考“BIDMatch”(canny J, 2015)[48]高性能机器学习库的GPU版本，见 【github仓库】。 (Ji S, 2016)[49]将计算向量内积转为矩阵运算，使得计算从L1 level BLAS转为L3 level BLAS，并实现了分布式版本，支持增加计算节点加速词向量训练，见【github仓库】。

笔者按：本文定位为论文阅读整理笔记，前前后后历时数月。如果错漏了知识，请在评论里指出，谢谢。全文没有公式，读者如果能耐心看到这里，我会很开心。接下来会在业余时间对word2vec进行代码走读，然后在这个基础上做些词义相关的小实验，希望得到有意思的结果。

[1]基于神经网络的词和文档语义向量表示方法研究，来斯惟，中科院自动化研究所, 2016，文章地址：百度网盘
[2] Daniel D Lee and H Sebastian Seung. Algorithms for non-negative matrix actorization. In Advances in neural information processing systems, pages 556–562, 2001.
[3] Chih-Jen Lin. Projected gradient methods for nonnegative matrix factorization. Neural computation, 19(10):2756–2779, 2007.
[4] Paramveer S. Dhillon, Dean P. Foster, and Lyle H. Ungar. Multi-view learning of word embeddings via cca. In Advances in Neural Information Processing Systems, pages 199–207, 2011.
[5] Paramveer S. Dhillon, Dean P. Foster, and Lyle H. Ungar. Eigenwords: Spectral word embeddings. The Journal of Machine Learning Research, 16, 2015.
[6] Rémi Lebret and Ronan Collobert. Word embeddings through hellinger pca. EACL 2014, page 482, 2014.
[7] Thomas K Landauer, Peter W Foltz, and Darrell Laham. An introduction to latent semantic analysis. Discourse processes, 25(2-3):259–284, 1998.
[8] Jeffrey Pennington, Richard Socher, and Christopher D Manning. GloVe : Global Vectors for Word Representation. In Proceedings of the Empiricial Methods in Natural Language Processing, 2014.
[9] Fernando Pereira, Naftali Tishby, and Lillian Lee. Distributional clustering of english words. In Proceedings of the 31st annual meeting on Association for Computational Linguistics, pages 183–190, 1993.
[10] Peter F Brown, Peter V Desouza, Robert L Mercer, Vincent J Della Pietra, and Jenifer C Lai. Class-based n-gram models of natural language. Computational linguistics, 18(4):467–479, 1992.
[11] Robert M. Bell and Yehuda Koren. Lessons from the netflix prize challenge. SIGKDD Explor. Newsl., 9:75–79, 2007.
[12]Joseph Turian, Lev Ratinov, and Yoshua Bengio. Word representations: a simple and general method for semi-supervised learning.
[13] Wei Xu and Alex Rudnicky. Can artificial neural networks learn language models? In Sixth International Conference on Spoken Language Processing, 2000.
[14] Yoshua Bengio, Réjean Ducharme, and Pascal Vincent. A neural probabilistic language model. In Advances in Neural Information Processing Systems, pages 932–938, 2001.
[15] Yoshua Bengio, Réjean Ducharme, Pascal Vincent, and Christian Jauvin. A Neural Probabilistic Language Model. The Journal of Machine Learning Research, 3:1137–1155, 2003.
[16] Andriy Mnih and Geoffrey Hinton. Three new graphical models for statistical language modelling. In Proceedings of the 24th international conference on Machine learning, pages 641–648, 2007.
[17] Andriy Mnih and Geoffrey E Hinton. A scalable hierarchical distributed language model. In Advances in neural information processing systems, pages 1081–1088, 2008.
[18] Andriy Mnih and Koray Kavukcuoglu. Learning word embeddings efficiently with noise-contrastive estimation. In Advances in Neural Information Processing Systems, pages 2265–2273, 2013.
[19] Tomáš Mikolov. Statistical language models based on neural networks. PhD thesis, Brno University of Technology, 2012.
[20] Tomas Mikolov, Martin Karafiát, Lukas Burget, Jan Cernockỳ, and Sanjeev Khudanpur. Recurrent neural network based language model. In INTERSPEECH 2010, 11th Annual Conference of the International Speech Communication Association, pages 1045–1048, 2010.
[21]Ronan Collobert and Jason Weston. A unified architecture for natural language processing: Deep neural networks with multitask learning. International Conference on Machine Learning, 2008
[22]Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. International Conference on Learning Representations Workshop Track, 2013.
[23]Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pages 3111–3119, 2013
[24] Turian J, Ratinov L, Bengio Y. Word representations: a simple and general method for semi-supervised learning[C]// ACL 2010, Proceedings of the, Meeting of the Association for Computational Linguistics, July 11-16, 2010, Uppsala, Sweden. 2010:780-1.
[25] Omer Levy and Yoav Goldberg. Neural word embedding as implicit matrix factorization. In Advances in Neural Information Processing Systems, pages 2177–2185, 2014.
[26] Yitan Li, Linli Xu, Fei Tian, Liang Jiang, Xiaowei Zhong, and Enhong Chen. Word embedding revisited: A new representation learning and explicit matrix factorization perspective.
[27] Pennington J, Socher R, Manning C. Glove: Global Vectors for Word Representation[C]// Conference on Empirical Methods in Natural Language Processing. 2014.
[28]Ronan Collobert, Jason Weston, L´eon Bottou,Michael Karlen, Koray Kavukcuoglu, and Pavel Kuksa. 2011. Natural Language Processing (Almost) from Scratch. JMLR, 12:2493–2537
[29] Minh-Thang Luong, Richard Socher, and Christopher D Manning. 2013. Better word representations with recursive neural networks for morphology. CoNLL-2013
[30] Omer Levy, Yoav Goldberg, and Israel Ramat-Gan. 2014. Linguistic regularities in sparse and explicit word representations. CoNLL-2014.
[31] Scott Deerwester, Susan T. Dumais, George W. Furnas, Thomas K. Landauer, and Richard Harshman. 1990. Indexing by latent semantic analysis. Journal of the American Society for Information Science, 41.
[32] Yogatama D, Faruqui M, Dyer C, et al. Learning Word Representations with Hierarchical Sparse Coding[J]. Eprint Arxiv, 2014.
[33] Scott Deerwester, Susan T. Dumais, George W. Furnas, Thomas K. Landauer, and Richard Harshman. 1990. Indexing by latent semantic analysis. Journal of the American Society for Information Science, 41.
[34] Bellegarda J R. A latent semantic analysis framework for large-Span language modeling.[C]// European Conference on Speech Communication and Technology, Eurospeech 1997, Rhodes, Greece, September. 1997.
[35] R. Kneser and H. Ney. Improved backing-off for m-gram language modeling. In International Conference on Acoustics, Speech and Signal Processing, pages 181–184, 1995.
[36] T.R. Niesler, E.W.D. Whittaker, and P.C. Woodland. Comparison of part-of-speech and automatically derived category-based language models for speech recognition. In International Conference on Acoustics, Speech and Signal Processing, pages 177–180, 1998.
[37] Deerwester S, Dumais S T, Furnas G W, et al. Indexing by latent semantic analysis[J]. Journal of the Association for Information Science and Technology, 1990, 41(6):391-407.
[38] Hinton, G. E. (2002). Training products of experts by minimizing contrastive divergence. Neural Computation, 14, 1711–1800.
[39] FredericMorin and Yoshua Bengio. Hierarchical probabilistic neural network language model. In Robert G. Cowell and Zoubin Ghahramani, editors, AISTATS’05, pages 246–252, 2005
[40] Goodman, J. (2001b). Classes for fast maximum entropy training. In International Conference on Acoustics, Speech, and Signal Processing, Utah.
[41] M.U. Gutmann and A. Hyv¨arinen. Noise-contrastive estimation of unnormalized statistical models, with applications to natural image statistics. Journal of Machine Learning Research, 13:307–361, 2012.
[42] Gutmann M U, Hyv&#, Rinen A. Noise-contrastive estimation of unnormalized statistical models, with applications to natural image statistics[J]. Journal of Machine Learning Research, 2012, 13(1):307-361.
[43] Faruqui M, Dodge J, Jauhar S K, et al. Retrofitting Word Vectors to Semantic Lexicons[J]. Eprint Arxiv, 2014.
[44] Perozzi B, Alrfou R, Skiena S. DeepWalk: online learning of social representations[J]. Eprint Arxiv, 2014:701-710.
[45] Tang J, Qu M, Wang M, et al. LINE: Large-scale Information Network Embedding[J]. 2015.
[46] Yu M, Dredze M. Improving Lexical Embeddings with Semantic Knowledge[C]// Meeting of the Association for Computational Linguistics. 2014:545-550.
[47] Manaal Faruqui and Chris Dyer. 2014. Improving vector space word representations using multilingual correlation. In Proceedings of EACL
[48] Canny J, Zhao H, Jaros B, et al. Machine learning at the limit[C]// IEEE International Conference on Big Data. IEEE Computer Society, 2015:233-242.
[49] Ji S, Satish N, Li S, et al. Parallelizing Word2Vec in Shared and Distributed Memory[J]. 2016.
[50]Yang Z, Cohen W W, Salakhutdinov R. Revisiting Semi-Supervised Learning with Graph Embeddings[J]. 2016.

Author: ShawnXiao@baidu

Part-of-Speech Tagging

训练方式：
从左到右训练，给定一个词，抽取该词和窗口内的特征作为网络的输入，输出为词性标签，无全局解码部分。
实验中特征比较简单，没有用复杂的人工特征设计，特征设计为当前词的$ \pm 3$ 个token窗口的词，类别，字符级别n-gram(up to length3)，前4个token的预测tag。得到所有特征拼接起来作为网络的输入。输出为当前位置各个标签的归一化概率。
网络结构如下，参考[7, cheng, 2014]：

Parsey McParseface[1, Daniel Andor, 2016]在postag上的表现：

Dependency Parsing: Transition-Based Parsing

简单介绍依存分析任务，词之间的依存关系如下图：

知道词之间的依存关系有助于我们回答问题，例如：
“I saw the man with glasses”，得到如下依存结构后，可以比较容易回答”whom did I see?, who saw the man with glasses?”这类问题。
模型采用arc-standard transition system方式，通过学习一系列操作得到句子的语法树。定义两个结构stack和buffer，有如下三个操作。

• SHIFT: 将单词放入stack中。比从buffer中取出一个词，放入stack
• LEFT_ARC: 从stack中取出头两个词.将第二个词的依存关系指向前一个，箭头向左
• RIGHT_ARC: 从stack中取出头两个词，也是将第二个词指向后一个词，但箭头向右

此为上述三个操作的动图，想了解依存分析更多知识，可以参看论文[2, Nivre 2007] ：

实验中使用的语料与POS任务一样，特征为窗口内的词，POS，附近词的依存关系(预测得到的k-best结果)

训好的模型Parsey McParseface，报告性能如下：

网络结构和前述POS略有区别，在softmax层上增加了CRF层，训练模型分两步：

1. local: 使用局部的数据窗口对模型进行pre-train，训练集训顶层为softmax的nn网络，目标函数为局部归一化损失函数，此处得到局部模型。这里和前面训练POStag模型很像，也有用到POStag模型的输出结果。
2. global: 保留除了顶层softmax层外其他层的参数，用全局目标函数进行二次训练，得到全局模型。在训练过程中有个细节，如果在某个位置的人工标注tag落在beam(beam search的约束[3, Bottou, 1997])外，则换用另一个包含目标标签的目标函数进行梯度计算。

具体全局模型和局部模型的细节，参见[1, Daniel Andor, 2016]，这种训练方式和网络结构更早在[8, Weiss, 2015]中可以看到。文中对于二者性能差异进行了理论论证。训练中采用上述结合的方式，能加快模型的收敛。
注：第一小节介绍POS时，论文POS实验结果最好结果为global Normalization，开源的McParseface文档里对POS任务采用的是local Normalization，这里需要做区分，之前和波大神聊的时候自己没看清。

Sentence Compression

句子压缩希望在不发生转义前提下，对句子的非主干部分进行删减。
基线为三层LSTM叠加模型[4, Filippova, 2015]，网络结构如下图。decode阶段有部分细节不同：先逆序输入句子中每一个词，再正序输入句子中每一个词开始打分。用到的特征为：当前词的词向量(256维)[5, Mikolov, 2013]，前词的label(3维: 1/0/EOF)。

基线单层LSTM结构，输入数据以回文方式进行，应该有Bi-directional LSTM结构上类似的效果。

NN的训练往往需要大量的语料才能保证收敛，基线的作者[6, Filippova, 2013]提出了一种启发式构造语料的方法。新闻的标题是高浓缩的句子，从新闻的标题和正文中的句子里，抽取出标题对应的原句，组成压缩句对(原句=>标题)。本文实验中作者抽取了2.3M压缩句对，2M作为训练集，130K作为开发集，160K作为测试集。
实验中句子压缩任务的模型结构和前述任务一致，隐层为400个节点(代码中设定为200*200)。
特征设置：窗口内词的特征，POS，依存关系，前词的预测结果。实验结果如下图：

注：andor的论文pos和语法依存效果不错，句子压缩这部分工作则未能胜过Filippova，如果需要调研建议采用Filippova论文里的方法，andor报告里速度100倍于Filippova，应该是没考虑了POS和依存分析两个前置任务的耗时，工程实现上速度可能未必有优势。

[1] Andor D, Alberti C, Weiss D, et al. Globally Normalized Transition-Based Neural Networks[J]. 2016.
[2] Nivre2006] Joakim Nivre. 2006. Inductive Dependency Parsing. Springer-Verlag New York, Inc.
[3] L´eon Bottou, Yann Le Cun, and Yoshua Bengio. 1997. Global training of document processing systems using graph transformer networks. In Proceedings of Computer Vision and Pattern Recognition (CVPR), pages 489–493.
[4]Filippova K, Alfonseca E, Colmenares C A, et al. Sentence Compression by Deletion with LSTMs[C] Conference on Empirical Methods in Natural Language Processing. 2015.
[5] Mikolov, T., I. Sutskever, K. Chen, G. S. Corrado & J. Dean (2013). Distributed representations of words and phrases and their compositionality. In Advances in Neural Information Processing Systems, pp. 3111–3119.
[6] Filippova K, Altun Y. Overcoming the lack of parallel data in sentence compression[C] 2013.
[7] Chen D, Manning C. A Fast and Accurate Dependency Parser using Neural Networks[C]// Conference on Empirical Methods in Natural Language Processing. 2014.
[8] Weiss D, Alberti C, Collins M, et al. Structured Training for Neural Network Transition-Based Parsing[J]. Computer Science, 2015.
Author： shawnxiao@baidu

1. FastDBT简介及代码走读，LightGBM简介
2. 从算法层面讨论下三者的异同点

FastDBT篇

树模型从模型层面和实现层面两种可行的改进方式：1.模型层面的改进：如SGBDT采用的样本采样方式[1]，或者对弱作用特征的剪枝[2]。2.实现层面的改进，见引文[3].FastDBT延续自SGBDT，SGBDT在每层树的构建中并非所有样本都使用到，按参数$\alpha$对数据进行随机采样。
FastDBT有如下三个实现层面上的加速：

1. 数据在内存的存储方式，分为两种a.结构体数据，b.数组结构体，如下图1。区别在于当对其中一维特征进行遍历的时候，按数组结构体的方式存储使得内存连续，提升内存访问速度。
2. 将正例负例进行区分存储，减少一半左右的计算累计直方图(calculation of the cumulative probability histograms， CPH)缓存占用，同时节约了if判断条件跳转的浪费。
3. 同层节点并行计算。由于每层的节点的数据来自于被父节点分割的子集，FastBDT在对不同的节点同时计算CPH（临时存储多个节点点的CPH），可以连续进行内存访问避免跳跃。
   

下面进行FastDBT建树部分代码走读：

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
34
35
36
37

main()
  ->train()
    ->data=readDataFile() //data结构为：vector<vector<float>>
    //上一步数据作为2D向量读入
    //FastDBT需要分桶后的数据,使用FeatureBinning对每个特征进行数据分桶。
    //先初始化FeatureBinning，对于每个特征，遍历所有样本对应的特征值，进行分桶边界的初始化
	for(unsigned int iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
	    //枚举特征，得到每个特征特征值列表
        std::vector<double> feature;
        feature.reserve(numberOfEvents);
        for(auto &event : data) 
          feature.push_back( event[iFeature] )
        //根据特征值进行对应桶的设定，
        featureBinnings.push_back(FastBDT::FeatureBinning<double>(nCuts, feature)); 
        nBinningLevels.push_back(nCuts)
 
   //eventSample存储完成特征值->分桶index的数据
   //将数据分为signal和background两个部分（1为signal，0为background），提供更快地访问速度
   for(auto &event : data)
     for(unsigned int iFeature = 0; iFeature < numberOfFeatures; ++iFeature)
	   //找到当前样本特征值对应特征所属的桶
       bins[iFeature] = featureBinnings[iFeature].ValueToBin( event[iFeature])
       // bins存有该样本的，权重为1
	   //signal取决于数据的_class标签是否为1;1则是正例，否则为负例。
        eventSample.AddEvent(bins, 1.0, _class == 1)
        
    //ForestBuilder类负责树模型的训练
    //输入为数据eventSample，树的个数nTrees
	//树的正则化因子Shrinkage，采样率randRatio,层数nLevels
    FastBDT::ForestBui1lder dt(eventSample, nTrees, shrinkage, randRatio, nLevels)
    //将生成的树组合为forest
    FastBDT::Forest<double> forest( dt.GetShrinkage(), dt.GetF0(), true)
    for( auto t : dt.GetForest() )
    //将树的节点由index转为特征值
      auto tmp=removeFeatureBinningTransformationFromTree(t,            
               featureBinnings)
      forest.AddTree(tmp)

有几个实现细节比较trick需要提一下

1. FeatureBinning的内部实现采用了二分查找树（调了几个小时代码没弄明白，幸亏Thomas解答并帮忙增加了注释）
   特征值分桶核心代码：

   1 2 3 4 5 6 7 8 9 10

   //枚举每一层树 for(uint64_t iLevel = 0; iLevel < nLevels; ++iLevel): //桶的数目double const uint64_t nBins = (1 << iLevel) //枚举每个桶 for(uint64_t iBin = 0; iBin < nBins; ++iBin) { //记特征值下标为 size/2^(iLevel+1)+iBin*size/2^iLevel //第bin_index指向的有序特征的对应二分查找位置 binning[++bin_index] = \ first[(size >> (iLevel+1)) + ((iBin*size) >> iLevel)]

2. ForestBuilder类的初始化时完成SGBDT每一棵树的级联
   boosting过程的核心代码：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   //生成nTrees棵树 for(unsigned int iTree = 0; iTree < nTrees; ++iTree): // Update the event weights according to their F value // 使用对应的F值进行更新每个样本的权重，F值为pseudo_response updateEventWeights(sample) // Prepare the flags of the events // 根据randRatio进行采样，eventsamples内有flag可以标记样本是否可用 prepareEventSample(sample, randRatio, sPlot ) // TreeBuilder类进行单棵树的生成, nLayersPerTree为树的层 TreeBuilder builder(nLayersPerTree, sample) //将生成的树加入到森林中 forest.push_back( Tree<unsigned int>( builder.GetCuts(), \ builder.GetNEntries(), builder.GetPurities(), \ builder.GetBoostWeights() ) )

3. TreeBuilder类完成单棵树的生成
   TreeBuilder核心代码走读：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   //生成每一棵树需要探索的节点，存在nodes列表 for(unsigned int iLayer = 0; iLayer <= nLayers; ++iLayer) for(unsigned int iNode = 0; iNode < (1<<iLayer); ++iNode) nodes.push_back( Node(iLayer, iNode) ); // 每棵树的节点是从顶向下，从左到右生成， // 树是贪心法生成，我们迭代计算每一层的节点 // 对于不同的分裂节点和特征，生成正负例的累计直方图 for(unsigned int iLayer = 0; iLayer < nLayers; ++iLayer) //计算累计直方图，signal,background分别计算 //由于signal,background在存储上物理分离，可以进行连续访问 CumulativeDistributions CDFs(iLayer, sample) //选择合适的特征和值，更新到当前节点 UpdateCuts(CDFs, iLayer) //采样数据，SGBDT特有操作 UpdateFlags(sample) //根据分裂节点划分样本 UpdateEvents(sample, iLayer)

4. 计算累计直方图，得到正例和负例的累计直方图

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   //对于所有在这一层的节点，每一个特征，填充累计直方图bins //将每个特征的bins进行填充 for(int iEvent = firstEvent; iEvent < lastEvent; ++iEvent) for(int iFeature = 0; iFeature < nFeatures; ++iFeature ) int subindex = nBinSums[iFeature] + values.Get(iEvent,iFeature); bins[index+subindex] += weights.Get(iEvent); //在前一步得到的bins中，顺序累计所有的桶内的值，得到累计直方图 for(int iNode = 0; iNode < nNodes; ++iNode) { for(int iFeature = 0; iFeature < nFeatures; ++iFeature) // 从位置2起始是因为0位置放置非自然数 for(int iBin = 2; iBin < nBins[iFeature]; ++iBin) unsigned int index = iNode*nBinSums.back() \ + nBinSums[iFeature] + iBin; bins[index] += bins[index-1];

5. 根据正负例的累计直方图，查找最优分裂点

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   Weight currentLoss = LossFunction(signal, bckgrd); //遍历每一个特征的每一个桶 for(int iFeature = 0; iFeature < nFeatures; ++iFeature) // 从位置2起始是因为0位置放置非自然数 for(unsigned int iCut = 2; iCut < nBins[iFeature]; ++iCut) { Weight s = CDFs.GetSignal(iNode, iFeature, iCut-1); Weight b = CDFs.GetBckgrd(iNode, iFeature, iCut-1); //计算基尼系数，从函数看这里应该是简化的基尼系数 Weight currentGain = currentLoss - \ LossFunction( signal-s, bckgrd-b ) - LossFunction( s, b ); if( cut.gain <= currentGain ) cut.gain = currentGain; cut.feature = iFeature; cut.index = iCut; cut.valid = true;

到这里为止，我们已经看完几个重要的模块，关于FastBDT的介绍告一段落，有需要的同学可以继续在github上阅读更详细的代码，附上代码仓库地址。

LightGBM篇

LightGBM主要思路还在GBDT框架内，重复部分不再赘述，这篇我打算偷个懒，把LightGBM的新特性细数一遍，当然附上详细的算法文档，里面介绍很到位：《LightGBM中的GBDT实现》@chenghuige 网盘地址，代码仓库地址。

1. 单机采用Histogram算法，这点同FastBDT一样，而XGboost单机是Greedy进行的。
2. 大多数GBDT工具(FastDBT/XGboost)按逐层(level wise)的方式进行生长，而LightGBM从当前节点出发找到一个分类增益最大的叶子，然后继续分裂(leaf wise)，如此循环。优点是在分类次数相同的前提下，可以得到更好的精度。缺点可能会导致树的深度过大，解决方式是增加最大深度限制。
3. 计算直方图时的优化：避免重复计算直方图，构造一个叶子的直方图后，可以用求差的方式得到它兄弟叶子的直方图。
   

XGboost/FastGBM/LightGBM，三者的异同点

三者都是GBDT很好的实现，枚举几点异同：

1. FastBDT在单机分类问题进行了极致的优化和探索，当然也限制了其在回归问题的应用。而XGboost和LightGBM可以用于分类和回归，并很好支持了并行化。
2. XGboost单机版本Greedy进行，并对每个特征有进行pre-sort操作，带了额外的开销。这点在FastBDT和LightGBM中进行了规避。
3. FastBDT中可以看到受SGBDT影响较大，XGboost也支持对样本的采样，LightGBM未做考核，暂无结论。
4. LightGBM选择生长树的方式选择分类增益最大叶子进行生长，而XGboost和FastBDT是逐层进行。

此外，XGboost在业界运用较多，对各大平台很友好，目前仍有活跃着很多贡献者，最新进展为《Support Dropout on XGBoost》

引文：
[0]Keck T. FastBDT: A speed-optimized and cache-friendly implementation of stochastic gradient-boosted decision trees for multivariate classification[J]. 2016.
[1]Tong Zhang Rie Johnson. Learning nonlinear functions using regularized greedy forest.IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(5):942–954, May 2014. doi: 10.1109/TPAMI.2013.159. PDF
[2]Ron Appel, Thomas Fuchs, Piotr Dollar, and Pietro Perona. Quickly boosting decision trees – pruning underachieving features early. In Sanjoy Dasgupta and David Mcallester, editors, Proceedings of the 30th International Conference on Machine Learning (ICML-13), volume 28, pages 594–602. JMLR Workshop and Conference Proceedings, May 2013. PDF .
Tong Zhang Rie Johnson. Learning nonlinear functions using regularized greedy forest. IEEE Transactions on Pattern Analysis and Machine Intelligence, 36(5):942–954, May 2014. doi: 10.1109/TPAMI.2013.159. PDF.
[4]如何看待微软新开源的LightGBM?, lightGBM作者@guolinke

PS. 家里有事，穿插了一次部门bui，没时间码字，sorry，接下来探索一下embeding方面的文章。
ShawnXiao@baidu

1. 树的结构如何？
2. 树的操作有哪些？
   主要包括：怎么生成一棵树？ 何时，且如何进行剪枝？什么时候进行数据采样，怎么采样？ 分布式并行怎么完成？

上面这2个问题是寻求实现具体算法的思考过程，笔者也在一边读一边记录，有理解错谬的地方请指出。

树的结构如何？

从代码的UML图可以看到RegTree派生自TreeModel类，TreeModel类中定义了子类Node，结构如下：

从代码角度介绍两个重要的数据结构TreeModel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

//TreeModel主要成员有：
std::vector<Node> nodes;// 节点
std::vector<int>  deleted_nodes;// 记录已删除节点
std::vector<TNodeStat> stats; //节点的统计量
std::vector<bst_float> leaf_vector; //存储节点的增量信息
//介绍上图TreeModel类的两个模板参数template<typename TSplitCond, typename TNodeStat>
typedef TSplitCond SplitCond; //对于回归树的话，分裂值类型为float。
//节点的统计量特征
typedef TNodeStat Nodestat; 
//Nodestat根据不同的树类型进行定义，如下RTreeNodeStat结构体。
struct RTreeNodeStat{
loss_chg; //当前节点的loss change
sum_hess, //hessian值的和
base_weight, //当前节点的权值
leaf_child_cnt, //当前孩子节点的数目
}

而Node具体代码为：

1
2
3
4
5
6
7
8
9
10
11

class Node{
int parent_; //父类
int cleft_, cright_; //左右叶子
unsigned sindex_; //选作分割节点的特征，最高位代表了方向左右，1表示左边。
Info info_; //union结构，存储叶子的值，或者分裂条件。结构如下：
//union Info{
//float leaf_value;
//TSplitCond split_cond;
//};
//此外包含许多相关的节点操作，例如set_split(), set_leaf(), set_parent()
}

对于基本数据结构稍事了解之后，我们开始进入主题，也是我着手写这篇文章的目的：

怎么生成一棵树？

在前一篇博客里面比较详细涉及到xgboost的一些算法，这些不再重复叙述，这里参考了杨军[2]的介绍，按单机版结合前面介绍的代码结构图，先进行一遍代码走读：

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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

Cli_main.cc:
main()
     -> CLIRunTask()
          -> CLITrain()
               -> DMatrix::Load()
               -> learner = Learner::Create()
               -> learner->Configure()
               -> learner->InitModel()
               -> for (i = 0; i < param.num_round; ++i)//train
                    -> learner->UpdateOneIter()
                    -> learner->Save()    
learner.cc:
Create()
      -> new LearnerImpl() //派生自learner
Configure() //配置obj, updater和模型的相关参数
InitModel()
     -> LazyInitModel()
          -> obj_ = ObjFunction::Create()
               // objective.cc
               //  Create():  
               //    SoftmaxMultiClassObj(multiclass_obj.cc)
               //    LambdaRankObj(rank_obj.cc)
               //    RegLossObj(regression_obj.cc)
               //    PoissonRegression(regression_obj.cc)
          -> gbm_ = GradientBooster::Create()
               // gbm.cc
               //  Create()
               //  GBTree(gbtree.cc)
               //  GBLinear(gblinear.cc)               
          -> obj_->Configure()
          -> gbm_->Configure()
UpdateOneIter()
      -> PredictRaw() //预测样本标签
      -> obj_->GetGradient() //计算样本的一阶导，二阶导
      -> gbm_->DoBoost() //进行boost(tree model/linear model)
/*当gbm为gbtree*/
gbtree.cc: 
Configure() //根据配置初始化树相关操作
      -> for (up in updaters)
           -> up->Init()
DoBoost() //每一级生成一颗RegTree
      -> BoostNewTrees()
           -> new_tree = new RegTree()
           -> for (up in updaters)
                -> up->Update(new_tree)    
/*updaters的定义*/
tree_updater.cc:
Create()
     -> ColMaker/DistColMaker(updater_colmaker.cc) 
        SketchMaker(updater_skmaker.cc)
        TreeRefresher(updater_refresh.cc)
        TreePruner(updater_prune.cc)
        HistMaker / CQHistMaker /
                  GlobalProposalHistMaker/
                  QuantileHistMaker(updater_histmaker.cc)
        TreeSyncher(updater_sync.cc)

从代码走读中可以看到，gbtree最核心处定义了ColMaker, DistColMaker, LocalHistMaker, GlobalHistMaker, HistMaker, TreePruner, TreeRefesher, SketchMaker, TreeSyncher 等多种树操作，在论文里有介绍的仅有部分。
下面逐一进行分解，看看这不同的操作实质上代表了什么动作，如何实现。
xgboost在树的操作定义使用装饰(decorator)模式[1]，基类TreeUpdater为抽象构件，定义了基本接口：

初始化init()，树的更新操作update(), 取得更新操作后叶子位置GetLeafPosition(), 产生具体构建updater的creat()函数。

ColMaker

从Updater类中派生ColMaker为具体构建类（为论文实现的单机多线程版本），主要用于实现单棵树生成，类的结构如下图。

ColMaker类中最重要为树的Builder 结构体，在Builder中实现ColMaker主要算法，主要实现在Builder->Update()函数中。

下面具体介绍下Builder->Update()函数的核心代码(updater_colmaker.cc)：

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

//核心代码：
//初始化数据和节点的映射关系，根据配置进行样本的降采样(伯努利采样)
//qexpand_用于存储每次探索出候选树节点，初始化为root节点。
this->InitData(gpair, *p_fmat, *p_tree);
//计算qexpand_队列中所有候选节点的损失函数和权重
this->InitNewNode(qexpand_, gpair, *p_fmat, *p_tree);
//根据树的最大深度进行生长
for (int depth = 0; depth < param.max_depth; ++depth) {
	//查找最佳分裂点
    this->FindSplit(depth, qexpand_, gpair, p_fmat, p_tree);
       this->UpdateSolution()//找到分裂点,有两种并行方式
          //特征间并行方式
          //每个线程处理一维特征，遍历数据累计统计量(grad/hess)得到最佳分裂点split_point
          this->EnumerateSplit() 
          //特征内并行方式
          //在每个线程里汇总各个线程内分配到的数据样本的统计量(grad/hess);
          //每个线程输出对应样本整体的统计量，得到一个线程级别统计量数组
          //在这个组内进行枚举选出最佳分裂点，进一步定位到对应线程的最优分割点
          this->ParallelFindSplit() 
       this->SyncBestSolution(qexpand);//找到最优解，设为当前分裂节点
    //根据分裂结果，将数据重新映射到子节点。    
    this->ResetPosition(qexpand_, p_fmat, *p_tree);
    //将待扩展分割的叶子结点用于替换qexpand_，作为下一轮split的候选节点
    this->UpdateQueueExpand(*p_tree, &qexpand_);
    //重新初始化，计算qexpand_队列中所有候选节点的损失函数和权重
    this->InitNewNode(qexpand_, gpair, *p_fmat, *p_tree);
    //若无需继续分裂，则停止
    if (qexpand_.size() == 0) break;
}

怎样剪枝

TreePruner (prune a tree given the statistics)

剪枝操作由TreePruner进行，对于一棵树，通过比对节点所带来的loss收益决定是否剪枝。
核心代码(updater_prune.cc)如下：

1
2
3
4
5
6
7
8

TreePruner->updater()
  for (each tree) 
    //对每一棵树进行剪枝
    ->DoPrune();
        ->for (each node)
          //对当前节点进行剪枝
          //如果loss_chg<threlshold，剪枝。并递归判断新节点是否需要剪枝。
          TryPruneLeaf();

如何进行分布式？

HistMaker (use histogram counting to construct a tree)

Histgram使用直方图法近似加速建树过程，HistMaker和Colmaker一样，用于建树，不同是HistMaker并不直接由基类派生，而是HistMaker->BaseMaker->Updater，关系如图：
HistMaker类定义了基于直方图法的方法接口，具体的实现在CQHistMaker/QuantileHistMaker，QuantileHistMaker中调用了SketchMaker进行采样.
BaseMaker(updater_basemaker-inl.h)在Updater基类上增加了一些公共操作，后面介绍的SketchMaker也是派生于BaseMaker。按row based进行分布式建树，每台机器各自找到各自候选分割点，每一部分算出自己的统计量，用allreduce合并起来后再根据全局统计量计算最终的分割点，最终层次遍历的构建树[1]
由核心代码(Updater_histmaker.cc)走读如下：

1
2
3
4
5
6
7
8
9
10
11

/初始化样本和树节点的映射关系，根据配置进行样本的降采样(伯努利采样)
//队列qexpand_用于存储每次探索出候选树节点，初始化为root节点。
->InitData()
  ->UpdateNode2WorkIndex() //node2workindex大小为树的节点个数。初始化为qexpand中待扩展节点。 
->InitWorkSet() //初始化fwork_set，大小为每颗树的节点，表示用于建树的特征。
->for (depth < param.max_depth)
  ->ResetPosAndPropose() //重置并设置候选分裂特征
  ->CreateHist() //生成近似直方图
  ->FindSplit() //通过直方图统计量找到合适的分裂节点
  ->ResetPositionAfterSplit() //对新加入的节点重新分配样本映射关系
  ->UpdateQueueExpand() //更新待探索的候选节点列表qexpand_

xgboost的论文中未有提及直方图法，是树模型常用的近似方法，对统计量进行聚合统计，存储为一个个桶，然后在这些桶之间寻找最佳分裂点，为了进一步了解这种方式的建树过程，这里需要重点探索下CreatHist() 以及FindSplit()，两处函数具体的实现在派生类CQHistMaker->HistMaker，CQHistMaker实现了具体的分布式计算，在InitWorkSet()中进行机器节点的数据分片和信息同步。其类UML图如下

CreatHist()作用为将统计量存储于待分割节点的直方图分桶中，对CreatHist()函数进行代码走读，其分布式计算是基于RABIT实现的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

fset: feature_index
//遍历所有特征
while (p_fmat->ColIterator(fset)->Next()) {
  const ColBatch &batch = iter->Value();//取得每个特征对应数据
  ->UpdateHistCol() //多线程更新特征直方图
    //对_qexpand每一个待分裂节点对应，特征为nid，初始化直方图
    //统计直方图，简介无cache优化的过程如下
    for (bst_uint j = 0; j < ColBatch.length; ++j)
      ->hbuilder[nid].Add(fvalue, gpair)//特征值fvalue用于确定分桶位置，gpair为统计量。
    //对_qexpand中节点计算其对应统计量的和
    ->GetNodeStats()  
}
//rabit::allreduce。借助mpi的allreduce进行理解，思考2
//从各个计算结点汇总统计量
->histred.Allreduce()

FindSplit()通过处理每个桶的特征量进行分裂点查找，代码走读如下：

1
2
3
4
5
6
7

//对于每一个待分裂节点
for (wid = 0; wid < qexpand.size(); ++wid)
  //对于每个特征
  for (size_t i = 0; i < fset.size(); ++i)
    //枚举查找最佳分裂点，直方图上从左到右，从右到左两个方向分别查找
    //根据统计量找到最好的桶，将桶的分界点作为特征的split_value
    ->EnumerateSplit()

近似算法怎么实现？

SketchMaker(use approximation sketch to construct a tree)

介绍SketchMaker之前，需要对此前论文导读中的加权分位数略图做少许补充。在传统的GK 算法[4]和其他扩展[5]之上，作者提出加权分位数略图算法，并引入支持merge和prune操作的数据结构进行实现。先介绍quantile summary，定义为以相对错误率$\varepsilon $返回分位数查询结果。

1. merge操作：若两个summary的的相对正确率分别为$\varepsilon_1 $和$\varepsilon_2 $，将二者merge得到的新summary的相对错误率为$max \{\varepsilon_1, \varepsilon_2 \}$
2. prune操作：将summary中元素个数缩减到$b+1$那么相对错误率率将从$\varepsilon$增加到$\varepsilon+{1 \over b}$。

二者如何实现，详细介绍见引文[3]附录部分《WEIGHTED QUANTILE SKETCH》。
xgboost通过不同的summary操作(WQSummary/WXQSummary/GKSummary)定义QuantileSketchTemplate类型，从而派生出不同的具体的sketch类(WQuantileSketch/WXQuantileSketch/GKQuantileSketch)。其中WXQSummary派生自WQSummary，在prune操作上效率要高些。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//初始化数据和节点的映射关系，根据配置进行样本的降采样(伯努利采样)
//qexpand_用于存储每次探索出候选树节点，初始化为root节点。
->InitData()
for (depth = 0; depth < param.max_depth; ++depth) {
  ->GetNodeStats() //对_qexpand中节点计算其对应统计量的和
  ->BuildSketch() //初始化WXQuantileSketch，用于分位图策略(采样策略，需后期进一步了解)
    ->UpdateSketchCol() //更新每个特征的WXQuantileSketch统计量 
					    //(pos_grad/neg_grad/sum_hess)
	->SetPrune() //根据sketchs_size进行剪枝
	//sketchs_size=sketch_ratio / sketch_eps(参数可配置)
  ->SyncNodeStats()  //同步所有节点的信息SKStats
  ->FindSplit()  //查找最佳分裂点
	  //枚举sketchs找到最佳特征的分裂点
      ->EnumerateSplit() 
  ->ResetPositionCol()  ///对新加入的节点重新分配样本映射关系
  ->UpdateQueueExpand()  //更新待探索的候选节点列表_qexpand

自此从代码角度交代了前文《xgboost: A Scalable Tree Boosting System论文及源码》的作者的具体实现思路，希望能够进一步加深对boosting方法的理解。目前最新的进展为XGBoost4J-Spark发布进一步融入Spark的应用场景中(2016/10/26)见附录[3]，后续的发展会继续跟进。
PS. TreeRefresher 代码中未见引用这里不做进一步介绍。

[1]设计模式——装饰模式（Decorator）, @shu_lin
[2]机器学习算法中GBDT和XGBOOST的区别有哪些？, @杨军
[3]Chen, Tianqi, and C. Guestrin. “XGBoost: A Scalable Tree Boosting System.” (2016).
[4]L. Breiman. “Random forests. Maching Learning”, 2001.
[5]Q. Zhang and W. Wang. A fast algorithm for approximate quantiles in high speed data streams. In Proceedings of the 19th International Conference on Scientic and Statistical Database Management, 2007.

附录：
[1]xgoost调参技巧：
使用TrainValidationSplit和RegressionEvaluator自动进行高度max_depth和树权重$\eta$调参。
[2]MPI Allreduce操作介绍，可结合reduce理解，reduce产生的作用示意如下图：

计算中需要归集所有结果，再分发到各个process中，Allreduce起这个作用，可以结合最小均方差的例子进行理解(点击链接)，具体在流程中的作用如下图示意：

[3]XGboost与Spark的完全集成 @Nan Zhu

彩蛋：
[1]《PRML中文版》百度网盘地址, @马春鹏

写这篇博客有个痛点，代码的过度抽象和大量模板类的使用对阅读带来比较大的伤害，也是这篇文章历时许久的部分原因。如果您有好的代码阅读工具，不吝一并推荐下。
介绍下我的两款辅助软件：
Source Insight: 主司代码阅读
visual paradigm for UML 主司UML类图解析
另外，推荐百度学术的引文功能，写博客很方便

ShawnXiao@baidu

1. 可扩展性强
2. 为稀疏数据设计的决策树训练方法
3. 理论上得到验证的加权分位数略图法
4. 并行和分布式计算
5. 设计高效核外计算，进行cache-aware数据块处理

分布式训练树模型boosting方法已有[1,2,3]。

整体目标

其中$L\left( \cdot \right)$为目标函数，$l(\cdot)$是损失函数，通常是凸函数，用于 刻画预测值${{{\hat y}_i}}$和真实值${{y_i}}$的差异，第二项$\Omega \left( \cdot \right)$为模型的正则化项， 用于降低模型的复杂度，减轻过拟合问题，类似的正则化方法可以在引文[4]看到。模型目标是最小化目标函数。
$L\left( \cdot \right)$为函数空间上的表达，我们可以将其转换为下面这张gradient boosting的方式，记${\hat y}^{(t)}_i$为第$i$个样本第$t$轮迭代：
$${L^{\left( t \right)}} = \sum\limits_{i = 1}^n {l\left( {{y_i},{{\hat y}_i}^{\left( {t - 1} \right)} + {f_t}\left( {{{\bf{x}}_i}} \right)} \right)} + \Omega \left( {{f_t}} \right)$$
对该函数在${\hat y}^{(t)}_i$位置进行二阶泰勒展开，可以加速优化过程，我们得到目标函数的近似：
$${L^{\left( t \right)}} \simeq \sum\limits_{i = 1}^n {\left[ {l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right) + {g_i}{f_t}\left( {{{\bf{x}}_i}} \right) + {1 \over 2}{h_i}f_t^2\left( {{{\bf{x}}_i}} \right)} \right]} + \Omega \left( {{f_t}} \right)$$
泰勒展开的推导部分，可以参考思考1，其中第一项是常数项，删除可得：
$${{\tilde L}^{\left( t \right)}} = \sum\limits_{i = 1}^n {\left[ {{g_i}{f_t}\left( {{{\bf{x}}_i}} \right) + {1 \over 2}{h_i}f_t^2\left( {{{\bf{x}}_i}} \right)} \right]} + \Omega \left( {{f_t}} \right)--(1)$$
下面对正则化项进行参数化定义。延续前文GBDT的概念，引入分裂节点$j$定义的区域记作$${I_j} = \left\{ {i|q\left( {{{\bf{x}}_i}} \right) = j} \right\}$$
那么$\Omega$展开原目标函数改写为：
$$\eqalign{ & {{\tilde L}^{\left( t \right)}} = \sum\limits_{i = 1}^n {\left[ {{g_i}{f_t}\left( {{{\bf{x}}_i}} \right) + {1 \over 2}{h_i}f_t^2\left( {{{\bf{x}}_i}} \right)} \right]} + \gamma T + {1 \over 2}\lambda \sum\limits_{j = 1}^T {w_j^2} \cr & \;\;\;\;\;{\rm{ = }}\sum\limits_{j = 1}^T {\left[ {\left( {\sum\limits_{i \in {I_j}} {{g_i}} } \right){w_j} + {1 \over 2}\left( {\sum\limits_{i \in {I_j}} {{h_i}} + \lambda } \right)w_j^2} \right]} + \gamma T \cr} --(2)$$
对于固定的树结构$q(x)$，对$w_j$求导得解析解$w^*_j$:
$$w_j^* = {{\sum\limits_{i \in {I_j}} {{g_i}} } \over {\sum\limits_{i \in {I_j}} {{h_i} + \lambda } }}$$
代入到$(1)$式中，可得
$${{\tilde L}^{\left( t \right)}}\left( q \right) = - {1 \over 2}{{{{\left( {\sum\limits_{i \in {I_j}} {{g_i}} } \right)}^2}} \over {\sum\limits_{i \in {I_j}} {{h_i} + \lambda } }} + \gamma T--(3)$$
公式$(3)$可以作为分裂节点的打分，形式上很像CART树纯度打分的计算，区别在于它是从目标函数中推导而得。图中显示目标函数值的计算：

实践中，很难去穷举每一颗树进行打分，再选出最好的。通常采用贪心的方式，逐层选择最佳的分裂节点。假设$I_L$和$I_R$为分裂节点的左右节点，记$I=I_L \cup I_R$。
则选择此节点分裂的收益为：
$${L_{split}} = {1 \over 2}\left[ {{{{{\left( {\sum\limits_{i \in {I_L}} {{g_i}} } \right)}^2}} \over {\sum\limits_{i \in {I_L}} {{h_i} + \lambda } }} + {{{{\left( {\sum\limits_{i \in {I_J}} {{g_i}} } \right)}^2}} \over {\sum\limits_{i \in {I_J}} {{h_i} + \lambda } }} - {{{{\left( {\sum\limits_{i \in I} {{g_i}} } \right)}^2}} \over {\sum\limits_{i \in I} {{h_i} + \lambda } }}} \right] - \gamma \;\;-- (4)$$
[补充]
1.作为GB类方法，也可以采用shrinkage策略
2.随机森林[5]的特征降采样(subsampling)克服过拟合代码，xgboost用了类似的技术。和传统的降采样不同，xgboost按列进行降采样，在并行化有加速作用。(待研究)

查找分裂节点(split finding)

贪心算法
贪心算法是最基本的方法，前面介绍的时候有提过。具体做法：遍历所有特征中可能的分裂点位置，根据公式$(4)$找到最合适的位置。$Split\_Finding()$算法流程如下
$$\eqalign{ & Split\_Finding(): \cr & Input:I,instance\;set\;of\;current\;node \cr & Input:d,feature\;dimension \cr & gain \leftarrow 0 \cr & G \leftarrow \sum\limits_{i \in I} {{g_i}} ,H \leftarrow \sum\limits_{i \in I} {{h_i}} \cr & for\;k = 1\;to\;m\;do \cr & \;\;\;\;{G_L} \leftarrow 0,{H_L} \leftarrow 0 \cr & \;\;\;\;for\;j\;in\;sorted\left( {I,by\;{{\bf{x}}_{jk}}} \right)\;do \cr & \;\;\;\;\;\;\;\;{G_L} \leftarrow {G_L} + {g_j},{H_L} \leftarrow {H_L} + {h_j} \cr & \;\;\;\;\;\;\;\;{G_R} \leftarrow G - {G_L},{H_R} \leftarrow H - {H_L} \cr & \;\;\;\;\;\;\;\;score \leftarrow \max \left( {score,{{G_L^2} \over {{H_L} + \lambda }} + {{G_R^2} \over {{H_R} + \lambda }} - {{{G^2}} \over {H + \lambda }}} \right) \cr & \;\;\;\;end \cr & end \cr & Output:\; split\_value\; with\; max \; score} $$
近似算法
如果数据不能一次读入内存，使用贪心算法效率较低。近似算法在过去也有应用[6, 7, 8]。具体描述为，对于某个特征${\bf x}_k$，找到该特征若干值域分界点$\{s_{k1}, s_{k2}, ... ,s_{kl}\}$。根据特征的值对样本进行分桶，对于每个桶内的样本统计值$G$、$H$进行累加（两个统计量含义同贪心算法），记为分界点$v$的统计量，$v$满足$\{{\bf x}_{kj}=s_{kv}\}$。最后在分界点集合上调用$Split\_Finding()$进行贪心查找，得到的结果为最佳分裂点的近似。具体如下：
$$\eqalign{ & for\;k = 1\;to\;m\;do \cr & \;\;\;\;Propose\;{S_k} = \left\{ {{s_{k1}},{s_{k2}},...,{s_{kl}}} \right\}\;by\;percentile\;on\;feature\;k \cr & \;\;\;\;Propose\;can\;be\;done\;per\;tree\left( {global} \right),or\;per\;split\left( {local} \right) \cr & end \cr & for\;k = 1\;to\;m\;do \cr & \;\;\;\;{G_{kv}} \leftarrow = \sum\limits_{j \in \left\{ {j|{s_{k,v}} \ge {x_{jk}} > {s_{k,v - 1}}} \right\}} {{g_j}} \cr & \;\;\;\;{H_{kv}} \leftarrow = \sum\limits_{j \in \left\{ {j|{s_{k,v}} \ge {x_{jk}} > {s_{k,v - 1}}} \right\}} {{h_j}} \cr & end \cr & call\;Split\_Finding\left( {} \right) \cr} $$
下面介绍找特征值域分界点$\{s_{k1}, s_{k2}, ... ,s_{kl}\}$的方法，加权分位数略图。为了尽可能地逼近最佳分裂点，我们需要保证采样后数据分布同原始数据尽可能一致。记${D_k} = \left\{ {\left( {{x_{1k}},{h_1}} \right),\left( {{x_{2k}},{h_2}} \right) \cdots \left( {{x_{nk}},{h_n}} \right)} \right\}$表示 每个训练样本的第$k$维特征值和对应二阶导数。接下来定义排序函数为$r_k(\cdot):R \rightarrow[0, +\infty)$
$${r_k}\left( z \right) = {1 \over {\sum\limits_{\left( {x,h} \right) \in {D_k}} h }}\sum\limits_{\left( {x,h} \right) \in {D_k},x < z} h $$
函数表示特征的值小于$z$的样本分布占比，其中二阶导数$h$可以视为权重，后面论述。在这个排序函数下，我们找到一组点$\{s_{k1}, s_{k2}, ... ,s_{kl}\}$ ,满足：
$$\left| {{r_k}\left( {{s_{k,j}}} \right) - {r_k}\left( {{s_{k,j + 1}}} \right)} \right| < \varepsilon$$
其中，${s_{k1}} = \mathop {\min }\limits_i {x_{ik}},{s_{kl}} = \mathop {\max }\limits_i {x_{ik}}$。$\varepsilon$为采样率，直观上理解，我们最后会得到$1/\varepsilon$个分界点。
讨论下为何$h_i$表示权重。从目标函数$(1)$出发，配方得到$$\sum\limits_{i = 1}^n {\left[ {{1 \over 2}{{\left( {{f_t}\left( {{x_i}} \right) - {g_i}/{h_i}} \right)}^2}} \right]} + \Omega \left( {{f_t}} \right) + constant$$
具体证明过程见原作附录。这是一个关于标签为${{g_i}/{h_i}}$和权重为$h_i$的平方误差形式。当每个权重相同的时候，退化为普通的分位数略图[9, 10]
接下来介绍另一个论文的亮点，寻找分裂点的过程中，如何克服数据稀疏。稀疏数据可能来自于missing value、大量的0值、或者特征工程例如采用one-hot表示带来的。为了解决这个问题，设定一个默认指向，当发生特征缺失的时候，将样本分类到默认分支，如下图：

默认方向由训练集中non-missing value学习而得，把不存在的值也当成missing value进行学习和处理，如下：
$$\eqalign{ & Sparsity\_Split\_Finding(): \cr & Input:I,instance\;set\;of\;current\;node \cr & Input:d,feature\;dimension \cr & gain \leftarrow 0 \cr & G \leftarrow \sum\limits_{i \in I} {{g_i}} ,H \leftarrow \sum\limits_{i \in I} {{h_i}} \cr & for\;k = 1\;to\;m\;do \cr & \;\;\;\;{G_L} \leftarrow 0,{H_L} \leftarrow 0 \cr & \;\;\;\;for\;j\;in\;sorted\left( {I_k,ascent order by\;{{\bf{x}}_{jk}}} \right)\;do \cr & \;\;\;\;\;\;\;\;{G_L} \leftarrow {G_L} + {g_j},{H_L} \leftarrow {H_L} + {h_j} \cr & \;\;\;\;\;\;\;\;{G_R} \leftarrow G - {G_L},{H_R} \leftarrow H - {H_L} \cr & \;\;\;\;\;\;\;\;score \leftarrow \max \left( {score,{{G_L^2} \over {{H_L} + \lambda }} + {{G_R^2} \over {{H_R} + \lambda }} - {{{G^2}} \over {H + \lambda }}} \right) \cr & \;\;\;\;end \cr & \;\;\;\;{G_R} \leftarrow 0,{H_R} \leftarrow 0 \cr & \;\;\;\;for\;j\;in\;sorted\left( {I_k,ascent order by\;{{\bf{x}}_{jk}}} \right)\;do \cr & \;\;\;\;\;\;\;\;{G_R} \leftarrow {G_R} + {g_j},{H_R} \leftarrow {H_R} + {h_j} \cr & \;\;\;\;\;\;\;\;{G_L} \leftarrow G - {G_R},{H_L} \leftarrow H - {H_R} \cr & \;\;\;\;\;\;\;\;score \leftarrow \max \left( {score,{{G_L^2} \over {{H_L} + \lambda }} + {{G_R^2} \over {{H_R} + \lambda }} - {{{G^2}} \over {H + \lambda }}} \right) \cr & \;\;\;\;end \cr & end \cr & Output:\; split\_value\; and\; default \;directions\; with\; max \; score} $$

论文后续内容为系统部分（包括并行化、cache-aware加速、数据块预处理，需要结合代码研读）、实验（在不同的数据集上进行了实验，包括分类、LTR、CTR预估）详见论文[11]
代码阅读：
代码易用，注释较完备，支持多种语言，目前仍在持续集成和更新，其中稀疏矩阵存储为CSR格式(见附录思考[2])。
很多核心的机器学习函数复用了作者的另一个机器学习库DMLC(Distributed Machine Learning Common Codebase)，和参考[12]中介绍代码版本对比，运用较多通用的工厂类方法(见附录思考[3])，草草介绍下主体代码组成，下一篇会进行详细拆解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Data.h 定义基础数据结构，
    如数据信息MetaInfo，稀疏矩阵RowBatch，数据集合RowSet，训练时矩阵表达DMatrix。
Tree_model.h 定义了树相关参数TreeParam，树的模板类TreeModel(对应树节点Node)，
    回归树RegTree，关于树的操作（增删改查，读写load,save,dump2text等）。
Tree_updater.h 完成对树的更新，包含对象工厂类用于注册不同的更新操作:
"updater_colmaker.cc",  通过数据列(论文介绍方式)树的更新（单机多线程版本）
"updater_skmaker.cc",  分位数略图法进行数据采样
"updater_refresh.cc",  更新操作
"updater_prune.cc",  更新过程中进行剪枝
"updater_histmaker.cc",  通过直方图相关统计量完成树的更新
"updater_sync.cc", 从分布训练机器节点中进行树的同步
Objective.h 定义了目标函数，具体优化目标实现，回归,分类,排序函数由对象工厂生成：
"multiclass_obj.cc", 多分类损失函数("SoftmaxMultiClass","SoftprobMultiClass")
"rank_obj.cc", 排序损失函数，有多种可选(PairwiseRankObj，LambdaRankNDCG，LambdaRankObjMAP)
"regression_obj.cc"，回归损失函数("GammaRegression")
看demo可知，xgboost允许用户自定义损失函数。
metric.h 模型效果评估类，包含elementwise_metric、multiclass_metric、rank_metric三类。
"elementwise_metric.cc": 定义评估函数有(RMSE, MAE, logLoss, Error, PosssionNegLoglik, 
    GammaDeviance, GammaNlogLik)
"multiclass_metric.cc": 定义两种评估指标(SoftmaxMultiClass, SoftprobMultiClass)
"rank_metric.cc": 定义评估指标(AMS, Auc, Precision, NDCG, MAP)

附录

引文
[1] Panda, Biswanath, et al. “PLANET: massively parallel learning of tree ensembles with MapReduce.” Proceedings of the Vldb Endowment 2.2(2009):1426-1437.
[2] Tyree, Stephen, et al. “Parallel boosted regression trees for web search ranking.” International Conference on World Wide Web ACM, 2011:387-396.
[3] Ye, Jerry, et al. “Stochastic gradient boosted distributed decision trees.” ACM Conference on Information and Knowledge Management, CIKM 2009, Hong Kong, China, November 2009:2061-2064.
[4] Johnson, Rie, and Z. Tong. “Learning Nonlinear Functions Using Regularized Greedy Forest.” IEEE Transactions on Pattern Analysis & Machine Intelligence 36.5(2013):942-54.
[5] Friedman, Jerome H., and B. E. Popescu. “Importance Sampled Learning Ensembles.” (2003).
[6] Li, Ping, C. J. C. Burges, and Q. Wu. “McRank: Learning to Rank Using Multiple Classification and Gradient Boosting.” Advances in Neural Information Processing Systems (2007):897-904.
[7] Bekkerman, Ron, M. Bilenko, and J. Langford. “Scaling up machine learning: parallel and distributed approaches.” ACM SIGKDD International Conference Tutorials ACM, 2011:1-1.
[8] Tyree, Stephen, et al. “Parallel boosted regression trees for web search ranking.” International Conference on World Wide Web ACM, 2011:387-396.
[9] Greenwald, Michael. “Space-efficient online computation of quantile summaries.” Acm Sigmod Record 30.2(2001):58–66.
[10] Zhang, Qi, and W. Wang. “A Fast Algorithm for Approximate Quantiles in High Speed Data Streams.” (2007):29-29.
[11]Chen, Tianqi, and C. Guestrin. “XGBoost: A Scalable Tree Boosting System.” (2016).
[12] xgboost导读和实战（百度云地址），王超，陈帅华
[13] xgboost代码参数说明, @zc02051126译
[14]xgboost: 速度快效果好的boosting模型,何通
[15]Introduction to Boosted Trees, 官网

思考
[1].不能直接看明白，手痒推导一把就通顺多了。函数$f(x)$在$x_0$处的二阶展开式为：$$f\left( x \right) = f\left( {{x_0}} \right) + f'\left( {{x_0}} \right)\left( {x - {x_0}} \right) + f''\left( {{x_0}} \right){\left( {x - {x_0}} \right)^2}$$
我们对$l(y_i, x)$在${\hat y}^{(t-1)}_i$处进行二阶展开得到
$$l({y_i},x) = l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right) + {{\partial l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right)} \over {\partial {{\hat y}^{\left( {t - 1} \right)}}}}\left( {x - {{\hat y}^{\left( {t - 1} \right)}}} \right) + {{{\partial ^2}l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right)} \over {\partial {{\hat y}^{\left( {t - 1} \right)}}}}{\left( {x - {{\hat y}^{\left( {t - 1} \right)}}} \right)^2}$$
令$x={\hat y}^{(t-1)}+f_t({\bf x}_i)$，且记一阶导为${g_i} = {{\partial l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right)} \over {\partial {{\hat y}^{\left( {t - 1} \right)}}}}$，二阶导为${h_i} = {{{\partial ^2}l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right)} \over {\partial {{\hat y}^{\left( {t - 1} \right)}}}}$。
我们得到$l(y_i, {\hat y}^{(t-1)}+f_t({\bf x}_i))$的二阶泰勒展开：
$$l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right) + {g_i}{f_t}\left( {{{\bf{x}}_i}} \right) + {1 \over 2}{h_i}f_t^2\left( {{{\bf{x}}_i}} \right)$$
带入目标函数可得：
$${L^{\left( t \right)}} \simeq \sum\limits_{i = 1}^n {\left[ {l\left( {{y_i},{{\hat y}^{\left( {t - 1} \right)}}} \right) + {g_i}{f_t}\left( {{{\bf{x}}_i}} \right) + {1 \over 2}{h_i}f_t^2\left( {{{\bf{x}}_i}} \right)} \right]} + \Omega \left( {{f_t}} \right)$$

[2]：csr格式是什么？类似的格式有什么，它们之间的区别是什么？
参见：稀疏矩阵存储格式总结+存储效率对比:COO,CSR,DIA,ELL,HYB

CSR有行偏移，列下标，值三种元素。行偏移数组大小为（总行数目+1），行偏移表示某一行的第一个元素在values里面的起始偏移位置。数值和列号与COO一致，表示一个元素以及其列号。如上图中，第一行元素1是0偏移，第二行元素2是2偏移，第三行元素5是4偏移，第4行元素6是7偏移。在行偏移的最后补上矩阵总的元素个数，本例中是9。

[3]思考：通用的工厂类，@tenfyzhong

ShawnXiao@baidu

有没有发现写了这么多，还是没有点题”GBDT”，先记下，且往下看
纸上得来终觉浅，希望能组织一波小伙伴把模型实现个遍嘞

回顾下：上一篇结尾部分，我们给出了通用的GB框架：

1. ${F_0}\left( {\bf{x}} \right) = \arg {\min _\rho }\sum\nolimits_{i = 1}^N {L\left( {{y_i},\rho } \right)} $
2. $For\;m = 1\;to\;M\;do:$
3. ${{\tilde y}_i} = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)}},i = 1,N$
4. ${{\bf{a}}_m} = \arg {\min _{{\bf{a}},\beta }}{\sum\nolimits_{i = 1}^N {\left[ {{{\tilde y}_i} - \beta h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right]} ^2}$
5. ${\rho _m} = \arg \mathop {\min }\limits_\rho \sum\nolimits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right)} $
6. ${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + {\rho _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right)$
7. $end For$

将若干learner $h({\bf x}_i;{\bf a})$用mixture方式进行组合最小化loss function，根据不同的loss function，第4行的负梯度计算也不同，下面介绍下几个常用的loss function：

最小均方差(LS)回归

loss function为$L\left( {y,F} \right) = {{{{\left( {y - F} \right)}^2}} \over 2}$。在$m$轮对$F_{m-1}$求导得到梯度，负梯度pseudore-response为${{\tilde y}_i} = {y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)$。通用框架中第4行只需要简单地拟合当前的残差，第5行线搜索步长$\rho _m$可以等价为第4行中的$\beta _m$。以最小均方差为loss function的可以推出残差拟合的级联方法，这也是最常见的形式。LS_Boost流程整理如下：
$$\eqalign{ & For\;m = 1\;to\;M\;do: \cr & \;\;\;\;{y_i} = {y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right),\;i = 1,N \cr & \;\;\;\;\left( {{\rho _m},{{\bf{a}}_m}} \right) = \mathop {\arg \min }\limits_{{\bf{a}},\rho } {\sum\limits_{i = 1}^N {\left[ {{{\tilde y}_i} - \rho h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right]} ^2} \cr & \;\;\;\;{F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + {\rho _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right) \cr & endFor\; \cr} $$

最小绝对值误差(LAD)回归

loss function 为$L\left( {y,F} \right) = \left| {y - F} \right|\;$，可以得到负梯度为pseudore-response
$${{\tilde y}_i} = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right){\rm{ = }}{F_{m - 1}}\left( {\bf{x}} \right)}} = sign\left( {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right)$$，这个求导过程放在附录思考[1]。
我们需要一组分类器$h({\bf x};{\bf a})$去拟合残差的符号（pseudore-response为符号函数值，拟合pseudore-response即拟合残差的符号）。通过线搜索得到
$$\eqalign{ & {\rho _m} = \arg \mathop {\min }\limits_\rho \sum\limits_{i = 1}^N {\left| {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right) - \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right|} \cr & {\kern 1pt} \;\;\;\; = \arg \mathop {\min }\limits_\rho \sum\limits_{i = 1}^N {\left| {h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right| \cdot \left| {{{{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \over {h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)}} - \rho } \right|} \cr & \;\;\;\;{\rm{ = media}}{{\rm{n}}_W}\left\{ {{{{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \over {h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)}}} \right\}_1^N,{w_i} = \left| {h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right|. \cr} $$
$media{n_W}\left\{ {} \right\}$表示先进行$w_i$加权，在得到的结果中，取得中位数。我们在GB过程中，采用上面的pseudore-response和$h({\bf x};{\bf a})$、以及步长$\rho_m$，可以得到loss function为LAD的GB算法。

用于回归的GBDT

上面介绍了GB方法中的LS和LAD，如果使用树模型例如CART树作为$h({\bf x};{\bf a})$，可以表述如下：$$h\left( {{\bf{x}};\left\{ {{b_j},{R_j}} \right\}_1^J} \right) = \sum\limits_{j = 1}^J {{b_j}1\left( {{\bf{x}} \in {R_j}} \right)} $$
$\left\{ {{R_j}} \right\}_1^J$表示从观测数据$\bf x$中生成的不联通区域，由树的分裂节点进行划分。而$$1\left( \cdot \right)$$，表示事件$x \in R_j$是否发生，判断样本点落在某个分支。树的参数有两部分，节点系数为$\left\{ {{b_j}} \right\}_1^J$、节点（包含选择哪个节点和确认它进行分裂的值）。回归树的更新公式为：
$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + {\rho _m}\sum\limits_{j = 1}^J {{b_{jm}}1\left( {{\bf{x}} \in {R_{jm}}} \right)} --(1)$$
这里$\left\{ {{R_{jm}}} \right\}_1^J$表示第$m$轮迭代中树的节点所划分的区域。若对于loss function为最小均方差(LS)，这些区域的累加用来表示当前的pseudo-response，$\left\{ {{b_{jm}}} \right\}$为最小均方差的系数：
$$b_{jm}=ave_{{\bf x}_i \in R_{jm}}{\tilde y}_i$$。步长$\rho_m$同上述一致，可以线搜索进行求解。
作者提供了一种简化方式，记${\gamma _{jm}} = {\rho _m}{b_{jm}}$。$(1)$式变化如下：
$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jm}}1\left( {{\bf{x}} \in {R_{jm}}} \right)} $$
从上面公式出发，我们可以视作每级增加$J$个不同的基函数。对这样的式子，我们可以通过优化下面这个式子得到函数参数：$$\left\{ {{\gamma _{jm}}} \right\}_1^J = \arg \mathop {\min }\limits_{\left\{ {{\gamma _j}} \right\}_1^J} \sum\limits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \sum\limits_{j = 1}^J {{\gamma _j}1\left( {{\bf{x}} \in {R_{jm}}} \right)} } \right)} $$
因为基函数代表的每个区域之间不相互依赖，对于每一级可以拆开视为$j$个最小单位的优化：$${\gamma _{jm}} = \arg \mathop {\min }\limits_\gamma \sum\limits_{{\bf x}_i \in R_{jm}}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \gamma } \right)} --(2)$$
给定当前的函数逼近$F_{m-1}(x)$在每个节点划分的区域上优化，在LAD的loss function下$(2)$可以演变为：$${\gamma _{jm}} = media{n_{{{\bf{x}}_i} \in {R_{jm}}}}\left\{ {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right\}$$。第$m$轮第$j$节点参数$\gamma$可以表示为残差的中位数。在每一轮迭代中回归树预测当前残差的中位数。
$$\eqalign{ & {F_0}\left( {\bf{x}} \right) = median\left\{ {{y_i}} \right\}_1^N \cr & For\;m = 1\;to\;M\;do: \cr & \;\;\;\;{{\tilde y}_i} = {\mathop{\rm sign}\nolimits} \left( {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right),i = 1,N \cr & \;\;\;\;\left\{ {{R_{jm}}} \right\}_1^J = J - node\;tree\left( {\left\{ {{{\tilde y}_i},{{\bf{x}}_i}} \right\}_1^N} \right) \cr & \;\;\;\;{\gamma _{jm}} = media{n_{{{\bf{x}}_i} \in {R_{jm}}}}\left\{ {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right\},j = 1,J \cr & \;\;\;\;{F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jm}}1\left( {{\bf{x}} \in {R_{jm}}} \right)} \cr & endFor \cr} $$
LAD只用了变量的顺序信息，pseudo-response只有$\{-1,1\}$二值，算法鲁棒性强（按，中位数其实挺难计算的，见附录思考3）如果loss function是最小均方误差LS的话，那么根据$(2)$式进行求导，可得$\gamma$更新公式。
再介绍一种更直接的思路，训练一棵树$tree$直接拟合LAD的loss。
$$tre{e_m}\left( {\bf{x}} \right) = \arg \mathop {\min }\limits_{J - node\;tree} \sum\limits_{i = 1}^N {\left| {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right) - tree\left( {{{\bf{x}}_i}} \right)} \right|} $$
$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)+tree_{m}({\bf x})$$

M-Regression（Huber loss function）

M-Regression增强模型对长尾的误差分布的鲁棒性，同时保持对正太分布误差计算的高效率。

待理解”M-regression techniques attempt resistance to longtailed error distributions and outliers while maintaining high efficiency for normally distributed errors”

给出下面的Huber loss function：
$$L\left( {y,F} \right) = \left\{ {\matrix{ {{1 \over 2}{{\left( {y - F} \right)}^2},\left| {y - F} \right| < \delta } \cr {\delta \left( {\left| {y - F} \right| - {\delta \over 2}} \right),\left| {y - F} \right| > \delta } \cr } } \right.$$
按前述GB框架，先求pseudore-response：
$$\eqalign{ & {{\tilde y}_i} = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)}} \cr & \;\;\;\; = \left\{ {\matrix{ {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right),\;\;\;\;\left| {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right| \le \delta } \cr {\delta \cdot {\mathop{\rm sign}\nolimits} \left( {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right),\;\;\left| {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right| \le \delta } \cr } } \right. \cr} $$
根据pseudo-response拟合$h({\bf x}; {\bf a})$：
$${\rho _m} = \arg \mathop {\min }\limits_\rho \sum\limits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right)} $$
关于Huber 函数具体细节参看引文[2]，$\delta$定义了残差里面哪部分属于outlier，这部分使用LAD约束，其他则使用LS损失函数约束。真实的$\delta$应由$y-F^*({\bf x})$决定，其中$F^*({\bf x})$由目标函数决定。实践中通常使用$|y-F^*(x)|$分布的$\alpha$-分位数的取值：
$${\delta _m} = quantil{e_\alpha }\left\{ {\left| {{y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right|} \right\}_1^N$$
关于中位数的猜想见附录思考4。
得到第$M$轮的pseudo-response之后我们用一颗回归树进行拟合。在第$j$个节点$R_{jm}$，Huber loss关于公式$(2)$的解可以一步标准迭代过程进行近似。先得到节点$R_{jm}$上残差$\{r_{m-1}({\bf x}_i)\}^N_i$中位数：
$${{\tilde r}_{jm}} = media{n_{{{\bf{x}}_i} \in {R_{jm}}}}\left\{ {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right\}$$
其中${r_{m - 1}}\left( {{{\bf{x}}_i}} \right) = {y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right)$。近似方法如下：
$${\gamma _{jm}} = {{\tilde r}_{jm}} + {1 \over {{N_{jm}}}}\sum\limits_{{{\bf{x}}_i} \in {R_{jm}}}^{} {{\mathop{\rm sign}\nolimits} \left( {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right) - {{\tilde r}_{jm}}} \right)} \cdot \min \left( {{\delta _m},abs\left( {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right) - {{\tilde r}_{jm}}} \right)} \right)$$
其中，$N_{jm}$为第$j$节点上观测值总数。有了$\gamma_{jm}$我们可以根据GBDT框架写出流程：
$$\eqalign{ & {F_0}\left( {\bf{x}} \right) = median\left\{ {{y_i}} \right\}_1^N \cr & For\;m = 1\;to\;M\;do: \cr & \;\;\;\;{r_{m - 1}}\left( {{{\bf{x}}_i}} \right) = {y_i} - {F_{m - 1}}\left( {{{\bf{x}}_i}} \right),i = 1,N \cr & \;\;\;\;{\delta _m} = quantil{e_\alpha }\left\{ {\left| {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right|} \right\}_1^N \cr & \;\;\;\;{{\tilde y}_i} = \left\{ {\matrix{ {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right),\;\;\;\;\left| {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right| \le {\delta _m}} \cr {{\delta _m} \cdot {\mathop{\rm sign}\nolimits} \left( {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right),\left| {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right| > {\delta _m}} \cr } } \right.,i = 1,N \cr & \;\;\;\;\left\{ {{R_{jm}}} \right\}_1^J = J - node\;tree\left( {\left\{ {{{\tilde y}_i},{{\bf{x}}_i}} \right\}_1^N} \right) \cr & \;\;\;\;{{\tilde r}_{jm}} = media{n_{{{\bf{x}}_i} \in {R_{jm}}}}\left\{ {{r_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right\},j = 1,J \cr & \;\;\;\;{\gamma _{jm}} = {{\tilde r}_{jm}} + {1 \over {{N_{jm}}}}\sum\limits_{}^{} {{\mathop{\rm sign}\nolimits} \left( {{r_{m - 1}}\left( {{x_i}} \right) - {{\tilde r}_{jm}}} \right) \cdot \min \left( {{\delta _m},abs\left( {{r_{m - 1}}\left( {{x_i}} \right) - {{\tilde r}_{jm}}} \right)} \right)} \cr & \;\;\;\;\;\;\;\;j = 1,N \cr & \;\;\;\;{F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jm}}1\left( {{\bf{x}} \in {R_{jm}}} \right)} \cr & endFor \cr} $$
下图绘制了LS、LAD、huber的LOSS曲线，可以看到以$\delta$为分界点，中间呈现LS的性质，两边呈现LAD的线性。

下面介绍GBDT用于分类问题：

GBDT用于二分类

如何用GB方式解决二分类问题。我们首先定义loss function为负二元log似然函数(negative binomial log-liklihood)：
$$L(y,F)=log(1+exp(-2yF)), y \in \{-1, 1\}$$
其中$$F\left( {\bf{x}} \right) = {1 \over 2}\log \left[ {{{\Pr \left( {y = 1|{\bf{x}}} \right)} \over {\Pr \left( {y = - 1|{\bf{x}}} \right)}}} \right]--(3)$$
有了loss function可以进一步得到pseudo-responce
$${y_i} = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)}} = {{2{y_i}} \over {1 + \exp \left( {2{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right)}}$$
步长通过线搜索得到：
$${\rho _m} = \arg \mathop {\min }\limits_\rho \sum\limits_{i = 1}^N {\log \left( {1 + \exp \left( { - 2{y_i}\left( {{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right)} \right)} \right)} $$
对于GBDT，我们用树模型作为${h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)}$。和回归问题的处理类似，我们可以得到每个节点$R_{jm}$上的更新规则：
$${\gamma _{jm}} = \arg \mathop {\min }\limits_\gamma \sum\limits_{{{\bf{x}}_i} \in {R_{jm}}}^{} {\log \left( {1 + \exp \left( { - 2{y_i}\left( {{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \gamma } \right)} \right)} \right)} -- (4)$$
公式$(4)$没有闭式解，我们通过单步拟牛顿法进行近似：
$${\gamma _{jm}} = \sum\limits_{{{\bf{x}}_i} \in {R_{jm}}} {{{{{\tilde y}_i}} \over {\sum\limits_{{{\bf{x}}_i} \in {R_{jm}}} {\left| {{{\tilde y}_i}} \right|\left( {2 - \left| {{{\tilde y}_i}} \right|} \right)} }}} $$
这里的${\tilde y}_i$为pseudo-response。算法流程为：
$$\eqalign{ & {F_0}\left( {\bf{x}} \right) = {1 \over 2}\log {{1 + \bar y} \over {1 - \bar y}} \cr & For\;m = 1\;to\;M\;do: \cr & \;\;\;\;{{\tilde y}_i} = {{2{y_i}} \over {1 + \exp \left( {2{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right)}},i = 1,N \cr & \;\;\;\;\left\{ {{R_{jm}}} \right\}_1^J = J - tree\left( {\left\{ {{{\tilde y}_i},{{\bf{x}}_i}} \right\}_1^N} \right) \cr & \;\;\;\;{\gamma _{jm}} = \sum\limits_{{{\bf{x}}_i} \in {R_{jm}}}^{} {{{{{\tilde y}_i}} \over {\sum\limits_{{{\bf{x}}_i} \in {R_{jm}}} {\left| {{{\tilde y}_i}} \right|\left( {2 - \left| {{{\tilde y}_i}} \right|} \right)} }}} ,j = 1,J \cr & \;\;\;\;{F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jm}}1\left( {{\bf{x}} \in {R_{jm}}} \right)} \cr & end\;For \cr} $$
得到最终的$F_m({\bf x})$为$F({\bf x})$的近似，$F({\bf x})$为：
$$F\left( {\bf{x}} \right) = {1 \over 2}\log \left[ {{{\Pr \left( {y = 1|{\bf{x}}} \right)} \over {\Pr \left( {y = - 1|{\bf{x}}} \right)}}} \right]--(3)$$
来了一个新样本$x_j$，若$F_m({x_j})>0$，则$y=1$，反之则$y=-1$。
根据$(3)$式，我们可以计算得到分属不同类别的概率：
$${p_ + }\left( {\bf{x}} \right) = \tilde Pr\left( {y = 1|{\bf{x}}} \right) = {1 \over {1 + \exp \left( { - 2{F_M}\left( {\bf{x}} \right)} \right)}}$$
$${p_ - }\left( {\bf{x}} \right) = \tilde Pr\left( {y = - 1|{\bf{x}}} \right) = {1 \over {1 + \exp \left( {2{F_M}\left( {\bf{x}} \right)} \right)}}$$
可以根据不同的应用，进行调权：
$$\tilde y\left( {\bf{x}} \right) = 2 \cdot 1\left( {c\left( { - 1,1} \right){p_ + }\left( {\bf{x}} \right) > c\left( {1, - 1} \right){p_ - }\left( {\bf{x}} \right)} \right) - 1$$
其中${c\left( {\tilde y, y} \right)}$为将$y$识别成$\tilde y$的cost。
剪枝
GB框架解决二分类问题的loss function在第m轮迭代中如下：
$${\phi _m}\left( {\rho ,{\bf{a}}} \right) = \sum\limits_{i = 1}^N {\log \left[ {1 + \exp \left( { - 2{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right) \cdot \exp \left( { - 2{y_i}\rho h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right)} \right]} $$
随着迭代继续，${{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)}$会变成很大，使得结果不再受新的样本影响。也就是说，当${{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)}$很大，$ \exp \left( { - 2{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right)$会相对很小。
视其为权重${w_i} = \exp \left( { - 2{y_i}{F_{m - 1}}\left( {{{\bf{x}}_i}} \right)} \right)$，作为第$i$个数据的影响力。
剪枝的做法是将权重$w_i \le w_{l(\alpha)}$，其中$l(\alpha)$为下式的解：
$$\sum\limits_{i = 1}^{l\left( \alpha \right)} {{w_{\left( i \right)}}} = \alpha \sum\limits_{i = 1}^N {{w_i}} $$
通常$\alpha \in [0.05, 0.2]$，这里的剪枝和AdaBoost的”weight trimming”是一样的。将近90%到95%的样本候选被剪枝，带来10%到20%的计算速度提升。下面介绍GBDT用于多分类问题。

GBDT用于多分类

对于 $K$-类问题，同样定义loss function是
$$L\left( {\left\{ {{y_k},{F_k}\left( {\bf{x}} \right)} \right\}_1^K} \right) = - \sum\limits_{k = 1}^K {{y_k}\log {p_k}\left( {\bf{x}} \right)}--(4) $$
其中，$y_k=1(class=k) \in \{0, 1\}$，$p_k({\bf x})=Pr(y_k=1|{\bf x})$，
$${p_k}\left( {\bf{x}} \right) = {{\exp \left( {{F_k}\left( {\bf{x}} \right)} \right)} \over {\sum\limits_{l = 1}^K {\exp \left( {{F_k}\left( {\bf{x}} \right)} \right)} }} -- (5)$$
$${F_k}\left( {\bf{x}} \right) = \log {p_k}\left( {\bf{x}} \right) - {1 \over K}\sum\limits_{l = 1}^K {\log {p_l}\left( {\bf{x}} \right)} --(6)$$
$(5)$、$(6)$是等价。
将$(6)$带入到$(4)$，求一阶导可得：
$${{\tilde y}_{ik}} = - {\left[ {{{\partial L\left( {\left\{ {{y_{il}},{F_l}\left( {{{\bf{x}}_i}} \right)} \right\}_{l = 1}^K} \right)} \over {\partial {F_k}\left( {{{\bf{x}}_i}} \right)}}} \right]_{\left\{ {{F_l}\left( {\bf{x}} \right) = {F_{l,m - 1}}\left( {\bf{x}} \right)} \right\}_1^K}} = {y_{ik}} - {p_{k,m - 1}}\left( {{{\bf{x}}_i}} \right)$$
其中，$p_{k,m-1}$从$F_{k,m-1}(x)$的函数$(5)$导出。第$m$轮用K棵trees预测对应每类的残差，每棵树有$J$个节点，记作$\{R_{jkm}\}^J_{j=1}$。模型的参数$\gamma _{jkm}$更新规则：
$$\left\{ {{\gamma _{jkm}}} \right\} = \arg \mathop {\min }\limits_{\left\{ {{\gamma _{jk}}} \right\}} \sum\limits_{i = 1}^N {\sum\limits_{k = 1}^N {\phi \left( {{y_{ik}},{F_{k,m - 1}}\left( {{{\bf{x}}_i}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jk}}1\left( {{{\bf{x}}_i} \in {R_{jm}}} \right)} } \right)} } (7)$$
其中，$\phi \left( {{y_k},{F_k}} \right) = - {y_k}\log {p_k}$，${F_k}\left( {\bf{x}} \right) = \log {p_k}\left( {\bf{x}} \right) - {1 \over K}\sum\limits_{l = 1}^K {\log {p_l}\left( {\bf{x}} \right)} $。$(7)$无闭式解，可以通过单步Newton-Raphson使用一个对角矩阵近似Hessian矩阵。
$${\gamma _{jkm}} = {{K - 1} \over K}{{\sum\limits_{{{\bf{x}}_i} \in {R_{jkm}}}^{} {{{\tilde y}_{ik}}} } \over {\sum\limits_{{{\bf{x}}_i} \in {R_{jkm}}}^{} {\left| {{{\tilde y}_{ik}}} \right|\left( {1 - \left| {{{\tilde y}_{ik}}} \right|} \right)} }}$$
这样我们可以构建出$K$类别的logistic GBDT框架如下：
$$\eqalign{ & {F_{k0}}\left( {\bf{x}} \right) = 0,k = 1,K \cr & For\;m = 1\;to\;M\;do: \cr & \;\;\;\;{p_k}\left( {\bf{x}} \right) = {{\exp \left( {{F_k}\left( {\bf{x}} \right)} \right)} \over {\sum\limits_{l = 1}^K {\exp \left( {{F_l}\left( {\bf{x}} \right)} \right)} }},k = 1,K \cr & \;\;\;\;For\;k = 1\;to\;K\;do: \cr & \;\;\;\;\left\{ {{R_{jkm}}} \right\}_{j = 1}^J = J - tree\left( {\left\{ {{{\tilde y}_{ik}},{{\bf{x}}_i}} \right\}_1^N} \right) \cr & \;\;\;\;{\gamma _{jkm}} = {{K - 1} \over K}{{\sum\limits_{{x_i} \in {R_{jkm}}} {{{\tilde y}_{ik}}} } \over {\sum\limits_{{{\bf{x}}_i} \in {R_{jkm}}} {\left| {{{\tilde y}_{ik}}} \right|\left( {1 - \left| {{{\tilde y}_{ik}}} \right|} \right)} }},j = 1,J \cr & \;\;\;\;{F_{km}}\left( {\bf{x}} \right) = {F_{k,m - 1}}\left( {\bf{x}} \right) + \sum\limits_{j = 1}^J {{\gamma _{jkm}}1\left( {{\bf{x}} \in {R_{jkm}}} \right)} \cr & \;\;\;\;endFor \cr & endFor \cr} $$
预测和二分类问题类似，我们得到$\left\{ {{F_{km}}\left( {\bf{x}} \right)} \right\}_1^K$可以用于预估$\left\{ {{p_{km}}\left( {\bf{x}} \right)} \right\}_1^K$。类别预测结果为：$${\hat k}\left( {\bf{x}} \right) = \arg \mathop {\min }\limits_{1 \le k \le K} \sum\limits_{k' = 1}^K {c\left( {k,k'} \right)} {p_{k'M}}\left( {\bf{x}} \right)$$
$c(k,k')$表示真实label($k'$)预测为predict($k$)的cost。

对于$p_{k'M}\left( {\bf{x}} \right)$为样本$\bf x$预测为$k$类的概率。而${\hat k}(x)$的$argmin$不太好理解。如果是求最终cost的话，能理解。但是对于前面介绍过的二分类标签的判断公式，似乎有难通顺的地方，是不是这里的比较部分应该是小于号$<$？：
$$\tilde y\left( {\bf{x}} \right) = 2 \cdot 1\left( {c\left( { - 1,1} \right){p_ + }\left( {\bf{x}} \right) > c\left( {1, - 1} \right){p_ - }\left( {\bf{x}} \right)} \right) - 1$$

1. 思考：最小绝对值偏差的导数为什么是sign(y-F) 下面图为|1-x|的曲线，导数为分段函数，值域为{-1,+1}

1. 思考：LAD (least absolut deviation)的拟合H(x;a, $\rho$)中$\rho$为何是中位数。
   H(X; a)为符号函数，而对于$\sum\nolimits_i {\left| {{y_i} - \rho } \right|} $，最优解为$median_y$
2. 思考： 最小绝对误差的均值比LAD里偏差的中位数更容易计算。LAD里偏差的中位数更鲁棒。
3. 思考：M-regression[huber]的$\alpha$分位数是什么概念
   猜想配合前面loss function定义这里应该是用的双侧分位数。$\alpha$-双侧分位数的定义：当随机变量$X$的分布函数为 $F(x)$，$0 \lt \alpha \lt 1$，$\alpha$分位数是使$P\{X \lt \delta\}=F(X)=0.5\alpha$ &$P\{X > \delta\}=F(X)=0.5\alpha$。假定我们令$\alpha=0.2$，那么我们将对$\delta$满足$P\{X \lt \delta\}<0.1$&$p\{x> \delta\}<0.1$的样本使用 loss function $\delta(|y-F|-\delta/2)$。其余样本使用LS loss。还需要进一步确认
4. 思考：GBDT和ADAboost什么关系：参看引文[1]第14页
5. 正则化，在每次迭代过程中增加一个学习率参数：$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + v \cdot {\rho _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right),\;\;0 < v \le 1$$

引文：
[1] Friedman J H. Greedy Function Approximation: A Gradient Boosting Machine[J]. Annals of Statistics, 2000, 29(5):1189–1232.
[2]Huber, P. (1964). Robust estimation ofa location parameter. Ann. Math. Statist. 35 73–101.
[3]Friedman J, Tibshirani R. Special Invited Paper. Additive Logistic Regression: A Statistical View of Boosting: Discussion[J]. Annals of Statistics, 2000, 28(2):pages. 374-376.

ShawnXiao@baidu

1. gradient boosting是什么框架 [上篇]
2. 最小绝对值误差LAD， 最小均方差LST， HUBER-M函数，三者有什么区别[下篇]
3. gbdt怎么处理分类问题[下篇]

本篇学习路径较深，建议先看引文[2]决策树之CART算法和[3] GBDT(MART)迭代决策树入门教程。
计划按提出者Jerome H. Friedman论文[1]思路介绍gbdt，希望通过总结这篇笔记，得到对算法更具体的认识，又能更抽象地记忆。

级联函数的介绍

给定${\bf{x}} = \left\{ {{x_1},...,{x_n}} \right\}$和对应的输出$y$，进行学习预测。根据样本集$\left\{ {{y_i},{{\bf{x}}_i}} \right\}_1^N$估计（逼近）函数$\hat F\left( x \right)$。在样本集上得到最小化 loss function 得到的函数，记为 ${F^*}\left( x \right)$。
$$\begin{equation}{F^*}\left( x \right) = \arg \mathop {\min }\limits_F {E_{y,{\bf{x}}}}L\left( {y,F\left( {\bf{x}} \right)} \right) = \arg \mathop {\min }\limits_F {E_{\bf{x}}}\left[ {{E_y}\left( {L\left( {y,F\left( x \right)} \right)} \right)|x} \right]\end{equation}$$
对于回归问题，loss function最常用最小均方误差$(y-F)^2$和$|y-F|$最小绝对值误差。分类问题常用二元负log似然loss function，$log(1+e^{-2yF})$，其中 $y \in \left\{ { - 1,1} \right\}$，后面还会介绍多元log似然loss function。
通常做法是将$F(\bf x)$限制为带参函数族$F(x; \bf{P})$。其中${\bf{P}} = \{ {p_1},{p_2},...\}$ ，$p_i$选定以后就可以得到$F(x)$中的每个组成函数。GBDT采用如下级联形式的公式：$$\begin{equation}F\left( {{\bf{x}};\left\{ {{\beta _m},{{\bf{a}}_m}} \right\}_1^M} \right) = \sum\limits_{m = 1}^M {{\beta _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right)} \end{equation}$$
公式$(2)$中的通用式$h\left( {{\bf{x}};{{\bf{a}}_m}} \right)$是关于$x$的带参函数，参数空间为$a={a_1, a_2, ...}$。通过选定不同的$a_m$，得到不同的级联函数子项。函数子项如果使用$CART$[2]作为回归树进行学习，那么参数$a_m$包含选择作为分裂点的变量（用何项分裂）、分裂点的分裂值（用何值进行分裂）、每棵树叶结点的均值（何时终止分裂），这就是GBDT的构造思路。

作者介绍了初始目标函数$(1)$的两种优化方法，数值优化和函数空间的数值优化，再引入GBDT的解法。前者适合辅助理解GBDT的构造，后者可以在原文中找到描述。

带参函数在数值空间的优化

引入参数表达后，我们把目标优化函数$(1)$式改造为
$$\begin{equation}{F^*}\left( x \right) = F\left( {x;{{\bf{P}}^*}} \right) = \arg \mathop {\min }\limits_p {E_{y,{\bf{x}}}}L\left( {y,F\left( {x;{\bf{P}}} \right)} \right)\end{equation}$$
对于大多数$F(x;\bf{P})$和loss function $L$，可以用数值优化算法进行求解。通常解的形式如下：$${{\bf{P}}^*} = \sum\limits_{m = 0}^M {{{\bf{p}}_m}} $$
其中$\bf{p_0}$随机初始化，$\left\{ {{{\bf{p}}_m}} \right\}_1^M$为随后每一步的增量，其值由优化算法决定。

梯度下降法

梯度下降法是最常用的数值最小化方法，记能量函数为$\Phi (x) = {E_{y,{\bf{x}}}}L\left( {y,F\left( {x;{\bf{P}}} \right)} \right)$，通过梯度下降法可以按如下套路进行求解：

1. 计算梯度$g_m$为$${g_m} = \left\{ {{g_{jm}}} \right\} = \left\{ {{{\left[ {{{\partial \Phi (x)} \over {\partial {P_j}}}} \right]}_{{\bf{P}} = {{\bf{P}}_{m - 1}}}}} \right\}$$这里${{\bf{P}}_{m - 1}} = \sum\limits_{i = 0}^{m - 1} {{{\bf{P}}_i}} $
2. 得到下降梯度方向，通过线搜索算法确定步长：
   $${{\bf{p}}_m} = - {\rho _m}{{\bf{g}}_m}$$，其中${\rho _m} = \arg \mathop {\min }\limits_\rho \Phi ({{\bf{P}}_{m - 1}} - \rho {{\bf{g}}_m})$。

有限集合的求解

如果我们在一个有限集合$\left\{ {{y_i},{{\bf{x}}_i}} \right\}_1^N$估计$\left( {y,{\bf{x}}} \right)$的联合分布，在这个集合上不能得到确定的解${E_y}\left[ { \cdot |{\bf{x}}} \right]$。我们需要学习这些训练样本得到最优函数表达$F^*({\bf x})$，进而去估计新的点${\bf x}$。样本点通过影响最终的函数对测试样本点的值施加约束。（按，同样是约束，我理解GBDT是判别形式，而高斯过程是产生形式，通过训练样本点和测试样本点的关系去施加约束，先估计联合高斯分布。）我们前面介绍过参数估计和优化的方法，可以写成如下形式：
$$\begin{equation}\left\{ {{\beta _m},{{\bf{a}}_m}} \right\}_1^M = \arg \mathop {\min }\limits_{\left\{ {\beta {'_m},a{'_m}} \right\}_1^M} \sum\limits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \beta 'h\left( {{{\bf{x}}_i};{\bf{a}}'} \right)} \right)} \end{equation}$$
这个解可以尝试进行贪心的梯度下降方法，通过每一级的逼近，对于$m=1,2,...M$，每一级参数估计如下：$$\begin{equation}\left\{ {{\beta _m},{{\bf{a}}_m}} \right\} = \arg \mathop {\min }\limits_{\beta ,{\bf{a}}} \sum\limits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \beta h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right)} \end{equation}$$
最后得到解函数的形式为：
$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \beta 'h\left( {{{\bf{x}}_i};{\bf{a}}'} \right)$$
在每一级的增加过程，逐级策略和数值优化介绍的逐步累加的方式有所区别。这种方法也叫boosting，$h(x;a)$为弱分类器，通常为分类树，如果不引发歧义，可以理解为子函数。

下面介绍GB的一般套路

假设给定了前$m-1$级的逼近函数$F_{m-1}({\bf x})$，当前的子函数$\beta_mh({\bf x;a})$可以视为最优解函数$F^*(x)$在梯度方向贪心策略的一步最佳逼近，这时子函数$h({\bf x;a})$视为参数化函数类$h({\bf x;a})$的成员，每一个级联过程就等同于最速下降法的每一步，我们可以通过梯度得到子函数的参数估计。
$$ - {g_m}\left( {{{\bf{x}}_i}} \right) = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)}}$$
我们可以得到第$M$步在训练集上关于$F_{m-1}(x)$的最佳梯度$-{\bf g}_m=\{-g_m({\bf x}_i) \} _1^N$。这些得到的梯度是从训练样本集中获取，并不能泛化到其他未知样本点。我们通过约束子函数$h({\bf x;a})$，使它满足在训练样本上的值${\bf h}_m=\{h({\bf x_i;a_m})\}_1^N$与$-{\bf g}_m \in R^N$平行。根据上面的论述，子函数$h({\bf x;a})$和$-{\bf g}_m(x)$强相关，可以从下面式子中解出来：$$\begin{equation} {{\bf{a}}_m} = \arg \mathop {\min }\limits_{{\bf{a}},\beta } {\sum\limits_{i = 1}^N {\left[ { - {g_m}\left( {{{\bf{x}}_i}} \right) - \beta h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right]} ^2} \end{equation}$$
负梯度$\{h({\bf x_i;a_m})\}_1^N$替换$-{\bf g}_m \in R^N$，前面说过，有了梯度方向，我们还需要通过线搜索得到最佳步长
$$\begin{equation} {\rho _m} = \arg \mathop {\min }\limits_\rho \sum\limits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right)} \end{equation}$$
那么第$m$级的函数逼近为：$${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + {\rho _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right)$$

将公式$(5)$中的解替换为$(6)(7)$带来的变化 ，作者描述为：”Basically, instead ofobtaining the solution under a smoothness constraint, the constraint is applied to the unconstrained (rough) solution”，需要后续琢磨下

通过$h({\bf x;a})$拟合pseudo-responses：$\left\{ {{{\tilde y}_i} = - {g_m}\left( {{x_i}} \right)} \right\}_{i = 1}^N$，在前面博客引用的wiki页中也称为pseudo -residuals，是一个概念。这样的变化把公式$(5)$难优化的问题转为了$(6)$中较容易优化的最小均方误差和$(7)$中较为简单的单参数优化。我们可以通过逐级的方式最小化任何可导的loss function$L(y,F)$。在每一级中，用最小均方误差从公式$(6)$中解出$h({\bf x;a})$。所以导出下面的通用GB流程：

1. ${F_0}\left( {\bf{x}} \right) = \arg {\min _\rho }\sum\nolimits_{i = 1}^N {L\left( {{y_i},\rho } \right)} $
2. $For\;m = 1\;to\;M\;do:$
3. ${{\tilde y}_i} = - {\left[ {{{\partial L\left( {{y_i},F\left( {{{\bf{x}}_i}} \right)} \right)} \over {\partial F\left( {{{\bf{x}}_i}} \right)}}} \right]_{F\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right)}},i = 1,N$
4. ${{\bf{a}}_m} = \arg {\min _{{\bf{a}},\beta }}{\sum\nolimits_{i = 1}^N {\left[ {{{\tilde y}_i} - \beta h\left( {{{\bf{x}}_i};{\bf{a}}} \right)} \right]} ^2}$
5. ${\rho _m} = \arg \mathop {\min }\limits_\rho \sum\nolimits_{i = 1}^N {L\left( {{y_i},{F_{m - 1}}\left( {{{\bf{x}}_i}} \right) + \rho h\left( {{{\bf{x}}_i};{{\bf{a}}_m}} \right)} \right)} $
6. ${F_m}\left( {\bf{x}} \right) = {F_{m - 1}}\left( {\bf{x}} \right) + {\rho _m}h\left( {{\bf{x}};{{\bf{a}}_m}} \right)$
7. $end For$

根据不同的loss函数，第4行的负梯度计算也不同，其他计算条件期望的拟合方法也可以用，例如最小绝对值误差(LAD)，Huber(M)。这里使用最小均方差(LS)表示只是因为比较自然，分类问题中还可以有$L(y,F)=L(yF)$。

下一篇介绍，最小绝对值误差LAD， 最小均方差LST， HUBER-M函数这三个不同loss function对应的方法，以及 gbdt怎么处理分类和回归问题

参考

[1] Friedman J H. Greedy Function Approximation: A Gradient Boosting Machine[J]. Annals of Statistics, 2000, 29(5):1189–1232.
[2] 决策树之CART算法
[3] GBDT（MART）迭代决策树入门教程

ShawnXiao@baidu

1. gbrank：gbdt怎么用在排序，如何进行pair-wise训练
2. logistRank：logistRank和gbrank的区别，和关于scale因子的思考

本篇博文分两篇将从应用出发，往算法细节深入了解的顺序进行介绍。上篇：第1部分，介绍基础的gbrank，可以知道gbdt用在learning to rank领域的应用法子。第2部分，介绍logistRank，希望进一步理解前一篇笔记中作者提出改进。下篇：主要按提出者Jerome H. Friedman论文思路介绍gbdt

相关拓展：纵向可以往前看adboost及在learning to rank(ltr)应用[2], 或者往后看xgboost、FastBDT、LightGBM。横向可以看看bagging的一些算法，包括随机森林。
ltr中常用的还有rankSVM（应用svm分类器）[3,4,5]、rankNet(应用神经网络)[6]、LambdaMART[9]

gbrank：如何进行pair-wise训练

learning to rank需要解决的问题是给定一个query，如何选择最相关的document。gbrank核心为将排序问题转化为一组回归问题，对于回归问题可以用gbdt进行求解，也可以用其他的回归函数[7]。
先介绍一组记号，对于所有的query-document pair，我们从pair抽取出一系列特征对其进行表示。例如query1-document1记为$x$，query1-document2记为$y$。记$x \succ y$表示，用户发起查询query1时，$x$比$y$更适合，更加满足query1的需求。记训练集合为$$S = \left\{ {\left\langle {{x_i},{y_i}} \right\rangle |{x_i} \succ {y_i},i = 1,...,N} \right\}$$
给定排序函数空间 $H$，我们希望得到一个排序函数$h$($h \in H$)，当$x_i \succ y_i$时，我们有$h\left( {{x_i}} \right) \ge h\left( {{y_i}} \right)$。损失函数定义为如下形式：$$ R\left( h \right) = {1 \over 2}{\sum\limits_{i = 1}^N {\left( {\max \left\{ {0,h\left( {{y_i}} \right) - h\left( {{x_i}} \right)} \right\} } \right)}^2}$$
这个函数可以解读为，对于训练数据中的一个 $\left\langle {{x_i},{y_i}} \right\rangle $，如果$h$学到了这种偏序关系，那么有$h(x_i)>h(y_i)$，$h$对于损失函数的贡献为0，否则为${\left( {h\left( {{y_i}} \right) - h\left( {{x_i}} \right)} \right)^2}$。直接优化loss比较困难，可以通过改变$h(x_i)$或者$h(y_i)$达到减少loss的目的，例如用回归的方式来拟合$h(x_i)$、$h(y_i)$。

为了避免优化函数$h$是一个常量，在loss fuction上增加一个平滑项$\tau $， $0 < \tau \le 1$。在实际应用中$\tau$为固定常数。$$R\left( {h,\tau } \right) = {1 \over 2}{\sum\limits_{i = 1}^N {\left( {\max \left\{ {0,h\left( {{y_i}} \right) - h\left( {{x_i}} \right) + \tau } \right\}} \right)} ^2} - \lambda {\tau ^2}$$

因为当$h$为常量函数时，原$R(h)=0$就没有再优化的空间了。
其实加了平衡项，就变相转为：如果希望${{x_i} \succ {y_i}}$，就得有$h\left( {{x_i}} \right) \ge h\left( {{y_i}} \right)+\tau$，更加严格。多了一个gap[8]

按一般套路，用梯度下降的方法去最小化loss function。假设有未知函数$h(x_i)$，$h(y_i)$，$i=1,...,N$，loss $R(h)$对$h(x_i)$，$h(y_i)$的负梯度分别为$$\max \left\{ {0,h\left( {{y_i}} \right) - h\left( {{x_i}} \right)} \right\},-\max \left\{ {0,h\left( {{y_i}} \right) - h\left( {{x_i}} \right)} \right\}$$。当$h$满足$< {x_i},{y_i} >$偏序关系，$h\left( {{y_i}} \right) - h\left( {{x_i}} \right) < 0$，上面两个梯度都会为0。当$h$不满足$< {x_i},{y_i} >$偏序关系时，梯度为$$h\left( {{y_i}} \right) - h\left( {{x_i}} \right),h\left( {{x_i}} \right) - h\left( {{y_i}} \right)$$
接下来，还需要知道如何将梯度作用到$h$的更新上，通过设定$x_i$的目标值为$h\left( {{y_i}} \right) + \tau $。$y_i$的目标值为$h\left( {{x_i}} \right) - \tau $。因此在每轮迭代中，当$h$不满足$< {x_i},{y_i} >$会产生一组数据：$$\left\{ {\left( {{x_i},h\left( {{y_i}} \right) + \tau } \right),\left( {{y_i},h\left( {{x_i}} \right) - \tau } \right)} \right\}$$ ，我们需要拟合本轮产生的所有负例。下面介绍详细算法
gbRank算法：

1. 估计一个初始函数$h_0$（任意选择一个都可以）。
2. 根据上一轮的$h_{k-1}$，将数据分为两个不相交的子集（正例和负例两个集合）： $${S^ + } = \{ \left\langle {{x_i},{y_i}} \right\rangle \in S|{h_{k - 1}}({x_i}) \ge {h_{k - 1}}({y_i}) + \tau \} $$和$$S^-=\{\left \langle x_i,y_i \right \rangle \in S | h_{k-1}(x_i) < h_{k-1}(y_i)+\tau \}$$。其中$S^-$作为我们下一步的训练集。
3. 使用GBDT拟合负例集合中的数据$$\{(x_i,h_{k-1}(y_i)+\tau),(y_i,h_{k-1}(x_i)-\tau) | (x_i,y_i) \in S^- \}$$得到$g_k(x)$。（作者设置$\tau=0.1$，其他值也可以尝试。）
4. 进行模型的更新：$$h_k(x) = \frac{kh_{k-1}(x)+\eta g_k(x)}{k+1}$$ 其中，$\eta$为伸缩因子。

可以看到step3里面每轮都拟合误判的结果，在迭代中这个集合会越来越小。还有一种做法是将曾经误判的集合维持在训练集中，那么训练集就会始终增长。在这个步骤中使用GBDT模型进行回归预测，当然其他的回归方法也可以使用。

logistRank：logistRank和gbrank的区别，和关于scale因子的思考

logistRank复用了gbdt框架，文中介绍篇幅比较短，反复看了看和gbrank的主要区别在point-wise与pair-wise两种不同的方式。通常，Logistic loss函数我们用在描述二分类问题(这部分感兴趣可以看引文[11,12])。$$L\left( {y,F} \right) = \log \left( {1 + \exp \left( { - yF} \right)} \right),y \in \left\{ {1, - 1} \right\}$$
作者认为，它能将positive/negative往positive/negative两个方向拉开，如果一个url的相关性是perfect，对应的打分会距离决策平面远一些。接下来结合gbdt框架介绍其具体做法（符号统一为freidman文章用法，gbdt将会在下一篇中说详细些）。
在训练阶段第$m$轮的学习目标pseudo-response，即梯度为：$$ - {h_m}\left( {{x_i}} \right) = - {\left[ {{{\partial L\left( {{y_i},F\left( {{x_i}} \right)} \right)} \over {\partial F\left( {{x_i}} \right)}}} \right]_{F\left( x \right) = {F_{m - 1}}\left( x \right)}} = {{y_i} \over {1 + \exp \left( {{y_i}{F_{m - 1}}\left( {{x_i}} \right)} \right)}}$$
为了刻画{perfec, excellent,good}三种不同的相关性label，引入梯度scale因子，对于不同的label给予不同的梯度scale因子{例如：perfect:3, excellent:2, good:1}。经过调整以后，第$m$轮的学习目标pseudo-response为：
$$pseudo - response \left( x \right) = - {g_m}\left( {{x_i}} \right) \times scale\left( {label} \right)$$
其中：scale(perfect)=3，scale(excellent)=2，scale(good | fair | bad )= 1.这种方法等价于给不同的label样本的loss进行加权，在每一轮树的生长过程中，产生影响。
树的节点通过$\gamma$系数进行组合：
$${\gamma _{jm}} = \arg \mathop {\min }\limits_\gamma \sum\limits_{{x_i} \in {R_{jm}}} {\log \left( {1 + \exp \left( { - {y_i}\left( {{F_{m - 1}}\left( {{x_i}} \right) + \gamma } \right)} \right)} \right)} $$
这个公式无解析解。通过下述牛顿-拉夫森公式进行逼近：
$${\gamma _{jm}} = \sum\limits_{{x_i} \in {R_{jm}}} {{{{{\tilde y}_i}} \over {\sum\limits_{{x_i} \in {R_{jm}}} {\left| {{{\tilde y}_i}\left( {2 - \left| {{{\tilde y}_i}} \right|} \right)} \right|} }}} , j=1,...,J$$
logistRank算法：
初始化${F_0}\left( x \right) = \bar y$
对于$m = 1...N$次迭代中：

1. $pseudo-response: {{\tilde y}_i} = {{{y_i}} \over {1 + \exp \left( {{y_i}{F_{m - 1}}\left( {{x_i}} \right)} \right)}}\times scale\left( {label} \right)$
2. $\left\{ {{R_{jm}}} \right\}_1^J = J 个叶结点的回归树tree\left\{ {{{\tilde y}_i},{x_i}} \right\}_1^N$
3. ${\gamma _{jm}} = \sum\limits_{{x_i} \in {R_{jm}}} {{{{{\tilde y}_i}} \over {\sum\limits_{{x_i} \in {R_{jm}}} {\left| {{{\tilde y}_i}\left( {2 - \left| {{{\tilde y}_i}} \right|} \right)} \right|} }}} , j=1,...,J$
4. ${F_m}\left( x \right) = {F_{m - 1}}\left( x \right) + \sum\limits_{j = 1}^J {{\gamma _{jm}}1\left( {x \in {R_{jm}}} \right)} $

得到$F_m(x)$作为模型打分。
关于scale对不同label的加权，我们可以看到，对于perfect或者excellent这类样本，回归的值会更大，不同等级的正例之间相关性的区别度相对明显。下图为作者实验结果展示：

雅虎线上结果显示，LogistRank减少了40%的bad document，在DCG5指标上提高了5%。

有点困惑，point-wise目前不是很流行的rank方法。有两个缺点：1.高频query对应候选的文档很多，相关度高的文档在训练集里面的label可能被低估，而对于低频长尾query，可满足的documet相关度较高，因此人工标准里面的label可能被高估。这样带来训练数据的不一致性。此外，同一档的文档（例如perfect里面的两篇文章）不能相互区分。
当然pair-wise也有它的问题。1. 只有， pair之间的顺序，并不考虑在全局的顺序，实际上排第1位置和排在第5位置的发生错误应该进行不同程度的惩罚，需要引入位置因素。2. 对于不同的查询相关文档集的数量差异很大，转换为文档对后，会带来训练集有偏。有的查询可能只有十几个文档对，而有的查询可能会有数百个对应的文档对，这对学习系统的效果评价带来了偏置。假设查询1对应500个文档对，查询2对应10个文档对，假设机器学习系统对应查询1能够判断正确480个文档对，对应查询2能够判断正确2个。对于总的文档对该系统准确率是（480+2）/（500+10）=95%，但从查询的角度，两个查询对应的准确率分别为：96%和20%，平均为58%，与总的文档对判断准确率相差巨大，这将使得模型偏向于相关文档集大的查询[10]。
请教l2r的同事，实验里面没有对gbrank做同样的正例加权(scale)，这样的比较可能不太公允，因为很难确定提升部分是来自scale还是说loss function的改变。

附录：牛顿-拉夫森迭代（百科地址）

[1]J. Friedman. Greedy function approximation: a gradient boosting machine. Ann. Statist., 2001
[2]Y. Freund, R. Iyer, R. Schapire and Y. Singer. An ecient boosting algorithm for combining preferences. Journal of Machine 2Learning Research, 2003.
[3]T. Joachims. Optimizing search engines using clickthrough data. Proceedings of the ACM Conference on Knowledge Discovery and Data Mining, 2002.
[4]T. Joachims. Evaluating retrieval performance using clickthrough data. Proceedings of the SIGIR Workshop on Mathematical/Formal Methods in Information Retrieval, 2002.
[5] T. Joachims, L. Granka, B. Pang, H. Hembrooke, and G. Gay. Accurately Interpreting Clickthrough Data as Implicit Feedback. Proceedings of the Annual International ACM SIGIR Conference on Research and Development in Information Retrieval, 2005.
[6]C. Burges, T. Shaked, E. Renshaw, A. Lazier, M. Deeds, N. Hamilton, and G. Hullender. Learning to rank using gradient descent. Proceedings of international conference on Machine learning, 89{96, 2005.
[7]Zheng Z, Zha H, Chen K, et al. Regression Framework for Learning Ranking Functions using Relative Preferences[J]. 2008.对应专利:百度云盘链接
[8] GBRank:一种基于回归的学习排序算法, 2016
[9] C. J. C. Burges. From RankNet to LambdaRank to LambdaMART: An overview. Technical report, Microsoft Research, 2010.
[10] 学习排序 Learning to Rank 小结
[11] gradient boosting decision tree[上篇]
[12] gradient boosting decision tree[下篇]

ShawnXiao@baidu

背景介绍，搜索引擎中query检索的主要问题：

1. query和document构词不太一样。例如query中为”how much tesla”，而文档中更多的是”price of tesla”。
2. 低频长尾网页的用户点击不可用，click modeling失效
3. 用户的一些提问表达或者口语化表达，如何进行意图理解
4. 时间维度的满足，例如”the safest cat”，返回”the safest cat is the 1998 toyota celica”可能不满足用户的需求。
5. 空间维度的满足，当用户搜索”restaurant”和”walmart”的时候，可能需要从搜索引擎中得到结果，按地理位置就近满足

文章对于上述问题展开了叙述

1. 介绍了雅虎最work的排序函数，提出线下评估结果和在线搜索体验的优化点。
2. 探索如何将用户的点击信息从高频query转移到低频query。
3. 通过改写提高相关性，尤其是低频query的相关性。
4. 提出了时间空间(LBS)相关性的解决方案

搜索引擎基础知识：

1. 搜索引擎的整体架构：
   采用分治思路，文档通过url计算md5，根据md5进行分布式存储，每个机器视为一个节点，可以并行工作。当发生query查询时，第一轮粗排序，先在每个节点中找到所有匹配该query的文档，这个过程完成文档召回，这里会对文档进行一个简单的打分和去重，返回指定数目的候选文档，同时对这些选定文档进行query相关特征抽取。进入第二轮精排序使用一个核心排序函数(Core Ranking Function)打分，得到最佳的文档。

2. 所用到的特征如下：

   1. Web graph, 通过www的链接情况进行文档质量打分，这里有大名鼎鼎的pagerank
   2. Document statistics，一些文档相关的基础统计特征，如词频，词的数目等等
   3. Document classifier，会用到一系列分类器，判断是否作弊文档，是否色情，文档语言，主题，质量和页面类型。
   4. Query features， 词的数目，query频次和其中不同词的词频
   5. Text match， 包括词之间的匹配，例如(query-doc.title), (query-doc.url), (query, doc.keywords), (query, doc.abstract)等等。这些特征可以进行组合形成新的特征，例如BM25. 以此判断文档和query的匹配程度
   6. Topical matching， 语义层面的匹配。
   7. Click， 利用用户的点击信息，预测包括prob of click, first click, last click, long dwell time click or only click。
   8. Time， 对于强时效性需求的query，文档的时效性要求很高。

3. 排序结果的评价指标–搜索相关性
   逐条对搜索结果进行分等级的打分, 分数有五档{Perfect: 5分, Excellent: 4分, Good: 3分, Fair: 2分, Bad: 1分}，假设文档在排序后的结果列表中位置为[1,N]，用如下DCG(Discounted Cumulative Gain)作为衡量指标：

   $$DC{G_N} = \sum\limits_{i = 1}^N {{{{G_i}} \over {{{\log }_2}\left( {i + 1} \right)}}} $$

   按：为了使得不同query下的结果容易比较，对DCG进行归一化得到$NDCG = {{DCG} \over {\max \_DCG}}$。作者为了评估时间相关性，引入时间的评价指标DCR和二者的综合指标RDDCG，后续内容会进一步介绍。
   下面介绍下测试集，从一年log里面随机抽取出2000query，按query的频次又可以细分为高频，中频，低频三档。中频query基本上一年就几次点击，低频的话平均一年不到一次用户点击，用户点击信息对低频query基本无效。文章主要对中低频query相关性进行优化。

用于排序的机器学习模型–gradient boosting decision trees

GBDT作为第二轮排序的打分模型，为了减少bad/fair url，作者选用(logistic loss)损失函数。如果将五档打分中的{perfect, excellent, good}视为正例(positive, +1)，{fair, bad}视为负例(negative, -1)，得到的损失函数为：
$$L\left( {y,F} \right) = \log \left( {1 + \exp \left( { - yF} \right)} \right),y \in \left\{ {1, - 1} \right\}$$
在训练阶段第$m$轮的学习目标pseudo-residuals，即梯度为：$$ - {g_m}\left( {{x_i}} \right) = - {\left[ {{{\partial L\left( {{y_i},F\left( {{x_i}} \right)} \right)} \over {\partial F\left( {{x_i}} \right)}}} \right]_{F\left( x \right) = {F_{m - 1}}\left( x \right)}} = {{yi} \over {1 + \exp \left( {{y_i}{F_{m - 1}}\left( {{x_i}} \right)} \right)}}$$
Logistic loss在2分类问题中，能有效降低不相关url在排序结果中头部占比，该loss除了用在分类，还能提供较为可靠的排序。和hinge loss不同，它能将positive/negative往positive/negative两个方向拉开，这样的话，如果一个url的相关性是perfect，那么它会距离决策平面远一些（按：放到下一篇进一步探讨）。
当然仅有正负二类对于排序而言是不足的，为了刻画{perfec, excellent,good}三种不同的相关性label，作者引入了梯度scale因子，对于不同的label给予不同的梯度scale因子{例如：perfect:3, excellent:2, good:1}。经过调整以后，第$m$轮的学习目标pseudo-residuals为：
$$pseudo - residuals\left( x \right) = - {g_m}\left( {{x_i}} \right) \times scale\left( {label} \right)$$
其中：scale(perfect)=3，scale(excellent)=2，scale(good | fair | bad )= 1.这种方法等价于给不同的label样本进行加权，影响每一轮树的构造。scale因子在传统GBDT训练过程中(步骤2.1)发生作用。作者将这种方法命名为LogisticRank。附上传统GBDT训练伪代码(wikipedia)：
实验设定：
参照模型1 GBrank[34]：loss为pointwise+pairwise。参照模型2 LambdaMart[4]

作者观察实验中LogisticRank主要收益在排除不相关的结果。实验环境和线上真实环境不一样，意味着线下有这么大提升，线上的提升幅度可能没那么乐观。下面的实验中模型固定为LogistcalRank，在这个基础上展开其他方面的探索。

基于上下文的重排序(Contextual Reranking)

我们前面介绍过检索的两层结构，第一层粗排序，第二层精排序。这两层所用到的特征为的匹配特征，url表示文档。同一个query召回的其他url这部分上下文信息没有利用到。接下来，介绍基于上下文的重排序过程。
这个过程中的候选是来自精排序的top-N结果(例如N=30)。主要用到的特征有：

1. 位置：url在精排序中的位置
2. 均值：精排序中各个特征的均值
3. 方差：精排序中各个特征的方差
4. 归一化特征：通过标准差和均值归一化后的特征
5. 主题模型特征：将top30url的主题分布累加起来作为query的topic分布，单独计算各url与query的topic分布的相似度
   作者解释为什么使用第二轮的排序位置而不是模型打分作为重排序的输入，主要是实践结论，尽管模型打分包含更完整的信息，但是这个值很容易发生波动。（按：原文Though the core-ranking phase score is more informative than the rank, its value can drift as the index refreshes, degrading third phase performance索引这里猜测是建库的索引，只是query-url应该不受影响，费解）。实验结果显示在table2，在部署的时候，精排序的模型打分可以并行进行，但重排序只能在一个机器节点中完成，Yahoo在重排序中用了30-50组原始特征。

语义匹配特征

这部分特征主要解决长尾query中缺少用户行为信息，url文本信息例如anchor文本缺失等，以及文本匹配中长尾query表达和url表达不同。三类语义匹配特征：点击相似(click similarity)、翻译文本匹配度(translated text matching)、深层语义匹配(deep semantic matching)。
点击特征(click similarity)
作者使用query的词表(vocabulary)将query, document表示在同一个向量空间中。query和document之间可以通过点击行为建一个二部图。边上的点击次数越多，表示文档和query越接近。
构成这个二部图的出发点，在这个向量空间中，document连接着相同的query越多，越相似。对query也一样，连接的相同的document越多，意图也越发相近。意味着可以从document向量中将词义转赋给相连的query，那么因为document产生相互联系的query可以表出在向量空间中的相似度。
二部图记为$G$，图中的点$V = D \cup Q$ $D$表示document，$Q$表示query。$C$表示邻接矩阵。$Q{V^n}$是一个$\left| Q \right| \times V$矩阵，其中第$i$列$QV_i^n$表示在第$n$轮迭代query向量$q_i$。同样的，$DV$是$\left| D \right| \times V$矩阵，每一行都是一个document向量。
每个向量都进行了归一化，初始的query矩阵为$Q{V^0}$，在第$n$轮迭代中，$DV_i^n$更新公式为：
$$DV_i^n = {1 \over {{{\left\| {\sum\nolimits_{i = 1}^{\left| Q \right|} {{C_{ij}} \cdot QV_i^n} } \right\|}_2}}}\sum\nolimits_{i = 1}^{\left| Q \right|} {{C_{i,j}} \cdot QV_i^n} $$
再通过累加与query相连的document向量进行query向量的更新：
$$QV_i^{n + 1} = {1 \over {{{\left\| {\sum\nolimits_{j = 1}^{\left| D \right|} {{C_{ij}} \cdot DV_j^n} } \right\|}_2}}}\sum\nolimits_{j = 1}^{\left| D \right|} {{C_{i,j}} \cdot DV_j^n} $$
在这个迭代的过程中，query得到新的terms同时还能得到权重。document也从query中得到更丰富的terms。如此对query和document同步进行了语义表达上的补全。实践中，因为为零的项太多，对权重使用稀疏表达方式存储。由于少数的词(term)拥有最大量的权重，其他的terms都很小，我们在每轮迭代中保留权重top-K的词(terms)。这个剪枝优化加速了收敛。
评估：得到query和document向量表达之后，通过点击可以得到其相似度，记为特征CS。在精排序中实验效果如下表：

可以看到在torso和tail部分提升比较明显。在所有特征重要性中，CS特征排第一位。实践中对query/document向量按月进行例行更新。
翻译文本匹配度(TTM)
CS特征无法用在未出现在点击日志的query和document之间。统计机器翻译将query翻译到document，通过机器翻译带来一系列特征，称为”Translated Text Matching(TTM)”.
使用query和点击title训一个翻译模型，对于任一query我们通过翻译模型得到$\left\{ {q_w^1,...,q_w^k} \right\}$这个向量空间为document标题的，给定document $d$，我们通过计算 $d$的标题和$\left\{ {q_w^1,...,q_w^k} \right\}$中每一个query的相似度得到$\left\{ {{s_1},...,{s_k}} \right\}$。最终的相似度打分函数为$F\left( {\left\{ {{s_1},...,{s_k}} \right\}} \right)$。 $F$表示一组函数，例如：max, average, median等等操作。 特征生成如下图。
实验中设定$k=10$取前10个改写后的query，尝试了多种特征组合，最成功的特征为 EXT_Q_TLM_1改写后query与document标题的最大相似度作为特征。AGG_Q_TLM集合相似度，使用标题LM改写后的query与给定document得到10个使用queryLM改写后的标题计算相似度。实验效果如上面的表中第二行。在特征重要性评估中，EXT_Q_TLM_1，AGG_Q_TLM分列第7和第10.具体部署中有些工程优化，下文介绍改写模型的时候一并描述。
深层语意匹配
CS特征和TTM部分解决了中长尾query的文本和用户行为信息不足，CS用来平滑点击信息并去除噪音点击，而TTM是query改写的一个应用。这些方法停留在词级别。我们需要进行语意级别的匹配，这里用DSSM[13]进行学习。(按：DSSM可以看高剑锋老师的报告，在度学堂有)，记query集合$Q$和其候选document集合${D_ \pm }$。得到query和document的向量表达之后用如下softmax函数计算似然：
$$L\left( {{D_ + }|Q} \right) = {{\exp \left( { - \cos \left( {{V_Q},{V_{D + }}} \right)} \right)} \over {\sum\nolimits_{D \pm } {\exp \left( { - \cos \left( {{V_Q},{V_{D \pm }}} \right)} \right)} }}$$
训练样本则通过在有序结果列表中以10-窗口滑动的方式产生，第1个为正例，后续9个样本为负例，最后得到30亿query-10-document样本。input为 query, document的标题和主域(例如：wiki, weather, imdb等)。模型使用tri-letter词表，每一个样本表达为tri-letter的组合，具体细节看DSSM的参考文献[13]（按：模型图中对中间两层做了抽象，实际上并非公用两个隐含层，也并非同时输入正负例）。

评估：上表中，DSM带来1.69%的DCG5收益。在高中低频query中都有收益。这维特征在全部特征中重要性处于第7位。在具体线上应用时，可以将document的向量表示先计算并存储在服务器中。当查询发生时，实时计算query的向量，计算内积作为GBDT模型输入。

query改写

由于query和document的行文风格不同，例如用户可能是输入”how much tesla”，而document对其满足较好的内容为”price of tesla”。改写的目的是为了扩大召回。Query改写(Query Rewrite, QRW)可以看成一种机器翻译(MT)问题，分为学习和解码两个阶段。
学习阶段：
改写的语料不太适合人工标注，其一，翻译语料需要大量的训练数据。其二，人工选择候选query的效率较低。这里采用点击行为收集语料，用户query和用户点击document的标题title。在query-title中，进行对齐、对齐片段抽取、片段打分。title经常大于query的长度，这里引入null空串，过滤错误的对齐。
解码阶段：
给定一个原始query，记为$q$，可能有不同的切分方式，召回不同的片段，可以轻松构成上百个候选。解码阶段需要找到最合适的候选$q_w$。定义每个候选$q_c$通过特征的线性组合得到。那么解码问题可以表述如下：
$${q_w} = \mathop {\arg \max }\limits_{{q_c}} \sum\nolimits_{i = 1}^m {{\lambda _i}{h_i}\left( {{q_c},q} \right)} $$
其中${{h_i}\left( {{q_c},q} \right)}$，为第$i$个特征函数，$\lambda_i$是权重，通过loss函数学习得到。
用到的特征函数有：

1. query feature functions: query $q$中词数目，停用词数目，语言模型打分，query频次，词的平均长度
2. rewrite query feature functions：改写后query $q_c$中词数目，停用词数目，语言模型打分，query频次，词的平均长度
3. pair feature functions：$h_{11}$：在query-url连接图中$q$和$q_c$的jaccard相似度。$h_{12}$原始query $q$与改写后$q_c$的频次的差、$h_{13}$二者词级别的cos相似度、不相同的词个数、相同词的个数、语言模型打分的差，停用词数目的差、平均词长度的差。
   实践中$h_{11}$、$h_{12}$、$h_{13}$是三个最有影响的特征。

改写的应用
假设我们有$q$和改写得到的$q_w$，各自召回top-N结果，进行归并，归并时遇到相同的url将保留打分高的分值。将最后的结果中选择top-N作为原始query的候选url返回。
实验效果下表，其中QRW是前述合并策略，QRW-RE表示将改写后query $q_c$用于发起新检索得到的结果。

线上优化
如何减少解码过程的时延，是部署改写模型的关键。给定query，在模型不变时，改写的候选和打分是一样的。为了线上部署，将1亿query的改写候选和打分存储在cache中。当发生miss情况时，仍会有较大延时。作者对候选词表进行剪枝，同时在解码的时候，使用beam search，对于少数特别慢的case直接舍弃。

组合实验

前面单独介绍很多特征，实践中经常有特征是有相关性的，效果不会简单线性累加，需要综合特征进行考察。下面是四个实验组
“base”：仅LogistcRank
“GBrank”：为传统的GBDT用于排序。
“base+feat”： LogistcRank+语意特征(CS, TTM, DSM)。
“base+all”： LogistcRank+语意特征(CS, TTM, DSM)+改写，

从效果上看，”base+feat”效果在DCG1、DCG3、DCG5三点上都优于”base”。语义匹配三个特征其综合效果高于各自单独的实验效果，证明这三种相互之间是有补充效果的。表为在query “how much tesla”下，”GBrank”VS”base+all”的结果对比图。

时效性满足排序

背景介绍的时候，提过时效性(recency)和空间位置(location)的满足。作者在这方面也做了探索。对于时效性的打分，定义了五个档级：”very fast(VF)”、”fresh(F)”、”slightly outdated”、”stale”、”non-time-sensitive”，引入了DCR（把DCG公式中的相关性指标换成时效性）和RDDCG（综合考虑DCG和DCR，具体解读如下表）

要进行时效性的排序，需要有这部分训练数据，在这份数据上，作者单独训练了一个时效性的打分函数（LogisticRank），记为${r_{fresh}}\left( x \right)$。此外引入时效性打分分类器的结果${c_{ts}}\left( x \right)$，新增的两个打分以如下方式结合：
$$f\left( x \right) = \left\{ {\matrix{ {{f_{relative}}\left( x \right) + {r_{fresh}}\left( x \right)\;\;if\;{c_{ts}}\left( x \right) > 0} \cr {{f_{relative}}\left( x \right)\;\;\;\;\;\;\;\;\;\;elsewise.} \cr } } \right.$$
当 ${c_{ts}}\left( x \right)$显示query是有时效性需求的时候才加上时效性打分函数的结果，以最后的分数进行排序。
实验是在500个有时效性需求的query上进行的，第一个表是在(DCG5、DCR5、RDDCG5)三个指标上的打分。后一个表是关于query “holly bobo”的结果对比，(按：这是一个杀人新闻，非名人的话，用于说明时效性满足是恰当的)。

空间位置满足排序

空间位置满足排序的目的是为了解决用户在搜索”宾馆”等query的时候，背后暗含的地理位置近优先的需求。为了计算空间位置相关性，需要在query-document两端进行地理位置信息抽取。首先从用户的query中抽取出显示地址，或者用用户所在地址代替隐式地址。而网页的地址则可以通过query-url 点击图，进行抽取，给定一个url，从其连接的query中可以得到地址，通过query地址描述url的位置信息。此外还有从url中之间挖掘的位置地理信息。
和时效性满足区别在于作者设定如果有地理位置需求，且相关性好，才能对排序结果产生影响，这一要求会体现在loss函数上。引入$d\left( {QUERY,URL} \right)$描述query-url的地理位置匹配程度，归一化到[0, 1]区间，记为$\hat d\left( {QUERY,URL} \right)$（值越大，表示地理位置相关性越强）。（按：这个打分细节没描述，猜想如果query无位置信息则0，如果有，那么按地图POI可以计算实际距离，再进行归一化及反比例变换，使得打分$\hat d\left( {QUERY,URL} \right)$具有[0,1]且值越大，距离越近）。
$$f\left( x \right) = {f_{relative}}\left( x \right) + w{1 \over {1 + {e^{\alpha {f_{relative}}\left( x \right) + \beta }}}}\hat d\left( {QUERY,URL} \right)$$
PS.作者论，改进后的logistic函数根据$f_{relative}( x )$控制地理位置相关性打分。
参数$w$, $\alpha$, $\beta$训练得到，训练的目标为$$\min \sum\nolimits_{\left( {{p_i},{p_j}} \right) \in P} {\max {{\left( {0,\;1 - f\left( {{x_i}} \right) + f\left( {{x_j}} \right)} \right)}^2}} $$
pair-wise训练，其中$P = \left\{ {\left( {{p_i},{p_j}} \right)|\;{p_i} > {p_j}} \right\}$为一个query下的偏序关系的url-pair。${p_i} > {p_j}$表示给定query下${p_i}$比${p_j}$结果更好，使用随机梯度下降(SGD)可以解之。
（按，感觉这个打分的设计有点复杂，可以再考虑简化下）。
评估测试集为500有地理位置需求的query。新的排序函数提升DCG5达6.92%。作者在小流量实验中，线上收益CTR提升4.78%，可想效果确实显著。下表是地理位置满足的一例case，检索”cvs”时baseline与location boosting的不同结果展示：

总结：这些方法高效且接地气，不限于搜索引擎，也可以用在垂搜领域。

按：
1.gbrank中怎么加入pointwise信息，后续了解
2.丝路搜索中看holly bobo，百度对英文时效性query是否有进行类似的调整。也可能是时效性需求识别未召回。
3.百度在中文检索中进行的探索深度和复杂程度不局限于作者提的这些方法和特性，例如色情类query屏蔽（国际化搜索则称色情query满足）、图片需求类query、用户个性化等等。wise端的场景更加丰富和具有挑战。

原文及部分引文：

[0]Yin, Dawei, Hu, Yuening, Tang, Jiliang, et al. Ranking Relevance in Yahoo Search[C] ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. ACM, 2016.
[4]C. J. C. Burges. From RankNet to LambdaRank to LambdaMART: An overview. Technical report, Microsoft Research, 2010.
[13]P.-S. Huang, X. He, J. Gao, L. Deng, A. Acero, and L. Heck. Learning deep structured semantic models for web search using clickthrough data. In CIKM ’13.
[34]K. Zhou, X. Li, and H. Zha. Collaborative ranking: Improving the
relevance for tail queries. In CIKM ’12.

• 模型、目标、算法
• 大规模数据上的应用技巧
  • 数据压缩
  • 特征选择和变换
  • 生成训练集合测试集
  • 并行的Multiplicative迭代
• 实验设定&结论

模型、目标、算法

a.模型

b.目标

优化目标：
最大化似然函数：
$$ \prod\limits_i^n {p\left( {{{\mathbf{y}}_i}} \right)} = \prod\limits_i^n {\frac{{{{\left( {{{\mathbf{w}}^T}{{\mathbf{x}}_i}} \right)}^{{{\mathbf{y}}_i}}}\exp \left( { - {{\mathbf{w}}^T}{{\mathbf{x}}_i}} \right)}}{{{{\mathbf{y}}_i}!}}} $$ 转求常用log似然： $$l\left( y \right) = \log L\left( y \right) = \sum\limits_i^{} {\left( {{y_i}\log \left( \lambda \right) - \lambda - \log \left( {{y_i}!} \right)} \right)} $$

c.算法

• 符号说明：$i,j,k$分别表示用户，特征，广告类型
• 注1:训练数据平滑，对于CTR公式的$\alpha \beta$`按每个类别计算，结果为给新用户推荐最热的类别。
• 注2:$\lambda = {w^T}x$为什么不用指数型$bda = \exp \left( {{w^T}x} \right)$，使用线性形式。初衷是方便在线计算,对于新的线上用户行为，$bda ' = \lambda {\delta ^{\Delta t}} + {w_j}\Delta {x_j}$
• 注3:为什么用NMF，W用来表示用户兴趣权重的，如果用户对某类广告不感兴趣，我们把它调为零即可。
• 注4：对于每个特征的权重$w_kj$的初始化可以用两种方式进行，
  • a.类似TF-IDF：$${w_{kj}} \leftarrow \frac{{\sum\nolimits_i {\frac{{{y_{ik}}{x_{ij}}}}{{\sum\nolimits_{j'} {{x_{ij'}}} }}} }}{{\sum\nolimits_i {{x_{ij}}} }}$$
  • b.全局类别上进行$${w_{kj}} \leftarrow \frac{{\sum\nolimits_i {\left( {{y_{ik}}{x_{ij}}} \right)\sum\nolimits_i {\left( {{y_{ik}}} \right)} } }}{{\sum\nolimits_{j'} {\left[ {\sum\nolimits_i {{y_{ik}}{x_{ij'}}} \sum\nolimits_i {{x_{ij'}}} } \right]} }}$$
    b的思考出发点是部分类别的模型训练时间较长，给一个较适合的初值，可能使得整体迭代数据速度变快。

大规模数据的应用技巧

1.log数据的预处理，指定数据的字段抽取，以cookie为单位合并数据。
2.再以用户和时间为组合键，按时间间隔合并次数 ，这里时间间隔需要和模型所需一致。一个月的数据能减少到2-3TB(这里尚未进行广告分类)

特征选择和反向索引

广告点击、页面浏览、和搜索query，这些特征空间比较复杂和稀疏，作者使用频次阈值进行筛选，得到（特征类型 click / search / view，实体entity，freq）组合，不选择互信息，互信息容易受数据稀疏影响。最后输出为3类特征的词典，从实验配置可以认为是ad_id、page_id、query，三种词典。得到上述词典以后，特征向量可以用(下标，值)的形式存储，下标指词典的偏移。
trick 1.特征过滤卡频次用cookie为单位计数的原因是防爬虫
trick 2.直接对特征卡频次，这样无需做排序取topN
trick 3.在无需排序归并的阶段，reducer可以用值排序。这样避免对复杂key进行排序，增加时耗

生成训练集合测试集

如图显示，通过滑动窗口的采集方式，可以在$o(1)$的时间内完成特征数据的生成。

数据驱动的权重更新

这里主要提及下权重更新的并行化
1.通过一个稀疏矩阵D，我们想估计一个dense的权重矩阵W。给定$Y$,$X$，求得$\arg {\max _w}\log p\left( {{Y^T}|W{X^T}} \right)$的解$W^*$. （按：这里和目标泊松分布log-似然函数有关联）
2.${Y^T} \approx W{X^T}$，可以复用NMF非负矩阵分解中的高效乘法方式，通过log似然进行约束。
a. W是dense的矩阵，因为集群节点内存限制，我们需要拆开读入。由于拆以后计算$W{X^T}$复杂度较高，引入下一步的内存caching
b. In-memory Caching.对样本xy进行cache，预先求得cache内数据的 $\sum\nolimits_i {\frac{{{y_{ik}}{x_{ij}}}}{{{\lambda _{ik}}}}} $ 向后传递。
c. 按k为key进行reduce，最后累积更新到权重$W$。伪代码在论文4.5.3节

实验部分：

• 数据和参数
  a.数据来源，广告点击，页面浏览，搜索query
  b.效果衡量方式，1.baseline对比，见下表CTR lift，2.ROC曲线比较。60种主要BT行为
• 基线模型： Logistic Regression，分别为两个模型的结果积在一起，一部分预测下一天的点击，一部分预测下一小时点击。

实验结果：

a.数据量方面：

数据均分为512份，训练集不同的量带来的效果如图。
b.特征方面比较：

（PS.之所以控制特征为ads和pages变化是因为，query在点击预估的影响比较小）
（之前的加速措施使得训练时间有不受特征数目显著影响的特性）
c.target时间窗方面比较（意义可能不大，略）：
d.分层抽样的效果
用户分三类：1.有点击行为 2.无广告点击，有广告view。3.广告点击和广告view都无
需要对后两类用户进行采样，第一栏的数字代表采样率。

(负样本只对分母有影响，而且是提前算好的。结果看一个较小的neg采样组合一个较大的view采样可以带来一个比较好的效果)

e.引入时间间隙，模拟训练。
因为在线的训练的时候，有data延迟，在特征时间窗和目标时间窗中间插入一个间隙。带来的效果对比，右边是模拟在线的时候的效果

可以看到如果无间隙的时候，CTR有显著收益，说明实时的特征对CTR预估影响较大。

总结：作者根据用户历史行为预测用户对不同类别广告的CTR，同时给了在大规模数据上的实现框架。
（summarizes by：shawn_xiao@baidu）
引文：
[1]Chen, Ye，Pavlov, Dmitry，Canny, John， Large-scale behavioral targeting, [2010]

1
2
3
4

FATAL (unknown path) [Line 2, Column 166]
  parseAggregate: expected colon after dict key
Template render error: (unknown path) [Line 2, Column 166]
  parseAggregate: expected colon after dict key

这个时候需要在公式前后插入:

1
2
3

{% raw %}
$${X_k} = \{{x_1},{x_2},...,{x_n}\} $$
{% endraw %}

当然，一篇文章公式动则十数计，逐一添加，效率较低。为了把自己从公式的格式调整中解放出来，专注写文字。
博主写了个python脚本：convert_formula.py，在公式自动添加raw标记对(第一次在win7中用记事本写脚本)。
云盘：http://pan.baidu.com/s/1hr7xo00
github: https://github.com/qiugen/tools.git

ShawnXiao@baidu

受限玻尔兹曼机和PoE

Restricted Boltzmann machines(RBMs)作为生成模型广泛用于很多类型数据的建模，包括有标记或者无标记图片，梅尔倒频谱系数窗(一种语音辨识中的特征表示，常称为MFCC)，文档，也有用于时序数据例如视频或者运动捕获数据、演讲。最广泛的应用还是在训练和构造深度置信网络中。

RBMs通常使用contrastive divergence 算法进行训练，这个算法将是本笔记中的主要介绍内容。当然在使用中还会遇到更细节处的参数设置，诸如学习率(learning rate)、动量(momentum)、权重代价(weighted-cost)、稀疏目标(sparcity target)、权重的初始化(the initial values of the weights)、隐单元的数目(the num of hidden units)、图像子集的大小(the size of each mini-batch)，包括每一次训练中应该怎么监控训练过程、以及何时停止训练。如果遇到这些问题，请移步《Guide》进行对应查阅。

假设训练图像为二值图像，在训练集上，建立一个两层的RBM，对于这个RBM而言，可见层的二值的像素点$v_i$与隐含层的二值特征监测器$h_j$建立对称加权关联。其能量式为

其中$v_i$,$h_j$分别是可见单元$i$和隐含单元$j$的二值状态，$a_i$，$b_j$是他们的偏置，$w_{ij}$为其权重。下图为RBM模型示意图

通过能量方程，RBM为每一对可见向量和隐含向量的可能组合给出了概率分布公式：

其中，配分函数$Z$为可见单元和隐含单元所有可能组合的概率之和：$$Z = \sum\nolimits_{v,h} {{e^{ - E({\bf{v}},{\bf{h}})}}} $$。对于可见向量$v$，其概率密度函数为

上面是关于模型的介绍，关于如何训练模型，hinton在本篇文章中用乘积叠加模型为引做了理论上的推导–PoE(Products of Experts,PoE)，和boost方法有类似之处，我理解区别主要在于boost为线性组合，PoE为非线性。对于高维空间中的数据向量，普通的单一模型(Export)可以给出部分满足其限定条件的数据向量的高概率推断。PoE通过将不同的概率模型乘积起来，可以很好地对高维数据进行拟合，最常见的例子为高斯模型的混合。作者指出，如果在混合模型中有足够多数量的单一模型，它可以准确近似表达任何光滑的分布。在拟合数据，对于混合模型的求解方法比较常用的有EM算法和梯度下降方法。

剩下的事情，就是如何将PoE模型拟合到数据了，这点不太好做。作者介绍了一种巧妙的方法，将优化目标，替换成了一个简单目标函数。当然会带来一定的损失，这一点我们在后面的推导里面能看到，不过，对于整个模型的训练方便而言，这样的损失是可以接受的。

使用最大似然法训练PoE

讨论比较容易计算导数的单一模型。数据向量${\bf{d}}$在$n$个单一模型组成的PoE中的概率为：

记${\bf{d}}$为离散空间的数据向量，${\theta _m}$为单一模型$m$的所有参数，${p_m}(d|{\theta _m})$为模型$m$中${\bf{d}}$的概率，$c$表示数据空间中所有可能的数据向量

将PoE拟合到一组iid的数据向量上，很自然就想到对每个数据向量的log似然求导，得到下面的式子：
$${{\partial \log p({\bf{d}}|{\theta _1} \ldots {\theta _n})} \over {\partial {\theta _m}}} = {{\partial \log {p_m}({\bf{d}}|{\theta _m})} \over {\partial {\theta _m}}} - \sum\limits_c^{} {p({\bf{c}}|{\theta _1} \ldots {\theta _n})} {{\partial \log {p_m}({\bf{c}}|{\theta _m})} \over {\partial {\theta _m}}}---(4)$$

等式右边第二项数据变量$c$的log概率的导数期望（ expected derivative ）。假设每个单一模型都容易求导，对于数据变量$c$的分布而言，那么比较难的地方就在于估计数据的log概率的导数。实现的方法有多种，对于离散数据可用拒绝采样：PoE中的每个单模型分别独立生成一组数据向量，重复这个步骤直到所有的单模型结果恰好一致。拒绝采样比较形象地表达了PoE对整体概率分布的拟合，但是效率低。使用Gibbs采样的马尔科夫链蒙特卡洛MCMC方法效率更高。在Gibbs采样中，给定当前其他变量的状态，对每个变量的后验分布进行采样。对于RBM，给定了观察数据，每个模型的隐含状态可以并行更新，因为它们是条件独立的。这样的话，如果对于每个单模型也有这样的性质：在给定单模型的隐含状态，数据向量的分布也是条件独立的。那么隐含和可见变量可以形成一个二分图，这样在隐含层和可见层之间形成一个二分图，给定隐含层状态后，我们并行更新所有的数据向量(即可见层的单元)。使用Gibbs采样可以在隐含层和可见层的并行更新中趋近数据变量的真实分布。

不巧的是，在采样前通过计算可以接近均衡分布虽然可行，这会带来了第二个难题。对均衡分布进行采样，由于样本来自模型的分布，会呈现出高度差异性，这种高度差异性使得导数难以计算。

最小化对比分歧（contrastive divergence）训练

最大化数据的log-似然等价于最小化数据分布$Q^0$和均衡分布$Q^\infty $的Kullback-Liebler divergence。如前所述均衡分布$Q^\infty $来自于生成模型的Gibbs采样。
$${Q^0}||{Q^\infty } = \sum\limits_{}^{} {Q_d^0\log Q_d^0 - \sum\limits_{}^{} {Q_d^0\log Q_d^\infty } } = - H({Q^0}) - < \log Q_d^\infty { > _{{Q^0}}}$$

其中||符号表示Kullback-Leibler divergence，尖括号表示下标式对应分布的期望，$H(Q^0)$为数据分布的熵。$Q^0$不依赖于模型的参数，因此在优化过程中可以忽视$H(Q^0)$。注意$Q_d^\infty$只是$p(\bf{d}|\theta_1...\theta_n)$的另一种形式。公式（4）重写为：

经过改写后，用上式计算log-似然的最大值更简单和效率高。这个目标函数包含了另一种优化可能，我可以用最小化${Q^0}||{Q^\infty }$和${Q^1}||{Q^\infty }$的差，$Q^1$是经过一个完整Gibbs采样步骤，重建后数据向量的分布。

最开始使用“constrastive divergence”的目的是我们希望通过使用Gibbs采样对Markov chain进行处理，使得初始可见层分布$Q^0$不会被改变。这样我们需要把这个chain推演到均衡分布，再与初始分布比较来求出导数。这里我们只使用一个简化版本，通过简单运行chain一次完整的Gibbs采样来更新参数，使得chain初始分布到第一步采样后的分布之间的变化下降趋势。理由是这样的，因为$Q^1$比$Q^0$距离均衡分布更近一些，我们如果可以保证“$Q^0||Q^{\infty}$ $ \ge $ $Q^1||Q^{\infty}$，等号成立的条件是$Q^0=Q^1$”，这样，contrastive divergence不会为负，在传播过程中整个markov chains都是非零概率。$Q^0=Q^1$意味着$Q^0=Q^{\infty}$，也就是说，如果模型很完美，会出现contrastive divergence为零的情况。从数值求解角度看，公式（5）里面等号右边第二项比较难算，通过换一种方式，可以避免对其直接求解：
$$ - {\partial \over {\partial {\theta _m}}}({Q^0}||{Q^\infty } - {Q^1}||{Q^\infty }) = {< {{{\partial \log {p_m}({\bf{d}}|{\theta _m})} \over {\partial {\theta _m}}}} > _{{Q^0}}} - {< {{{\partial \log {p_m}({\bf{\hat d}}|{\theta _m})} \over {\partial {\theta _m}}}} > _{{Q^1}}} + {{\partial {Q^1}} \over {\partial {\theta _m}}}{{\partial {Q^1}||{Q^\infty }} \over {\partial {Q^1}}}--(6)$$

如果每个单模型容易求解，那么很容易计算出${\log {p_m}({\bf{d}}|{\theta _m})}$和${\log {p_m}({\bf{\hat d}}|{\theta _m})}$的导数。从$Q^0$和$Q^1$中采样也比较直观可行，因此等式右边前两项的值比较容易得到。$Q^1$的无偏采样流程如下

1. 在数据分布$Q^0$中，选择一个数据向量，$\bf{d}$
2. 对每一个单模型，给定数据向量$\bf{d}$，分别计算其后验概率分布
3. 从后验概率分布中选择一个值，赋给隐含层变量
4. 给定隐含层变量后，将每个单模型的条件分布乘积后计算可见层变量的条件分布。
5. 从条件分布中为每个可见变量选取一个值，这些值构成了重建后的数据向量$\bf{\hat d}$

公式（6）等式右边的第三项也是相当难算，大量的模拟表明，由于这项很小并极少与前两项表现出相反性质，可以被忽略。这样的话，我们只通过前两项来近似contrastive divergence的导数，可以调节模型的参数。
$$\Delta {\theta _m} \propto {\langle {{{\partial \log {p_m}({\bf{d}}|{\theta _m})} \over {\partial {\theta _m}}}} \rangle _{{Q^0}}} - {\langle {{{\partial \log {p_m}({\bf{\hat d}}|{\theta _m})} \over {\partial {\theta _m}}}} \rangle _{{Q^1}}}$$

使用第一步重建的数据向量来代替最终的重建的概率分布是一种行之有效的方法。由于重建的过程有随机性，数据向量的导数和他们重建数据存在偏差。当PoE对数据进行建模合宜的时候，数据经过一步重建与数据向量的差别非常小。

参考文章：
1.Hinton G E. Training products of experts by minimizing contrastive divergence[J]. Neural computation, 2002, 14(8): 1771-1800.

前言，在观看斯坦福公开课女神Daphne Koller的时候，对视频week1.6里介绍的两个算法不理解，找了些资料帮助理解，特记录如下，欢迎交流

文本分类问题中，要解决的问题是如何对一个文本进行分类，这样的分类可以看为将文本对类别进行一次映射。问题的数学描述如下，给定的文档集合$X$ $X=\{X_1,X_2,...,X_{n} \}$，其中文档由很多属性构成$X_k=\{x_1,x_2,...,x_{n} \}$。贝叶斯分类器中将词作为文档的基本属性，例如$X_k$为"good study, Day day up"，其文档属性特征向量为$X_k(Good,good,study,Day,day,up)$。$X$由n个文档组成。预先定义的文档类别集合$Y=\{Y_1,Y_2,...,Y_{|c|} \}$，我们的任务是找到一个有效映射函数$\Phi $，准确实现文档到类别的映射$\Phi:X \to Y $。

在进入问题之前，先回忆下贝叶斯公式。对于事件$A$、$B$，其概率分别为$P\left(X\right)$、$P\left(Y\right)$。事件$A$发生条件下，$B$也发生的概率为:$P\left( {Y|X} \right) = \frac{{P\left( {X,Y} \right)}}{{P\left( X \right)}}$。对于文档$X_k$归属于哪个类，我们希望找到文档$X_k(x_1,x_2,...,x_m)$属于每个类别$Y_i$的概率，用如下公式表示为$$ P\left( {{Y_j}|{X_i}} \right) = \frac{{P\left( {{Y_j}} \right)P\left( {X_i|Y_j} \right)}}{{P\left( X_i \right)}} = \frac{{P\left( Y_j \right)P\left( {x_1,x_2,...,x_m|Y_j} \right)}}{{P(x_1,x_2,...,x_m)}}$$

然后根据最大的概率值判读文档的具体归属类别。因为上述公式中${{P(x_1,x_2,...,x_m)}}$是常数，目标函数可以转化为下面形式：
$$\mathop {\arg \max }\limits_{{Y_j}} P(Y_j)P(X_i|Y_j) $$
$$ \mathop {\arg \max }\limits_{{Y_j}}P\left( {{Y_j}} \right)P\left( {x_1,x_2,...,x_m|{Y_j}} \right) $$
朴素贝叶斯分类器的假设前提是条件独立性。给定文档类别$Y$，假设文档的属性即特征项是相互独立的。即：
$$P(X_i|Y_j)= P\left( {{x_1},{x_2}, \ldots ,{x_n}|{Y_j}} \right) = \prod\limits_{i = 1}^m {P\left( {{x_i}|{Y_j}} \right)} $$

可知我们的目标函数可以进一步简化为：
$$ \mathop {\arg \max }\limits_{{Y_j}} P\left( {{Y_j}} \right) \prod\limits_{i = 1}^m {P\left( {{x_i}|{Y_j}} \right)} $$

我们得到目标函数以后，下面考虑贝叶斯模型的选择。
常见三种模型：伯努利算法，多项式模型，高斯模型。伯努利更多用于离散变量的计算，后者高斯模型可以用于处理连续变量。

• 伯努利朴素贝叶斯算法： $$P(X_i|Y_j) = \prod\limits_{i = 1}^m {({B_{x_i}}P({x_i}|{Y_j}) + (1 - {B_{x_i}})(1 - P({x_i}|{Y_j})))} $$ 其中文档集合的词表有$m$个特征词，二值变量$B_{x_i}$表示待分类文档中出现$x_t$的情况：$B_{x_i}=1$表示特征词$x_t$在待分类文档中，反之，则为0。$P({x_i}|{Y_j})$表示训练集文档属于${Y_j}$时，特征词${x_i}$出现的概率。具体计算时采用$P({x_i}|{Y_j}) = \frac{{1 + {n_{ij}}}}{{2 + {n_j}}}$，其中$n_{ij}$为类$Y_j$包含特征词$x_i$的文档总数，$n_j$为类$Y_j$中包含的总文档数目。
  先验概率的计算公式$P(Y_j)=\frac{类Y_j中的训练文本总数}{训练样本总数}$
  可得计算待分类文档属于每个类$Y_j$的概率，可得$ \mathop {\arg \max }\limits_{{Y_j}} P(Y_j)P(X_i|Y_j) $
• 对上述方法进一步解释：对于目标待分类文档$X_k$，特征词服从伯努利分布，在文档中出现特征词一次记为1，不出现记为0，用变量$B_{x_i}$表示。文档中有m个不重复特征词，通过m次伯努利实验产生对目标后验概率的估计：$$P(X_i|Y_j) = \prod\limits_{i = 1}^m {({B_{x_i}}P({x_i}|{Y_j}) + (1 - {B_{x_i}})(1 - P({x_i}|{Y_j})))} $$ 其中$P({x_i}|{Y_j})$表示文档属于${Y_j}$时，特征词${x_i}$出现的概率。从公式可以看出，在多变量伯努利模型中，文档$X_i$归属后验概率$P(X_i|Y_j)$表示为所有特征词的类条件概率的乘积，如果特征词在待分类文档中出现，乘以$P(x_i|Y_j)$，否则，乘以$1-P(x_i|Y_j)$。
  给定类别${Y_j}$，特征词$x_i$的类条件概率$P(x_i|Y_j)$的估算通过统计训练文档频数得到：$P({x_i}|{Y_j}) = \frac{{{n_{ij}}}}{{{n_j}}}$，其中$n_ij$为类$Y_j$包含特征词$x_i$的文档总数，$n_j$为类$Y_j$中包含的总文档数目。为了避免出现零概率，通常需要加入平滑因子，一般采用$m$估计方法，上述类条件概率$P(x_i|Y_j)$改写为$P({x_i}|{Y_j}) = \frac{{1 + {n_{ij}}}}{{2 + {n_j}}}$例如取$m=2$，$p=1/2$

PS.可以看出伯努利模型忽略了每个特征词(单词)在文档中出现的频次，这个信息很重要。因此该模型的分类效果通常不是很好。

• 多项式模型
  先验概率$P(Y_j)$= 类$Y_j$特征词总数 / 整个训练样本的特征词总数
  单词的类条件概率$P(x_i|Y_j)$=(类$Y_j$下单词$x_i$在各个文档中出现过的次数之和+1)/(类$Y_j$下特征词总数+训练样本词典特征词数目)
  将单词的类条件概率累加起来得到文档的类条件概率：$$ P({X_i}|{Y_j}) = \prod\limits_{i = 1}^n {{{P({x_i}|{Y_j})}}} = \prod\limits_{i = 1}^n\frac{{\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} + 1}}{{\sum\limits_{i = 1}^{|V|} {\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} } + |V| }} $$
  其中，待分类文档有$n$个特征词（$n$是总字数，重复出现也计字数），${\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} }$表示特征词$x_i$在类别$Y_j$文档集合出现次数的总和。${\sum\limits_{i = 1}^{|V|} {\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} } }$为类$Y_j$中所有特征项的总次数，$V$是训练样本的特征词表，$|V|$表示词表的特征词总数
  我们得到，$ \mathop {\arg \max }\limits_{{Y_j}} P(Y_j)P(X_i|Y_j) $
• 进一步解释，采用不同于伯努利模型的最大化后验概率求解方法，通过考虑单篇文章的词频，提高了分类能力。文档$X_i$属于类$Y_j$时，统计$x_i$的频率，出现一次的概率为$P (x_i|Y_j）$，那么，同时出现$n_k$次的概率为$P (x_i|Y_j)^{n_k}$。假定文档中，特征词的个数有$n=n_{x_1}+n_{x_2}+...+n_{x_k} $个。那么$ P({X_i}|{Y_j}) = \prod\limits_{i = 1}^n {P({x_i}|{C_j})} $。在多项式模型中，$P({x_i}|{Y_j})$的词频估算为$$P({x_i}|{Y_j}) = \frac{{\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} }}{{\sum\limits_{i = 1}^{|V|} {\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} } }}$$，其中，${\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} }$表示特征词$x_i$在$Y_j$文档出现次数的总和。${\sum\limits_{i = 1}^{|V|} {\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} } }$为类$C_j$中所有特征项的总次数，V是训练样本的单词表(PS.抽取单词，多次出现的单词，只算一个)。同样为了避免零概率，加入平滑因子，取$m=V$，$p=1/|V|$，公式更新为：$$P({x_i}|{Y_j}) = \frac{{\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} + 1}}{{\sum\limits_{i = 1}^{|V|} {\sum\limits_{k = 1}^{|X|} {N({x_i},{X_k})} + |V|} }}$$
• 高斯模型
  特征属性是连续值的情况，当特征属性为连续值时，通常假定其值服从高斯分布（也称正态分布）。上面的特征词，下面用特征项代替。$$P({x_i}|{Y_k}) = g({x_i},\mu ,\delta ) = {1 \over {\sqrt {2\pi } \delta }}\exp \left( { - {{{{(x - \mu )}^2}} \over {2{\delta ^2}}}} \right)$$ 因此只要计算出训练样本中各个类别中此特征项划分的各均值和标准差，代入上述公式即可得到需要的估计值。
  值得一提的是，当$P(x_i|Y_j)=0$，即某个类别下某个特征项划分没有出现时，会令分类器质量大大降低。为了解决这个问题，我们引入Laplace校准，对每个类别下所有划分的计数加1。这个做法和伯努利模型、多项式模型类似。

参考文章：
1.李丹. “基于朴素贝叶斯方法的文本分类研究,” n.d.cnki

2.灵魂机器. “基于朴素贝叶斯的文本分类算法” n.d. blog

3.PhoenixZq.”贝叶斯分类 “ cnblogs

再休怪我的脸沉

不要着恼，乖乖，不要怪嫌
我的脸绷得直长，
我的脸绷得是长，
可不是对你，对恋爱生厌。

不要凭空往大坑里盲跳：
胡猜是一个大坑，
这里面坑得死人；
你听我讲，乖，用不着烦恼。

你，我的恋爱，早就不是你：
你我早变成一身，
呼吸，命运，灵魂——
再没有力量把你我分离。

你我比是桃花接上竹叶，
露水合着嘴唇吃，
经脉胶成同命丝，
单等春风到开一个满艳。