使用TENSORFLOW訓練循環神經網絡語言模型

作者：佚名 2017-08-28 21:31:37

Language Model，即語言模型，其主要思想是，在知道前一部分的詞的情況下，推斷出下一個最有可能出現的詞。在本文中，我們更加關注的是，如何使用RNN來推測下一個詞。

讀了將近一個下午的TensorFlow Recurrent Neural Network教程，翻看其在PTB上的實現，感覺晦澀難懂，因此參考了部分代碼，自己寫了一個簡化版的Language Model，思路借鑒了Keras的LSTM text generation。

代碼地址：Github

轉載請注明出處：Gaussic

語言模型

Language Model，即語言模型，其主要思想是，在知道前一部分的詞的情況下，推斷出下一個最有可能出現的詞。例如，知道了 The fat cat sat on the，我們認為下一個詞為mat的可能性比hat要大，因為貓更有可能坐在毯子上，而不是帽子上。

這可能被你認為是常識，但是在自然語言處理中，這個任務是可以用概率統計模型來描述的。就拿The fat cat sat on the mat來說。我們可能統計出第一個詞The出現的概率p(The)p(The)，The后面是fat的條件概率為p(fat|The)p(fat|The)，The fat同時出現的聯合概率：

p(The,fat)=p(The)⋅p(fat|The)p(The,fat)=p(The)·p(fat|The)

這個聯合概率，就是The fat的合理性，即這句話的出現符不符合自然語言的評判標準，通俗點表述就是這是不是句人話。同理，根據鏈式規則，The fat cat的聯合概率可求：

p(The,fat,cat)=p(The)⋅p(fat|The)⋅p(cat|The,fat)p(The,fat,cat)=p(The)·p(fat|The)·p(cat|The,fat)

在知道前面的詞為The cat的情況下，下一個詞為cat的概率可以推導出來：

p(cat|The,fat)=p(The,fat,cat)p(The,fat)p(cat|The,fat)=p(The,fat,cat)p(The,fat)

分子是The fat cat在語料庫中出現的次數，分母是The fat在語料庫中出現的次數。

因此，The fat cat sat on the mat整個句子的合理性同樣可以推導，這個句子的合理性即為它的概率。公式化的描述如下：

p(S)=p(w1,w2,⋅⋅⋅,wn)=p(w1)⋅p(w2|w1)⋅p(w3|w1,w2)⋅⋅⋅p(wn|w1,w2,w3,⋅⋅⋅,wn−1)p(S)=p(w1,w2,···,wn)=p(w1)·p(w2|w1)·p(w3|w1,w2)···p(wn|w1,w2,w3,···,wn−1)

（公式后的n-1應該為下標，插件問題，下同）

可以看出一個問題，每當計算下一個詞的條件概率，需要計算前面所有詞的聯合概率。這個計算量相當的龐大。并且，一個句子中大部分詞同時出現的概率往往少之又少，數據稀疏非常嚴重，需要一個非常大的語料庫來訓練。

一個簡單的優化是基于馬爾科夫假設，下一個詞的出現僅與前面的一個或n個詞有關。

最簡單的情況，下一個詞的出現僅僅和前面一個詞有關，稱之為bigram。

p(S)=p(w1,w2,⋅⋅⋅,wn)=p(w1)⋅p(w2|w1)⋅p(w3|w2)⋅p(w4|w3)⋅⋅⋅p(wn|wn−1)p(S)=p(w1,w2,···,wn)=p(w1)·p(w2|w1)·p(w3|w2)·p(w4|w3)···p(wn|wn−1)

再復雜點，下一個詞的出現僅和前面兩個詞有關，稱之為trigram。

p(S)=p(w1,w2,⋅⋅⋅,wn)=p(w1)⋅p(w2|w1)⋅p(w3|w1,w2)⋅p(w4|w2,w3)⋅⋅⋅p(wn|wn−2,wn−1)p(S)=p(w1,w2,···,wn)=p(w1)·p(w2|w1)·p(w3|w1,w2)·p(w4|w2,w3)···p(wn|wn−2,wn−1)

這樣的條件概率雖然好求，但是會丟失大量的前面的詞的信息，有時會對結果產生不良影響。因此如何選擇一個有效的n，使得既能簡化計算，又能保留大部分的上下文信息。

