July 2019 - Structilmy

Review Course Online Berbayar tentang AI/ML/Deep Learning

July 20, 2019

4 min read

Tahun 2018-2019 ini alhamdulillah saya dapat kesempatan untuk merasakan dua course online yang (seharusnya) berbayar dengan topik AI, machine learning, atau deep learning. Saya akan coba review singkat kedua course tersebut, semoga bisa jadi pertimbangan jika ada yang tertarik mengikutinya.

Datacamp

Course online pertama yang saya dapat adalah Datacamp, saya dapat premium student plan-nya berkat bantuan kerja sama Pak Widiawan, dosen UGM, sekitar pertengahan tahun 2018. Course tersebut berlangsung sekitar 4 bulan.

Di Datacamp, tersedia beberapa alur belajar dengan fokus tujuan tertentu yang disebut “track”, misalnya Track “Machine Learning with Python” atau “Python Programmer”. Sebuah track akan terdiri dari beberapa course yang harus diselesaikan, dan sebuah course terdiri dari beberapa chapter. Dengan akun premium kita bisa mengambil course manapun dengan urutan manapun, “track” hanyalah fasilitas tidak wajib. Sedangkan dengan akun gratis kita hanya bisa mengakses chapter pertama setiap course.

Setiap course materi selalu disampaikan dengan dua metode: video penjelasan teori terlebih dahulu lalu dilanjut praktik dengan menggunakan interaktif window. Kita juga akan mendapatkan slide yang digunakan di video dan “catatan” saat menggunakan interaktif window.

Menurut saya bagian utama di Datacamp ada pada Interaktif window. Saya sering men-skip bagian video dan langsung mengerjakan praktik sambil membaca slidenya. Di interaktif window, kita akan semakin dilatih dalam menggunakan tools-tools programming kita. Setiap sintaks akan dikupas cukup dalam di bagian praktik. Bagusnya, praktik di sini tidak hanya fokus pada “coding”, tetapi juga ada praktik yang memaksa kita untuk eksplorasi data dan memahami teori.

Ada dua fitur sampingan yang menarik di Datacamp, yakni “Practice” dan “Projects”. Practice adalah kuis-kuis singkat yang bisa kita ikuti kapanpun dengan topik beragam, mempermudah kita untuk me-recall apa yang telah kita pelajari. Sedangkan Projects adalah fitur favorit saya, di sini kita akan berusaha menyelesaikan sebuah kasus studi yang real di mana kita diharapkan dapat meng-elaborate beberapa pengetahuan yang diperoleh dari course yang berbeda. Misalnya pada gambar di atas saya melakukan analisis data yang berhubungan dengan penemuan Handwashing.

Udacity: Deep Learning Nanodegree

Course kedua saya dapat dari Udacity, alhamdulillah saya dapat beasiswa deep learning nanodegree dari Facebook awal tahun ini setelah mengikuti tahapan seleksinya. Course online tersebut berlangsung sekitar 5 bulanan.

Di Udacity proses belajar lebih mirip kuliah, kita bayar per-program yang kita ambil. Sebuah program akan terdiri dari beberapa Course dan beberapa Projek. Untuk bisa lulus dan mendapat sertifikat, kita perlu mengerjakan semua Projek besarnya. Kita juga tidak hanya mendapat materi berupa video, tetapi juga banyak catatan tulisan dan paper-paper referensi untuk dipelajari mandiri. Nilai plus di Udacity adalah video pelajaran terasa lebih interaktif, dengan animasi, coret-coret, atau kuis di tengah-tengah video.

Secara konten, Udacity juga memberikan konten-konten yang cukup mutakhir. Di program Deep Learning Nanodegree, ada course tentang metode-metode terbaru seperti Attention, GAN, Pix2Pix, Tensorflow, dan sebagainya. Bahkan penemu algoritma GAN juga sempat menjelaskan intuisi di balik GAN. Udacity tidak menyediakan interactive window seperti Datacamp, tetapi berupa akses ke Jupyter Notebook yang berada pada server Udacity.

Bagian lain yang saya suka dari Udacity adalah fitur “portal karir” nya. Udacity turut membantu pesertanya untuk mengejar karir di bidangnya. Ada beberapa proyek yang mengharuskan kita merombak profil LinkedIn, CV atau tampilan Github kita. Tujuannya agar memudahkan kita melamar kerja nantinya. Setelah selesai course kita juga bisa mengakses alumni portal yang berisi resource lain seperti webinar cara-cara wawancara dan seagainya.

Ringkasan

