此文为学习何晗老师《自然语言处理入门》笔记

由于词语级别的模型天然缺乏OOV召回能力，我们需要更细粒度的模型。

比词语更细的颗粒就是字符，如果字符级模型能够掌握汉字组词的规律，那么它就能够由字构词、动态的识别新词汇，而不局限于词典。

序列标注问题

序列标注（tagging）指的是给定一个序列 $x = x_1 x_2 \ldots x_n$ ，找出序列中每个元素对应的标签 $y = y_1 y_2 \ldots y_n$ 的问题。

其中 $y$ 是所有可能的取值集合，称为标注集*（tagset）。

最简单的奇偶标注

求解序列标注问题的模型一般称为序列标注器（tagger）。

通常模型从一个标注数据集 ${X, Y} = \{(x^i, y^i)\}, i = 1, \ldots K$ 中学习相关知识后再进行预测。

在NLP问题中， $x$ 通常是字符或词语，而 $y$ 则是待预测的组词角色或词性等标签。

序列标注与中文分词

比如下面，{B,M,E,S}为最流行的标注集，其中：

B: Begin 词首
E: End 词尾
M: Middle 词中
S: Single 单字成词

标注后，按照最近的两个BE标签对应区间合并为一个词，S标签对应单字词语，按顺序输出即为分词过程。

序列标注与词性标注

序列标注与命名实体识别

所谓命名实体就是现实存在的实体，比如人名、地名和机构名。命名实体是OOV的主要组成部分，往往也是最令人关注的成分。

隐马尔科夫模型

隐马尔科夫模型（Hidden Markov Model, HMM）是描述两个时序序列联合分布 $p(x, y)$ 的概率模型：

观测序列（Observation Sequence）： $x$ 序列外界可见
状态序列（State Sequence）： $y$ 序列外界不可见

从马尔科夫假设到隐马尔科夫模型

马尔科夫假设：每个事件发生的概率只取决于前一个事件
马尔科夫链：将满足该假设的连续多个事件串联在一起构成

在NLP语境下，可以将事件具象为单词，于是马尔科夫模型就具象为二元语法模型。

根据联合概率分布特性

$p(x, y) = p(x)p(y|x) = p(y)(x|y) = p(y, x)$

假定先有状态，后有观测，取决于两个序列的可见与否。

状态与观测之间的依赖关系确定以后，隐马尔科夫模型利用三个要素来模拟时序序列的发生过程：

初始状态概率向量（下图中 $\pi$ ）
状态转移概率矩阵（下图中 $A$ ）
发射概率矩阵（也称观测概率矩阵，下图中 $B$ ）

初始概率向量、状态转移概率矩阵和发射概率矩阵被称为隐马尔科夫模型的三元组： ?\lambda =(\pi, A, B)?

初始状态概率向量

系统启动时进入的第一状态 $y_i$ 称为初始状态。

假设 $y$ 有 $N$ 种取值，即 $y \in \{s_1, s_2, \cdots, s_N\}$ ，那么 $y_1$ 就是一个独立的离散型随机变量，由 $p(y_i | \pi)$ 描述。其中初始概率向量： $\pi = (\pi_1,\cdots,\pi_N)^T, 0 \leq \pi_i \leq 1, \sum_{i=1}^N \pi_i = 1$

比如中文分词问题采用 $\{B, M, E, S\}$ 标注集时： $p(y_i = B) = 0.7$ $p(y_i = M) = 0$ $p(y_i = E) = 0$ $p(y_i = S) = 0.3$

则 $\pi = [0.7, 0, 0, 0.3]$

状态转移概率矩阵

根据马尔科夫假设， $t+1$ 时的状态取决于 $t$ 时的状态。在 $N$ 种状态下，从状态 $s_i$ 转移到状态 $s_j$ 的概率就构成了一个 $N \times N$ 的状态转移概率矩阵 $A$ ： $A = [p(y_{t+1} = s_j| y_t = s_i)]_{N \times N}$ 其中下标 $i, j$ 分别表示状态 $i$ 转移到状态 $j$ 概率。

发射概率矩阵

根据马尔科夫假设，当前观测 $x_t$ 仅取决于当前状态 $y_t$ 。

