Seq2seq (Sequence to Sequence) modell PyTorch segítségével

Mi az NLP?

Az NLP vagy a Natural Language Processing a mesterséges intelligencia egyik népszerű ága, amely segít a számítógépeknek megérteni, manipulálni az embert, vagy a természetes nyelvükön válaszolni rá. Az NLP a motor mögött Google Translate ami segít más nyelvek megértésében.

Mi az a Seq2Seq?

Seq2Seq egy kódoló-dekódoló alapú gépi fordítási és nyelvi feldolgozási módszer, amely a szekvencia bemenetét egy címkével és figyelmi értékkel rendelkező sorozat kimenetére képezi le. Az ötlet az, hogy 2 RNN-t használjunk, amelyek együtt működnek egy speciális tokennel, és megpróbálják megjósolni a következő állapotsort az előző sorozatból.

Hogyan lehet előre megjósolni a sorozatot az előző sorozatból

A következő lépések az előző szekvencia előrejelzésének lépései a PyTorch segítségével.

1. lépés) Adataink betöltése

Adatkészletünkhöz a következőtől származó adatkészletet fogja használni Tabulátorral tagolt kétnyelvű mondatpárok. Itt az angol-indonéz adatkészletet fogom használni. Bármit választhat, de ne felejtse el megváltoztatni a fájl nevét és könyvtárát a kódban.

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. lépés) Adat-előkészítés

Az adatkészletet közvetlenül nem használhatja. A mondatokat szavakra kell osztania, és át kell alakítania One-Hot Vector-ba. A Lang osztályban minden szó egyedileg indexelve lesz szótár létrehozásához. A Lang osztály minden mondatot tárol, és szóról szóra felosztja az addSentence segítségével. Ezután hozzon létre egy szótárt úgy, hogy minden ismeretlen szót indexel a Sequence to series modellekhez.

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

A Lang osztály egy olyan osztály, amely segít nekünk szótárt készíteni. Minden nyelv esetében minden mondatot szavakra osztanak, majd hozzáadják a tárolóhoz. Mindegyik konténer a megfelelő indexben tárolja a szavakat, megszámolja a szót, és hozzáadja a szó indexét, hogy felhasználhassuk egy szó indexét, vagy egy szót az indexéből.

Mivel adatainkat TAB választja el, használnia kell pandák mint adatbetöltőnk. A Pandák az adatainkat dataFrame-ként olvassák fel, és felosztják forrás- és célmondatunkra. Minden mondatodért,

• kisbetűre normalizálod,
• távolítson el minden nem karaktert
• konvertálni ASCII-re Unicode-ból
• oszd fel a mondatokat, így minden szó benne van.

#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

Egy másik hasznos funkció, amelyet használni fog, a párok Tensorba konvertálása. Ez nagyon fontos, mert hálózatunk csak tenzor típusú adatokat olvas. Ez azért is fontos, mert ez az a rész, hogy a mondat minden végén lesz egy token, amely jelzi a hálózatnak, hogy a bevitel befejeződött. A mondat minden szavához megkapja az indexet a szótár megfelelő szavaiból, és a mondat végére egy jelet ad.

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

A PyTorch Seq2seq modell egy olyan modell, amely a PyTorch kódoló dekódert használja a modellen felül. A kódoló a mondatot szóról szóra kódolja egy indexelt szókincsbe vagy ismert szavakba indexelve, és a dekódoló előrejelzi a kódolt bemenet kimenetét a bemenet sorban történő dekódolásával, és megpróbálja az utolsó bemenetet használni következő bemenetként, ha lehetséges. Ezzel a módszerrel az is lehetséges, hogy megjósoljuk a következő bemenetet a mondat létrehozásához. Minden mondathoz hozzárendelünk egy jelzőt, amely a sorozat végét jelzi. Az előrejelzés végén egy token is lesz, amely a kimenet végét jelöli. Tehát a kódoló egy állapotot ad át a dekódernek, hogy megjósolja a kimenetet.

Az Encoder a bevitt mondatainkat szóról szóra sorban kódolja, és a végén lesz egy token, amely a mondat végét jelöli. A kódoló egy beágyazási rétegből és egy GRU rétegből áll. A Beágyazás réteg egy keresőtábla, amely a bemenetünk beágyazását egy rögzített méretű szótárba tárolja. Egy GRU rétegnek lesz átadva. A GRU-réteg egy kapuzott ismétlődő egység, amely több rétegtípusból áll RNN amely kiszámítja a szekvenált bemenetet. Ez a réteg kiszámítja a rejtett állapotot az előzőhöz képest, és frissíti a visszaállítást, frissítést és az új kapukat.

A dekóder dekódolja a bemenetet a kódoló kimenetéről. Megpróbálja megjósolni a következő kimenetet, és megpróbálja azt következő bemenetként használni, ha lehetséges. A dekóder egy beágyazási rétegből, egy GRU rétegből és egy lineáris rétegből áll. A beágyazási réteg létrehoz egy keresési táblázatot a kimenethez, és átadja azt egy GRU rétegnek, hogy kiszámítsa a várható kimeneti állapotot. Ezt követően egy Lineáris réteg segít az aktiválási függvény kiszámításában, hogy meghatározza a várható kimenet valódi értékét.

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. lépés) A modell betanítása

A Seq2seq modellekben a képzési folyamat azzal kezdődik, hogy minden mondatpárt tenzorokká konvertálnak a Lang indexükből. A sorozat-szekvencia modellünk az SGD-t használja optimalizálóként és az NLLLoss függvényt a veszteségek kiszámításához. A betanítási folyamat azzal kezdődik, hogy egy mondatpárt betáplálunk a modellbe, hogy megjósoljuk a helyes kimenetet. Minden lépésben a modell kimenetét az igaz szavakkal számítják ki, hogy megtalálják a veszteségeket és frissítsék a paramétereket. Tehát mivel 75000 75000 iterációt fog használni, a sorozat-szekvencia modellünk véletlenszerűen XNUMX XNUMX párt generál az adatkészletünkből.

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. lépés) Tesztelje a modellt

A Seq2seq PyTorch kiértékelési folyamata a modell kimenetének ellenőrzése. A Sequence to Sequence modellek minden párja bekerül a modellbe, és előállítja az előrejelzett szavakat. Ezután minden kimenetnél meg kell nézni a legmagasabb értéket, hogy megtalálja a megfelelő indexet. És a végén összehasonlítja a modell-előrejelzésünket az igaz mondattal

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))

Most kezdjük a képzést a Seq to Seq-vel, az iterációk száma 75000 1 és az RNN réteg száma 512, a rejtett méret XNUMX.

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)

Amint láthatja, a megjósolt mondatunk nem egyezik túl jól, ezért a nagyobb pontosság érdekében sokkal több adattal kell edzeni, és meg kell próbálnia több iterációt és rétegszámot hozzáadni a Sequence segítségével a szekvenciatanuláshoz.

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>