Menurut saya, keduanya punya plus minusnya sendiri. Datacamp lebih cocok untuk pemula, karena terlalu fokus ke menghafal dan memahami sintaks program (bukan teori). Sedangkan pembelajaran di Udacity terasa lebih umum, bisa jadi pemula akan kesulitan di bagian programmingnya karena untuk mengerjakan project bisa jadi banyak sekali bagian yang harus diprogram. Di Deep Learning Nanodegree kemarin saja, hanya 70% an siswa yang berhasil lulus.

Udacity juga terasa lebih unggul dengan lebih banyak memberi fitur tambahan yang mendukung, video yang lebih interaktif, dan projek besar yang lumayan melatih kemampuan programming kita. Plusnya, di Datacamp latihan “Project” terasa lebih real karena menggunakan kasus-kasus nyata, Di Udacity hal ini (penggunaan kasus nyata untuk berlatih) terasa kurang tersentuh.

Secara harga, Udacity lebih mahal, yakni sekitar $999 per-program yang diambil, sedangkan Datacamp hanya sekitar $30 per bulan untuk mengakses semua coursenya. Jika ditanya apakah worth it? bagi saya pribadi dengan gaji orang Indonesia, saya akan lebih memilih untuk mendalami dengan belajar menggunakan resource gratis, tetapi jika ada kesempatan beasiswa lagi dari Datacamp atau Udacity, kenapa tidak? keduanya akan tetap menambah ilmu dan wawasan bagi orang yang mau belajar 🙂

Convolutional Neural Network (CNN) menggunakan PyTorch

July 17, 2019

by Rian Adam

7 min read

Add Comment

Artikel ini akan langsung berfokus pada implementasi Convolutional Neural Network (CNN) menggunakan PyTorch. Bagi yang ingin memperdalam teori dibalik CNN terlebih dahulu bisa baca pada link artikel sebelumnya yang berisi kumpulan sumber belajar CNN dan jika ingin memperdalam PyTorch, juga bisa baca artikel sebelumnya tentang PyTorch.

Dataset

Kita akan menggunakan Convolutional Neural Network untuk mengklasifikasi citra barang-barang yang ada di sebuah toko (Freiburg Groceries Dataset). Dataset dan code bisa didownload di repository berikut.

Dataset yang digunakan jumlahnya akan lebih sedikit dari dataset asli agar mempercepat proses pelatihan. Dataset pada repo yang kita gunakan hanya terdiri dari 5 kelas, yakni citra produk Susu (MILK), Air mineral (WATER), soda (SODA), jus (JUICE), dan cuka (VINEGAR), dengan sekitar 900-an gambar untuk pelatihan dan 120 gambar untuk pengujian. Semua citra berukuran sama, yakni 256×256 pixel.

Convolutional Neural Network Data — salah satu citra dengan kelas “MILK”

Kita akan menggunakan dataset yang ada pada folder “train” untuk pelatihan dan yang ada pada folder “test” untuk pengujian. Pada tutorial ini kita masih belum menggunakan teknik validasi seperti menggunakan data validasi atau cross-validation.

Pengolahan Dataset di PyTorch

Untuk pengolahan citra ada dua package dari python yang bisa kita gunakan, yakni torchvision.datasets dan torchvision.transforms

from torchvision import transforms, datasets

1	from torchvision import transforms, datasets

Datasets dan Transforms

Kita gunakan datasets untuk memudahkan proses pembacaan data. Dengan struktur folder seperti yang ada di repo (terkelompok untuk setiap kelas) maka dengan datasets kita bisa menyimpan data beserta label dengan mudah. Sedangkan transforms kita gunakan untuk pengolahan awal dataset.

train_dir = "train/"
test_dir = "test/"

train_transform = transforms.Compose([
    transforms.CenterCrop(150),
    transforms.RandomRotation(5), 
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
test_transform = transforms.Compose([
    transforms.CenterCrop(150),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])

train_img = datasets.ImageFolder(train_dir, transform=train_transform)
test_img = datasets.ImageFolder(test_dir, transform=test_transform)

train_dir = "train/"

test_dir = "test/"

train_transform = transforms.Compose([

transforms.CenterCrop(150),

transforms.RandomRotation(5),

transforms.RandomHorizontalFlip(),

transforms.ToTensor(),

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])

test_transform = transforms.Compose([

transforms.CenterCrop(150),

transforms.ToTensor(),

transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])

])

train_img = datasets.ImageFolder(train_dir, transform=train_transform)

test_img = datasets.ImageFolder(test_dir, transform=test_transform)

Pada contoh di atas, saya baca dataset pada folder train dan test menggunakan datasets.ImageFolder() lalu masing-masingnya kita beri pengolahan yang telah saya definisikan. Misalnya pada data train, pengolahan yang saya lakukan menggunakan train_transform:

