淺談分詞算法（5）基於字的分詞方法（bi-LSTM）

目錄

• 前言
• 目錄
• 循環神經網絡
• 基於LSTM的分詞
  • Embedding
  • 數據預處理
  • 模型
  • 如何添加用戶詞典

前言

很早便規划的淺談分詞算法，總共分為了五個部分，想聊聊自己在各種場景中使用到的分詞方法做個總結，種種事情一直拖到現在，今天抽空趕緊將最后一篇補上。前面幾篇博文中我們已經闡述了不論分詞、詞性標注亦或NER，都可以抽象成一種序列標注模型，seq2seq，就是將一個序列映射到另一個序列，這在NLP領域是非常常見的，因為NLP中語序、上下文是非常重要的，那么判斷當前字或詞是什么，我們必須回頭看看之前說了什么，甚至之后說了什么，這也符合人類在閱讀理解時的習慣。由於抽象成了Seq2Seq的模型，那么我們便可以套用相關模型來求解，比如HMM、CRF以及深度中的RNN，本文我們就來聊聊LSTM在分詞中的應用，以及使用中的一些trick，比如如何添加字典等。

目錄

淺談分詞算法（1）分詞中的基本問題
淺談分詞算法（2）基於詞典的分詞方法
淺談分詞算法（3）基於字的分詞方法（HMM）
淺談分詞算法（4）基於字的分詞方法（CRF）
淺談分詞算法（5）基於字的分詞方法（LSTM）

循環神經網絡

在之前的博文馬里奧AI實現方式探索 ——神經網絡+增強學習，我闡述了關於神經網絡的歷程，以及最近這波人工智能浪潮的起始CNN，即卷積神經網絡的概念。卷積神經網絡給圖像領域帶來了質的飛越，也將之前由李飛飛教授建立的ImageNet比賽提升到了新的高度，圖像識別領域，計算機第一次超越了人類，從而引爆了最近兩三年來對人工智能、深度學習的持續關注。
當CNN在圖像領域火爆之后，自然作為人工智能三大領域之一的NLP，也很快拿來使用，即著名的Text-CNN，大家感興趣的可以去看看這篇論文Convolutional Neural Networks for Sentence Classification，對NLP領域也具有重要的里程碑意義，現在引用量也達到了3436。
但是CNN有個比較嚴重的問題是，其沒有序列的概念在里面，如果我們將一個句子做好embedding丟到CNN中做分類模型，那么CNN更多的是將這個句子看做一個詞袋（bag-of-words bag），這樣在NLP領域重要的語序信息就丟失了，那么我們便引出了RNN，即循環神經網絡或說遞歸神經網絡（這里值得注意的是，如果是對語句做分類模型，那么用CNN進行不同kernel的卷積，然后拼接是可以提取到一些語序信息，這其中也涉及到各種變種的CNN，大家可以多查查資料）。
對於循環神經網絡，其實與CRF、HMM有很多共通之處，對於每一個輸入\(x_t\)，我們通過網絡變換都會得到一個狀態\(h_t\)，對於一個序列來說，每一個token（可以是字也可以是詞，在分詞時是字）都會進入網絡迭代，注意網絡中的參數是共享的。這里不可免俗的放上經典圖像吧：

這里將循環神經網絡展開，就是后面那樣。大家注意下圖中的\(A\)，在RNN中就是一個比較簡單的前饋神經網絡，在RNN中會有一個嚴重的問題，就是當序列很長的時候，BP算法在反饋時，梯度會趨於零，即所謂的梯度消失（vanishing gradient）問題，這便引出了LSTM（Long Short Term Memory）。
LSTM本質上還是循環神經網絡，只不過呢它把上面我們提到的\(A\)換了換，加了三個門，其實就是關於向量的幾個變換表達式，來規避這種梯度消失問題，使得LSTM的邏輯單元能夠更好的保存序列信息，同樣不可免俗上下面這張經典的圖片：

圖中對應了四個表達式如下：
遺忘門：

