Apa itu NLP?
NLP atau Natural Language Processing adalah salah satu cabang Artificial Intelligence yang membantu komputer memahami, memanipulasi, atau merespons manusia dalam bahasa aslinya. NLP adalah mesin di balik Google Terjemahan yang membantu kami memahami bahasa lain.
Apa itu Seq2Seq?
Seq2Seq adalah metode terjemahan mesin berbasis encoder-decoder dan pemrosesan bahasa yang memetakan masukan urutan ke keluaran urutan dengan nilai tag dan perhatian. Idenya adalah menggunakan 2 RNN yang akan bekerja bersama dengan token khusus dan mencoba memprediksi urutan keadaan berikutnya dari urutan sebelumnya.
Langkah 1) Memuat Data kami
Untuk kumpulan data kami, Anda akan menggunakan kumpulan data dari Tab-delimited Bilingual Sentence Pairs. Disini saya akan menggunakan dataset Bahasa Inggris ke Bahasa Indonesia. Anda dapat memilih apapun yang Anda suka tetapi ingat untuk mengubah nama file dan direktori dalam kode.
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")
Langkah 2) Persiapan Data
Anda tidak dapat menggunakan kumpulan data secara langsung. Anda perlu membagi kalimat menjadi kata-kata dan mengubahnya menjadi One-Hot Vector. Setiap kata akan diindeks secara unik di kelas Lang untuk membuat kamus. Kelas Lang akan menyimpan setiap kalimat dan membaginya kata demi kata dengan addSentence. Kemudian buat kamus dengan mengindeks setiap kata yang tidak diketahui untuk model Urutan ke urutan.
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
Kelas Lang adalah kelas yang akan membantu kita membuat kamus. Untuk setiap bahasa, setiap kalimat akan dipecah menjadi kata-kata dan kemudian ditambahkan ke wadah. Setiap wadah akan menyimpan kata-kata dalam indeks yang sesuai, menghitung kata, dan menambahkan indeks kata sehingga kita dapat menggunakannya untuk menemukan indeks kata atau menemukan kata dari indeksnya.
Karena data kami dipisahkan oleh TAB, Anda perlu menggunakan panda sebagai pemuat data kami. Panda akan membaca data kami sebagai dataFrame dan membaginya menjadi kalimat sumber dan target kami. Untuk setiap kalimat yang Anda miliki,
- Anda akan menormalkannya menjadi huruf kecil,
- hapus semua non-karakter
- dikonversi ke ASCII dari Unicode
- pisahkan kalimatnya, sehingga Anda memiliki setiap kata di dalamnya.
#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
Fungsi berguna lainnya yang akan Anda gunakan adalah konversi pasangan menjadi Tensor. Ini sangat penting karena jaringan kami hanya membaca data jenis tensor. Ini juga penting karena ini adalah bagian yang di setiap akhir kalimat akan ada token untuk memberi tahu jaringan bahwa input sudah selesai. Untuk setiap kata dalam kalimat, ini akan mendapatkan indeks dari kata yang sesuai di kamus dan menambahkan token di akhir kalimat.
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)
Model Seq2Seq
Sumber: Seq2Seq
Model PyTorch Seq2seq adalah jenis model yang menggunakan dekoder encoder PyTorch di bagian atas model. Encoder akan menyandikan kalimat kata demi kata ke dalam kosa kata yang diindeks atau kata-kata yang dikenal dengan indeks, dan decoder akan memprediksi output dari input yang dikodekan dengan mendekode input secara berurutan dan akan mencoba menggunakan input terakhir sebagai input berikutnya jika itu mungkin. Dengan metode ini, dimungkinkan juga untuk memprediksi masukan selanjutnya untuk membuat kalimat. Setiap kalimat akan diberi token untuk menandai akhir urutan. Di akhir prediksi, juga akan ada token untuk menandai akhir keluaran. Jadi, dari encoder, ia akan meneruskan status ke decoder untuk memprediksi keluaran.
Sumber: Model Seq2Seq
Encoder akan menyandikan kalimat masukan kita kata demi kata secara berurutan dan pada akhirnya akan ada token untuk menandai akhir kalimat. Encoder terdiri dari lapisan Embedding dan lapisan GRU. Lapisan Penyematan adalah tabel pencarian yang menyimpan penyematan masukan kita ke dalam kamus kata berukuran tetap. Ini akan diteruskan ke lapisan GRU. GRU layer adalah Gated Recurrent Unit yang terdiri dari beberapa tipe RNN yang akan menghitung input yang diurutkan. Lapisan ini akan menghitung keadaan tersembunyi dari yang sebelumnya dan memperbarui pengaturan ulang, pembaruan, dan gerbang baru.
Sumber: Seq2Seq
Decoder akan memecahkan kode input dari output encoder. Ini akan mencoba memprediksi keluaran berikutnya dan mencoba menggunakannya sebagai masukan berikutnya jika memungkinkan. Decoder terdiri dari lapisan Embedding, lapisan GRU, dan lapisan Linear. Lapisan embedding akan membuat tabel pencarian untuk keluaran dan diteruskan ke lapisan GRU untuk menghitung status keluaran yang diprediksi. Setelah itu, lapisan Linear akan membantu menghitung fungsi aktivasi untuk menentukan nilai sebenarnya dari keluaran yang diprediksi.
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
Langkah 3) Melatih Model
Proses pelatihan dalam model Seq2seq dimulai dengan mengubah setiap pasangan kalimat menjadi Tensor dari indeks Lang mereka. Model sequence to sequence akan menggunakan SGD sebagai pengoptimal dan fungsi NLLLoss untuk menghitung kerugian. Proses pelatihan dimulai dengan memasukkan pasangan kalimat ke model untuk memprediksi keluaran yang benar. Pada setiap langkah, keluaran dari model akan dihitung dengan kata-kata yang benar untuk menemukan kerugian dan memperbarui parameter. Jadi karena Anda akan menggunakan 75000 iterasi, model sequence to sequence akan menghasilkan 75000 pasang acak dari dataset kami.
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
Langkah 4) Uji Model
Proses evaluasi Seq2seq PyTorch adalah untuk memeriksa keluaran model. Setiap pasangan model Sequence to sequence akan dimasukkan ke dalam model dan menghasilkan kata-kata yang diprediksi. Setelah itu Anda akan melihat nilai tertinggi pada setiap keluaran untuk menemukan indeks yang benar. Dan pada akhirnya, Anda akan membandingkan untuk melihat prediksi model kita dengan kalimat yang sebenarnya
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))
Sekarang, mari kita mulai pelatihan kita dengan Seq to Seq, dengan jumlah iterasi 75000 dan jumlah layer RNN 1 dengan ukuran tersembunyi 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)
Seperti yang Anda lihat, prediksi kalimat kami tidak cocok dengan baik, jadi untuk mendapatkan akurasi yang lebih tinggi, Anda perlu berlatih dengan lebih banyak data dan mencoba menambahkan lebih banyak iterasi dan jumlah lapisan menggunakan Pembelajaran Urutan ke urutan.
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