Модель Seq2seq (Sequence to Sequence) з PyTorch
Евелін Кларк
Що таке НЛП?
НЛП або обробка природної мови є однією з популярних гілок штучного інтелекту, яка допомагає комп’ютерам розуміти, маніпулювати або реагувати на людину їхньою природною мовою. НЛП - це двигун Google Translate що допомагає нам розуміти інші мови.
Що таке Seq2Seq?
Seq2Seq це метод машинного перекладу та обробки мови на основі кодера-декодера, який відображає вхід послідовності на вихід послідовності з тегом і значенням уваги. Ідея полягає в тому, щоб використовувати 2 RNN, які працюватимуть разом зі спеціальним маркером і намагатимуться передбачити наступну послідовність станів на основі попередньої послідовності.
Як передбачити послідовність з попередньої послідовності
Нижче наведено кроки для прогнозування послідовності з попередньої послідовності за допомогою PyTorch.
Крок 1) Завантаження наших даних
Для нашого набору даних ви використовуватимете набір даних із Двомовні пари речень, розділені табуляцією. Тут я буду використовувати набір даних з англійської на індонезійську. Ви можете вибрати будь-що, але не забудьте змінити назву файлу та каталог у коді.
from __future__ import unicode_literals, print_function, division
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
import numpy as np
import pandas as pd
import os
import re
import random
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
Крок 2) Підготовка даних
Ви не можете використовувати набір даних безпосередньо. Вам потрібно розділити речення на слова та перетворити їх у One-Hot Vector. Кожне слово буде унікально проіндексовано в класі Lang для створення словника. Клас Lang зберігатиме кожне речення та розбиватиме його слово за словом за допомогою addSentence. Потім створіть словник, проіндексувавши кожне невідоме слово для моделей послідовності.
SOS_token = 0
EOS_token = 1
MAX_LENGTH = 20
#initialize Lang Class
class Lang:
def __init__(self):
#initialize containers to hold the words and corresponding index
self.word2index = {}
self.word2count = {}
self.index2word = {0: "SOS", 1: "EOS"}
self.n_words = 2 # Count SOS and EOS
#split a sentence into words and add it to the container
def addSentence(self, sentence):
for word in sentence.split(' '):
self.addWord(word)
#If the word is not in the container, the word will be added to it,
#else, update the word counter
def addWord(self, word):
if word not in self.word2index:
self.word2index[word] = self.n_words
self.word2count[word] = 1
self.index2word[self.n_words] = word
self.n_words += 1
else:
self.word2count[word] += 1
Клас Lang - це клас, який допоможе нам створити словник. Для кожної мови кожне речення буде розбито на слова, а потім додано до контейнера. Кожен контейнер зберігатиме слова у відповідному індексі, підраховуватиме слово та додасть індекс слова, щоб ми могли використовувати його для пошуку індексу слова або пошуку слова з його індексу.
Оскільки наші дані розділені символом TAB, вам потрібно використовувати панди як наш завантажувач даних. Pandas читатиме наші дані як dataFrame і розділить їх на наше вихідне та цільове речення. За кожне твоє речення,
- ви нормалізуєте його до нижнього регістру,
- видалити всі не символи
- конвертувати в ASCII з Unicode
- розділіть речення, щоб у вас було кожне слово.
#Normalize every sentence
def normalize_sentence(df, lang):
sentence = df[lang].str.lower()
sentence = sentence.str.replace('[^A-Za-z\s]+', '')
sentence = sentence.str.normalize('NFD')
sentence = sentence.str.encode('ascii', errors='ignore').str.decode('utf-8')
return sentence
def read_sentence(df, lang1, lang2):
sentence1 = normalize_sentence(df, lang1)
sentence2 = normalize_sentence(df, lang2)
return sentence1, sentence2
def read_file(loc, lang1, lang2):
df = pd.read_csv(loc, delimiter='\t', header=None, names=[lang1, lang2])
return df
def process_data(lang1,lang2):
df = read_file('text/%s-%s.txt' % (lang1, lang2), lang1, lang2)
print("Read %s sentence pairs" % len(df))
sentence1, sentence2 = read_sentence(df, lang1, lang2)
source = Lang()
target = Lang()
pairs = []
for i in range(len(df)):
if len(sentence1[i].split(' ')) < MAX_LENGTH and len(sentence2[i].split(' ')) < MAX_LENGTH:
full = [sentence1[i], sentence2[i]]
source.addSentence(sentence1[i])
target.addSentence(sentence2[i])
pairs.append(full)
return source, target, pairs
Ще одна корисна функція, яку ви використовуватимете, це перетворення пар у Tensor. Це дуже важливо, оскільки наша мережа читає лише дані тензорного типу. Це також важливо, тому що в цій частині в кожному кінці речення буде маркер, який повідомляє мережі, що введення завершено. Для кожного слова в реченні він отримає індекс відповідного слова зі словника та додасть лексему в кінці речення.
def indexesFromSentence(lang, sentence):
return [lang.word2index[word] for word in sentence.split(' ')]
def tensorFromSentence(lang, sentence):
indexes = indexesFromSentence(lang, sentence)
indexes.append(EOS_token)
return torch.tensor(indexes, dtype=torch.long, device=device).view(-1, 1)
def tensorsFromPair(input_lang, output_lang, pair):
input_tensor = tensorFromSentence(input_lang, pair[0])
target_tensor = tensorFromSentence(output_lang, pair[1])
return (input_tensor, target_tensor)
Модель Seq2Seq
Модель PyTorch Seq2seq — це модель, яка використовує декодер PyTorch поверх моделі. Кодер кодуватиме речення слово за словом у індексований словник або відомі слова з індексом, а декодер передбачатиме вихід закодованого введення шляхом послідовного декодування введення та намагатиметься використати останній вхід як наступний, якщо це можливо. За допомогою цього методу також можна передбачити наступний вхід для створення речення. Кожному реченню буде присвоєно маркер, який позначатиме кінець послідовності. У кінці передбачення також буде маркер, який позначатиме кінець виведення. Отже, від кодера він передасть стан до декодера, щоб передбачити вихід.
Кодувальник буде кодувати наше вхідне речення слово за словом у послідовності, і в кінці буде маркер, який позначатиме кінець речення. Кодер складається з рівня вбудовування та шарів GRU. Рівень вбудовування — це таблиця пошуку, яка зберігає вбудовування нашого введення в словник слів фіксованого розміру. Його буде передано на рівень GRU. Рівень GRU — це закритий рекурентний блок, який складається з кількох типів рівнів RNN який обчислить послідовний вхід. Цей шар обчислить прихований стан із попереднього та оновить скидання, оновлення та нові ворота.
Декодер декодуватиме вхід із виходу кодера. Він спробує передбачити наступний вихід і спробує використати його як наступний вхід, якщо це можливо. Декодер складається з рівня вбудовування, рівня GRU та лінійного рівня. Рівень вбудовування створить таблицю пошуку для вихідних даних і передасть її на рівень GRU для обчислення прогнозованого стану вихідних даних. Після цього лінійний рівень допоможе обчислити функцію активації, щоб визначити справжнє значення прогнозованого виходу.
class Encoder(nn.Module):
def __init__(self, input_dim, hidden_dim, embbed_dim, num_layers):
super(Encoder, self).__init__()
#set the encoder input dimesion , embbed dimesion, hidden dimesion, and number of layers
self.input_dim = input_dim
self.embbed_dim = embbed_dim
self.hidden_dim = hidden_dim
self.num_layers = num_layers
#initialize the embedding layer with input and embbed dimention
self.embedding = nn.Embedding(input_dim, self.embbed_dim)
#intialize the GRU to take the input dimetion of embbed, and output dimention of hidden and
#set the number of gru layers
self.gru = nn.GRU(self.embbed_dim, self.hidden_dim, num_layers=self.num_layers)
def forward(self, src):
embedded = self.embedding(src).view(1,1,-1)
outputs, hidden = self.gru(embedded)
return outputs, hidden
class Decoder(nn.Module):
def __init__(self, output_dim, hidden_dim, embbed_dim, num_layers):
super(Decoder, self).__init__()
#set the encoder output dimension, embed dimension, hidden dimension, and number of layers
self.embbed_dim = embbed_dim
self.hidden_dim = hidden_dim
self.output_dim = output_dim
self.num_layers = num_layers
# initialize every layer with the appropriate dimension. For the decoder layer, it will consist of an embedding, GRU, a Linear layer and a Log softmax activation function.
self.embedding = nn.Embedding(output_dim, self.embbed_dim)
self.gru = nn.GRU(self.embbed_dim, self.hidden_dim, num_layers=self.num_layers)
self.out = nn.Linear(self.hidden_dim, output_dim)
self.softmax = nn.LogSoftmax(dim=1)
def forward(self, input, hidden):
# reshape the input to (1, batch_size)
input = input.view(1, -1)
embedded = F.relu(self.embedding(input))
output, hidden = self.gru(embedded, hidden)
prediction = self.softmax(self.out(output[0]))
return prediction, hidden
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, device, MAX_LENGTH=MAX_LENGTH):
super().__init__()
#initialize the encoder and decoder
self.encoder = encoder
self.decoder = decoder
self.device = device
def forward(self, source, target, teacher_forcing_ratio=0.5):
input_length = source.size(0) #get the input length (number of words in sentence)
batch_size = target.shape[1]
target_length = target.shape[0]
vocab_size = self.decoder.output_dim
#initialize a variable to hold the predicted outputs
outputs = torch.zeros(target_length, batch_size, vocab_size).to(self.device)
#encode every word in a sentence
for i in range(input_length):
encoder_output, encoder_hidden = self.encoder(source[i])
#use the encoder’s hidden layer as the decoder hidden
decoder_hidden = encoder_hidden.to(device)
#add a token before the first predicted word
decoder_input = torch.tensor([SOS_token], device=device) # SOS
#topk is used to get the top K value over a list
#predict the output word from the current target word. If we enable the teaching force, then the #next decoder input is the next word, else, use the decoder output highest value.
for t in range(target_length):
decoder_output, decoder_hidden = self.decoder(decoder_input, decoder_hidden)
outputs[t] = decoder_output
teacher_force = random.random() < teacher_forcing_ratio
topv, topi = decoder_output.topk(1)
input = (target[t] if teacher_force else topi)
if(teacher_force == False and input.item() == EOS_token):
break
return outputs
Крок 3) Навчання моделі
Процес навчання в моделях Seq2seq починається з перетворення кожної пари речень у тензори з їх індексу Lang. Наша модель послідовності використовує SGD як оптимізатор і функцію NLLLoss для обчислення втрат. Процес навчання починається з передачі пари речень моделі для прогнозування правильного результату. На кожному кроці вихідні дані моделі обчислюватимуться з істинними словами, щоб знайти втрати та оновити параметри. Отже, оскільки ви будете використовувати 75000 ітерацій, наша модель послідовності згенерує випадкові 75000 пар із нашого набору даних.
teacher_forcing_ratio = 0.5
def clacModel(model, input_tensor, target_tensor, model_optimizer, criterion):
model_optimizer.zero_grad()
input_length = input_tensor.size(0)
loss = 0
epoch_loss = 0
# print(input_tensor.shape)
output = model(input_tensor, target_tensor)
num_iter = output.size(0)
print(num_iter)
#calculate the loss from a predicted sentence with the expected result
for ot in range(num_iter):
loss += criterion(output[ot], target_tensor[ot])
loss.backward()
model_optimizer.step()
epoch_loss = loss.item() / num_iter
return epoch_loss
def trainModel(model, source, target, pairs, num_iteration=20000):
model.train()
optimizer = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.NLLLoss()
total_loss_iterations = 0
training_pairs = [tensorsFromPair(source, target, random.choice(pairs))
for i in range(num_iteration)]
for iter in range(1, num_iteration+1):
training_pair = training_pairs[iter - 1]
input_tensor = training_pair[0]
target_tensor = training_pair[1]
loss = clacModel(model, input_tensor, target_tensor, optimizer, criterion)
total_loss_iterations += loss
if iter % 5000 == 0:
avarage_loss= total_loss_iterations / 5000
total_loss_iterations = 0
print('%d %.4f' % (iter, avarage_loss))
torch.save(model.state_dict(), 'mytraining.pt')
return model
Крок 4) Перевірте модель
Процес оцінки Seq2seq PyTorch полягає у перевірці вихідних даних моделі. Кожна пара моделей «Послідовність до послідовності» буде подаватися в модель і генерувати передбачувані слова. Після цього ви подивіться на найвище значення на кожному виході, щоб знайти правильний індекс. І врешті-решт ви порівняєте наше прогнозування моделі з істинним реченням
def evaluate(model, input_lang, output_lang, sentences, max_length=MAX_LENGTH):
with torch.no_grad():
input_tensor = tensorFromSentence(input_lang, sentences[0])
output_tensor = tensorFromSentence(output_lang, sentences[1])
decoded_words = []
output = model(input_tensor, output_tensor)
# print(output_tensor)
for ot in range(output.size(0)):
topv, topi = output[ot].topk(1)
# print(topi)
if topi[0].item() == EOS_token:
decoded_words.append('<EOS>')
break
else:
decoded_words.append(output_lang.index2word[topi[0].item()])
return decoded_words
def evaluateRandomly(model, source, target, pairs, n=10):
for i in range(n):
pair = random.choice(pairs)
print(‘source {}’.format(pair[0]))
print(‘target {}’.format(pair[1]))
output_words = evaluate(model, source, target, pair)
output_sentence = ' '.join(output_words)
print(‘predicted {}’.format(output_sentence))
Тепер давайте почнемо наше навчання з Seq to Seq, з кількістю ітерацій 75000 і кількістю шару RNN 1 із прихованим розміром 512.
lang1 = 'eng'
lang2 = 'ind'
source, target, pairs = process_data(lang1, lang2)
randomize = random.choice(pairs)
print('random sentence {}'.format(randomize))
#print number of words
input_size = source.n_words
output_size = target.n_words
print('Input : {} Output : {}'.format(input_size, output_size))
embed_size = 256
hidden_size = 512
num_layers = 1
num_iteration = 100000
#create encoder-decoder model
encoder = Encoder(input_size, hidden_size, embed_size, num_layers)
decoder = Decoder(output_size, hidden_size, embed_size, num_layers)
model = Seq2Seq(encoder, decoder, device).to(device)
#print model
print(encoder)
print(decoder)
model = trainModel(model, source, target, pairs, num_iteration)
evaluateRandomly(model, source, target, pairs)
Як бачите, наше прогнозоване речення не дуже добре узгоджується, тому, щоб отримати вищу точність, вам потрібно потренуватися з набагато більшою кількістю даних і спробувати додати більше ітерацій і кількість шарів за допомогою навчання послідовності.
random sentence ['tom is finishing his work', 'tom sedang menyelesaikan pekerjaannya']
Input : 3551 Output : 4253
Encoder(
(embedding): Embedding(3551, 256)
(gru): GRU(256, 512)
)
Decoder(
(embedding): Embedding(4253, 256)
(gru): GRU(256, 512)
(out): Linear(in_features=512, out_features=4253, bias=True)
(softmax): LogSoftmax()
)
Seq2Seq(
(encoder): Encoder(
(embedding): Embedding(3551, 256)
(gru): GRU(256, 512)
)
(decoder): Decoder(
(embedding): Embedding(4253, 256)
(gru): GRU(256, 512)
(out): Linear(in_features=512, out_features=4253, bias=True)
(softmax): LogSoftmax()
)
)
5000 4.0906
10000 3.9129
15000 3.8171
20000 3.8369
25000 3.8199
30000 3.7957
35000 3.8037
40000 3.8098
45000 3.7530
50000 3.7119
55000 3.7263
60000 3.6933
65000 3.6840
70000 3.7058
75000 3.7044
> this is worth one million yen
= ini senilai satu juta yen
< tom sangat satu juta yen <EOS>
> she got good grades in english
= dia mendapatkan nilai bagus dalam bahasa inggris
< tom meminta nilai bagus dalam bahasa inggris <EOS>
> put in a little more sugar
= tambahkan sedikit gula
< tom tidak <EOS>
> are you a japanese student
= apakah kamu siswa dari jepang
< tom kamu memiliki yang jepang <EOS>
> i apologize for having to leave
= saya meminta maaf karena harus pergi
< tom tidak maaf karena harus pergi ke
> he isnt here is he
= dia tidak ada di sini kan
< tom tidak <EOS>
> speaking about trips have you ever been to kobe
= berbicara tentang wisata apa kau pernah ke kobe
< tom tidak <EOS>
> tom bought me roses
= tom membelikanku bunga mawar
< tom tidak bunga mawar <EOS>
> no one was more surprised than tom
= tidak ada seorangpun yang lebih terkejut dari tom
< tom ada orang yang lebih terkejut <EOS>
> i thought it was true
= aku kira itu benar adanya
< tom tidak <EOS>