\[f_t=\sigma (W_f\cdot [h_{t-1},x_t]+b_f \]

輸入門：

\[i_t=\sigma (W_i\cdot [h_{t-1},x_t]+b_i \]

\[\widetilde{C}=tanh(W_C\cdot [h_{t-1},x_t]+b_C \]

狀態更新：

\[C_t=f_t*C_{t-1}+i_t*\widetilde{C}_t \]

輸出門：

\[O_t=\sigma (W_o[h_{t-1},x_t]+b_o) \]

\[h_t=O_t*tanh(C_t) \]

一般呢LSTM都是一個方向將序列循環輸入到網絡之中，然而有時候我們需要兩頭關注序列的信息，這樣便引出了Bi-LSTM，即雙向LSTM，很簡單，就是對於一個序列，我們有兩個LSTM網絡，一個正向輸入序列，一個反向輸入序列，然后將輸出的state拼接在一起，供后續使用。
到這里我們簡單的說了下關於循環神經網絡的事情，下面我們看下在分詞中應用LSTM

基於LSTM的分詞

前文以及之前的系列博文，我們已經熟悉分詞轉換為Seq2Seq的思路，那么對於LSTM，我們需要做的是將一串句子映射成為Embedding，然后逐個輸出到網絡中，得到狀態輸出，進行序列標注。我們采用TensorFlow來開發。

Embedding

關於Embedding，我們可以直接下載網上公開的Wiki數據集訓練好的Embedding，一般維度是100，也可以自己根據場景，利用Word2Vec、Fasttext等訓練自己的Embedding。

數據預處理

其實深度的好多模型已經很成熟，最麻煩的是數據的預處理，在數據預處理階段核心要做的是將序列映射到Embedding文件對應的id序列，並且按照Batch來切分，一般根據數據集的大小會設置64、128、256等不同的batch大小，在向網絡輸入數據，進行epoch迭代時，注意進行必要的shuffle操作，對於結果提高很有用，shuffle類似如下：

def shuffle(char_data, tag_data, dict_data, len_data):
    char_data = np.asarray(char_data)
    tag_data = np.asarray(tag_data)
    dict_data = np.asarray(dict_data)
    len_data = np.asarray(len_data)
    idx = np.arange(len(len_data))
    np.random.shuffle(idx)

    return (char_data[idx], tag_data[idx], dict_data[idx], len_data[idx])

數據預處理我這里不多講了，讀者可以直接看github上開源的代碼，有問題隨時留言，我有空會來解答~

模型

我們的核心模型結構也很簡單，將輸入的id序列，通過Tensorflow 的查表操作，映射成對應的Embedding，然后輸入到網絡中，得到最終結果，進行Decode操作，得到每個字符的標記（BEMS），核心代碼如下：

    def __init__(self, config, init_embedding = None):
        self.batch_size = batch_size = config.batch_size
        self.embedding_size = config.embedding_size # column
        self.hidden_size = config.hidden_size
        self.vocab_size = config.vocab_size # row

        # Define input and target tensors
        self._input_data = tf.placeholder(tf.int32, [batch_size, None], name="input_data")
        self._targets = tf.placeholder(tf.int32, [batch_size, None], name="targets_data")
        self._dicts = tf.placeholder(tf.float32, [batch_size, None], name="dict_data")
        self._seq_len = tf.placeholder(tf.int32, [batch_size], name="seq_len_data")

        with tf.device("/cpu:0"):
            if init_embedding is None:
                self.embedding = tf.get_variable("embedding", [self.vocab_size, self.embedding_size], dtype=data_type())
            else:
                self.embedding = tf.Variable(init_embedding, name="embedding", dtype=data_type())
        inputs = tf.nn.embedding_lookup(self.embedding, self._input_data)
        inputs = tf.nn.dropout(inputs, config.keep_prob)
        inputs = tf.reshape(inputs, [batch_size, -1, 9 * self.embedding_size])
        d = tf.reshape(self._dicts, [batch_size, -1, 16])
        self._loss, self._logits, self._trans = _bilstm_model(inputs, self._targets, d, self._seq_len, config)
        # CRF decode
        self._viterbi_sequence, _ = crf_model.crf_decode(self._logits, self._trans, self._seq_len)
        with tf.variable_scope("train_ops") as scope:
            # Gradients and SGD update operation for training the model.
            self._lr = tf.Variable(0.0, trainable=False)
            tvars = tf.trainable_variables()  # all variables need to train
            # use clip to avoid gradient explosion or gradients vanishing
            grads, _ = tf.clip_by_global_norm(tf.gradients(self._loss, tvars), config.max_grad_norm)
            self.optimizer = tf.train.AdamOptimizer(self._lr)
            self._train_op = self.optimizer.apply_gradients(
                zip(grads, tvars),
                global_step=tf.contrib.framework.get_or_create_global_step())

            self._new_lr = tf.placeholder(data_type(), shape=[], name="new_learning_rate")
            self._lr_update = tf.assign(self._lr, self._new_lr)
        self.saver = tf.train.Saver(tf.global_variables())

代碼邏輯很清晰，將各種輸入得到后，embedding查表結束后，放入Bi-LSTM模型，得到的結果進行Decode，這里注意我們用了一個CRF進行尾部Decode，經過試驗效果更好，其實直接上一層Softmax也ok。對於bilstm如下：

def _bilstm_model(inputs, targets, dicts, seq_len, config):
    '''
    @Use BasicLSTMCell, MultiRNNCell method to build LSTM model
    @return logits, cost and others
    '''
    batch_size = config.batch_size
    hidden_size = config.hidden_size
    vocab_size = config.vocab_size
    target_num = config.target_num  # target output number
    seq_len = tf.cast(seq_len, tf.int32)

    fw_cell = lstm_cell(hidden_size)
    bw_cell = lstm_cell(hidden_size)

    with tf.variable_scope("seg_bilstm"): # like namespace
        # we use only one layer
        (forward_output, backward_output), _ = tf.nn.bidirectional_dynamic_rnn(
            fw_cell,
            bw_cell,
            inputs,
            dtype=tf.float32,
            sequence_length=seq_len,
            scope='layer_1'
        )
        # [batch_size, max_time, cell_fw.output_size]/[batch_size, max_time, cell_bw.output_size]
        output = tf.concat(axis=2, values=[forward_output, backward_output])  # fw/bw dimension is 3
        if config.stack: # False
            (forward_output, backward_output), _ = tf.nn.bidirectional_dynamic_rnn(
                fw_cell,
                bw_cell,
                output,
                dtype=tf.float32,
                sequence_length=seq_len,
                scope='layer_2'
            )
            output = tf.concat(axis=2, values=[forward_output, backward_output])

        output = tf.concat(values=[output, dicts], axis=2)  # add dicts to the end
        # outputs is a length T list of output vectors, which is [batch_size*maxlen, 2 * hidden_size]
        output = tf.reshape(output, [-1, 2 * hidden_size + 16])
        softmax_w = tf.get_variable("softmax_w", [hidden_size * 2 + 16, target_num], dtype=data_type())
        softmax_b = tf.get_variable("softmax_b", [target_num], dtype=data_type())

        logits = tf.matmul(output, softmax_w) + softmax_b
        logits = tf.reshape(logits, [batch_size, -1, target_num])

    with tf.variable_scope("loss") as scope:
        # CRF log likelihood
        log_likelihood, transition_params = tf.contrib.crf.crf_log_likelihood(
            logits, targets, seq_len)
        loss = tf.reduce_mean(-log_likelihood)
    return loss, logits, transition_params

注意這里做了兩次LSTM，並將結果拼接在一起，而我們的損失函數是關於crf_log_likelihood。

如何添加用戶詞典

我們可以看到在整個模型訓練好后，inference的過程是直接根據網絡權重進行的，那么如何添加用戶詞典呢，這里我們采用的方式是將用戶詞典作為額外的特征拼接在Bi-LSTM結果的后面，就是在上面代碼的output = tf.concat(values=[output, dicts], axis=2) # add dicts to the end這里，這個詞典會分成四個部分，head、mid、single、tail，詞頭、詞中、詞尾以及單字詞，這樣對於用戶詞典是否出現用one-hot形式表達，不過實際使用過程中也還是存在切不出來的問題，讀者可以考慮加強這部分特征。

整個代碼我放在github上了，感興趣的讀者直接看源代碼，有問題歡迎留言~
https://github.com/xlturing/machine-learning-journey/tree/master/seg_bilstm

終於寫好這個系列了，之后謝謝最近在弄的Attention、Transformer以及BERT這一套在文本分類中的應用哈，歡迎大家交流。