以上均是傳統語言模型的描述。如果不太深究細節，我們的任務就是，知道前面n個詞，來計算下一個詞出現的概率。并且使用語言模型來生成新的文本。

在本文中，我們更加關注的是，如何使用RNN來推測下一個詞。

數據準備

TensorFlow的官方文檔使用的是Mikolov準備好的PTB數據集。我們可以將其下載并解壓出來：

$ wget http://www.fit.vutbr.cz/~imikolov/rnnlm/simple-examples.tgz 
$ tar xvf simple-examples.tgz

部分數據如下，不常用的詞轉換成了<unk>標記，數字轉換成了N：

we 're talking about years ago before anyone heard of asbestos having any questionable properties 
there is no asbestos in our products now 
neither <unk> nor the researchers who studied the workers were aware of any research on smokers of the kent cigarettes 
we have no useful information on whether users are at risk said james a. <unk> of boston 's <unk> cancer institute 
the total of N deaths from malignant <unk> lung cancer and <unk> was far higher than expected the researchers said

讀取文件中的數據，將換行符轉換為<eos>，然后轉換為詞的list：

def _read_words(filename): 
    with open(filename, 'r', encoding='utf-8') as f: 
        return f.read().replace('\n', '<eos>').split()

f = _read_words('simple-examples/data/ptb.train.txt') 
print(f[:20])

得到：

['aer', 'banknote', 'berlitz', 'calloway', 'centrust', 'cluett', 'fromstein', 'gitano', 'guterman', 'hydro-quebec', 'ipo', 'kia', 'memotec', 'mlx', 'nahb', 'punts', 'rake', 'regatta', 'rubens', 'sim']

構建詞匯表，詞與id互轉：

def _build_vocab(filename): 
    data = _read_words(filename) 
 
    counter = Counter(data) 
    count_pairs = sorted(counter.items(), key=lambda x: -x[1]) 
 
    words, _ = list(zip(*count_pairs)) 
    word_to_id = dict(zip(words, range(len(words)))) 
 
    return words, word_to_id

words, words_to_id = _build_vocab('simple-examples/data/ptb.train.txt') 
print(words[:10]) 
print(list(map(lambda x: words_to_id[x], words[:10])))

輸出：

('the', '<unk>', '<eos>', 'N', 'of', 'to', 'a', 'in', 'and', "'s") 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

將一個文件轉換為id表示：

def _file_to_word_ids(filename, word_to_id): 
    data = _read_words(filename) 
    return [word_to_id[x] for x in data if x in word_to_id]

words_in_file = _file_to_word_ids('simple-examples/data/ptb.train.txt', words_to_id) 
print(words_in_file[:20])

詞匯表已根據詞頻進行排序，由于第一句話非英文，所以id靠后。

[9980, 9988, 9981, 9989, 9970, 9998, 9971, 9979, 9992, 9997, 9982, 9972, 9993, 9991, 9978, 9983, 9974, 9986, 9999, 9990]

將一句話從id列表轉換回詞：

def to_words(sentence, words): 
    return list(map(lambda x: words[x], sentence))

將以上函數整合：

def ptb_raw_data(data_path=None): 
    train_path = os.path.join(data_path, 'ptb.train.txt') 
    valid_path = os.path.join(data_path, 'ptb.valid.txt') 
    test_path = os.path.join(data_path, 'ptb.test.txt') 
 
    words, word_to_id = _build_vocab(train_path) 
    train_data = _file_to_word_ids(train_path, word_to_id) 
    valid_data = _file_to_word_ids(valid_path, word_to_id) 
    test_data = _file_to_word_ids(test_path, word_to_id) 
 
    return train_data, valid_data, test_data, words, word_to_id

以上部分和官方的例子有一定的相似之處。接下來的處理和官方存在很大的不同，主要參考了Keras例程處理文檔的操作：

def ptb_producer(raw_data, batch_size=64, num_steps=20, stride=1): 
    data_len = len(raw_data) 
 
    sentences = [] 
    next_words = [] 
    for i in range(0, data_len - num_steps, stride): 
        sentences.append(raw_data[i:(i + num_steps)]) 
        next_words.append(raw_data[i + num_steps]) 
 
    sentences = np.array(sentences) 
    next_words = np.array(next_words) 
 
    batch_len = len(sentences) // batch_size 
    x = np.reshape(sentences[:(batch_len * batch_size)], \ 
        [batch_len, batch_size, -1]) 
 
    y = np.reshape(next_words[:(batch_len * batch_size)], \ 
        [batch_len, batch_size]) 
 
    return x, y

