代碼實現 MNLM

語言: CN / TW / HK

這篇文章呢在自然語言處理領域有里程碑意義,是 word embedding 的開山之作。今天我們就來複現一下這篇文章的代碼。

先回顧一下子模型結構

論文筆記看: https://xie.infoq.cn/article/c3ca7ece5b6d09131b66ab52f

論文原文看: ResearchGate:A Neural Probabilistic Language Model

論文講解視頻看: MNLM:A neural probabilistic language model_嗶哩嗶哩_bilibili

寫之前先回顧一下模型構造,知道構造才能知道要寫什麼嘛。

公式是:

  • y 是輸出

  • x 是輸入,之後會轉化為圖中的 C, 但是原文公式還用的 x 表示

  • d 是隱藏層的 bias

  • H 是輸入層到隱藏層的權重

  • U 是隱藏層到輸出層的權重

  • W 是 c 直接到輸出層的權重

  • b 是輸出層的 bias

解釋一下網絡是怎麼出來的

我們可以知道這是一個 有一個隱藏層的神經網絡 。 並且看一下上圖的註解,寫的是 是第 i 個單詞的 特徵向量 。所以輸入要進行 embedding 處理。

這裏我們還是要注意一點,就是雖然收入要經過一個 embedding 的處理,但是原公式中還是寫的輸入是 X。

注意我標紅的部分,這裏是輸入直接有一個到輸出的。

就是下圖紅框的部分。

去掉紅框剩下的就是常規的多層感知機,就不用多解釋了。

看一下論文原文部分:

這部分説了一下模型的參數設置,先是説了一下 W 和 x 這兩個量。x 是一個 word embedding 的矩陣。W 是一個初始化為 0 的矩陣。然後就是剩下的幾個參數説了一下參數的形狀。

代碼

模型代碼

然後就可以創建好我們的網絡了。

class NNLM(nn.Module):    def __init__(self):        super(NNLM, self).__init__()        self.C = nn.Embedding(n_class, m)        self.H = nn.Parameter(torch.randn(len_sen * m, n_hidden,requires_grad=True))        self.d = nn.Parameter(torch.randn(n_hidden))        self.U = nn.Parameter(torch.randn(n_hidden, n_class,requires_grad=True))        self.W = nn.Parameter(torch.zeros(len_sen * m, n_class,requires_grad=True))        self.b = nn.Parameter(torch.randn(n_class))
def forward(self, X): # X : [batch_size, len_sen] X = self.C(X) # X : [batch_size, len_sen, m] X = X.view(-1, len_sen * m) # [batch_size, len_sen * m] tanh = torch.tanh(self.d + X @ self.H) # [batch_size, n_hidden] output = self.b + X @ self.W + tanh @ self.U # [batch_size, n_class] return output

複製代碼

代碼解析:

  • __init__(self) 這部分是上面一些參數量。

  • self.C 是一個 embedding 操作。

  • 其餘的就是網絡中的參數。提到的 W 初始化為 0 矩陣,所以 W 那裏就用 torch.zeros ,其餘的就使用隨機初始化 torch.randn

  • forward(self, X) 就是設置前向傳播,

  • X = self.C(X) ,先將 X 進行一個 embedding 處理,然後再將結果還給 X。就對應了我們前面提到的,雖然要經過一個 embedding 處理,但是原公式中輸入還是用 X 表示的。

  • Tensor.view 函數是修改張量形狀的。 torch.Tensor.view — PyTorch 1.11.0 documentation 。修改維度之後就是將每個句子中每個單詞的 word embedding 向量拼接起來。

  • self.d + X @ self.H 這裏是輸入層的隱藏層的計算。

  • tanh = torch.tanh(self.d + X @ self.H) 計算結果要經過 tanh 的激活函數。這裏是將 tanh 激活函數計算之後的結果直接賦值給了一個叫 tanh 的變量。

  • output = self.b + X @ self.W + tanh @ self.U 然後是輸出層計算。這裏要注意輸出層的結果是有兩部分組成的。一部分是隱藏層傳過來的結果,一部分是輸入層傳過來的結果,二者相加之後才是隱藏層的計算。

維度解析:

