Machine Learning dengan Torch

By | November 18, 2022
Print Friendly, PDF & Email
122 Views

Machine Learning dengan Torch – Framework machine learning digunakan untuk mempermudah kita dalam melakukan pekerjaan dasar. Mengapa butuh framework? Yup urusan machine learning saat ini banyak menggunakan Python dengan pytorch dan tensorflow nya, namun begitu ke bahasa R, pilihannya belum ada. Membuat code sendiri untuk machine learning butuh effort yang besar, oleh sebab itu dengan adanya framework maka membuat arsitektur dan tunning parameternya menjadi lebih mudah. Itulah mengapa kita butuh framework.

Pada pembahasan sebelumnya Neural Network MLP dengan package Neuralnet yang merupakan package untuk machine learning MLP secara sederhana telah kita pelajari, kemudian kita mengenal framework machine learning yaitu   Torch versi R telah tersedia Framework Machine Learning. 2 Postingan tersebut sebaiknya kalian baca terlebih dahulu.

Bila sudah, maka kita akan membahas cara membuat model Torch di R. Model yang akan kita buat nanti seperti model MLP yang terdiri dari beberapa layer saja. Seperti biasanya untuk contoh sederhana MLP, saya lebih suka menggunakan contoh kasus logika XOR. Alasan dibaliknya adalah kasus XOR merupakan tipe non linear sehingga sangat cocok sebagai contoh dasar. Belajar Algoritma Multi Layer Percepton. Non Linear adalah kasus yang tidak bisa dipecahkan oleh perceptron sehingga munculah Multi Layer Perceptron / MLP.

Nanti dilanjut kan dengan dataset iris yang terdiri dari 4 input dan 1 target dengan menggunakan function aktifasi relu.

Logika XOR

Yuk kita buat terlebih dahulu datasetnya menggunakan data frame yang terdiri dari 2 atribut input dan 1 target.

library(torch)

df  = data.frame(x1=c(1,1,0,0),x2=c(1,0,1,0),y=c(1,0,0,1))

mengingat masih dalam bentuk data frame, kita perlu ubah ke matrix

x_train = as.matrix(df[,-3])
y_train = as.matrix(df[,3])

Machine Learning dengan Torch membutuhkan operasi tensor, oleh sebab itu harus di convert ke tensor dengan type float

x_train = torch_tensor(x_train, dtype = torch_float())
y_train = torch_tensor(y_train, dtype = torch_float())

Model Torch Machine Learning

Cara membuat model Torch di R sangat mudah kok, Kita harus menentukan layer dan fungsi aktifasinya. Layer bisa bertipe linear/dense dengan beberapa layer yang saling dihubungkan dengan fungsi aktifasi sigmoid. Karena Model Torch Machine Learning mempunyai rentang nilai 0 sampai dengan 1.

net  <- nn_module(
  "Model-Logika-XOR",
  initialize = function(){
    self$layer1 = nn_linear(in_features = 2, out_features = 4)
    self$layer2 = nn_linear(in_features = 4, out_features = 3)
    self$layer3 = nn_linear(in_features = 3, out_features = 1)
    self$sigmoid = nn_sigmoid()
  },
  forward = function(x){
    x %>%
      self$layer1() %>%
      self$sigmoid() %>%
      self$layer2() %>%
      self$sigmoid() %>%
      self$layer3() %>%
      self$sigmoid()
    
  }
)

dari contoh kode diatas, kita jadi teringat konsep object oriented programming di Python ya! Langkah selanjutnya menentukan metode optimasi serta loss function (pakai MSE saja)

model <- net()
#model$to(device = "cuda")
optimizer = optim_adam(model$parameters,lr=0.01)
criterion = nn_mse_loss()

kita lakukan iterasi dan perbaikan bobot

l = c() #loss tiap epoch
for (epoch in c(1:1000)){
  optimizer$zero_grad()
  output = model(x_train)
  loss = criterion(output,y_train)
  loss$backward()
  optimizer$step()
  l = c(l,loss$item())
  if(epoch %% 100==0)
  cat(" Epoch:", epoch,"Loss: ", loss$item(),"\n")
}

Hemm. kalian bisa melihat loss yang semakin turun setiap epoch

Epoch: 100 Loss:  0.2493794 
Epoch: 200 Loss:  0.2335983 
Epoch: 300 Loss:  0.05096761 
Epoch: 400 Loss:  0.007002922 
Epoch: 500 Loss:  0.00306071 
Epoch: 600 Loss:  0.001811262 
Epoch: 700 Loss:  0.001227058 
Epoch: 800 Loss:  0.0008979964 
Epoch: 900 Loss:  0.0006909413 
Epoch: 1000 Loss:  0.0005506711

Agar lebih menarik, kita plot kan saja

library(ggplot2)
library(dplyr)

df2 = data.frame(error = l)
df2$iterasi = c(1:nrow(df2))

ggplot(data = df2, aes(x=iterasi,y=error))+
  geom_line()+
  labs(title = "Logika XOR Torch R", 
       subtitle = "Loss di tiap iterasi", 
       caption = "Data source: https://softscients.com", 
       x = "Iterasi", 
       y = "Loss")

hasilnya sebagai berikut

See also  Yuk Belajar Tuning Model

Kita cek hasilnya antar target dan prediksi yang dihasilkan

prediksi = model(x_train)
hasil = data.frame(target=as.matrix(y_train),prediksi = as.matrix(prediksi))
hasil

