PyTorch – Backward dan Step Optimizer serta membuat MLP

By | November 27, 2022
Print Friendly, PDF & Email
678 Views

Backward dan Step Optimizer – Tensor sebagai tipe data yang dioperasikan oleh library pytorch dan tensorflow merupakan core engine yang didalamnya sudah ada kemudahan dalam melakukan operasi derivatif biasa dikenal dengan operasi turunan serta perbaikan gradient. Operasi Apa itu Gradient Descent-Machine Learning? yang telah dibahas sebelumnya masih menggunakan cara manual dengan menggunakan operasi matematika empiris. Operasi gradient descent sebenarnya sudah dibungkus secara rapi pada Pytorch dengan memanfaatkan method step optimizer serta backward untuk derivatif.

Operasi Backward

Mari kita coba dengan persamaan matematika y(x) = x^2+x-6. Berapa nilai \frac{dy}{dx} bila x=1? Sesuai persamaan berikut didapatkan untuk turunan fungsi pertama / derivatif nya yaitu \frac{dy}{dx}= 2x+1. Sehingga ketika x=1 maka \frac{dy}{dx}=2 \cdot 1 + 1 = 3. Mari kita coba dengan tensor saja pada PyTorch. Berikut kode yang digunakan

import torch 
import torch.nn as nn
x = torch.ones(1, requires_grad=True)
y = x**2+x-6
y.backward() #hitung gradient
print(x.grad)

hasilnya yaitu 3.

Operasi Step Optimizer

Kalian masih ingat arti dari gradient descent? untuk mencari titik minimum global dengan teknik iterasi? x_{i+1} = x_{i} - \alpha \frac{df}{dx}. Yuk kita coba sesuai rumus tersebut dengan nilai \alpha=0.001 sebagai berikut

hasil = x - 0.001*x.grad
print(hasil)

hasilnya

tensor([0.9970], requires_grad=True)

langkah diatas sebenarnya cukup menggunakan kode berikut

optim = torch.optim.SGD([x], lr=0.001)
optim.step()
print(x)

dari operasi diatas, kalian sudah bisa tahu dasar cara kerja neural network di pytorch. Kalian masih ingat donk operasi  Mengenal Operasi  Linear, Bobot, dan Bias pada Algoritma CNN yang merupakan operasi dot matrix antar x*W^t+b. Kita akan membuat neural network sederhana yang terdiri dari beberapa layer menggunakan 4 record yang setiap record punya 2 ciri fitur atau disebut dengan kasus logika Boolean XOR.

x2 = torch.tensor([
    [1.0,1.0],
    [1.0,0.0],
    [0.0,0.1],
    [0.0,0.0]
    ],requires_grad =True)


target2 = torch.tensor([[1.0],[0.0],[0.0],[1.0]],requires_grad =True)

Arsitektur yang kita gunakan, saya pilih menggunakan 3 layer yaitu

  1. self.layer1 = nn.Linear(2,10) artinya yaitu input 2, output 10
  2. self.layer2 = nn.Linear(10,5) artinya yaitu input 10, output 5
  3. self.layer3 = nn.Linear(5,1) artinya yaitu 5 input, output 1
See also  Pytorch Mengenal Arsitektur LeNet untuk klasifikasi objek

Kalau saya gambarkan dalam bentuk node Neural Network Backpropagation menggunakan tools http://alexlenail.me/NN-SVG/index.html

Adapun untuk fungsi aktifasi yang digunakan yaitu

  1. hidden #1 ke hidden #2 menggunakan fungsi aktifasi ReLU
  2. hidden #2 ke hidden #3 menggunakan fungsi aktifasi ReLU
  3. hidden #3 ke output menggunakan fungsi aktifasi sigmoid sesuai output yang digunakan yaitu 0 dan 1 sehingga nanti diharapkan akan mendekati 0 dan 1

Untuk membuat neural network backpropagation maka kita akan extend dari class nn.Module, misalkan kita beri nama Net2 namun yang wajib kalian perhatikan yaitu 2 method/function penting yaitu __init__ dan  forward()