假设观测 $x$ 一共有 $M$ 种可能的取值，即 $x \in \{o_1, \cdots, o_M\}$ 。由于 $y$ 共有 $N$ 种，所以这些参数向量构成了 $N \times M$ 的发射概率矩阵 $B$ ： $B = [p(x_t = o_i|y_t = s_j)]_{N \times M}$

示例

下图中，

$N = 2$

$M = 3$

$\lambda = [0.6, 0.4]$

$A = \left[ \begin{matrix} 0.7 & 0.3 \\ 0.4 & 0.6 \end{matrix} \right]$

$B = \left[ \begin{matrix} 0.5 & 0.4 & 0.1 \\ 0.1 & 0.3 & 0.6 \end{matrix} \right]$

$y$ 为健康、发烧， $x$ 为正常、体寒、头晕可观测矩阵

隐马尔科夫模型三个基本用法

样本生成问题：给定模型 $\lambda =(\pi, A, B)$ ，生成满足模型约束的样本，即一系列观测序列及对应的状态序列 $\{(x^i, y^i)\}$
模型训练问题：给定训练集 $\{(x^i, y^i)\}$ ，估计模型参数 $\lambda =(\pi, A, B)$
序列预测问题：已知模型参数 $\lambda =(\pi, A, B)$ ，给定观测序列 $x$ ，求最可能的状态序列 $y$

马尔科夫模型样本生成

隐马尔科夫模型训练

在监督学习中，我们利用极大似然法来估计隐马尔科夫模型参数。

归一化函数及转为为 $\log$ 函数，方便后期计算时，使用加法代替乘法。

/**
 * 频次向量归一化为概率分布
 * 并将概率转换为log，方便后期将乘法改为加法
 *
 * @param freq 输入的一维度矩阵（1 X n）
 */
void normalizeAndToLog(float[] freq){
    // 累计一行的SUM
    float sum = MathUtility.sum(freq);
    for (int i = 0; i < freq.length; i++) {
        // 归一化
        freq[i] /= sum;
        // 使用log函数
        freq[i] = Math.log(freq[i])
    }
}

初始化状态概率向量的估计

初始状态可以看作是状态转移的一种特例，即 $y_1$ 是由BOS转移而来。统计 $y_1$ 的所有取值的频次记作向量 $c(1 \times n)$

$\hat \pi_i = \frac {c_i} {\sum_{j=1}^{N} c_j}, i = 1, 2, \cdots, N$

由初始状态 $BOS$ 到 $s$ 的概率向量：

$BOS$ \ $s$	$s_1$	$s_2$	$\cdots$	$s_N$
$BOS$	$BOS \rightarrow s_1$	$BOS \rightarrow s_2$	$\cdots$	$BOS \rightarrow s_N$

/**
 * 估计初始状态概率向量
 *
 * @param samples 训练样本集
 *                是包含多个2*N的矩阵样本数据，每个矩阵第0行为观测值，第1行为状态值
 * @param max_state 状态的最大下标，等于N-1
 */
void estimateStartProbability(Collection<int[][]> samples, int max_state) {
    // 初始状态概率向量
    float[] start_probability = new float[max_state + 1];
    for (int[][] sample : samples) {
        // 只取第一个状态进行累加
        int s = sample[1][0];
        ++start_probability[s];
    }
    // 归一化 log化
    normalizeAndToLog(start_probability);
}

转移概率矩阵的估计

记样本序列在时刻 $t$ 处于状态 $s_i$ ，时刻 $t+1$ 转移到状态 $s_j$ 。

统计这样的转移频次计入矩阵元素 $A_{i,j}$ ，根据极大似然估计，从 $s_i$ 转移到 $s_j$ 的转移概率 $a_{i,j}$ 可估计为矩阵第 $i$ 行频次的归一化：

$\hat a_{i,j} = \frac {A_{i,j}} {\sum_{j = 1}^N A_{i,j}}, i,j=1,2, \cdots,N$

有前一状态 $\hat s$ 转移到当前状态 $s$ ，矩阵如下：