從第十一行代碼開始,我在後面都標註了維度的。現在我們來解釋一下。

最開始 X 是輸入了幾個句子,然後每個句子有不同的長度。這裏你輸入幾個句子就是你的樣本數量,我們用 batch_size 表示。每個句子的長度用 len_sen 表示。

m 是 embedding 向量的長度。使用外號的向量表示一個單詞的時候,你的詞彙表有多長,你的表示向量就有多長。但是你現在使用特徵值來表示一個單詞。你僅需要設定你想表示的特徵向量的長度即可,這個 m 是可以自己設置的。因為這個代碼裏用到的數據比較簡單,所以你設置的小一點也沒有關係。我在這裏是設置為 3。

隱藏層的大小設置為 n_hidden 。詞彙表的長度是 n_class

  • 最開始你的輸入是一組句子嘛,所以你的輸入 X 的形狀應該是 [batch_size, len_sen]。此時矩陣的每一個元素都是一個單詞。

  • 經過第一步 embedding 計算之後,就會將其轉化為特徵向量表示。此時的 X 的形狀應該是[batch_size, len_sen, m]。因為原來你是一個元素,表示一個詞。現在變成了一個詞,用一個特徵向量來表示。所以就增加了一個維度來表示這個特徵向量。現在變成了一個三維矩陣。

  • 經過 Tensor.view 修改形狀。這裏是 X.view(-1, len_sen * m) 修改為二維矩陣,矩陣的第二維是 len_sen * m,第一維度自適應(-1 是自適應的意思)。意思就是把一個句子中不同單詞的表示做一個 concate,拼接起來。

  • tanh 這裏已經到了隱藏層了。所以輸入向量的長度會變成隱藏層的大小。這個隱藏層的大小 n_hidden 也是需要自己設置的。隱藏層大小決定網絡的質量。當然我們這裏數據量比較小,所以好不好其實隱藏層大小的影響根本就不大。一般隱藏層的大小遵循以下幾個規則。

  • 假設:

  • 輸入層大小為

  • 輸出層分為

  • 樣本數量為

  • 一個常數

  • 常見的觀點有隱藏層數量

  • c ( n + m ) s c [ 2 , 1 0 ]

  • c c [ 1 , 1 0 ]

  • n m

  • ……

  • 神經網絡中如何確定隱藏層的層數和大小_LolitaAnn的技術博客_51CTO博客

  • 在這裏我們就使用 。在我們的代碼裏輸入的長度就是 len_sen * m 。分類大小就是單詞表的長度 n_class 。計算之後 h 的大小為 14。

  • 此時的 tanh 維度為[batch_size, n_hidden]。

  • 輸出層形狀是[batch_size, n_class],輸出層要做的對每一個樣本計算最終獲得一個向量。這向量的長度和單詞表的長度一樣,以此指出預測結果在單詞表中的位置。

數據預處理部分的代碼

我們先要製作一個單詞表。這裏是一個最基礎的一個處理。用空格進行分詞,然後把所有的單詞都轉化成小寫放到單詞表中,再製作好對應的索引。

    sentences = ["The cat is walking in the bedroom",                 "A dog was running in a room",                 "The cat is running in a room",                 "A dog is walking in a bedroom",                 "The dog was walking in the room"]
word_list = " ".join(sentences).lower().split() word_list = list(set(word_list)) word_dict = {w: i for i, w in enumerate(word_list)} number_dict = {i: w for i, w in enumerate(word_list)}

複製代碼

  • 第七行代碼 word_list 是把數據集中的所有句子都用空格拼接起來。然後再將其轉化成小寫。然後再用空格將其分開,分成不同的詞。此時就得到了一個單詞列表。但是現在裏面會有很多重複的詞。

  • 第八行的代碼 word_list 先使用 set,把上面得到的那個列表轉換成一個集合,去掉重複的詞,然後再轉換回列表。

  • 第九行和第十行代碼就是使用枚舉創建單詞表的詞典。

因為給定的數據是一堆句子,我們要把它分開,分為輸入和輸出,我們在這裏做的一個任務是預測下一個詞。我們選擇用論文原文中的長度為 7 的句子,我們將前 6 個詞作為輸入來預測最後一個詞。所以數據預處理部分就是先將一個句子拆分成輸入和輸出。