crop citra menjadi ukuran 150×150
lalu secara random beberapa data saya rotasi 5 derajat
beberapa data juga secara random saya cerminkan secara horizontal
saya ubah citra menjadi tensor 3D (3 x 150 x 150)
saya normalisasi masing-masing channel sehingga rata-rata dan standar deviasinya bernilai 0.5

Setelah terbaca menggunakan datasets maka citra-citra kita akan ter-sebagai objek torch.datasets yang mirip dengan list of tuple. Setiap tuple bagian pertama adalah tensor citra, dan bagian kedua adalah label citra tersebut.

print("train_img type   :",type(train_img)) # objek datasets
print("train_img length :",len(train_img)) # 940 data train
print("test_img length :",len(test_img)) # 120 data test
print("train_img classes:",train_img.classes) # nama kelas
print("train_img[0] type:",type(train_img[0])) # tuple
print("train_img[0][0] s:",train_img[0][0].size()) # tensor citra
print("train_img[0][1]  :",train_img[0][1]) # label

print("train_img type :",type(train_img)) # objek datasets

print("train_img length :",len(train_img)) # 940 data train

print("test_img length :",len(test_img)) # 120 data test

print("train_img classes:",train_img.classes) # nama kelas

print("train_img[0] type:",type(train_img[0])) # tuple

print("train_img[0][0] s:",train_img[0][0].size()) # tensor citra

print("train_img[0][1] :",train_img[0][1]) # label

Objek datasets tersebut, kita ubah bentuknya menjadi DataLoader untuk memudahkan proses batch.

trainloaders = torch.utils.data.DataLoader(train_img, batch_size=64, shuffle=True)
testloaders = torch.utils.data.DataLoader(test_img, batch_size=32, shuffle=True)

1 2	trainloaders = torch.utils.data.DataLoader(train_img, batch_size=64, shuffle=True) testloaders = torch.utils.data.DataLoader(test_img, batch_size=32, shuffle=True)

Implementasi Convolutional Neural Network

Ada 3 bagian utama dalam implementasi CNN menggunakan PyTorch:

Class Model / Arsitektur CNN
Alur pelatihan
Alur pengujian

Arsitektur CNN

Kita akan menggunakan model CNN dengan dua convolutional layer dan sebuah fully connected layer. Dengan detail parameter setiap layer sebagai berikut:

Conv1
K = 4
S = 1
P = 0
FM = 16
ReLU

Pool1
Max
K = 3
S = 2
P = 0

Conv2
K = 3
S = 1
P = 0
FM = 32
ReLU

Pool2
Max
K = 3
S = 2
P = 0

Fully
Connected
N = 512
ReLU
Dropout

Output
N = 5

K = kernel size, S = stride, P = padding, FM = feature map, N = jumlah neuron, Max = MaxPooling

Pembuatan model pada PyTorch dilakukan dengan menyusun urutan layer dan perhitungan yang akan terjadi. Model yang digunakan biasanya dalam bentuk Class dengan sebuah fungsi forward(x) untuk menghitung proses forward propagation

Sebelum mendefinsikan model beberapa library perlu yang diimport untuk pembentukan model, yakni:

import torch
import torch.nn as nn
import torch.nn.functional as F

import torch

import torch.nn as nn

import torch.nn.functional as F

Lalu untuk membuat modelnya kita buat dengan mendefinisikan class berikut:

class Net(nn.Module):
   
    def __init__(self):
        super(Net, self).__init__()

        self.conv1 = nn.Conv2d(3, 16, kernel_size=4, stride=1, padding=0)
        self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=0)
        self.fc1 = nn.Linear(39200, 512)
        self.fc2 = nn.Linear(512, 5)
        self.do = nn.Dropout()
    
    def forward(self, x):
        ## Define forward behavior
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.reshape(x.shape[0], -1)
        x = self.do(F.relu(self.fc1(x)))
        x = self.fc2(x)
        return x

class Net(nn.Module):

def __init__(self):

super(Net, self).__init__()

self.conv1 = nn.Conv2d(3, 16, kernel_size=4, stride=1, padding=0)

self.pool = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)

self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=1, padding=0)

self.fc1 = nn.Linear(39200, 512)

self.fc2 = nn.Linear(512, 5)

self.do = nn.Dropout()

def forward(self, x):

## Define forward behavior

x = self.pool(F.relu(self.conv1(x)))

x = self.pool(F.relu(self.conv2(x)))

x = x.reshape(x.shape[0], -1)

x = self.do(F.relu(self.fc1(x)))

x = self.fc2(x)

return x

Angka 39200 pada kode di atas adalah banyak neuron/fitur yang menjadi input FullyConnected layer. Dihitung dengan menggunakan rumus konvolusi berikut empat kali (Conv1 sampai Pool2) pada masing-masing dimensinya:

$$ FiturAkhir =\frac{FiturAwal – K + 2P}{S} + 1 $$

