運用TensorFlow處理簡單的NLP問題

時間 2019-11-17

標籤運用 tensorflow 處理簡單 nlp 問題简体版

原文原文鏈接

當前「人工智能」是繼「大數據」後又一個即將被毀的詞，每家公司都宣稱要發力人工智能，就跟4-5年前大數據同樣，業界叫的都很是響亮，不由想到以前一個老外說過的話：php

Big Data is like teenage sex: Everyone talks about it, nobody really knows how to do it, everyone thinks everyone else is doing it, so everyone claims.html

如今看來，上面的」Big Data」能夠換成」AI」了，在你們還沒搞明白大數據的時候，人工智能就開始引領下一個潮流了。本着跟風的態度，我也嘗試去窺探個究竟。git

引言

當前不管是學術界仍是工業界，深度學習都受到極大的追捧，尤爲是在Google開源深度學習平臺TensorFlow以後，更是給深度學習火上澆油。目前在開源社區Github上全部開源項目中，TensorFlow最爲活躍，從推出到如今，經歷了幾個版本的演進，能夠說可以靈活高效地解決大量實際問題。本文主要嘗試闡述TensorFlow在天然語言處理(NLP)領域的簡單應用，讓你們夥兒更加感性地認識TensorFlow。github

說到NLP，其實我對它並非很熟悉，以前也不曾有過NLP的相關經驗，本文是我最近學習TensorFlow的一些積累，就當拋磚引玉了。當前互聯網天天都在產生大量的文本和音頻數據，經過挖掘這些數據，咱們能夠作一些更加便捷的應用，例如機器翻譯、語音識別、詞性標註以及信息檢索等，這些都屬於NLP範疇。而在NLP領域中，語言模型是最基本的一個環節，本文主要圍繞語言模型展開，首先介紹其基本原理，進而引出詞向量(word2vec)、循環神經網絡(RNN)、長短時記憶網絡(LSTM)等深度學習相關模型，並詳細介紹如何利用 TensorFlow 實現上述模型。算法

語言模型

語言模型是一種機率模型，它是基於一個語料庫建立，獲得每一個句子出現的機率，通俗一點講就是看一句話是否是正常人說出來的，數學上表示爲:api