hasil bisa kalian round() kan bila perlu

  target   prediksi
1      1 0.97308481
2      0 0.02729683
3      0 0.02402997
4      1 0.98771101

Dataset IRIS

Machine Learning dengan Torch bagaimana dengan data iris? Konsep membuat persiapan datasetnya sama seperti pembahasan sebelumnya yaitu input dinormalisasikan terlebih dahulu / jika tidak mau nanti pakai fungsi relu diawal sedangkan untuk target bisa dengan teknik one hot encoding.

Yuk kita loading datasetnya sekalian berikan target dalam bentuk angka

library(dplyr)
library(torch)
df = iris
df

spc = df %>% distinct(Species)
spc$id = c(1:nrow(spc))
spc

for(i in c(1:nrow(spc))){
  
  df = df %>% mutate(Target=ifelse(Species==spc$Species[i],spc$id[i],Species))
}

datasetnya menjadi seperti berikut

  Sepal.Length Sepal.Width Petal.Length Petal.Width Species Target
1          5.1         3.5          1.4         0.2  setosa      1
2          4.9         3.0          1.4         0.2  setosa      1
3          4.7         3.2          1.3         0.2  setosa      1
4          4.6         3.1          1.5         0.2  setosa      1
5          5.0         3.6          1.4         0.2  setosa      1

kita pakai kolom 1 sd 4 sebagai input dan kolom 6 sebagai target.

x_train = as.matrix(df[,1:4])
y_train = as.matrix(df[,6])

x_train = torch_tensor(x_train, dtype = torch_float())
y_train = torch_tensor(y_train, dtype = torch_float())

Model Torch Machine Learning

Mengingat nilai input dan target lebih dari 1, maka nanti pakai relu dan sigmoid ditengah nya. Jadi kita nggak usah pakai teknik normalisasi dan one hot encoding targetnya. Berikut cara membuat model Torch di R  dengan fungsi relu.

Model Torch Machine Learning ini menggunakan fungsi relu? Yup karena input dan target yang digunakan mempunyai rentang nilai diatas 0 sampai tak hingga. Agar lebih efektif, maka ditengah2 layer tetap menggunakan fungsi sigmoid.

net  <- nn_module(
  "Model-iris data ",
  initialize = function(){
    self$layer1 = nn_linear(in_features = 4, out_features = 18)
    self$layer2 = nn_linear(in_features = 18, out_features = 6)
    self$layer3 = nn_linear(in_features = 6, out_features = 1)
    self$relu = nn_relu()
    self$sigmoid = nn_sigmoid()
  },
  forward = function(x){
    x %>%
      self$layer1() %>%
      self$relu() %>%
      self$layer2() %>%
      self$sigmoid() %>%
      self$layer3() %>%
      self$relu()
    
  }
)

untuk Loss function dan optimizernya sama dengan sebelumnya

model <- net()
#model$to(device = "cuda")
optimizer = optim_adam(model$parameters,lr=0.01)#optim_sgd(model$parameters, lr = 0.01)
criterion = nn_mse_loss()

bila sudah siap, lakukan iterasi Model Torch Machine Learning  agar nilai loss nya semakin mengecil.

l = c() #loss per epoch
for (epoch in c(1:1000)){
  optimizer$zero_grad()
  output = model(x_train)
  loss = criterion(output,y_train)
  loss$backward()
  optimizer$step()
  l = c(l,loss$item())
  if(epoch %% 100==0){
    hasil = data.frame(target=as.matrix(y_train),prediksi = round(as.matrix(output)))
    hasil = hasil %>% mutate(keterangan=ifelse(prediksi==target,"benar","salah"))
    akurasi = ((nrow(hasil %>% filter(keterangan=="benar")))/nrow(hasil)*100)
    cat(" Epoch:", epoch,"Loss: ", loss$item()," akurasi: ",akurasi,"\n")
  }
}

Ploting loss tiap epoch biar tampak keren

See also  Yuk Belajar Tuning Model

hasil tiap epoch yaitu

Epoch: 100 Loss:  0.3852514  akurasi:  60.66667 
Epoch: 200 Loss:  0.03256994  akurasi:  98 
Epoch: 300 Loss:  0.02988581  akurasi:  98 
Epoch: 400 Loss:  0.02870255  akurasi:  98 
Epoch: 500 Loss:  0.02761709  akurasi:  98 
Epoch: 600 Loss:  0.0264603  akurasi:  98 
Epoch: 700 Loss:  0.02512933  akurasi:  98 
Epoch: 800 Loss:  0.02356768  akurasi:  97.33333 
Epoch: 900 Loss:  0.02185466  akurasi:  97.33333 
Epoch: 1000 Loss:  0.02012367  akurasi:  98

hemmm sangat lumayan dengan hasil sebesar 98%. Bagaimana menurut kalian Machine Learning dengan Torch?

Membuat Model tanpa konsep OOP/Class

Sebenarnya untuk membuat model tidak harus seperti diatas, bisa menggunakan cara berikut

model = nn_sequential(  
  # Layer 1
  nn_linear(2, 10),
  nn_relu(),

  # Layer 2
  nn_linear(10, 5),
  nn_relu(),
  
  # Layee 3
  nn_linear(5,1),
  nn_sigmoid()
)

 

Leave a Reply

Your email address will not be published.




Enter Captcha Here :