$\hat s$ \ $s$	$s_1$	$s_2$	$\cdots$	$s_N$
$\hat s_1$	$\hat s_1 \rightarrow s_1$	$\hat s_1 \rightarrow s_2$	$\cdots$	$\hat s_1 \rightarrow s_N$
$\hat s_2$	$\hat s_2 \rightarrow s_1$	$\hat s_2 \rightarrow s_2$	$\cdots$	$\hat s_2 \rightarrow s_N$
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$
$\hat s_N$	$\hat s_N \rightarrow s_1$	$\hat s_N \rightarrow s_2$	$\cdots$	$\hat s_N \rightarrow s_N$

/**
 * 估计转移概率矩阵
 *
 * @param samples 训练样本集
 *                是包含多个2*N的矩阵样本数据，每个矩阵第0行为观测值，第1行为状态值
 * @param max_state 状态的最大下标，等于N-1
 */
void estimateTransitionProbability(Collection<int[][] samples, int max_state) {
    // 状态转移概率矩阵
    float[][] transition_probability = new float[max_state + 1][max_state + 1];
    for (int[][] sample: samples) {
        // 处理一个序列
        int prev_s = sample[1][0];
        for (int i = 1; i < sample[0].length; i++) {
            // 获取当前状态
            int s = sample[1][i];
            // 累计状态转移矩阵的对应值
            ++transition_probability[prev_s][s];
            // 转移到下一个状态
            prev_s = s;
        }
    }
    
    for (int i = 0; i < transition_probality.length; i++) {
        // 归一化每一个状态（一行数据）
        normalizeAndToLog(transition_probability[i])
    }
}

发射概率矩阵的估计

统计样本中状态为 $s_i$ 且观测为 $o_j$ 的频次，计入矩阵元素 $B_{i,j}$ ，则状态 $s_j$ 发射观测 $o_j$ 的概率估计为： $\hat b_{i,j} = \frac {B_{i,j}} {\sum_{j=1}^{M} B_{i,j}}, i=1, 2, \dots, N;j=1, 2, \dots, M$

由当前状态 $s$ 发射到 $o$ 的矩阵：

$s$ \ $o$	$o_1$	$o_2$	$\dots$	$o_M$
$s_1$	$s_1 \rightarrow o_1$	$s_1 \rightarrow o_2$	$\cdots$	$s_1 \rightarrow o_M$
$s_2$	$s_2 \rightarrow o_1$	$s_2 \rightarrow o_2$	$\cdots$	$s_2 \rightarrow o_M$
$\vdots$	$\vdots$	$\vdots$	$\vdots$	$\vdots$
$s_N$	$s_N \rightarrow o_1$	$s_N \rightarrow o_2$	$\cdots$	$s_N \rightarrow o_M$

/**
 * 估计状态发射概率
 *
 * @param samples 训练样本集
 *                是包含多个2*N的矩阵样本数据，每个矩阵第0行为观测值，第1行为状态值
 * @param max_state 状态的最大下标，等于N-1
 * @param max_obser 观测的最大下标
 */
 void estimateEmissionProbability(Collection<int[][]> samples, int max_state, int max_obser) {
    float[][] emission_probability = new float[max_state + 1][max_obser + 1];
    
    for (int[][] sample : samples) {
        // 计算每一个序列
        for (int i = 0; i < sample[0].length; i++) {
            int o = sample[0][i];
            int s = sample[1][i];
            ++emission_probability[s][o];
        }
    }
    for (int i = 0; i < emission_probability.length; i++) {
        normalizeAndToLog(emission_probability[i]);
    }
 }

隐马尔科夫模型的预测

预测：给定观测序列，求解最可能的状态序列极其概率。

比如一个一个病人，他最近三天的感受是：正常、体寒、头晕，请预测他这三天最可能的健康状态和相应的概率。

概率计算的前向算法

给定观测序列 $x$ 和一个状态序列 $y$ ，计算两者的联合概率 $p(x, y)$ ，以及搜索其中的最大概率。

$p(y_1 = s_1) = \pi_i, t = 1$

$p(y_t = s_j | y_{t-1} = s_i) = A_{i,j}, t \ge 2$

$p(y) = p(y_1, y_2, \cdots, y_T) = p(y_1) \prod_{t=2}^{T} p(y_t | y_{t-1})$

$p(x_t = o_j | y_t = s_i) = B_{i,j}$

那么给定长为 $T$ 的状态序列 $y$ ，对应 $x$ 的概率就是：