Setelah class tersebut jadi, untuk membuat model kita cukup membuat sebuah objek baru dari class tersebut

model = Net()

1	model = Net()

Alur Pelatihan

Proses pelatihan dilakukan akan per batch dengan bantuan DataLoader. Kita definisikan terlebih dahulu algoritma dan parameter pelatihan:

criterion = nn.CrossEntropyLoss() # loss function
optimizer = torch.optim.Adam(model.parameters()) # algoritma backprop
epoch = 20 # iterasi pelatihan

criterion = nn.CrossEntropyLoss() # loss function

optimizer = torch.optim.Adam(model.parameters()) # algoritma backprop

epoch = 20 # iterasi pelatihan

Karena kita akan menggunakan GPU, maka jangan lupa juga pindahkan model kita ke GPU dengan cara berikut:

model = model.to("cuda")

1	model = model.to("cuda")

Setelahnya alur pelatihan dilakukan menggunakan kode di bawah. Dapat diperhatikan ada dua iterasi yang terjadi, iterasi pertama untuk banyak epoch sedangkan iterasi kedua menunjukkan proses backpropagation yang dilakukan setiap mini-batch dari data training (trainloaders).

model.train()
for i in range(epoch):
    total_loss = 0
    total_sample = 0
    total_correct = 0

    for image, label in trainloaders: # data tiap batch (64 citra)
        # image adalah tensor berukuran 64 x 3 x 150 x 150
        # label adalah tensor berukuran 64 x 1

        image = image.to('cuda') # pindahkan image ke GPU
        label = label.to('cuda') # pindahkan label ke GPU

        out = model(image) # forward propagation
        loss = criterion(out, label) # hitung error

        optimizer.zero_grad() # langkah awal backprop
        loss.backward() # backpropagation
        optimizer.step() # update bobot berdasar algoritma optimizer

        total_loss += loss.item() # untuk merata2 eror
        total_sample += len(label) # untuk merata2 eror dan akurasi
        total_correct += torch.sum(torch.max(out,1)[1]==label).item()*1.0 # untuk merata2 eror akurasi

    print("epoch", i, total_loss/total_sample, total_correct/total_sample) # menampilkan rata2 eror dan akurasi tiap epoch

model.train()

for i in range(epoch):

total_loss = 0

total_sample = 0

total_correct = 0

for image, label in trainloaders: # data tiap batch (64 citra)

# image adalah tensor berukuran 64 x 3 x 150 x 150

# label adalah tensor berukuran 64 x 1

image = image.to('cuda') # pindahkan image ke GPU

label = label.to('cuda') # pindahkan label ke GPU

out = model(image) # forward propagation

loss = criterion(out, label) # hitung error

optimizer.zero_grad() # langkah awal backprop

loss.backward() # backpropagation

optimizer.step() # update bobot berdasar algoritma optimizer

total_loss += loss.item() # untuk merata2 eror

total_sample += len(label) # untuk merata2 eror dan akurasi

total_correct += torch.sum(torch.max(out,1)[1]==label).item()*1.0 # untuk merata2 eror akurasi

print("epoch", i, total_loss/total_sample, total_correct/total_sample) # menampilkan rata2 eror dan akurasi tiap epoch

Jika tidak terjadi masalah maka akan tampak nilai rata-rata eror akan terus menurun dan rata-rata akurasi akan terus meningkat. Saya melakukan pelatihan di laptop saya ASUS A455L dengan GPU Nvidia 920m, lama pelatihan untuk 20 iterasi tidak sampai setengah jam.

epoch 0 0.03158918555746687 0.30638297872340425
epoch 1 0.021654276264474748 0.39787234042553193
epoch 2 0.01974692699757028 0.46702127659574466
...
epoch 18 0.004239923189929191 0.8978723404255319
epoch 19 0.0036402822967539442 0.9287234042553192

epoch 0 0.03158918555746687 0.30638297872340425

epoch 1 0.021654276264474748 0.39787234042553193

epoch 2 0.01974692699757028 0.46702127659574466

...

epoch 18 0.004239923189929191 0.8978723404255319

epoch 19 0.0036402822967539442 0.9287234042553192

Alur Pengujian

Setelah model selesai dilatih, maka kita akan uji dengan data test. Data test yang belum kita gunakan ini saya pilih secara acak dari masing-masing kelas dan tidak ada di data train.

Proses pengujian tidak beda banyak dengan pelatihan, kita cukup memastikan tidak terjadi backpropagation ataupun update bobot pada saat pengujian. Hal ini dilakukan dengan mengubah status model menjadi eval() dan menghapus bagian backprop.

model.eval()
total_loss = 0
total_sample = 0    
total_correct = 0

