Seq2seq-Modell (Sequenz zu Sequenz) mit PyTorch
Evelyn Clarke
Was ist NLP?
NLP oder Natural Language Processing ist einer der beliebtesten Zweige der künstlichen Intelligenz, der Computern hilft, einen Menschen in seiner natürlichen Sprache zu verstehen, zu manipulieren oder auf ihn zu reagieren. NLP ist der Motor dahinter Google Translate Das hilft uns, andere Sprachen zu verstehen.
Was ist Seq2Seq?
Seq2Seq ist eine Methode der Encoder-Decoder-basierten maschinellen Übersetzung und Sprachverarbeitung, die eine Sequenzeingabe einer Sequenzausgabe mit einem Tag und einem Aufmerksamkeitswert zuordnet. Die Idee besteht darin, zwei RNNs zu verwenden, die mit einem speziellen Token zusammenarbeiten und versuchen, die nächste Zustandssequenz aus der vorherigen Sequenz vorherzusagen.
So prognostizieren Sie die Sequenz aus der vorherigen Sequenz
Im Folgenden finden Sie Schritte zum Vorhersagen einer Sequenz aus der vorherigen Sequenz mit PyTorch.
Schritt 1) Laden unserer Daten
Für unseren Datensatz verwenden Sie einen Datensatz von Durch Tabulatoren getrennte zweisprachige Satzpaare. Hier verwende ich den Englisch-Indonesisch-Datensatz. Sie können alles auswählen, was Sie möchten, aber denken Sie daran, den Dateinamen und das Verzeichnis im Code zu ändern.
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")
Schritt 2) Datenvorbereitung
Sie können den Datensatz nicht direkt verwenden. Sie müssen die Sätze in Wörter aufteilen und in One-Hot Vector umwandeln. Jedes Wort wird in der Lang-Klasse eindeutig indiziert, um ein Wörterbuch zu erstellen. Die Lang-Klasse speichert jeden Satz und teilt ihn Wort für Wort mit addSentence auf. Erstellen Sie dann ein Wörterbuch, indem Sie jedes unbekannte Wort für Sequenz-zu-Sequenz-Modelle indizieren.
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
Die Lang-Klasse ist eine Klasse, die uns beim Erstellen eines Wörterbuchs hilft. Für jede Sprache wird jeder Satz in Wörter aufgeteilt und dann dem Container hinzugefügt. Jeder Container speichert die Wörter im entsprechenden Index, zählt das Wort und fügt den Index des Wortes hinzu, damit wir ihn verwenden können, um den Index eines Wortes oder ein Wort aus seinem Index zu finden.
Da unsere Daten durch TAB getrennt sind, müssen Sie sie verwenden Pandas als unser Datenlader. Pandas liest unsere Daten als DataFrame und teilt sie in unseren Quell- und Zielsatz auf. Für jeden Satz, den Sie haben,
- Sie werden es auf Kleinbuchstaben normalisieren,
- Entfernen Sie alle Nicht-Charaktere
- von Unicode in ASCII konvertieren
- Teilen Sie die Sätze auf, sodass jedes Wort darin enthalten ist.
#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
Eine weitere nützliche Funktion, die Sie verwenden werden, ist die Konvertierung von Paaren in Tensor. Dies ist sehr wichtig, da unser Netzwerk nur Daten vom Tensortyp liest. Dies ist auch deshalb wichtig, weil in diesem Teil an jedem Ende des Satzes ein Token steht, das dem Netzwerk mitteilt, dass die Eingabe abgeschlossen ist. Für jedes Wort im Satz wird der Index des entsprechenden Wortes im Wörterbuch abgerufen und am Ende des Satzes ein Token hinzugefügt.
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-Modell
Das PyTorch Seq2seq-Modell ist eine Art Modell, das zusätzlich zum Modell den PyTorch-Encoder-Decoder verwendet. Der Encoder codiert den Satz Wort für Wort in einen Index von Vokabeln oder bekannten Wörtern mit Index, und der Decoder sagt die Ausgabe der codierten Eingabe voraus, indem er die Eingabe der Reihe nach decodiert und versucht, die letzte Eingabe als nächste Eingabe zu verwenden, wenn es ist möglich. Mit dieser Methode ist es auch möglich, die nächste Eingabe zur Bildung eines Satzes vorherzusagen. Jedem Satz wird ein Token zugewiesen, um das Ende der Sequenz zu markieren. Am Ende der Vorhersage gibt es auch ein Token, das das Ende der Ausgabe markiert. Vom Encoder wird also ein Zustand an den Decoder übergeben, um die Ausgabe vorherzusagen.
Der Encoder kodiert unseren Eingabesatz Wort für Wort der Reihe nach und am Ende gibt es ein Token, das das Ende eines Satzes markiert. Der Encoder besteht aus einer Einbettungsschicht und einer GRU-Schicht. Die Einbettungsebene ist eine Nachschlagetabelle, die die Einbettung unserer Eingaben in ein Wortwörterbuch fester Größe speichert. Es wird an eine GRU-Ebene übergeben. Die GRU-Schicht ist eine Gated Recurrent Unit, die aus mehreren Schichten besteht RNN Dadurch wird die sequenzierte Eingabe berechnet. Diese Ebene berechnet den verborgenen Zustand aus dem vorherigen und aktualisiert die Reset-, Update- und neuen Gates.
Der Decoder dekodiert die Eingabe vom Encoder-Ausgang. Es wird versucht, die nächste Ausgabe vorherzusagen und sie, wenn möglich, als nächste Eingabe zu verwenden. Der Decoder besteht aus einer Einbettungsschicht, einer GRU-Schicht und einer linearen Schicht. Die Einbettungsschicht erstellt eine Nachschlagetabelle für die Ausgabe und übergibt sie an eine GRU-Schicht, um den vorhergesagten Ausgabestatus zu berechnen. Danach hilft eine lineare Ebene bei der Berechnung der Aktivierungsfunktion, um den wahren Wert der vorhergesagten Ausgabe zu bestimmen.
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
Schritt 3) Trainieren des Modells
Der Trainingsprozess in Seq2seq-Modellen beginnt mit der Konvertierung jedes Satzpaars in Tensoren aus seinem Lang-Index. Unser Sequenz-zu-Sequenz-Modell verwendet SGD als Optimierer und die NLLLoss-Funktion zur Berechnung der Verluste. Der Trainingsprozess beginnt damit, dass das Satzpaar dem Modell zugeführt wird, um die korrekte Ausgabe vorherzusagen. Bei jedem Schritt wird die Ausgabe des Modells mit den wahren Wörtern berechnet, um die Verluste zu finden und die Parameter zu aktualisieren. Da Sie also 75000 Iterationen verwenden, generiert unser Sequenz-zu-Sequenz-Modell zufällige 75000 Paare aus unserem Datensatz.
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
Schritt 4) Testen Sie das Modell
Der Evaluierungsprozess von Seq2seq PyTorch besteht darin, die Modellausgabe zu überprüfen. Jedes Paar von Sequenz-zu-Sequenz-Modellen wird in das Modell eingespeist und generiert die vorhergesagten Wörter. Anschließend suchen Sie bei jedem Ausgang nach dem höchsten Wert, um den richtigen Index zu finden. Und am Ende vergleichen Sie unsere Modellvorhersage mit dem wahren Satz
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))
Beginnen wir nun unser Training mit Seq to Seq, mit der Anzahl der Iterationen von 75000 und der Anzahl der RNN-Schichten von 1 mit der versteckten Größe von 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)
Wie Sie sehen, stimmt unser vorhergesagter Satz nicht sehr gut überein. Um eine höhere Genauigkeit zu erzielen, müssen Sie also mit viel mehr Daten trainieren und versuchen, mithilfe von Sequenz-zu-Sequenz-Lernen mehr Iterationen und Schichten hinzuzufügen.
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>
