流程概述:
1. 生成特征函数
2. 构建概率图
3. 计算node和path的代价:node代价计算即该node对应的所有特征函数权重;path代价即该path对应的所有特征函数权重之和(node和path是有特定的label的)
4. 前向-后向算法计算alpha和beta, 计算期望
以上都是针对某个训练样本
以下是针对所有样本
5. 计算梯度g(w)(所有训练样本的期望-1),计算目标函数L(W)
6. LGBLF算法一轮迭代后更新W(代码中的alpha)
开启多线程
目前CRF++支持两种训练算法，一种是拟牛顿算法中的LBFGS算法(批处理优化的ML问题中常用, 缺点是收敛速度慢)，另一种是MIRA算法， 本篇文章主要探讨LBFGS算法的实现过程。在learn函数中，训练算法的入口代码如下：
switch (algorithm) {
case MIRA: //MIRA算法的入口
if (!runMIRA(x, &feature_index, &alpha[0],
maxitr, C, eta, shrinking_size, thread_num)) {
WHAT_ERROR("MIRA execute error");
}
break;
case CRF_L2: //LBFGS-L2正则化的入口函数
if (!runCRF(x, &feature_index, &alpha[0],
maxitr, C, eta, shrinking_size, thread_num, false)) {
WHAT_ERROR("CRF_L2 execute error");
}
break;
case CRF_L1: //LBFGS-L1正则化的入口函数
if (!runCRF(x, &feature_index, &alpha[0],
maxitr, C, eta, shrinking_size, thread_num, true)) {
WHAT_ERROR("CRF_L1 execute error");
}
break;
}runCRF函数中会初始化CRFEncoderThread数组，并启动每个线程，源码如下：
bool runCRF(const std::vector<TaggerImpl* > &x,
EncoderFeatureIndex *feature_index,
double *alpha,
size_t maxitr,
float C,
double eta,
unsigned short shrinking_size,
unsigned short thread_num,
bool orthant) {
... //省略代码
for (size_t itr = 0; itr < maxitr; ++itr) { //开始迭代， 最大迭代次数为maxitr，即命令行参数-m
for (size_t i = 0; i < thread_num; ++i) {
thread[i].start(); //启动每个线程，start函数中会调用CRFEncoderThread类中的run函数
}
for (size_t i = 0; i < thread_num; ++i) {
thread[i].join(); //等待所有线程结束
}
... //省略代码
CRFEncoderThread类中的run函数调用gradient函数，完成一系列的核心计算。源码如下：
void run() {
obj = 0.0;
err = zeroone = 0;
std::fill(expected.begin(), expected.end(), 0.0); //excepted变量存放期望
for (size_t i = start_i; i < size; i += thread_num) {//每个线程并行处理多个句子， 并且每个线程处理的句子不相同， size是句子的个数
obj += x[i]->gradient(&expected[0]); //x[i]是TaggerImpl对象，代表一个句子， gradient函数主要功能： 1. 构建无向图 2. 调用前向后向算法 3. 计算期望
int error_num = x[i]->eval();
err += error_num;
if (error_num) {
++zeroone;
}
}
}构造无向图
我们知道条件随机场是概率图模型，几乎所有的概率计算都是在无向图上进行的。那么这个图是如果构造的呢？答案就在gradient函数第一个调用 —— buildLattice函数中。该函数完成2个核心功能，1. 构建无向图 2. 计算节点以及边上的代价，先看一下无向图的构造过程：
void TaggerImpl::buildLattice() {
if (x_.empty()) {
return;
}
feature_index_->rebuildFeatures(this); //调用该方法初始化节点（Node）和边（Path），并连接
... //省略代码
}void FeatureIndex::rebuildFeatures(TaggerImpl *tagger) const {
size_t fid = tagger->feature_id(); //取出当前句子的feature_id，上篇介绍构造特征的时候，在buildFeatures函数中会set feature_id
const size_t thread_id = tagger->thread_id();
Allocator *allocator = tagger->allocator();
allocator->clear_freelist(thread_id);
FeatureCache *feature_cache = allocator->feature_cache();
//每个词以及对应的所有可能的label，构造节点
for (size_t cur = 0; cur < tagger->size(); ++cur) { //遍历每个词，
const int *f = (*feature_cache)[fid++]; //取出每个词的特征列表，词的特征列表对应特征模板里的Unigram特征
for (size_t i = 0; i < y_.size(); ++i) { //每个词都对应不同的label， 每个label用数组的下标表示，每个特征+当前的label就是特征函数
Node *n = allocator->newNode(thread_id); //初始化新的节点，即Node对象
n->clear();
n->x = cur; //当前词
n->y = i; //当前词的label
n->fvector = f; //特征列表
tagger->set_node(n, cur, i); //有一个二维数组node_存放每个节点
}
}
//从第二个词开始构造节点之间的边，两个词之间有y_.size()*y_.size()条边
for (size_t cur = 1; cur < tagger->size(); ++cur) {
const int *f = (*feature_cache)[fid++]; //取出每个边的特征列表，边的特征列表对应特征模板里的Bigram特征
for (size_t j = 0; j < y_.size(); ++j) {//前一个词的label有y_.size()种情况，即y_.size()个节点
for (size_t i = 0; i < y_.size(); ++i) {//当前词label也有y_.size()种情况，即y_.size()个节点
Path *p = allocator->newPath(thread_id);//初始化新的节点，即Path对象
p->clear();
//add函数会设置当前边的左右节点，同时会把当前边加入到左右节点的边集合中
p->add(tagger->node(cur - 1, j), //前一个节点
tagger->node(cur, i)); //当前节点
p->fvector = f;
}
}
}
}图构造完成后， 接下来看看节点和边上的代价是如何计算的。那么代价是什么？我的理解就是特征函数值乘以特征的权重。这部分源码在buildLattice函数中，具体如下：
for (size_t i = 0; i < x_.size(); ++i) {
for (size_t j = 0; j < ysize_; ++j) {
feature_index_->calcCost(node_[i][j]); //计算节点的代价
const std::vector<Path *> &lpath = node_[i][j]->lpath;
for (const_Path_iterator it = lpath.begin(); it != lpath.end(); ++it) {
feature_index_->calcCost(*it); //计算边的代价
}
}
}
//节点的代价计算函数
void FeatureIndex::calcCost(Node *n) const {
n->cost = 0.0;
#define ADD_COST(T, A) \
do { T c = 0; \
for (const int *f = n->fvector; *f != -1; ++f) { c += (A)[*f + n->y]; } \ //取每个特征以及当前节点的label，即为特征函数，且值为1，特征函数乘以权重（alpha_[*f + n->y]）是代价，特征函数为1所以代价=alpha_[*f + n->y]*1，对所有代价求和
n->cost =cost_factor_ *(T)c; } while (0) //cost_factor_是代价因子
if (alpha_float_) {
ADD_COST(float, alpha_float_);
} else {
ADD_COST(double, alpha_); //将会在这里调用， 上一篇内容可以看到，CRF++初始化的是alpha_变量
}
#undef ADD_COST
}
//边的代价计算函数与节点类似，不再赘述看完源码，我们举个例子来可视化一下无向图，假设这三个词分别是“我”、“爱”、“你”。构建的无向图如图一所示。
图一
这个例子中，有三个词和三个label，每个label用0,1，2表示，之前我们说过用数组下标代替label。每个词有3个节点，且这三个节点的特征列表f是一样的，由于label不一样，所以他们的特征函数值不一样。由于没有bigram特征，所有边上的特征列表都是f=[-1]。大部分资料的无向图前后会加一个start节点和stop节点，加上后可以便于理解和公式推导。CRF++源码中没加，所以我们这里就没有表示。在这里node_[0][0]对应就是最左上角的节点，代表“我”这个词label为0的节点。我们再看一下node_[0][0]这个节点的代价如何计算的，node_[0][0]的cost = alpha_[0 + 0] + alpha_[3 + 0] = alpha_[0] + alpha_[3]，由于alpha_第一次节点初始化为0，所以cost=0。其余节点和边计算方法类似。
前向-后向算法
有了无向图，我们就可以在图上进行前向-后向算法。利用前向-后向算法，很容易计算标记序列在位置i（词）的label是yi的条件概率，以及在位置i-1（前一个词）与位置i（当前词）的label是yi-1与yi的条件概率。进行CRF++源码阅读之前先看一下条件随机场矩阵的表示形式。对一个句子的每一个位置（单词） i=1,2,…，n+1，定义一个 m 阶矩阵（m 是标记 yi 取值的个数），i=0代表start节点， i=n+1代表stop节点。
Wi 的解释：当前节点代价 + 与该节点相连的一条边的代价。(所谓代价即特征函数*对应权值,这里的代价仅与当前节点有关,而不是从start开始的持续代价)
M矩阵中的每个元素即代价
节点之间的转移概率，用矩阵的形式表现如下：
Mi 的解释：以
为例，代表第2个位置（第2个词）label是1，前一个词label是2，计算Wi，再取exp后的值。接下来，我们看一下用矩阵表示的前向-后向算法。
对i = 0, 1, 2, ... n+1， 定义前向向量αi(x)，对于起始状态i = 0：
对于之后的状态 i=1,2,...,n+1，递推公式为：
假设label个数是m，α是m*1的列向量，Mi(yi-1,yi|x) 是m*m的矩阵，α解释：前一个单词每个节点的α分别乘以（与当前节点相连的边的代价 + 当前节点的代价），再求和 。(因为Wi 的解释：当前节点代价 + 与该节点相连的一条边的代价)
同样，后向算法β计算， 对于i = 0, 1, 2, ..., n+1，定义后向向量βi(x)：
向前递推公式如下：
βi是m*1的列向量， Mi(yi,yi+1|x)是m*m的矩阵。β解释：（当前词与下一个词连接的边的代价 + 下一个词的代价） 分别乘以下一个词的β，再相加。
由前向-后向向量定义不难得到：
需要注意一下，矩阵表示形式的代价是对特征函数乘以权重加和后再取exp的值， 而上面的CRF++ calcCost函数中并没有取exp值。
接下来继续看下α和β在CRF++中是如何计算的。在gradient函数中调用的forwardbackward函数即是这部分的核心代码，具体如下：
void TaggerImpl::forwardbackward() {
if (x_.empty()) {
return;
}
for (int i = 0; i < static_cast<int>(x_.size()); ++i) { //前向算法
for (size_t j = 0; j < ysize_; ++j) {
node_[i][j]->calcAlpha();
}
}
for (int i = static_cast<int>(x_.size() - 1); i >= 0; --i) { //后向算法
for (size_t j = 0; j < ysize_; ++j) {
node_[i][j]->calcBeta();
}
}
Z_ = 0.0;
for (size_t j = 0; j < ysize_; ++j) { //计算Z(x)
Z_ = logsumexp(Z_, node_[0][j]->beta, j == 0);
}
return;
}
void Node::calcAlpha() {
alpha = 0.0;
for (const_Path_iterator it = lpath.begin(); it != lpath.end(); ++it) { //这里遍历当前节点的左边(path)的集合， 对应的就是Mi(yi-1,yi|x)矩阵中的某一列
alpha = logsumexp(alpha,
(*it)->cost +(*it)->lnode->alpha,
(it == lpath.begin())); //函数里面回取exp，因此边的代价 + 上一个节点的α，会转化成相乘，取完exp还会再取log，取log为了方式直接exp导致的溢出
}
alpha += cost; //统一加上当前节点的代价， Mi(yi-1,yi|x)每列中每个元素都加了当前节点的代价， 只不过CRF++是在后面统一加上
}
void Node::calcBeta() { //与上面类似
beta = 0.0;
for (const_Path_iterator it = rpath.begin(); it != rpath.end(); ++it) {
beta = logsumexp(beta,
(*it)->cost +(*it)->rnode->beta,
(it == rpath.begin()));
}
beta += cost; //这里需要注意，在矩阵的推导过程中，没有加当前节点的代价，但是CRF++里面加了， 后续我们会看到有一个减当前节点代价的一段代码
}
// log(exp(x) + exp(y));
// this can be used recursivly
// e.g., log(exp(log(exp(x) + exp(y))) + exp(z)) =
// log(exp (x) + exp(y) + exp(z))
// 这部分取log的操作是为了防止直接取exp溢出，具体的解释以及推导参考 计算指数函数的和的对数
inline double logsumexp(double x, double y, bool flg) {
if (flg) return y; // init mode
const double vmin = std::min(x, y);
const double vmax = std::max(x, y);
if (vmax > vmin + MINUS_LOG_EPSILON) {
return vmax;
} else {
return vmax + std::log(std::exp(vmin - vmax) + 1.0);
}
}阅读完上述代码会发现，这里的α计算除了没有对最终结果取exp以外，跟上面矩阵推导的α计算是一样的。可以利用矩阵方法和CRF++的算法具体算一下α或β的值，对比一下理解的会更深， 这个过程并不复杂。
概率计算
在这之上的计算都是针对一个训练样本, 而数学期望的计算是针对一组(即一个线程)训练样本的累计值. 因为期望对于一组训练样本才有意义
有了α和β，就可以进行条件概率和期望的计算。一个句子在位置i的label是yi的条件概率，以及在位置i-1与位置i标记为yi-1与yi的概率：
第一个式子可以说是节点的概率，第二个式子是节点之间边的概率。有了条件概率，就可以计算特征函数fk 关于条件分布 P(Y|X) 的数学期望是：
计算特征函数的期望是因为后续计算梯度的时候会用到。这里，如果fk是unigram特征（状态特征,对应于第一个期望公式），对应的条件概率是节点的概率， 如果是bigram特征（转移特征,对应于第二个期望公式），条件概率就是边的概率。继续看下CRF++中是如何计算条件概率和特征函数的期望的，代码在gradient函数中：
for (size_t i = 0; i < x_.size(); ++i) { //遍历每一个节点的，遍历计算每个节点和每条边上的特征函数，计算每个特征函数的期望
for (size_t j = 0; j < ysize_; ++j) {
node_[i][j]->calcExpectation(expected, Z_, ysize_);
}
}
void Node::calcExpectation(double *expected, double Z, size_t size) const { //状态特征的期望
const double c = std::exp(alpha + beta - cost - Z); //这里减去一个多余的cost，剩下的就是上面提到的节点的概率值 P(Yi=yi | x)，这里已经取了exp，跟矩阵形式的计算结果一致
for (const int *f = fvector; *f != -1; ++f) {
expected[*f + y] += c; //这里会把所有节点的相同状态特征函数对应的节点概率相加，特征函数值*概率再加和便是期望。由于特征函数值为1，所以直接加概率值
}
for (const_Path_iterator it = lpath.begin(); it != lpath.end(); ++it) { //转移特征的期望
(*it)->calcExpectation(expected, Z, size);
}
}
void Path::calcExpectation(double *expected, double Z, size_t size) const {
const double c = std::exp(lnode->alpha + cost + rnode->beta - Z); //这里计算的是上面提到的边的条件概率P(Yi-1=yi-1,Yi=yi|x)，这里取了exp，跟矩阵形式的计算结果一致
for (const int *f = fvector; *f != -1; ++f) {
expected[*f + lnode->y * size + rnode->y] += c; //这里把所有边上相同的转移特征函数对应的概率相加
}
}至此，CRF++中前后-后向算法、条件概率计算以及特征函数的期望便介绍完毕，接下来看看如何计算似然函数值和梯度。
计算梯度
条件随机场的训练，我们这里主要看CRF++中应用的LBFGS算法。先做简单的推导， 再结合实际的CRF++源码去理解。条件随机场模型如下：
训练函数的对数似然如下：
t代表所有的训练样本， 一般使用m来表示，但是上面已经把m给用了， 为了避免歧义， 我们用t来表示训练样本。我们求似然函数最大值来求解最优参数w，同时也可以对似然函数加负号，通过求解最小值来求最优的w。这里我们与CRF++保持一致，将似然函数取负号，再对wj求导，推导如下：
对于一个句子来说，特征函数的期望减去特征函数真实值就是我们要计算的梯度，Σt 代表对所有句子求和得到最终的梯度。接下来看下CRF++中是如何实现的，代码还是在gradient函数中：
for (size_t i = 0; i < x_.size(); ++i) { //遍历每一个位置（词）
for (const int *f = node_[i][answer_[i]]->fvector; *f != -1; ++f) { //answer_[i]代表当前样本的label，遍历每个词当前样本label的特征，进行减1操作，遍历所有节点减1就相当于公式中fj(y,x)
--expected[*f + answer_[i]]; //状态特征函数期望减去真实的状态特征函数值
}
s += node_[i][answer_[i]]->cost; // UNIGRAM cost 节点的损失求和
const std::vector<Path *> &lpath = node_[i][answer_[i]]->lpath;
for (const_Path_iterator it = lpath.begin(); it != lpath.end(); ++it) {//遍历边，对转移特征做类似计算
if ((*it)->lnode->y == answer_[(*it)->lnode->x]) {
for (const int *f = (*it)->fvector; *f != -1; ++f) {
--expected[*f +(*it)->lnode->y * ysize_ +(*it)->rnode->y]; //转移特征函数期望减去真实转移特征函数值
}
s += (*it)->cost; // BIGRAM COST 边损失求和
break;
}
}
}
viterbi(); // call for eval() 调用维特比算法做预测，为了计算分类错误的次数，算法详细内容下篇介绍
return Z_ - s ; //返回似然函数值，看L(w)推导的最后一步，大括号内有两项，其中一项是logZw(x)，我们知道变量Z_是没有取exp的结果，我们要求这一项需要先对Z_取exp，取exp再取log相当于还是Z_，因此 logZw(x) = Z_
//再看另一项，是对当前样本代价求和，正好这一项是没有取exp的因此该求和项就等于s， 之前说过CRF++是对似然函数取负号，因此返回Z_ - s至此，一个句子的似然函数值和梯度就计算完成了。公式的Σt 是对所有句子求和，CRF++的求和过程是在run函数调用gradient函数结束后由线程内汇总，然后所有线程结束后再汇总。runCRF函数剩下的代码便是所有线程完成一轮计算后的汇总逻辑，如下：
for (size_t i = 1; i < thread_num; ++i) { //汇总每个线程的数据
thread[0].obj += thread[i].obj; //似然函数值
thread[0].err += thread[i].err;
thread[0].zeroone += thread[i].zeroone;
}
for (size_t i = 1; i < thread_num; ++i) {
for (size_t k = 0; k < feature_index->size(); ++k) {
thread[0].expected[k] += thread[i].expected[k]; //梯度值求和
}
}
size_t num_nonzero = 0;
if (orthant) { // L1 根据L1或L2正则化，更新似然函数值
for (size_t k = 0; k < feature_index->size(); ++k) {
thread[0].obj += std::abs(alpha[k] / C);
if (alpha[k] != 0.0) {
++num_nonzero;
}
}
} else { //L2
num_nonzero = feature_index->size();
for (size_t k = 0; k < feature_index->size(); ++k) {
thread[0].obj += (alpha[k] * alpha[k] /(2.0 * C));
thread[0].expected[k] += alpha[k] / C;
}
}
...省略代码
if (lbfgs.optimize(feature_index->size(),
&alpha[0],
thread[0].obj,
&thread[0].expected[0], orthant, C) <= 0) { //传入似然函数值和梯度等参数，调用LBFGS算法
return false;
}最终调用LBFGS算法更新w，CRF++中的LBFGS算法最终是调用的Fortran语言编译后的C代码，可读性比较差,至此，一次迭代的计算过程便介绍完毕。