class Net2(nn.Module):
    def __init__(self):
        super().__init__()
        self.layer1 = nn.Linear(2,10)
        self.layer2 = nn.Linear(10,5)
        self.layer3 = nn.Linear(5,1)
        self.sigmoid = nn.Sigmoid()
        self.relu = nn.ReLU()
        
    def forward(self,x):
        x = self.layer1(x)
        x = self.relu(x)
        x = self.layer2(x)
        x = self.relu(x)
        x = self.layer3(x)
        x = self.sigmoid(x)
        return x

Langkah selanjutnya yaitu membuat instance objek dari model diatas

model2 = Net2()

membuat function gradient descent

optimizer = torch.optim.SGD(model2.parameters(), lr = 0.01)

serta membuat loss function yang merupakan fungsi objektif yang dijadikan target agar setiap iterasi harus mengecil nilainya. Kita gunakan function MSE saja. MSE inilah yang akan di derifativ kan seperti pada contoh Tensorflow 2.0-Linear Regression bagian 3 nanti Tensor akan melakukan derivatif terhadap MSE

loss_fcn = nn.MSELoss()

Selain itu kita butuh visualisasi mengenai pergerakan error MSE per epoch, kita butuh pandas dan matplotlib

from matplotlib import pyplot as plt
import pandas as pd

bila sudah semuanya! kita buat iterasi yang didalamnya ada backward dan step optimizer

list_err = list()
for i in range(0,100000):
    optimizer.zero_grad() 
    prediksi = model2(x2)
    loss = loss_fcn(prediksi,target2)
    loss.backward()
    optimizer.step()
    list_err.append(loss.item())
    if(i%100)==0:
        print("Epoch {: >8} Loss: {}".format(i, loss.item()))
    if(loss.item()<=0.001):
        break   
print(prediksi)
p = pd.DataFrame(list_err)
p.plot()

arti kode diatas yaitu akan dilakukan iterasi sebanyak 100 ribu kali dan akan berhenti jika MSE < 0.001. Berikut pergerakan MSE setiap epoch yang terhenti pada 40ribu

See also  Loss Function pada Machine Learning

sesuai hasil yang didapatkan yaitu mendekati 0 dan 1

print(prediksi)
tensor([[0.9850],
        [0.0069],
        [0.0446],
        [0.9583]], grad_fn=<SigmoidBackward>)

Perhatikan cara meletakan perintah backward() diatas yang artinya setiap 1 epoch (4 record) akan dilakukan optimizer dengan kode berikut yang setiap iterasi ( 1 record) akan dilakukan optimizer.

model2 = Net2()
optimizer = torch.optim.SGD(model2.parameters(), lr = 0.01)
target2 = torch.tensor([[1.0],[0.0],[0.0],[1.0]],requires_grad =True)
x2 = torch.tensor([
    [1.0,1.0],
    [1.0,0.0],
    [0.0,0.1],
    [0.0,0.0]
    ],requires_grad =True)

list_err = list()
for idx in range(0,50000):
    for input, target in zip(x2, target2):
        optimizer.zero_grad()   # zero the gradient buffers
        output = model2(input)
        loss = loss_fcn(output, target)
        loss.backward()
        optimizer.step()    # Does the update
    list_err.append(loss.item())
    if idx % 100 == 0:
        print("Epoch {: >8} Loss: {}".format(idx, loss.item()))
    if(loss.item()<=0.001):
        break
print(prediksi)
p = pd.DataFrame(list_err)
p.plot()

ternyata menghasilkan error iterasi yang berbeda! yaitu hanya 17.5 ribu epoch saja sudah berhenti mirip pelana kuda yaitu naik tajam terus kemudian turun drastis mencapai konvergen. Saya sudah melakukan uji coba berkali-kali tetap hasilnya sama grafiknya. Silahkan kalian yang bisa menggunakan metode dibawah ini (biasa disebut 1 batch)

Demikian pembahasan mengenai Backward dan Step Optimizer pada PyTorch semoga kalian bisa paham cara kerja neural network backpropagation

ref:

https://stackoverflow.com/questions/53975717/pytorch-connection-between-loss-backward-and-optimizer-step

https://medium.com/biaslyai/pytorch-introduction-to-neural-network-feedforward-neural-network-model-e7231cff47cb

 

Leave a Reply

Your email address will not be published.




Enter Captcha Here :