參數解析：

raw_data: 即ptb_raw_data()函數產生的數據
batch_size: 神經網絡使用隨機梯度下降，數據按多個批次輸出，此為每個批次的數據量
num_steps: 每個句子的長度，相當于之前描述的n的大小，這在循環神經網絡中又稱為時序的長度。
stride: 取數據的步長，決定數據量的大小。

代碼解析：

這個函數將一個原始數據list轉換為多個批次的數據，即[batch_len, batch_size, num_steps]。

首先，程序每一次取了num_steps個詞作為一個句子，即x，以這num_steps個詞后面的一個詞作為它的下一個預測，即為y。這樣，我們首先把原始數據整理成了batch_len * batch_size個x和y的表示，類似于已知x求y的分類問題。

為了滿足隨機梯度下降的需要，我們還需要把數據整理成一個個小的批次，每次喂一個批次的數據給TensorFlow來更新權重，這樣，數據就整理為[batch_len, batch_size, num_steps]的格式。

打印部分數據：

train_data, valid_data, test_data, words, word_to_id = ptb_raw_data('simple-examples/data') 
x_train, y_train = ptb_producer(train_data) 
print(x_train.shape) 
print(y_train.shape)

輸出：

(14524, 64, 20) 
(14524, 64)

可見我們得到了14524個批次的數據，每個批次的訓練集維度為[64, 20]。

print(' '.join(to_words(x_train[100, 3], words)))

第100個批次的第3句話為：

despite steady sales growth <eos> magna recently cut its quarterly dividend in half and the company 's class a shares

print(words[np.argmax(y_train[100, 3])])

它的下一個詞為：

the

構建模型

配置項

class LMConfig(object): 
    """language model 配置項""" 
    batch_size = 64       # 每一批數據的大小 
    num_steps = 20        # 每一個句子的長度 
    stride = 3            # 取數據時的步長 
 
    embedding_dim = 64    # 詞向量維度 
    hidden_dim = 128      # RNN隱藏層維度 
    num_layers = 2        # RNN層數 
 
    learning_rate = 0.05  # 學習率 
    dropout = 0.2         # 每一層后的丟棄概率

讀取輸入

讓模型可以按批次的讀取數據。

class PTBInput(object): 
    """按批次讀取數據""" 
    def __init__(self, config, data): 
        self.batch_size = config.batch_size 
        self.num_steps = config.num_steps 
        self.vocab_size = config.vocab_size # 詞匯表大小 
 
        self.input_data, self.targets = ptb_producer(data, 
            self.batch_size, self.num_steps) 
 
        self.batch_len = self.input_data.shape[0] # 總批次 
        self.cur_batch = 0  # 當前批次 
 
    def next_batch(self): 
        """讀取下一批次""" 
        x = self.input_data[self.cur_batch] 
        y = self.targets[self.cur_batch] 
 
        # 轉換為one-hot編碼 
        y_ = np.zeros((y.shape[0], self.vocab_size), dtype=np.bool) 
        for i in range(y.shape[0]): 
            y_[i][y[i]] = 1 
 
        # 如果到最后一個批次，則回到最開頭 
        self.cur_batch = (self.cur_batch +1) % self.batch_len 
 
        return x, y_

模型

