O que é PNL?
PNL ou Processamento de Linguagem Natural é um dos ramos populares da Inteligência Artificial que ajuda os computadores a entender, manipular ou responder a um ser humano em sua linguagem natural. PNL é o motor por trás do Google Translate que nos ajuda a entender outras línguas.
O que é Seq2Seq?
Seq2Seq é um método de tradução de máquina baseada em codificador-decodificador e processamento de linguagem que mapeia uma entrada de sequência para uma saída de sequência com uma tag e valor de atenção. A ideia é usar 2 RNNs que trabalharão juntos com um token especial e tentar prever a próxima sequência de estado a partir da sequência anterior.
Etapa 1) Carregando nossos dados
Para nosso conjunto de dados, você usará um conjunto de dados de pares de frases bilíngues delimitados por tabulação. Aqui, usarei o conjunto de dados de inglês para indonésio. Você pode escolher o que quiser, mas lembre-se de alterar o nome do arquivo e o diretório no código.
from __future__ import unicode_literals, print_function, divisionimport torchimport torch.nn as nnimport torch.optim as optimimport torch.nn.functional as Fimport numpy as npimport pandas as pdimport osimport reimport randomdevice = torch.device("cuda" if torch.cuda.is_available() else "cpu")
Etapa 2) Preparação de dados
Você não pode usar o conjunto de dados diretamente. Você precisa dividir as frases em palavras e convertê-las em One-Hot Vector. Cada palavra será indexada exclusivamente na classe Lang para fazer um dicionário. A classe Lang armazenará todas as frases e as dividirá palavra por palavra com o addSentence. Em seguida, crie um dicionário indexando cada palavra desconhecida de Sequência para modelos de sequência.
SOS_token = 0EOS_token = 1MAX_LENGTH = 20#initialize Lang Classclass Lang:def __init__(self):#initialize containers to hold the words and corresponding indexself.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 containerdef 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 counterdef addWord(self, word):if word not in self.word2index:self.word2index[word] = self.n_wordsself.word2count[word] = 1self.index2word[self.n_words] = wordself.n_words += 1else:self.word2count[word] += 1
A classe Lang é uma aula que nos ajudará a fazer um dicionário. Para cada idioma, todas as frases serão divididas em palavras e adicionadas ao contêiner. Cada contêiner armazenará as palavras no índice apropriado, contará a palavra e adicionará o índice da palavra para que possamos usá-lo para encontrar o índice de uma palavra ou encontrar uma palavra em seu índice.
Como nossos dados são separados por TAB, você precisa usar o pandas como nosso carregador de dados. O Pandas lerá nossos dados como dataFrame e os dividirá em nossa frase de origem e de destino. Para cada frase que você tem,
- você irá normalizá-lo para minúsculas,
- remover todos os não-caractere
- converter para ASCII de Unicode
- divida as frases, para que você tenha cada palavra nela.
#Normalize every sentencedef 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 sentencedef read_sentence(df, lang1, lang2):sentence1 = normalize_sentence(df, lang1)sentence2 = normalize_sentence(df, lang2)return sentence1, sentence2def read_file(loc, lang1, lang2):df = pd.read_csv(loc, delimiter='\t', header=None, names=[lang1, lang2])return dfdef 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
Outra função útil que você usará é a conversão de pares em Tensor. Isso é muito importante porque nossa rede só lê dados do tipo tensor. Também é importante porque esta é a parte em que em cada final da frase haverá um token para dizer à rede que a entrada foi concluída. Para cada palavra na frase, ele obterá o índice da palavra apropriada no dicionário e adicionará um token no final da frase.
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)
Modelo Seq2Seq
Fonte: Seq2Seq
O modelo PyTorch Seq2seq é um tipo de modelo que usa o decodificador do codificador PyTorch na parte superior do modelo. O codificador codificará a frase palavra por palavra em um vocabulário indexado ou palavras conhecidas com índice, e o decodificador preverá a saída da entrada codificada decodificando a entrada em sequência e tentará usar a última entrada como a próxima entrada se é possível. Com este método, também é possível prever a próxima entrada para criar uma frase. Cada frase receberá um token para marcar o final da sequência. No final da previsão, também haverá um token para marcar o final da saída. Portanto, a partir do codificador, ele passará um estado para o decodificador para prever a saída.
Fonte: Modelo Seq2Seq
O codificador codificará nossa frase de entrada palavra por palavra em sequência e no final haverá um token para marcar o final de uma frase. O codificador consiste em uma camada de incorporação e uma camada de GRU. A camada Embedding é uma tabela de pesquisa que armazena a incorporação de nossa entrada em um dicionário de palavras de tamanho fixo. Ele será passado para uma camada GRU. A camada GRU é uma unidade recorrente bloqueada que consiste em um tipo de camada múltipla de RNN que calculará a entrada sequenciada. Esta camada calculará o estado oculto da anterior e atualizará a reinicialização, atualização e novas portas.
Fonte: Seq2Seq
O decodificador decodificará a entrada da saída do codificador. Ele tentará prever a próxima saída e tentar usá-la como a próxima entrada, se possível. O decodificador consiste em uma camada de incorporação, uma camada GRU e uma camada linear. A camada de incorporação criará uma tabela de pesquisa para a saída e passará para uma camada GRU para calcular o estado de saída previsto. Depois disso, uma camada Linear ajudará a calcular a função de ativação para determinar o valor real da saída prevista.
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 layersself.input_dim = input_dimself.embbed_dim = embbed_dimself.hidden_dim = hidden_dimself.num_layers = num_layers#initialize the embedding layer with input and embbed dimentionself.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 layersself.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, hiddenclass 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 layersself.embbed_dim = embbed_dimself.hidden_dim = hidden_dimself.output_dim = output_dimself.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, hiddenclass Seq2Seq(nn.Module):def __init__(self, encoder, decoder, device, MAX_LENGTH=MAX_LENGTH):super().__init__()#initialize the encoder and decoderself.encoder = encoderself.decoder = decoderself.device = devicedef 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 outputsoutputs = torch.zeros(target_length, batch_size, vocab_size).to(self.device)#encode every word in a sentencefor i in range(input_length):encoder_output, encoder_hidden = self.encoder(source[i])#use the encoder’s hidden layer as the decoder hiddendecoder_hidden = encoder_hidden.to(device)#add a token before the first predicted worddecoder_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_outputteacher_force = random.random() < teacher_forcing_ratiotopv, topi = decoder_output.topk(1)input = (target[t] if teacher_force else topi)if(teacher_force == False and input.item() == EOS_token):breakreturn outputs
Etapa 3) Treinamento do modelo
O processo de treinamento em modelos Seq2seq é iniciado com a conversão de cada par de sentenças em tensores de seu índice Lang. Nosso modelo de sequência para sequência usará SGD como o otimizador e a função NLLLoss para calcular as perdas. O processo de treinamento começa alimentando o par de uma frase com o modelo para prever a saída correta. Em cada etapa, a saída do modelo será calculada com as palavras verdadeiras para encontrar as perdas e atualizar os parâmetros. Portanto, como você usará 75.000 iterações, nosso modelo de sequência para sequência gerará 75.000 pares aleatórios de nosso conjunto de dados.
teacher_forcing_ratio = 0.5def clacModel(model, input_tensor, target_tensor, model_optimizer, criterion):model_optimizer.zero_grad()input_length = input_tensor.size(0)loss = 0epoch_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 resultfor ot in range(num_iter):loss += criterion(output[ot], target_tensor[ot])loss.backward()model_optimizer.step()epoch_loss = loss.item() / num_iterreturn epoch_lossdef trainModel(model, source, target, pairs, num_iteration=20000):model.train()optimizer = optim.SGD(model.parameters(), lr=0.01)criterion = nn.NLLLoss()total_loss_iterations = 0training_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 += lossif iter % 5000 == 0:avarage_loss= total_loss_iterations / 5000total_loss_iterations = 0print('%d %.4f' % (iter, avarage_loss))torch.save(model.state_dict(), 'mytraining.pt')return model
Etapa 4) Teste o modelo
O processo de avaliação do Seq2seq PyTorch é verificar a saída do modelo. Cada par de modelos de sequência para sequência será alimentado no modelo e gerará as palavras previstas. Depois disso, você verá o valor mais alto em cada saída para encontrar o índice correto. E no final, você vai comparar para ver nossa previsão do modelo com a frase verdadeira
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('')breakelse:decoded_words.append(output_lang.index2word[topi[0].item()])return decoded_wordsdef 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))
Agora, vamos começar nosso treinamento com Seq a Seq, com o número de iterações de 75000 e número da camada RNN de 1 com o tamanho oculto de 512.
lang1 = 'eng'lang2 = 'ind'source, target, pairs = process_data(lang1, lang2)randomize = random.choice(pairs)print('random sentence {}'.format(randomize))#print number of wordsinput_size = source.n_wordsoutput_size = target.n_wordsprint('Input : {} Output : {}'.format(input_size, output_size))embed_size = 256hidden_size = 512num_layers = 1num_iteration = 100000#create encoder-decoder modelencoder = 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 modelprint(encoder)print(decoder)model = trainModel(model, source, target, pairs, num_iteration)evaluateRandomly(model, source, target, pairs)
Como você pode ver, nossa sentença prevista não corresponde muito bem, então, para obter maior precisão, você precisa treinar com muito mais dados e tentar adicionar mais iterações e número de camadas usando Sequência para sequenciar o aprendizado.
random sentence ['tom is finishing his work', 'tom sedang menyelesaikan pekerjaannya']Input : 3551 Output : 4253Encoder((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.090610000 3.912915000 3.817120000 3.836925000 3.819930000 3.795735000 3.803740000 3.809845000 3.753050000 3.711955000 3.726360000 3.693365000 3.684070000 3.705875000 3.7044> this is worth one million yen= ini senilai satu juta yen< tom sangat satu juta yen> she got good grades in english= dia mendapatkan nilai bagus dalam bahasa inggris< tom meminta nilai bagus dalam bahasa inggris > put in a little more sugar= tambahkan sedikit gula< tom tidak > are you a japanese student= apakah kamu siswa dari jepang< tom kamu memiliki yang jepang > 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 > speaking about trips have you ever been to kobe= berbicara tentang wisata apa kau pernah ke kobe< tom tidak > tom bought me roses= tom membelikanku bunga mawar< tom tidak bunga mawar > no one was more surprised than tom= tidak ada seorangpun yang lebih terkejut dari tom< tom ada orang yang lebih terkejut > i thought it was true= aku kira itu benar adanya< tom tidak