$p(x | y) = \prod_{t=1}^{T} p(x_t | y_t)$

由以上公式，得到显隐状态序列的联合概率：

$p(x, y) = p(y) p(x | y) = p(y_1) \prod_{t=2}^{T} p(y_t | y_{t-1}) \prod_{t=1}^{T} p(x_t | y_t)$

将其中的每个 $x_t, y_t$ 对应上实际发生的序列 $s_i, o_j$ ，就能带入 $(\pi, A, B)$ 中相应元素，从而计算出任意序列的概率了。

搜索状态序列的维比特算法

要搜索上式最大概率所对应的状态，可以将每个状态作为有向图中的一个节点：

节点间的距离由转移概率决定
节点本身的花费由发射概率决定

那么所有备选状态构成一幅有向无环图，待求概率最大的状态序列就是求取图中最长路径，此时的搜索算法称为维比特算法（如红色为示意找到的最佳路径）：

暴力搜索：枚举每个时刻的 $N$ 种备选状态，相邻两个时刻之间的状态由 $N^2$ 组合，则 $T$ 个时刻的复杂度是 $O(TN^2)$

维比特算法

可以论证，最优解情况下 $y_{t+1}$ 仅依赖于 $y_t$ 。定义二维数据 $\sigma_{t,i}$ 表示时刻 $t$ 以 $s_i$ 结尾的所有局部路径最大概率， $t$ 从 $1$ 递推到 $N$ ，每次递推都是在上一次的N条局部路径中挑选，所以复杂度 $O(TN)$ 。为了追踪最优解，还需要记录每个状态的前驱：定义另外一个二维数组 $\psi$ ，同 $\sigma$ 下标定义，存储局部最优路径状态 $y_t$ 的前驱状态。

计算过程：

初始化： $t = 1$ 时初始最优路径的备选由 $N$ 个状态组成，它们的前驱为空： $\sigma_{1, i} = \pi_i B_{i, o_1}, i = 1, 2, \cdots, N$

$\psi_{1,i} = 0, i = 1, 2, \cdots, N$

递推：根据转移概率矩阵和发射概率计算花费，找出新的局部最优解，更新两个数组 $\sigma_{t, j} = \max(\sigma_{t-1, j}A_{j,i})B_{i, o_t}, i = 1, 2, \cdots, N$

$\psi_{t, j} = \arg \max_{1 \le j \le N}(\sigma_{t-1, j}A_{j, i}), i = 1, 2, \cdots, N$

终止：找出最终时刻 $\sigma_{T, i}$ 数组中的最大概率 $p^*$ ，以及相应的结尾状态 $i_T^*$

$p^* = \max_{1 \le i \le N} \sigma_{T, i}$

$i_T^* = \arg \max_{1 \le i \le N} \sigma_{T, i}$

回溯：根据前驱数组 $\psi$ 回溯前驱状态，取得最优路径下标 $i^* = i_1^*, \cdots, i_T^*$ ，其中

$i_t^* = \psi_{t+1, i_{t+1}^*}, t = T - 1, T - 2, \cdots, 1$

path路径矩阵，保存每个状态的前驱状态，如上面的维比特算法示意，对应前驱路径矩阵如下：

$t$ \ $s$	$s_1$	$s_2$	$\cdots$	$s_N$
$1$	$s_3$	$\color{blue}{s_2}$	$\cdots$	$s_1$
$2$	$s_N$	$s_1$	$\cdots$	$\color{blue}{s_2}$
$\vdots$	$\vdots$	$\vdots$	$\color{blue}{\vdots}$	$\vdots$
$T-1$	$s_2$	$\color{blue}{s_1}$	$\cdots$	$s_8$

每个状态的最大分数表（仅仅示例）

$score$ \ $s$	$s_1$	$s_2$	$\cdots$	$s_N$
$T-1$	$0.1$	$\color{red}{0.3}$	$\cdots$	$0.01$

代码

/*
 * 预测（维比特算法）
 *
 * @param observeration 观测序列
 * @param state 预测状态序列
 * @return 概率的对象，可利用Math.exp(maxScore)还原log函数
 */