class PTBModel(object): 
    def __init__(self, config, is_training=True): 
 
        self.num_steps = config.num_steps 
        self.vocab_size = config.vocab_size 
 
        self.embedding_dim = config.embedding_dim 
        self.hidden_dim = config.hidden_dim 
        self.num_layers = config.num_layers 
        self.rnn_model = config.rnn_model 
 
        self.learning_rate = config.learning_rate 
        self.dropout = config.dropout 
 
        self.placeholders()  # 輸入占位符 
        self.rnn()           # rnn 模型構建 
        self.cost()          # 代價函數 
        self.optimize()      # 優化器 
        self.error()         # 錯誤率 
 
 
    def placeholders(self): 
        """輸入數據的占位符""" 
        self._inputs = tf.placeholder(tf.int32, [None, self.num_steps]) 
        self._targets = tf.placeholder(tf.int32, [None, self.vocab_size]) 
 
 
    def input_embedding(self): 
        """將輸入轉換為詞向量表示""" 
        with tf.device("/cpu:0"): 
            embedding = tf.get_variable( 
                "embedding", [self.vocab_size, 
                    self.embedding_dim], dtype=tf.float32) 
            _inputs = tf.nn.embedding_lookup(embedding, self._inputs) 
 
        return _inputs 
 
 
    def rnn(self): 
        """rnn模型構建""" 
        def lstm_cell():  # 基本的lstm cell 
            return tf.contrib.rnn.BasicLSTMCell(self.hidden_dim, 
                state_is_tuple=True) 
 
        def gru_cell():   # gru cell，速度更快 
            return tf.contrib.rnn.GRUCell(self.hidden_dim) 
 
        def dropout_cell():    # 在每個cell后添加dropout 
            if (self.rnn_model == 'lstm'): 
                cell = lstm_cell() 
            else: 
                cell = gru_cell() 
            return tf.contrib.rnn.DropoutWrapper(cell, 
                output_keep_prob=self.dropout) 
 
        cells = [dropout_cell() for _ in range(self.num_layers)] 
        cell = tf.contrib.rnn.MultiRNNCell(cells, state_is_tuple=True)  # 多層rnn 
 
        _inputs = self.input_embedding() 
        _outputs, _ = tf.nn.dynamic_rnn(cell=cell, 
            inputs=_inputs, dtype=tf.float32) 
 
        # _outputs的shape為 [batch_size, num_steps, hidden_dim] 
        last = _outputs[:, -1, :]  # 只需要最后一個輸出 
 
        # dense 和 softmax 用于分類，以找出各詞的概率 
        logits = tf.layers.dense(inputs=last, units=self.vocab_size)    
        prediction = tf.nn.softmax(logits)   
 
        self._logits = logits 
        self._pred = prediction 
 
    def cost(self): 
        """計算交叉熵代價函數""" 
        cross_entropy = tf.nn.softmax_cross_entropy_with_logits( 
            logits=self._logits, labels=self._targets) 
        cost = tf.reduce_mean(cross_entropy) 
        self.cost = cost 
 
    def optimize(self): 
        """使用adam優化器""" 
        optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate) 
        self.optim = optimizer.minimize(self.cost) 
 
    def error(self): 
        """計算錯誤率""" 
        mistakes = tf.not_equal( 
            tf.argmax(self._targets, 1), tf.argmax(self._pred, 1)) 
        self.errors = tf.reduce_mean(tf.cast(mistakes, tf.float32))

訓練

def run_epoch(num_epochs=10): 
    config = LMConfig()   # 載入配置項 
 
    # 載入源數據，這里只需要訓練集 
    train_data, _, _, words, word_to_id = \ 
        ptb_raw_data('simple-examples/data') 
    config.vocab_size = len(words) 
 
    # 數據分批 
    input_train = PTBInput(config, train_data) 
    batch_len = input_train.batch_len 
 
    # 構建模型 
    model = PTBModel(config) 
 
    # 創建session，初始化變量 
    sess = tf.Session() 
    sess.run(tf.global_variables_initializer()) 
 
    print('Start training...') 
    for epoch in range(num_epochs):  # 迭代輪次 
        for i in range(batch_len):   # 經過多少個batch 
            x_batch, y_batch = input_train.next_batch() 
 
            # 取一個批次的數據，運行優化 
            feed_dict = {model._inputs: x_batch, model._targets: y_batch} 
            sess.run(model.optim, feed_dict=feed_dict) 
 
            # 每500個batch，輸出一次中間結果 
            if i % 500 == 0: 
                cost = sess.run(model.cost, feed_dict=feed_dict) 
 
                msg = "Epoch: {0:>3}, batch: {1:>6}, Loss: {2:>6.3}" 
                print(msg.format(epoch + 1, i + 1, cost)) 
 
                # 輸出部分預測結果 
                pred = sess.run(model._pred, feed_dict=feed_dict) 
                word_ids = sess.run(tf.argmax(pred, 1)) 
                print('Predicted:', ' '.join(words[w] for w in word_ids)) 
                true_ids = np.argmax(y_batch, 1) 
                print('True:', ' '.join(words[w] for w in true_ids)) 
 
    print('Finish training...') 
    sess.close()

需要經過多次的訓練才能得到一個較為合理的結果。

責任編輯：龐桂玉來源： 36大數據

TensorFlow 深度學習神經網絡