for image, label in testloaders:
    image = image.to(device)
    label = label.to(device)
    
    out = model(image)

    loss = criterion(out, label)
    total_loss += loss.item()
    total_sample += len(label)
    total_correct += torch.sum(torch.max(out, 1)[1] == label).item()*1.0

print("test loss", total_loss/total_sample)
print("test accuracy", total_correct/total_sample)

model.eval()

total_loss = 0

total_sample = 0

total_correct = 0

for image, label in testloaders:

image = image.to(device)

label = label.to(device)

out = model(image)

loss = criterion(out, label)

total_loss += loss.item()

total_sample += len(label)

total_correct += torch.sum(torch.max(out, 1)[1] == label).item()*1.0

print("test loss", total_loss/total_sample)

print("test accuracy", total_correct/total_sample)

Jika kode di atas dijalankan akan menampilkan akurasi model kita. Di laptop saya akurasi yang muncul adalah sekitar 70%. Akurasi ini sudah lebih “cerdas” daripada sekadar menebak kelas secara random. Akurasi ini sudah cukup bagus menurut saya mengingat data yang cukup sulit dan model yang sangat simpel.

Apakah akurasi ini masih bisa ditingkatkan? insyaAllah.. silakan coba ganti-ganti arsitektur dan parameter untuk mendapatkan akurasi yang lebih baik (disebut Tuning Parameter). Misalnya dengan mengubah algoritma, jumlah neuron, atau banyak epoch. Beberapa eksperimen harus dilakukan untuk menjadikan akurasi kita benar-benar baik dan valid.

Kita akan coba meningkatkan akurasi model kita dengan beberapa teknik di artikel selanjutnya 🙂

Tutorial Dasar PyTorch : Tensor dan Autograd

July 11, 2019

by Rian Adam

4 min read

Add Comment

Saya mulai menggunakan PyTorch semenjak mengerjakan Tesis di tahun 2017 akhir. PyTorch merupakan pengembangan dari Torch Framework yang dikembangkan oleh Facebook dan difokuskan sebagai framework berbahasa Python untuk proses komputasi Machine Learning, sehingga bisa disandingkan dengan framework sejenis seperti Tensorflow (dikembangkan oleh Google), Keras, Theano (sudah tidak dikembangkan), Caffe2, dan lainnya.

Menurut saya salah satu keunggulan PyTorch dibanding framework lain adalah sintaks yang digunakan tidak terlalu beda dengan fungsi-fungsi pada Numpy, bahkan rasanya dia memiliki sintaks yang lebih rapi dan sederhana

Untuk memulai belajar PyTorch, menurut saya ada dua komponen utama yang perlu dipahami terlebih dahulu, yakni Tensor dan Autograd.

PyTorch Tensor

Tensor adalah sebuah tipe data atau class yang merepresentasikan sebuah array, atau tepatnya ndimensional array karena tidak terbatas pada dimensi-dimensi tertentu. Pada contoh di bawah adalah tensor dengan dimensi 1 bernilai [1,2,3]

import torch
t = torch.tensor([1,2,3])
print(t)

import torch

t = torch.tensor([1,2,3])

print(t)

Sebuah tensor pada PyTorch dapat dibuat dengan tiga cara:

Diberi langsung nilai arraynya
Generate dengan fungsi bawaan (misalnya random)
Diconvert dari Numpy array

t = torch.tensor([1,2,3]) # cara 1
print(t)
t = torch.rand(3,4) # cara 2
print(t)
x = numpy.array([[2.5, 3.2],[1.0,1.9]]) # cara 3
t = torch.from_numpy(x)
print(t)

t = torch.tensor([1,2,3]) # cara 1

print(t)

t = torch.rand(3,4) # cara 2

print(t)

x = numpy.array([[2.5, 3.2],[1.0,1.9]]) # cara 3

t = torch.from_numpy(x)

print(t)

Class Tensor dapat dikenali dari tipenya. Jika digunakan fungsi bawaan Python type(x) maka akan diberitahu bahwa x adalah class tensor dari PyTorch. Namun, itu hanya sebatas menginfokan bahwa x adalah tensor, tetapi tidak menampilkan tipe dari elemen yang terkandung di dalamnya. Untuk menampilkan tipe data dari elemennya gunakan .type() bawaan dari PyTorch:

t = torch.tensor([1,2,3])
print(type(t))
# output : <class 'torch.Tensor'>
print(t.type())
# output : torch.LongTensor

t = torch.tensor([1,2,3])

print(type(t))

# output : <class 'torch.Tensor'>

print(t.type())

# output : torch.LongTensor

Untuk mengubah tipe, gunakan parameter dtype

t = torch.tensor([1,2,3], dtype=torch.float32)
print(t.type())
# output : torch.FloatTensor

