Belajar RNN untuk kasus Sederhana

Salah satu model deep learning yang mempunyai keunggulan dalam mengolah data berbasis time series yaitu RNN. Ada banyak jenis RNN seperti many to one yang telah dibahas disini, juga jenis one to one untuk kasus recognition yang telah dibahas disini juga.

Belajar RNN untuk kasus Sederhana yang akan kita pelajari disini lebih kepada memanfaatkan function built in di pytorch yaitu nn.RNN() serta memanfaatkan class Dataset() guna menyiapkan dataset training. Class Dataset bisa kalian pelajari disini juga. Oiya sebagai tambahan RNN yang kita buat nanti berjenis one to one karena sudah jelas/fix panjang input dan output/targetnya.

Belajar RNN untuk kasus Sederhana salah satunya yaitu melatih komputer dengan dataset sifat non linear sederhana yaitu logika XOR yang bilamana kita plotkan dalam 2 dimensi tidak akan mampu kita pisahkan menggunakan garis lurus. Belajar Algoritma Multi Layer Percepton . Kalian bisa coba plotkan 4 titik berikut pada sumbu x dan y serta pisahkan menggunakan garis lurus? tentu tidak akan bisa

Namun apakah RNN bisa melakukanya? mari kita coba langsung saja untuk import semua kebutuhan package yang diperlukan.

import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, Dataset

Untuk dataset kita pakai array numpy saja

x  =  np.array([[1,1],
                [1,0],
                [0,1],
                [0,0]])
y = np.array([1,0,0,1])

Seperti yang sudah dijelaskan, kita akan belajar mempersiapkan dataset untuk pytorch menggunakan class Dataset agar lebih tertata dengan baik. Yuk langsung kita buat dengan menurunkan class Dataset, kita beri nama dengan CustomDataset yang constructor nya dilengkapi 2 argumen input berupa x dan y

class CustomDataset(Dataset):
    def __init__(self,x,y):
        self.x = x
        self.y = torch.tensor(y)#.float()
        
    def __getitem__(self, index):
        x  = self.x[index,:].reshape([1,2])
        x = torch.tensor(x).float()
        return (x, self.y[index])

    def __len__(self):
        return len(self.x)

Yuk kita coba 1 batch saja karena hanya terdiri dari 4 record saja.

train_loader = DataLoader(dataset, batch_size=1, shuffle=True)
for batch in train_loader:
    inputs,targets = batch
    print('input: ',inputs,'target: ',targets)

hasilnya

input:  tensor([[[1., 0.]]]) target:  tensor([0])
input:  tensor([[[0., 0.]]]) target:  tensor([1])
input:  tensor([[[1., 1.]]]) target:  tensor([1])
input:  tensor([[[0., 1.]]]) target:  tensor([0])

Model RNN yang akan kita buat cukup sederhana, seperti berikut ini yang menggunakan output 2 kolom karena nantinya kita akan pakai loss function berupa cross entropy

class RNN(nn.Module):
    def __init__(self, input_size, output_size, hidden_dim, n_layers):
        super(RNN, self).__init__()
        self.hidden_dim = hidden_dim
        self.rnn = nn.RNN(input_size, hidden_dim, n_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, output_size)

    def forward(self, x, hidden):
        r_out, hidden = self.rnn(x, hidden)
        r_out = r_out.view(-1, self.hidden_dim)  
        output = self.fc(r_out)        
        return output, hidden

Kalian bisa melihat ada 2 point penting yaitu pertama setelah dimasukan ke RNN dilanjutkan ke Linear. Pengaturan RNN yaitu

• output nya nanti terdiri dari 2 class
• hidden_dim nya 7 saja
• n_layers 5 saja

input_size= x.shape[1] #jumlah fitur atau jumlah kolom 
output_size = 2 #target hanya 2 kolom saja mencoba untuk multi class
hidden_dim = 7
n_layers = 5

Langsung kita panggil model RNN nya dan setting paramater loss dan jenis pembelajarannya

rnn = RNN(input_size, output_size, hidden_dim, n_layers)
criterion = nn.CrossEntropyLoss() #dianggap mutliclass saja
optimizer = torch.optim.Adam(rnn.parameters(), lr=0.01)

Sekarang kita lakukan training dengan 1 ribu epoch dan akan melihat grafik loss nya apakah terjadi penurunan? Oiya kalian bisa perhatikan hidden state diawal kita setting None dan selanjutnya menggunakan hidden hasil pembelajaran

rnn.train()
hidden = None
loss_list = list()
loss_total = 0
for i in range(1,1000):
    for batch in train_loader:
        inputs,targets = batch
        prediction, hidden = rnn(inputs,hidden)
        hidden = hidden.data
        loss = criterion(prediction, targets)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    loss_total = loss_total + loss.item()
    print('epoch: ',i,' loss: ',loss_total/i)
    loss_list.append(loss_total/i)

hasil grafiknya sebagai berikut yang sangat menarik sekali

plt.figure()
plt.xlabel('epoch')
plt.ylabel('loss')
plt.plot(np.array(loss_list))
plt.title('Grafik Loss')
plt.show()

Yuk kita langsung saja melakukan validasi Belajar RNN untuk kasus Sederhana logika XOR

rnn.eval()
x_tensor = torch.tensor(x)
inputs = x_tensor.unsqueeze(0).float()
prediction, hidden = rnn(inputs,None)
prediction  = torch.argmax(prediction,dim=1)
print('target: ',y,' Prediksi: ',prediction)

Hasilnya sangat sempurna ternyata RNN berhasil belajar mengenali non linear data

target:  [1 0 0 1]  Prediksi:  tensor([1, 0, 0, 1])