P (W) = P (w 1 w 2 \dots w t) = P (w 1) P (w 2 | w 1) P (w 3

上述公式的意義是：一個句子出現的機率等於給定前面的詞狀況下，緊接着後面的詞出現的機率。它是經過條件機率公式展開獲得。其中條件機率 $P (w_{2} | w_{1}), P (w_{3} | w_{1} w_{2}), \dots, P (w_{t} | w_{1} w_{2} \dots w_{t - 1})$ 網絡

P (w t | w 1 w 2 \dots w t - 1) = P ( w 1 w 2 \dots w t ) P (

根據大數定理上述公式又能夠近似爲：session

P (w t | w 1 w 2 \dots w t - 1) = c o u n t ( w 1 w 2 \dots w t )

假如語料庫裏有 $N$ 架構

P (w t | w 1 w 2 \dots w t - 1) \approx P (w t | w t - n + 1 \dots w

這意思就是說一個詞出現的機率只與它前面 $n - 1$ app

近年也流行起神經網絡語言模型，從機器學習的角度來看，一開始不所有計算這些詞串的機率值，而是經過一個模型對詞串的機率進行建模，而後構造一個目標函數，不斷優化這個目標，獲得一組優化的參數，當須要哪一個詞串機率時，利用這組優化的參數直接計算獲得對應的詞串機率。將詞串機率 $P (w | c o n t e x t (w))$

P (w | c o n t e x t (w)) = F (w, c o n t e x t (w), Θ) (2-5)

目標函數採用對數似然函數，表示以下(其中 $N$

O b j = 1 N \sum i = 1 N l o g P ( w i | c o n t e x t i ) (2-6)

經過優化算法不斷最小化目標函數獲得一組優化的參數 $Θ$

上述神經網絡包括輸入層、投影層、隱藏層以及輸出層，其中投影層只是對輸入層作了一個預處理，將輸入的全部詞進行一個鏈接操做，假如一個詞表示爲 $m$

Z Y = σ (W X + p) = U Z + q (2-7)

其中 $σ$

詞向量(word2vec)

詞向量要作的事就是將語言數學化表示，以往的作法是採用 One-hot Representation 表示一個詞，即語料庫詞典中有 $N$

詞被映射到3維空間，每一個詞表示爲一個3維向量，相近的詞離的較近，能夠看到兩組差很少關係的詞，他們之間的詞向量距離也差很少。

要想獲得詞向量，須要藉助語言模型訓練獲得，本質上來講，詞向量是在訓練語言模型過程當中獲得的副產品。解決word2vec問題有兩種模型，即 CBOW 和 Skip-Gram 模型[3]，以下圖所示：

CBOW 模型是根據詞的上下文預測當前詞，這裏的上下文是由待預測詞的先後 $c$

Skip-Gram 模型

前面也提到， Skip-Gram 模型是根據當前詞去預測上下文，例若有以下語句：

「php 是世界上最好的語言」

假定上下文是由待預測詞的先後2個詞組成，那麼由以上句子能夠獲得以下正樣本：

(世界上, 是), (世界上, php), (世界上, 最好的), (世界上, 語言), (最好的, 世界上), …

訓練目標爲最大化如下對數似然函數：

O b j = 1 N \sum i = 1 N \sum - c ⩽ j ⩽ c , j \neq 0 l o g p ( w i +

其中 $c$

p (w O | w I) = e x p ( θ w O T v w I ) \sum

其中 $v_{w}$

O b j = l o g σ (θ w O T v w I) + \sum j = 1 k E

以上表達式稱之爲 NCE(Noise-contrastive estimation)[4]目標函數，其中等號右邊第二項表示經過一個服從 $P_{n} (w)$

負採樣算法

詞典中的每一個詞在語料庫中出現的頻次有高有低，理論上來講，對於那些高頻詞，被選爲負樣本的機率較大，對於那些低頻詞，被選爲負樣本的機率較小。基於這個基本事實，能夠經過帶權採樣方法來實現，假設每一個詞的詞頻表示爲單位線段上的一小分段，對於詞典大小爲 $N$

文[2]中在實際負採樣計算詞頻時，作了一點修正，不是簡單的統計詞的出現次數，而是對詞的出現次數作了 $α$

f r e q (w) = [ c o u n t e r ( w ) ] 3 / 4 \sum u \in W [ c o u n

高頻詞二次採樣

在一個大語料庫中，不少常見的詞大量出現，如「的」、「是」等。這些詞雖然詞頻較高，可是能提供的有用信息卻不多。通常來講，這些高頻詞的詞向量在訓練幾百萬樣本後基本不會有太大的變化，爲了提升訓練速度，平衡低頻詞和高頻詞，文[2]中提出一種針對高頻詞二次採樣的技巧，對於每一個詞，按以下機率丟棄而不作訓練。

P (w i) = 1 - t f ( w i )-----\sqrt (3-5)

其中 $f (w_{i})$

TensorFlow實現

根據以上實現原理，下面結合代碼闡述利用TensorFlow實現一個簡易的word2vec模型[5]，藉助TensorFlow豐富的api以及強大的計算引擎，咱們能夠很是方便地表達模型。給定語料庫做爲訓練數據，首先掃描語料庫創建字典，爲每一個詞編號，同時將那些詞頻低於min_count的詞過濾掉，即不對那些陌生詞生成詞向量。對於一個樣本(「世界上」, 「php」)，利用負採樣獲得若干負實例，分別計算輸入詞爲「世界上」到「php」以及若干負樣本的logit值，最後經過交叉熵公式獲得目標函數(3-3)。

構建計算流圖

首先定義詞向量矩陣，也稱爲 embedding matrix，這個是咱們須要經過訓練獲得的詞向量，其中vocabulary_size表示詞典大小，embedding_size表示詞向量的維度，那麼詞向量矩陣爲 vocabulary_size $\times$

1 2	embeddings = tf.Variable( tf.random_uniform([vocabulary_size, embedding_size], -1.0, 1.0))

定義權值矩陣和偏置向量（對應於3-3式中的 $θ$

weights = tf.Variable(
 tf.truncated_normal([vocabulary_size, embedding_size],
 stddev=1.0 / math.sqrt(embedding_size)))
biases = tf.Variable(tf.zeros([vocabulary_size]))

給定一個batch的輸入，從詞向量矩陣中找到對應的向量表示，以及從權值矩陣和偏置向量中找到對應正確輸出的參數，其中examples是輸入詞，labels爲對應的正確輸出，一維向量表示，每一個元素爲詞在字典中編號：

# Embeddings for examples: [batch_size, embedding_size]
example_emb = tf.nn.embedding_lookup(embeddings, examples)
# Weights for labels: [batch_size, embedding_size]
true_w = tf.nn.embedding_lookup(weights, labels)
# Biases for labels: [batch_size, 1]
true_b = tf.nn.embedding_lookup(biases, labels)

負採樣獲得若干非正確的輸出，其中labels_matrix爲正確的輸出詞，採樣的時候會跳過這些詞，num_sampled爲採樣個數，distortion即爲公式(3-4)中的冪指數：

labels_matrix = tf.reshape(
 tf.cast(labels,
 dtype=tf.int64),
 [batch_size, 1])
# Negative sampling.
sampled_ids, _, _ = tf.nn.fixed_unigram_candidate_sampler(
 true_classes=labels_matrix,
 num_true=1,
 num_sampled=num_samples,
 unique=True,
 range_max=vocab_size,
 distortion=0.75,
 unigrams=vocab_counts.tolist())

找到採樣樣本對應的權值和偏置參數：

# Weights for sampled ids: [num_sampled, embedding_size]
sampled_w = tf.nn.embedding_lookup(weights, sampled_ids)
# Biases for sampled ids: [num_sampled, 1]
sampled_b = tf.nn.embedding_lookup(biases, sampled_ids)

分別計算正確輸出和非正確輸出的logit值，即計算 $W X + b$

# True logits: [batch_size, 1]
true_logits = tf.reduce_sum(tf.mul(example_emb, true_w), 1) + true_b
# Sampled logits: [batch_size, num_sampled]
# We replicate sampled noise lables for all examples in the batch
# using the matmul.
sampled_b_vec = tf.reshape(sampled_b, [num_samples])
sampled_logits = tf.matmul(example_emb,
 sampled_w,
 transpose_b=True) + sampled_b_vec
# cross-entropy(logits, labels)
true_xent = tf.nn.sigmoid_cross_entropy_with_logits(
 true_logits, tf.ones_like(true_logits))
sampled_xent = tf.nn.sigmoid_cross_entropy_with_logits(
 sampled_logits, tf.zeros_like(sampled_logits))
# NCE-loss is the sum of the true and noise (sampled words)
# contributions, averaged over the batch.
loss = (tf.reduce_sum(true_xent) +
 tf.reduce_sum(sampled_xent)) / batch_size

訓練模型

計算流圖構建完畢後，咱們須要去優化目標函數。採用梯度降低逐步更新參數，首先須要肯定學習步長，隨着迭代進行，逐步減小學習步長，其中trained_words爲已訓練的詞數量，words_to_train爲全部待訓練的詞數量：

1 2	lr = init_learning_rate * tf.maximum( 0.0001, 1.0 - tf.cast(trained_words, tf.float32) / words_to_train)

定義優化算子，使用梯度降低訓練模型：

optimizer = tf.train.GradientDescentOptimizer(lr)
train = optimizer.minimize(loss,
 global_step=global_step,
 gate_gradients=optimizer.GATE_NONE)
session.run(train)

驗證詞向量

通過以上步驟後，便可獲得詞向量矩陣，即上述代碼中的變量embeddings，那麼如何驗證獲得的詞向量矩陣的好壞呢，Mikolov等人發現[2]，若是一對關係差很少的詞，其詞向量在空間中的連線近乎平行，以下圖所示。

爲此，給定基準測試集，其每行包含4個詞組成一個四元組 $(w_{1}, w_{2}, w_{3}, w_{4})$

V e c t o r (w 1) - V e c t o r (w 2) + V e c t o r (w 4) = V e c t o r (w 3)

循環神經網絡(RNN)

人類不是從腦子一片空白開始思考，當你讀一篇文章的時候，你會根據前文去理解下文，而不是每次看到一個詞後就忘掉它，理解下一個詞的時候又從頭開始。傳統的神經網絡模型是從輸入層到隱藏層再到輸出層，每層之間的節點是無鏈接的，這種普通的神經網絡不具有記憶功能，而循環神經網絡(Recurrent Neural Network，RNN)就是來解決這類問題，它具有記憶性，一般用於處理時間序列問題，在衆多NLP問題中，RNN取得了巨大成功以及普遍應用。

在RNN網絡中，一個序列當前的輸出除了與當前輸入有關之外，還與前面的輸出也有關，下圖爲RNN中一個單元的結構示意圖，圖片來源於文[7]。

上圖理解起來可能還不是很形象，根據時間序列將上圖平鋪展開獲得以下圖，其鏈式的特徵揭示了 RNN 本質上是與序列相關的，因此 RNN 對於這類數據來講是最天然的神經網絡架構。

然而 RNN 有一個缺點，雖然它能夠將以前的信息鏈接到當前的輸入上，可是若是當前輸入與以前的信息時間跨度很大，因爲梯度衰減等緣由，RNN 學習如此遠的信息的能力會降低，這個問題稱之爲長時間依賴（Long-Term Dependencies）問題。例如預測一句話「飛機在天上」下一個詞，可能不須要太多的上下文就能夠預測到下一個詞爲「飛」，這種狀況下，相關信息與要預測的詞之間的時間跨度很小，RNN 能夠很容易學到以前的信息。再好比預測「他來自法國，…，他會講」的下一個詞，從當前的信息來看，下一個詞多是一種語言，可是要想準確預測哪一種語言，就須要再去前文找信息了，因爲前文的「法國」離當前位置的時間跨度較大，RNN很難學到如此遠的信息。更多長時間依賴細節參考文[8]。幸運的是，有一種 RNN 變種，叫作長短時記憶網絡(Long Short Term Memory networks, LSTM)，能夠解決這個問題。

長短時記憶網絡(LSTM)

LSTM 是一種帶有選擇性記憶功能的 RNN，它能夠有效的解決長時間依賴問題，並能學習到以前的關鍵信息。以下圖所示爲 LSTM 展開後的示意圖。

相對於 RNN , LSTM 只是在每一個單元結構上作了改進，在 RNN 中，每一個單元結構只有單個激活函數，而 LSTM 中每一個單元結構更爲複雜，它增長了一條狀態線（圖中最上面的水平線），以記住從以前的輸入學到的信息，另外增長三個門(gate)來控制其該狀態，分別爲忘記門、輸入門和輸出門。忘記門的做用是選擇性地將以前不重要的信息丟掉，以便存儲新信息；輸入門是根據當前輸入學習到新信息而後更新當前狀態；輸出門則是結合當前輸入和當前狀態獲得一個輸出，該輸出除了做爲基本的輸出外，還會做爲下一個時刻的輸入。下面用數學的方式表達每一個門的意思。

忘記門，要丟掉的信息以下：

f t = σ (W f [h t - 1, x t] + b f) (5-1)

輸入門，要增長的信息以下：

i t C t ~ = σ (W i [h t - 1, x t] + b i)

那麼根據忘記門和輸入門，狀態更新以下：

C t = f t * C t - 1 + i t * C t ~ (5-3)

輸出門，獲得輸出信息以下：

o t h t = σ (W o [h t - 1, x t] + b o) = o

LSTM 單元輸入都是上一個時刻的輸出與當前時刻的輸入經過向量concat鏈接而獲得，基於這個輸入，利用sigmoid函數做爲三個門的篩選器，分別獲得 $f_{t}$

深層LSTM網絡

深度學習，其特色在於深，前面已經講述單層 LSTM 網絡結構，深層 LSTM 網絡其實就是將多層 LSTM 疊加，造成多個隱藏層，以下圖所示。

上圖中每一個 LSTM 單元內部結構以下圖所示，對於 $l$

根據上面的結構，能夠獲得 $l$

f i o g c l t h l t = σ (W f [h l -

其中 $c_{t - 1}^{l}$

正則化

然而，實踐證實大規模的 LSTM 網絡很容易過擬合，實際應用中，須要採起正則化方法來避免過擬合，神經網絡中常見的正則化方法是Dropout方法[11]，文[12]提出一種簡單高效的Dropout方法運用於 RNN/LTSM 網絡。以下圖所示，Dropout僅應用於虛線方向的輸入，即僅針對於上一層的輸出作Dropout。

根據上圖的Dropout策略，公式(5-5)能夠改寫成以下形式：

f i o g c l t h l t = σ (W f [D (h

其中 $D$

TensorFlow實現

根據前面所述的 LSTM 模型原理，實現以前提到的語言模型，即根據前文預測下一個詞，例如輸入「飛機在天上」預測下一個詞「飛」，使用 TensorFlow 來實現 LSTM 很是的方便，由於 TensorFlow 已經提供了基本的 LSTM 單元結構的Operation，其實現原理就是基於文[12]提出的帶Dropout的 LSTM 模型。完整代碼請參考ptb_word_lm.py

構建LSTM模型

利用TensorFlow提供的Operation，實現 LSTM 網絡很簡單，首先定義一個基本的 LSTM 單元，其中size爲 LSTM 單元的輸出維度，再對其添加Dropout，根據 LSTM 的層數num_layers獲得多層的 RNN 結構單元。

lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(size, forget_bias=0.0)
lstm_cell = tf.nn.rnn_cell.DropoutWrapper(
 lstm_cell, output_keep_prob=keep_prob)
cell = tf.nn.rnn_cell.MultiRNNCell([lstm_cell] * num_layers)

每次給定一個batch的輸入，將 LSTM 網絡的狀態初始化爲0。詞的輸入由詞向量表示，因此先定義一個embedding矩陣，這裏能夠不要關心它一開始有沒有，它會在訓練過程當中的慢慢獲得的，僅做爲訓練的副產品。假設LSTM網絡展開num_steps步，每一步給定一個batch的詞做爲輸入，通過 LSTM 單元處理後，狀態更新並獲得輸出，並經過softmax歸一化後計算損失函數。

initial_state = cell.zero_state(batch_size, tf.float32)
embedding = tf.get_variable("embedding", [vocab_size, size])
# input_data: [batch_size, num_steps]
# targets： [batch_size, num_steps]
input_data = tf.placeholder(tf.int32, [batch_size, num_steps])
targets = tf.placeholder(tf.int32, [batch_size, num_steps])
inputs = tf.nn.embedding_lookup(embedding, input_data)
outputs = []
for time_step in range(num_steps):
 (cell_output, state) = cell(inputs[:, time_step, :], state)
 outputs.append(cell_output)

output = tf.reshape(tf.concat(1, outputs), [-1, size])
softmax_w = tf.get_variable("softmax_w", [size, vocab_size])
softmax_b = tf.get_variable("softmax_b", [vocab_size])
logits = tf.matmul(output, softmax_w) + softmax_b

loss = tf.nn.seq2seq.sequence_loss_by_example(
 [logits],
 [tf.reshape(targets, [-1])],
 [tf.ones([batch_size * num_steps])])

訓練模型

簡單採用梯度降低優化上述損失函數，逐步迭代，直至最大迭代次數，獲得final_state，即爲LSTM所要學習的參數。

optimizer = tf.train.GradientDescentOptimizer(lr)
train_op = optimizer.minimize(loss)
for i in range(max_epoch):
 _, final_state = session.run([train_op, state],
 {input_data: x,
 targets: y})

驗證測試模型

模型訓練完畢後，咱們已經獲得LSTM網絡的狀態，給定輸入，通過LSTM網絡後便可獲得輸出了。

1 2	(cell_output, _) = cell(inputs, state) session.run(cell_output)

小結

在使用TensorFlow處理深度學習相關問題時，咱們不須要太關注其內部實現細節，只需把精力放到模型的構建上，利用TensorFlow已經提供的抽象單元結構就能夠構建靈活的模型。也偏偏正是由於TensorFlow的高度抽象化，有時讓人理解起來頗費勁。因此在咱們使用TensorFlow的過程當中，不要把問題細化的太深，一切數據當作Tensor便可，利用Tensor的操做符對其進行運算，不要在腦海裏想如何如何的運算細節等等，否則就會身陷囹圄。

參考文獻

[1]. Bengio Y, Schwenk H, Senécal J S, et al. Neural probabilistic language models[M]//Innovations in Machine Learning. Springer Berlin Heidelberg, 2006: 137-186.MLA.
[2]. Mikolov T, Sutskever I, Chen K, et al. Distributed representations of words and phrases and their compositionality[C]//Advances in neural information processing systems. 2013: 3111-3119.
[3]. Mikolov T, Le Q V, Sutskever I. Exploiting similarities among languages for machine translation[J]. arXiv preprint arXiv:1309.4168, 2013.
[4]. Gutmann M U, Hyvärinen A. Noise-contrastive estimation of unnormalized statistical models, with applications to natural image statistics[J]. The Journal of Machine Learning Research, 2012, 13(1): 307-361.
[5]. Vector Representations of Words. https://www.tensorflow.org/versions/r0.8/tutorials/word2vec/index.html#vector-representations-of-words
[6]. word2vec 中的數學原理詳解. http://www.cnblogs.com/peghoty/p/3857839.html
[7]. Understanding LSTM Networks. http://colah.github.io/posts/2015-08-Understanding-LSTMs/
[8]. Bengio Y, Simard P, Frasconi P. Learning long-term dependencies with gradient descent is difficult[J]. Neural Networks, IEEE Transactions on, 1994, 5(2): 157-166.
[9]. Graves A. Generating sequences with recurrent neural networks[J]. arXiv preprint arXiv:1308.0850, 2013.
[10]. Recurrent Neural Networks. https://www.tensorflow.org/versions/r0.8/tutorials/recurrent/index.html#recurrent-neural-networks
[11]. Srivastava N. Improving neural networks with dropout[D]. University of Toronto, 2013.
[12]. Zaremba W, Sutskever I, Vinyals O. Recurrent neural network regularization[J]. arXiv preprint arXiv:1409.2329, 2014.

轉載請註明出處，本文永久連接：http://sharkdtu.com/posts/nn-nlp.html

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。