t = torch.tensor([1,2,3], dtype=torch.float32)

print(t.type())

# output : torch.FloatTensor

Class Tensor yang merupakan bawaan PyTorch tentu masih terbatas dan tidak bisa disamakan dengan Numpy array atau Python list. Untuk itu jika terdapat fungsi yang belum ada pada PyTorch yang kita butuhkan, proses konversi bisa dilakukan (fungsi tambahan clone() diperlukan untuk menghindari pass by reference).

t = torch.tensor([1,2,3], dtype=torch.float32)

n = t.clone().numpy()   # dari tensor ke numpy
print(type(n))

new_t = torch.tensor(n).clone() # dari numpy ke tensor
print(type(new_t))

t = torch.tensor([1,2,3], dtype=torch.float32)

n = t.clone().numpy() # dari tensor ke numpy

print(type(n))

new_t = torch.tensor(n).clone() # dari numpy ke tensor

print(type(new_t))

Tensor Operation

Operasi yang dapat dilakukan pada Numpy hampir semua sudah bisa dilakukan di Tensor, meskipun beberapa memiliki penulisan sintaks yang berbeda. Berikut beberapa operasi sederhana pada tensor

t = torch.tensor([[1,2,3],[4,5,6],[7,8,9]])
print(t)

# variasi operasi dasar: penjumlahan
t += 1
print(t)
t.add_(2)
print(t)
new_t = t + 2
print(new_t)
new_t = torch.add(t,2)
print(new_t)

# slicing
print(t[0,1:]) # baris pertama, kolom kedua sampai habis
print(t[:,[1,2]]) # semua baris, kolom index 1 dan 2
print(t[[0,2],1:]) # baris index 0 dan 2, kolom kedua sampai habis

# dua tensor
s = torch.tensor([[1,2],[3,4],[5,6]])
print(torch.mm(t,s)) # perkalian dua matriks
s = torch.ones((3,3), dtype=torch.long)
print(s + t) # penjumlahan dua matriks

# fungsi lain-lain
print(t.view(9)) # resize dari 3x3 menjadi 1x9 (satu dimensi)
print(t.view(3,1,3)) # resize menjadi 3x1x3 (tiga dimensi)
print(t.sum()) # menjumlahkan semua elemennya
print(t.sum(dim=0)) # menjumlahkan per kolom

t = torch.tensor([[1,2,3],[4,5,6],[7,8,9]])

print(t)

# variasi operasi dasar: penjumlahan

t += 1

print(t)

t.add_(2)

print(t)

new_t = t + 2

print(new_t)

new_t = torch.add(t,2)

print(new_t)

# slicing

print(t[0,1:]) # baris pertama, kolom kedua sampai habis

print(t[:,[1,2]]) # semua baris, kolom index 1 dan 2

print(t[[0,2],1:]) # baris index 0 dan 2, kolom kedua sampai habis

# dua tensor

s = torch.tensor([[1,2],[3,4],[5,6]])

print(torch.mm(t,s)) # perkalian dua matriks

s = torch.ones((3,3), dtype=torch.long)

print(s + t) # penjumlahan dua matriks

# fungsi lain-lain

print(t.view(9)) # resize dari 3x3 menjadi 1x9 (satu dimensi)

print(t.view(3,1,3)) # resize menjadi 3x1x3 (tiga dimensi)

print(t.sum()) # menjumlahkan semua elemennya

print(t.sum(dim=0)) # menjumlahkan per kolom

Terdapat lebih dari 100 operasi yang bisa dilakukan Tensor, untuk info lebih lengkap silakan kujungi halaman dokumentasi resmi Tensor: https://pytorch.org/docs/stable/tensors.html

Autograd

Autograd adalah sebuah package yang memudahkan dalam melakukan perhitungan turunan (diferensial). Turunan adalah bagian penting pada Machine Learning khususnya Neural Network, contohnya untuk Backpropagation.

Tensor memiliki sebuah attribut .requires_grad yang secara default bernilai False. Jika .requires_grad diberi nilai True maka operasi-operasi yang terjadi pada tensor tersebut akan dicatat, sehingga memungkinkan untuk dilakukan operasi turunan yang berantai.

t = torch.tensor([1,2,3], dtype=torch.float32)
print(t.requires_grad)
# output : False

t = torch.tensor([1,2,3], dtype=torch.float32)

print(t.requires_grad)

# output : False

Berikut ini kita coba gunakan autograd untuk menghitung turunan. Misalnya kita punya persamaan berikut:

$$ z = 2x^2 + y^3 $$

Sehingga misal nilai x awalnya adalah 2 dan y adalah 3, maka dapat kita hitung turunan untuk masing-masing variabel adalah:

$$ \frac{dz}{dx} = 4x + 0 = 4(2) = 8$$