float predict(int[] observeration, int[] state) {
    // 序列长度
    final int T = observation.length;
    // 状态种类
    final int max_s = start_probability.length;
    float[] score = new float[max_s];
    // 如上面的二维表格
    // path[t][s]: 第t个状态在为s时，存储前一个状态
    int[][] path = new int[T][max_s];
    // 第一个时刻，使用初始概率乘以发射概率，遍历状态
    for (int cur_s = 0; cur_s < max_s; ++cur_s) {
        // 由于初始概率与发射概率都已经log化过，此处的加法，就是乘法
        score[cur_s] = start_probability[cur_s] + emission_probability[cur_s][observation[0]];
    }
    // 第二个时刻，需考虑上一时刻的概、转移概率以及发射概率
    float[] pre = new float[max_s];
    // 遍历观察序列
    for (int t = 1; t < T; t++) {
        // swap(now, pre)
        float[] temp = pre;
        // 保存前一状态的分数
        pre = score;
        score = temp;
        // 遍历状态
        for (int s = 0; s < max_s; s++) {
            score[s] = Integer.MIN_VALUE;
            // 计算转移概率
            for (int f = 0; f < max_s; f++) {
                // log化后的加法相当于乘法
                // 计算路径长度：前驱状态f转移到当前状态s
                float p = pre[f] + transition_probability[f][s] + emission_probability[s][observation[t]];
                // 取路径最大的，记录其前驱状态f
                if (p > socre[s]) {
                    score[s] = p;
                    path[t][s] = f;
                }
            }
        }
    }
    float max_score = Integer.MIN_VALUE;
    int best_s = 0;
    // 计算最终分数最高的最终状态
    for (int s = 0; s < max_s; s++) {
        if (score[s] > max_score) {
            max_score = score[s];
            best_s = s;
        }
    }
    // 回溯前向路径矩阵
    for (int t = path.length - 1; t >= 0; --t) {
        // 由最终最优状态向前回溯状态
        state[t] = best_s;
        // 取得最大score的pre状态，进行回溯
        best_s = path[t][best_s];
    }
    return max_score;
}

隐马尔科夫模型应用于中文分词

如果将观测换成字符，状态换成{B, M, E, S}，我们就能应用隐马尔科夫模型驱动中文分词。

然而隐马尔科夫模型用于中文分词的效果并不理想。事实上，隐马尔科夫模型假设人们说的话仅仅取决于一个隐藏的{B, M, E, S}序列，这个假设太单纯，不符合语言规律。语言不是由那么简单的标签序列生成，语言含有更多特征，而隐马尔科夫模型没有捕捉到。

隐马尔科夫模型能捕捉到仅限两种特征：

前一个标签是什么
当前字符是什么朴素的隐马尔科夫模型并不适合分词，需要更高级的模型。

特征提取

劳动者 的 合法权益 又 如何 保障 ？

protected List<String[]> convertToSequence(Sentence sentence) {
    List<String[]> charList = new LinkedList<String[]>();
    // 遍历每个单词
    for (Word w : sentence.toSimpleWordList()) {
        String word = CharTable.convert(w.value);
        if (word.length() == 1) {
            // 词：标签 第0行是词，第1行是标签
            charList.add(new String[]{word, "S"});
        } else {
            charList.add(new String[]{word.substring(0, 1), "B"});
            for (int i = 1; i < word.length() - 1; ++i) {
                charList.add(new String[]{word.substring(i, i + 1), "M"});
            }
            charList.add(new String[]{word.substring(word.length() - 1), "E"});
        }
    }
    return charList;
}

训练

特性转换

// sentenceList为特征提取里面提到的
List<int[][]> sampleList = new ArrayList<int[][]>(sequenceList.size());
for (List<String[]> sequence : sequenceList)
{
    int[][] sample = new int[2][sequence.size()];
    int i = 0;
    for (String[] os : sequence)
    {
        // 显性序列 字符
        sample[0][i] = vocabulary.idOf(os[0]);
        assert sample[0][i] != -1;
        // 隐形状态 标签{B, M, E, S}
        sample[1][i] = tagSet.add(os[1]);
        ++i;
    }
    sampleList.add(sample);
}

model.train(sampleList);

训练及预测同上面的HMM训练过程

自然语言处理入门笔记-> 隐马尔科夫模型HMM