def dataset():    input = []    target = []
for sen in sentences: word = sen.lower().split() # space tokenizer i = [word_dict[n] for n in word[:-1]] # create (1~n-1) as input t = word_dict[word[-1]] # create (n) as target, We usually call this 'casual language model'
input.append(i) target.append(t)
return input, target

複製代碼

這張代碼應該不用過多的解釋了,看一下這個輸出結果你們就能懂了。就是把每個樣本都處理好了之後,再拼接到一個矩陣裏面。

完整代碼

import torchimport torch.nn as nnimport torch.optim as optim
def dataset(): input = [] target = []
for sen in sentences: word = sen.lower().split() # space tokenizer i = [word_dict[n] for n in word[:-1]] # create (1~n-1) as input t = word_dict[word[-1]] # create (n) as target, We usually call this 'casual language model'
input.append(i) target.append(t)
return input, target
# Modelclass NNLM(nn.Module): def __init__(self): super(NNLM, self).__init__() self.C = nn.Embedding(n_class, m) self.H = nn.Parameter(torch.randn(len_sen * m, n_hidden,requires_grad=True)) self.d = nn.Parameter(torch.randn(n_hidden)) self.U = nn.Parameter(torch.randn(n_hidden, n_class,requires_grad=True)) self.W = nn.Parameter(torch.zeros(len_sen * m, n_class,requires_grad=True)) self.b = nn.Parameter(torch.randn(n_class))
def forward(self, X): # X : [batch_size, len_sen, m] X = self.C(X) # X : [batch_size, len_sen, m] X = X.view(-1, len_sen * m) # [batch_size, len_sen * m] tanh = torch.tanh(self.d + X @ self.H) # [batch_size, n_hidden] output = self.b + X @ self.W + tanh @ self.U # [batch_size, n_class] return output
if __name__ == '__main__':
sentences = ["The cat is walking in the bedroom", "A dog was running in a room", "The cat is running in a room", "A dog is walking in a bedroom", "The dog was walking in the room"]
word_list = " ".join(sentences).lower().split() word_list = list(set(word_list)) word_dict = {w: i for i, w in enumerate(word_list)} number_dict = {i: w for i, w in enumerate(word_list)} n_class = len(word_dict) # number of Vocabulary len_sen = 6 # number of steps, n-1 in paper m = 3 # embedding size, m in paper n_hidden = (int)((len_sen*m*n_class)**0.5) # number of hidden size, h in paper
model = NNLM()
loss = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.003)
input, target = dataset() input = torch.LongTensor(input) target = torch.LongTensor(target)
# 訓練之前先看一下效果。 predict = model(input).data.max(1, keepdim=True)[1] print([sen.split()[:6] for sen in sentences], '->', [number_dict[n.item()] for n in predict.squeeze()])
# Training for epoch in range(5000): optimizer.zero_grad() output = model(input)
# output : [batch_size, n_class], target : [batch_size] Loss = loss(output, target) if (epoch + 1) % 1000 == 0: print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(Loss))
Loss.backward() optimizer.step()
# Predict & test predict = model(input).data.max(1, keepdim=True)[1] print([sen.split()[:6] for sen in sentences], '->', [number_dict[n.item()] for n in predict.squeeze()])

複製代碼

訓練前後的輸出對比:

[['The', 'cat', 'is', 'walking', 'in', 'the'], ['A', 'dog', 'was', 'running', 'in', 'a'], ['The', 'cat', 'is', 'running', 'in', 'a'], ['A', 'dog', 'is', 'walking', 'in', 'a'], ['The', 'dog', 'was', 'walking', 'in', 'the']] -> ['dog', 'walking', 'cat', 'a', 'walking']

[['The', 'cat', 'is', 'walking', 'in', 'the'], ['A', 'dog', 'was', 'running', 'in', 'a'], ['The', 'cat', 'is', 'running', 'in', 'a'], ['A', 'dog', 'is', 'walking', 'in', 'a'], ['The', 'dog', 'was', 'walking', 'in', 'the']] -> ['bedroom', 'room', 'room', 'bedroom', 'room']