$$ \frac{dz}{dy} = 0 + 3y^2 = 3(3)^2 = 27 $$

jika proses ini dilakukan menggunakan kode:

x = torch.tensor(2, dtype=torch.float32, requires_grad=True)
y = torch.tensor(3, dtype=torch.float32, requires_grad=True)
z = 2*x**2 + y**3
z.backward()   # proses diferensial/autograd
print(x.grad)  # hasil dz/dx = 8
print(y.grad)  # hasil dz/dy = 27

x = torch.tensor(2, dtype=torch.float32, requires_grad=True)

y = torch.tensor(3, dtype=torch.float32, requires_grad=True)

z = 2*x**2 + y**3

z.backward() # proses diferensial/autograd

print(x.grad) # hasil dz/dx = 8

print(y.grad) # hasil dz/dy = 27

Sekian tutorial singkat PyTorch Tensor dan Autograd, semoga bermanfaat 🙂

sumber gambar: flickr

Membuat Movie Recommender System Dengan Python

July 4, 2019

by Rian Adam

5 min read

Add Comment

Pada artikel sebelumnya telah saya bahas sekilas serba-serbi recommender system. Kali ini kita akan coba membuat movie recommender system yang akan merekomendasikan film yang belum pernah ditonton seorang user berdasarkan riwayat film yang telah dia rating sebelumnya (Content-Based Filtering). Implementasi recommender system ini akan menggunakan Python.

Step by Step Content-Based Recommender System

Sebelum kita mulai coding, saya akan tunjukkan perhitungan Content-based recommender system langkah per langkah. Sebenarnya ada banyak pengembangan dan metode lain yang dapat digunakan tapi untuk kali ini saya akan tunjukkan konsep dasar yang paling sederhana.

1. Buat matrix riwayat user

Content-based menggunakan riwayat user dan profil item sebagai bahan dasar saat merekomendasikan. Untuk movie recommender, pertama-tama kita buat matrix atau tabel yang barisnya merupakan daftar semua film yang telah dirating oleh user, dan kolomnya ada semua “fitur” atau profil dari sebuah film.

“Fitur” atau profil film ini dapat kita tentukan sendiri dengan beragam cara dari yang sederhana hingga rumit. Yang paling sederhana adalah dengan mengekstrak secara manual profil sebuah film yang biasanya menjadi pertimbangan dalam menonton. Misalnya saya contohkan pada tabel di bawah adalah genre sebuah film.

	Mystery	Sci-Fi	Drama	Thriller	Horror	Rating
Unbreakable	1	1	1			8.5
The Sixth Sense	1		1		1	5
Gone Girl	1		1	1		8
Alien		1			1	6.5
Memento	1			1		8

Pada contoh di atas saya menggunakan fitur 5 genre film (Misteri, Sci-Fi, Drama, Thriller, Horror). Ketika sebuah film masuk dalam salah satu genre tersebut maka diberi angka 1 pada sel yang bersesuaian (one-hot encoding). Sedangkan kolom rating adalah kolom “target” yang menjadi acuan suka tidaknya user terhadap sebuah film. Rating diberikan antara 1-10.

2. Dapatkan vektor profil user

Vektor profil user adalah sebuah vektor (array 1 dimensi) yang merangkum matrix riwayatnya. Paling sederhana adalah dengan menjumlahkan semua nilai pada kolom fitur yang sama (tidak termasuk kolom rating), seperti berikut:

	Mystery	Sci-fi	Drama	Thriller	Horror
User A	4	2	3	2	2

Tetapi metode menjumlahkan tentu tidak “merangkum” dengan baik. Tampak nilai pada kolom Sci-fi, Thriller, dan Horror adalah sama tanpa menunjukkan mana yang lebih disukai. Metode ini juga bisa menghasilkan bias. Seorang user bisa jadi dianggap menyukai kategori yang sering dia tonton, walaupun dia selalu memberi rating dengan nilai buruk pada kategori tersebut.

Metode lain yang dapat digunakan adalah dengan merata-rata rating setiap kolom fiturnya. Untuk memudahkan secara notasi matematika matrix ini kita beri nama matrix $M$ dengan $m_{ij}$ merujuk pada film ke-$i$ fitur ke-$j$. Sedangkan, bagian rating kita beri nama $R$ dengan $r_i$ merujuk pada rating film ke-$i$. Dengan menganggap milai matrix yang kosong dengan angka 0, proses merata-rata fitur ke-$j$ bisa dirumuskan sebagai berikut:

$$ ProfilFitur_j = \frac {\sum_i m_{ij} \times r_i} {\sum_i m_{ij}} $$

Sebagai contoh, untuk kolom Sci-Fi nilai akhirnya dihitung dengan cara:

$$ SciFi = \frac{(1 \times 8.5) + (0 \times 5) + (0 \times 8) + (1 \times 6.5) + (0 \times 8)}{1 + 0 + 0 +1 + 0} = 7.5 $$

Sehingga diperoleh profil user dari matrix di atas adalah:

	Mystery	Sci-fi	Drama	Thriller	Horror
User A	7.37	7.5	7.17	8	5.75

3. Prediksi rating film berdasarkan profil

Setelah diperoleh vektor profil user, kita dapat memprediksi film mana yang akan disukai oleh user. Misalnya jika diketahui dua film berikut, kira-kira mana yang lebih disukai?

	Mystery	Sci-fi	Drama	Thriller	Horror
Bad Times at the El Royale	1		1
Angels and Demons	1			1

Kita bisa hitung perkiraan rating yang akan diberikan oleh user A dengan cara yang mirip dengan sebelumnya. Yakni merata-rata hasil perkalian profil film tersebut dengan profil user (rata-rata dilakukan per-film/per-baris):

$$ BadTimes = \frac {(1 \times 7.37) + (0 \times 7.5) + (1 \times 7.17) + (0 \times 8) + (0 \times 5.75)}{1 + 0 + 1 + 0 + 0} = 7.27$$

$$ AngelsD = \frac {(1 \times 7.37) + (0 \times 7.5) + (0 \times 7.17) + (1 \times 8) + (0 \times 5.75)}{1 + 0 + 0 + 1 + 0} = 7.68$$

Dari perhitungan di atas dapat diprediksi user A akan lebih menyukai film Angels and Demons.

Dataset

Untuk implementasi ini saya akan menggunakan dataset yang dimodifikasi dari MovieLens. Dataset original MovieLens yang bisa didownload di sini (saya menggunakan yang “ml-latest-small.zip”). Dataset tersebut terdiri dari beberapa file yang masing-masing deskripsinya bisa dibaca di bagian README.

Dataset tersebut saya modifikasi untuk memudahkan dengan penggabungan fitur-fitur (serta penambahan melalui crawling) yang dirasa perlu pada satu file dataset. Karena kita akan membuat content-based recommender system untuk satu user, maka dataset yang saya modifikasi juga berfokus hanya riwayat rating satu user saja.

Dataset yang telah dimodifikasi dapat didownload di sini yang merupakan bagian dari repository github tutorial ini. Dataset yang tersedia telah terbagi menjadi dua bagian, yakni data train yang berisi rating beserta profil film yang telah dirating oleh seorang user sebelum tahun 2017 dan data test yang merupakan rating beserta profil film yang telah dirating oleh user yang sama pada tahun 2017-2018.

Implementasi

Karena kodenya tidak terlalu panjang, saya tidak akan menuliskan secara detail di artikel ini. Kode lengkap bisa lihat di repo github berikut pada file recommender.py. Saya menggunakan pandas sebagai library utama untuk manipulasi matrix.

Di kode tersebut saya menggunakan 21 fitur: 19 fitur pertama adalah genre film, dan 2 fitur berikutnya adalah aktor utama pada film tersebut (2 nama ini dipilih dari 2 nama aktor yang filmnya paling sering dirating oleh user pada data train), dapat dilihat pada variabel list features.

Lalu inti dari kode tersebut terbagi menjadi tiga bagian (dapat dibaca di comment section kode tersebut):

Memformat dataset, karena dataset yang tersedia bukan one-hotencoded seperti tabel contoh di atas maka perlu penyesuaian terlebih dahulu.
Membuat user profile, sesuai dengan rumus di atas menggunakan rata-rata rating tiap fitur
Memprediksi hasil pada data test, sesuai dengan cara di atas menggunakan rata-rata juga..

Hasil prediksi dapat dilihat di file result.csv setelah program dijalankan. Jika diperhatikan hasilnya belum terlalu bagus, tetapi beberapa film yang di rating oleh user dengan hasil yang tinggi juga berhasil terprediksi dengan nilai yang tinggi.

Masih ada banyak metode yang dapat digunakan untuk meningkatkan kualitas recommender ini, yang jika ada kesempatan akan saya bahas. Sekian, semoga bermanfaat 🙂

Sumber gambar cover: flickr

Archive - July 2019

Datacamp

Udacity: Deep Learning Nanodegree

Ringkasan

Dataset

Pengolahan Dataset di PyTorch

Datasets dan Transforms

Implementasi Convolutional Neural Network

Arsitektur CNN

Alur Pelatihan

Alur Pengujian

PyTorch Tensor

Tensor Operation

Autograd

Step by Step Content-Based Recommender System

1. Buat matrix riwayat user

2. Dapatkan vektor profil user

3. Prediksi rating film berdasarkan profil

Dataset

Implementasi