一、介紹
1.1 文章組織
本文簡要介紹了BiLSTM的基本原理，並以句子級情感分類任務為例介紹為什麼需要使用LSTM或BiLSTM進行建模。在文章的最後，我們給出在PyTorch下BiLSTM的實現程式碼，供讀者參考。
1.2 情感分類任務
自然語言處理中情感分類任務是對給定文字進行情感傾向分類的任務，粗略來看可以認為其是分類任務中的一類。對於情感分類任務，目前通常的做法是先對詞或者短語進行表示，再通過某種組合方式把句子中詞的表示組合成句子的表示。最後，利用句子的表示對句子進行情感分類。
舉一個對句子進行褒貶二分類的例子。
句子：我愛賽爾
情感標籤：褒義
1.3 什麼是LSTM和BiLSTM？
LSTM的全稱是Long Short-Term Memory，它是RNN（Recurrent Neural Network）的一種。LSTM由於其設計的特點，非常適合用於對時序資料的建模，如文字資料。BiLSTM是Bi-directional Long Short-Term Memory的縮寫，是由前向LSTM與後向LSTM組合而成。兩者在自然語言處理任務中都常被用來建模上下文資訊。
1.4 為什麼使用LSTM與BiLSTM？
將詞的表示組合成句子的表示，可以採用相加的方法，即將所有詞的表示進行加和，或者取平均等方法，但是這些方法沒有考慮到詞語在句子中前後順序。如句子“我不覺得他好”。“不”字是對後面“好”的否定，即該句子的情感極性是貶義。使用LSTM模型可以更好的捕捉到較長距離的依賴關係。因為LSTM通過訓練過程可以學到記憶哪些資訊和遺忘哪些資訊。
但是利用LSTM對句子進行建模還存在一個問題：無法編碼從後到前的資訊。在更細粒度的分類時，如對於強程度的褒義、弱程度的褒義、中性、弱程度的貶義、強程度的貶義的五分類任務需要注意情感詞、程度詞、否定詞之間的互動。舉一個例子，“這個餐廳髒得不行，沒有隔壁好”，這裡的“不行”是對“髒”的程度的一種修飾，通過BiLSTM可以更好的捕捉雙向的語義依賴。
二、BiLSTM原理簡介
2.1 LSTM介紹
2.1.1 總體框架
LSTM模型是由時刻的輸入詞
，細胞狀態
，臨時細胞狀態
，隱層狀態
，遺忘門
，記憶門
，輸出門
組成。LSTM的計算過程可以概括為，通過對細胞狀態中資訊遺忘和記憶新的資訊使得對後續時刻計算有用的資訊得以傳遞，而無用的資訊被丟棄，並在每個時間步都會輸出隱層狀態
，其中遺忘，記憶與輸出由通過上個時刻的隱層狀態
和當前輸入
計算出來的遺忘門
，記憶門
，輸出門
來控制。
總體框架如圖1所示。
圖1. LSTM總體框架
2.1.2 詳細介紹計算過程
計算遺忘門，選擇要遺忘的資訊。
輸入：前一時刻的隱層狀態
，當前時刻的輸入詞
輸出：遺忘門的值
圖2. 計算遺忘門
計算記憶門，選擇要記憶的資訊。
輸入：前一時刻的隱層狀態
輸出：記憶門的值
，臨時細胞狀態
圖3. 計算記憶門和臨時細胞狀態
計算當前時刻細胞狀態
輸入：記憶門的值
，臨時細胞狀態
，上一刻細胞狀態
輸出：當前時刻細胞狀態
圖4. 計算當前時刻細胞狀態計算輸出門和當前時刻隱層狀態
輸入：前一時刻的隱層狀態
，當前時刻細胞狀態
輸出：輸出門的值
，隱層狀態
圖5. 計算輸出門和當前時刻隱層狀態
最終，我們可以得到與句子長度相同的隱層狀態序列{,
, ...,
}。
2.2 BiLSTM介紹
前向的LSTM與後向的LSTM結合成BiLSTM。比如，我們對“我愛中國”這句話進行編碼，模型如圖6所示。
圖6. 雙向LSTM編碼句子前向的依次輸入“我”，“愛”，“中國”得到三個向量{
,
,
}。後向的
依次輸入“中國”，“愛”，“我”得到三個向量{
,
,
}。最後將前向和後向的隱向量進行拼接得到{[
,
], [
,
], [
,
]}，即{
,
,
}。
對於情感分類任務來說，我們採用的句子的表示往往是[,
]。因為其包含了前向與後向的所有資訊，如圖7所示。
圖7. 拼接向量用於情感分類
三、BiLSTM程式碼實現樣例
3.1 模型搭建
使用PyTorch搭建BiLSTM樣例程式碼。程式碼地址為https://github.com/albertwy/BiLSTM/。
class BLSTM(nn.Module):
"""
Implementation of BLSTM Concatenation for sentiment classification task
"""
def __init__(self, embeddings, input_dim, hidden_dim, num_layers, output_dim, max_len=40, dropout=0.5):
super(BLSTM, self).__init__()
self.emb = nn.Embedding(num_embeddings=embeddings.size(0),
embedding_dim=embeddings.size(1),
padding_idx=0)
self.emb.weight = nn.Parameter(embeddings)
self.input_dim = input_dim
self.hidden_dim = hidden_dim
self.output_dim = output_dim
# sen encoder
self.sen_len = max_len
self.sen_rnn = nn.LSTM(input_size=input_dim,
hidden_size=hidden_dim,
num_layers=num_layers,
dropout=dropout,
batch_first=True,
bidirectional=True)
self.output = nn.Linear(2 * self.hidden_dim, output_dim)
def bi_fetch(self, rnn_outs, seq_lengths, batch_size, max_len):
rnn_outs = rnn_outs.view(batch_size, max_len, 2, -1)
# (batch_size, max_len, 1, -1)
fw_out = torch.index_select(rnn_outs, 2, Variable(torch.LongTensor([0])).cuda())
fw_out = fw_out.view(batch_size * max_len, -1)
bw_out = torch.index_select(rnn_outs, 2, Variable(torch.LongTensor([1])).cuda())
bw_out = bw_out.view(batch_size * max_len, -1)
batch_range = Variable(torch.LongTensor(range(batch_size))).cuda() * max_len
batch_zeros = Variable(torch.zeros(batch_size).long()).cuda()
fw_index = batch_range + seq_lengths.view(batch_size) - 1
fw_out = torch.index_select(fw_out, 0, fw_index) # (batch_size, hid)
bw_index = batch_range + batch_zeros
bw_out = torch.index_select(bw_out, 0, bw_index)
outs = torch.cat([fw_out, bw_out], dim=1)
return outs
def forward(self, sen_batch, sen_lengths, sen_mask_matrix):
"""
:param sen_batch: (batch, sen_length), tensor for sentence sequence
:param sen_lengths:
:param sen_mask_matrix:
:return:
"""
''' Embedding Layer | Padding | Sequence_length 40'''
sen_batch = self.emb(sen_batch)
batch_size = len(sen_batch)
''' Bi-LSTM Computation '''
sen_outs, _ = self.sen_rnn(sen_batch.view(batch_size, -1, self.input_dim))
sen_rnn = sen_outs.contiguous().view(batch_size, -1, 2 * self.hidden_dim) # (batch, sen_len, 2*hid)
''' Fetch the truly last hidden layer of both sides
'''
sentence_batch = self.bi_fetch(sen_rnn, sen_lengths, batch_size, self.sen_len) # (batch_size, 2*hid)
representation = sentence_batch
out = self.output(representation)
out_prob = F.softmax(out.view(batch_size, -1))
return out_prob
__init__()函式中對網路進行初始化，設定詞向量維度，前向/後向LSTM中隱層向量的維度，還有要分類的類別數等。
bi_fetch()函式的作用是將與
拼接起來並返回拼接後的向量。由於使用了batch，所以需要使用句子長度用來定位開始padding時前一個時刻的輸出的隱層向量。
forward()函式裡進行前向計算，得到各個類別的概率值。
3.2 模型訓練
def train(model, training_data, args, optimizer, criterion):
model.train()
batch_size = args.batch_size
sentences, sentences_seqlen, sentences_mask, labels = training_data
# print batch_size, len(sentences), len(labels)
assert batch_size == len(sentences) == len(labels)
''' Prepare data and prediction'''
sentences_, sentences_seqlen_, sentences_mask_ = \
var_batch(args, batch_size, sentences, sentences_seqlen, sentences_mask)
labels_ = Variable(torch.LongTensor(labels))
if args.cuda:
labels_ = labels_.cuda()
assert len(sentences) == len(labels)
model.zero_grad()
probs = model(sentences_, sentences_seqlen_, sentences_mask_)
loss = criterion(probs.view(len(labels_), -1), labels_)
loss.backward()
optimizer.step()
程式碼中training_data是一個batch的資料，其中包括輸入的句子sentences（句子中每個詞以詞下標表示），輸入句子的長度sentences_seqlen，輸入的句子對應的情感類別labels。 訓練模型前，先清空遺留的梯度值，再根據該batch資料計算出來的梯度進行更新模型。
model.zero_grad()
probs = model(sentences_, sentences_seqlen_, sentences_mask_)
loss = criterion(probs.view(len(labels_), -1), labels_)
loss.backward()
optimizer.step()
3.3 模型測試
以下是進行模型測試的程式碼。
def test(model, dataset, args, data_part="test"):
"""
:param model:
:param args:
:param dataset:
:param data_part:
:return:
"""
tvt_set = dataset[data_part]
tvt_set = yutils.YDataset(tvt_set["xIndexes"],
tvt_set["yLabels"],
to_pad=True, max_len=args.sen_max_len)
test_set = tvt_set
sentences, sentences_seqlen, sentences_mask, labels = test_set.next_batch(len(test_set))
assert len(test_set) == len(sentences) == len(labels)
tic = time.time()
model.eval()
''' Prepare data and prediction'''
batch_size = len(sentences)
sentences_, sentences_seqlen_, sentences_mask_ = \
var_batch(args, batch_size, sentences, sentences_seqlen, sentences_mask)
probs = model(sentences_, sentences_seqlen_, sentences_mask_)
_, pred = torch.max(probs, dim=1)
if args.cuda:
pred = pred.view(-1).cpu().data.numpy()
else:
pred = pred.view(-1).data.numpy()
tit = time.time() - tic
print " Predicting {:d} examples using {:5.4f} seconds".format(len(test_set), tit)
labels = numpy.asarray(labels)
''' log and return prf scores '''
accuracy = test_prf(pred, labels)
return accuracy
def cal_prf(pred, right, gold, formation=True, metric_type=""):
"""
:param pred: predicted labels
:param right: predicting right labels
:param gold: gold labels
:param formation: whether format the float to 6 digits
:param metric_type:
:return: prf for each label
"""
num_class = len(pred)
precision = [0.0] * num_class
recall = [0.0] * num_class
f1_score = [0.0] * num_class
for i in xrange(num_class):
''' cal precision for each class: right / predict '''
precision[i] = 0 if pred[i] == 0 else 1.0 * right[i] / pred[i]
''' cal recall for each class: right / gold '''
recall[i] = 0 if gold[i] == 0 else 1.0 * right[i] / gold[i]
''' cal recall for each class: 2 pr / (p+r) '''
f1_score[i] = 0 if precision[i] == 0 or recall[i] == 0 \
else 2.0 * (precision[i] * recall[i]) / (precision[i] + recall[i])
if formation:
precision[i] = precision[i].__format__(".6f")
recall[i] = recall[i].__format__(".6f")
f1_score[i] = f1_score[i].__format__(".6f")
''' PRF for each label or PRF for all labels '''
if metric_type == "macro":
precision = sum(precision) / len(precision)
recall = sum(recall) / len(recall)
f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
elif metric_type == "micro":
precision = 1.0 * sum(right) / sum(pred) if sum(pred) > 0 else 0
recall = 1.0 * sum(right) / sum(gold) if sum(recall) > 0 else 0
f1_score = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0
return precision, recall, f1_score
四、總結
本文中，我們結合情感分類任務介紹了LSTM以及BiLSTM的基本原理，並給出一個BiLSTM樣例程式碼。除了情感分類任務，LSTM與BiLSTM在自然語言處理領域的其它任務上也得到了廣泛應用，如機器翻譯任務中使用其進行源語言的編碼和目標語言的解碼，機器閱讀理解任務中使用其對文章和問題的編碼等。