Di tutorial ini kita akan coba membuat model machine learning untuk dataset CIFAR10. Kita akan buat modelnya dari scratch menggunakan PyTorch dan tidak menggunakan pre-trained model agar kita bisa lebih dalam memahami apa yang terjadi. Kita juga akan menarget (sebagai tantangan) untuk mendapatkan akurasi >85% dalam 40 epoch.

Source code tutorial ini tersedia dalam bentuk Google Colab di sini (akan terus dilengkapi komentar dan catatan pada notebook tersebut)

Catatan: Artikel ini tidak membahas dasar-dasar deep learning menggunakan PyTorch. Bagi yang ingin tahu dasar deep learning atau dasar PyTorch bisa mengunjungi artikel terkait di blog ini:

• Jaringan Saraf Tiruan dan Deep Learning
• Tutorial dasar Pytorch
• Jaringan Saraf Tiruan menggunakan Pytorch
• CNN menggunakan Pytorch

CIFAR10 Dataset

Dataset CIFAR10 adalah dataset citra berukuran 32×32 pixel berwarna. Sesuai namanya, CIFAR10 terdiri dari 10 kelas (kucing, burung, …, kapal). Jelas dataset ini berbeda dari MNIST yang hanya hitam putih. Selain itu jika dilihat di paper-paper, rata-rata akurasi yang diperoleh untuk CIFAR10 adalah sekitar 92% (dibanding MNIST yang bisa sampai >98%). Meskipun begitu, dataset ini masih tergolong mudah dan cocok untuk buat latihan klasifikasi citra. Dataset CIFAR10 bisa didownload langsung menggunakan perintah dari PyTorch.

1. Arsitektur Dasar

Untuk arsitektur dasar, kita akan membuat CNN sederhana yang terdiri dari 3 layer konvolusi dan 2 fully connected layer. Tapi sebelumnya, langkah pertama kita adalah download dan normalisasi dataset terlebih dahulu.

Data Preparation

# dataset transform functions
train_transform = transforms.Compose(
    [transforms.ToTensor(), # convert image to tensor
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization
    
test_transform = transforms.Compose(
    [transforms.ToTensor(), # convert image to tensor
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization

# download dataset
train_set = datasets.CIFAR10("cifar10", train=True, download=True, transform=train_transform)
test_set = datasets.CIFAR10("cifar10", train=False, download=True, transform=test_transform)

# create pytorch data loader
# we set 256 images for a single batch
train_loader = torch.utils.data.DataLoader(train_set, batch_size=256, shuffle=True) 
test_loader = torch.utils.data.DataLoader(test_set, batch_size=256, shuffle=True)  

Karena dataset ini berukuran tidak terlalu besar, kita akan menggunakan batch size yang cukup besar, yakni 256 gambar, dalam sekali training, harapannya model bisa lebih cepet optimal. Kita juga normalisasi data CIFAR10 menggunakan rekomendasi yang ada di sini.

Arsitektur

Arsitektur dasar yang kita buat kira-kira seperti ini jika dituliskan dalam kode Pytorch:

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) 
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
        self.do = nn.Dropout() # dropout layer
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10)  
    
    def forward(self, x): # forward propagation
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = self.pool(torch.relu(self.conv3(x)))
        x = x.reshape(batch_size, -1)       
        x = self.do(torch.relu(self.fc1(x))) # dropout layer
        x = self.fco(x) 
        return x

Atau seperti ini jika divisualisasikan:

Jika diperhatikan, ada beberapa catatan pada arsitektur tersebut:

1. Jumlah feature map yang kita gunakan cukup besar, yakni 128 pada konvolusi pertama dan 256 pada konvolusi kedua dan ketiga. Hal ini mengingat CIFAR10 dataset yang lebih kompleks dibanding MNIST dan kita menarget untuk mendapat akurasi >85% dalam waktu singkat, karenanya walau arsitektur dasar, tapi akan kita buat cukup besar.
2. Terdapat layer dropout pada salah satu fully-connected layer, hal ini bertujuan untuk mengurangi overfitting model deep learning.

Optimizer

Selanjutnya kita train model tersebut selama 40 epoch menggunakan Stochastic Gradient Descent (SGD) dengan learning rate 0.01, lalu kita tambahkan momentum 0.9, weight decay 0.0005 dan juga menggunakan learning rate scheduler, Cosine Annealing. Apa maksud setiap pengaturan itu? kita bahas satu-satu

epoch = 40 
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, momentum=0.9, weight_decay=0.0005) 
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epoch)

Momentum

Penggunaan momentum pada SGD seperti memberi “dorongan” agar model optimal lebih cepat. Pada Pytorch, rumus SGD akan berubah menjadi seperti ini jika menggunakan momentum:

$$ \theta_t = \theta_{t-1} – \alpha (\mu g_{t-1} + g_t) $$

$\theta$ adalah parameter (bobot / bias model), $\alpha$ adalah learning rate, $g_t$ adalah nilai turunan eror terhadap parameter, dan $\mu$ adalah nilai momentum. Bayangkan kita sedang menuruni gunung, ketika kemiringan tanahnya curam, maka kita akan turun lebih cepat dibanding di tanah landai, kan? Dengan memperhatikan nilai turunan eror pada iterasi sebelumnya ($g_{t-1}$), optimizer akan memperhatikan kecuraman eror yang bisa mengantarkan kita ke titik optimal lebih cepat.

Weight decay

Weight decay bermanfaat sebagai pencegah overfitting. Weight decay menambahkan syarat, selain meminimalkan eror, optimizer juga harus meminimalkan nilai parameter modelnya (nilai bobot/biasnya, $\theta$). Rumus SGD akan menjadi seperti ini, dengan $\lambda$ adalah nilai parameter weight decay:

$$ \theta_t = \theta_{t-1} – \alpha (\mu g_{t-1} + g_t + \lambda \theta_{t-1}) $$

Dengan memiliki nilai bobot yang kecil, harapannya model akan menjadi tidak terlalu kompleks.

Learning rate scheduler

LR scheduler berfungsi untuk mengubah-ubah nilai learning rate pada saat proses training. Pada tutorial ini kita menggunakan metode Cosine Annealing yang membuat proses pengubahan learning rate layaknya fungsi cosine (bisa naik-turun). Pada kode di atas, untuk menginisiasi scheduler kita perlu menambahkan dua parameter, yakni optimizer mana yang akan diupdate learning ratenya, dan juga T_max, yakni seberapa lama learning rate akan naik/turun sebelum dia akhirnya berubah arahnya (Dari turun jadi naik, dan sebaliknya). Tutorial ini menggunakan T_max=epoch, yakni 40, sehingga learning rate akan terus turun hingga akhir pelatihan. Kalian bisa cek bacaan menarik tentang LR Scheduler di sini.

Hasil = 80.89%

Setelah kita train selama 40 epoch (source code training standard bisa cek di colab), akurasi 80.89% saya peroleh untuk model basic ini untuk data test. Not bad!

2. Batch Normalization

Optimasi yang pertama akan kita lakukan adalah kita akan menambahkan batch normalization pada model. Apa itu batch normalization?

Kita mungkin tahu normalization (normalisasi) adalah teknik untuk mengubah nilai atau skala pada data tanpa menghilangkan informasi antardatanya. Normalisasi biasanya kita lakukan di awal, sebelum data masuk ke model machine learning dengan tujuan memudahkan model untuk menemukan pola pada data. Nah, Batch normalization itu konsepnya sama seperti normalisasi biasanya hanya saja kita lakukan pada tengah-tengah layer. Detail penjelasannya bisa agak panjang, blog menarik untuk dibaca tentang batch norm ada di sini.

Penambahan

Penambahan terdapat pada arsitektur model sehingga tertulis seperti di bawah ini. Karena kita menggunakan CNN, kita gunakan BatchNorm2D yang akan menormalisasi pada setiap channel/feature map. Karenanya, untuk setiap inisiasi kita tambahkan parameter jumlah feature map yang diterima batch norm.

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) # initiating batch norm
        self.conv2_bn = nn.BatchNorm2d(256) # initiating batch norm
        self.conv3_bn = nn.BatchNorm2d(256) # initiating batch norm
        
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10) 
    
    def forward(self, x): 
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) # batch norm
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x)))) # batch norm
        x = self.pool(torch.relu(self.conv3_bn(self.conv3(x)))) # batch norm
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x))) 
        x = self.fco(x) 
        return x

Sama seperti normalisasi yang dilakukan di awal, biasanya kita mengubah rentang nilai data sehingga memiliki rata-rata 0 dan standar deviasi 1. Pada batch norm, setial layer batch norm akan menormalisasi sehingga memiliki rata-rata dan standar deviasi tertentu. Nilai ini ditentukan selama proses training. Karenanya perlu diingat:

1. Batch norm tiap layer harus diinisasi sendiri-sendiri
2. Pastikan gunakan mode .train() dan .eval() agar batch norm tahu kita sedang training atau testing. (cek kode)

Hasil = 83.63%

Naik 3%! yey!

3. Residual Connection

Salah satu pengubahan arsitektur yang cukup sederhana adalah dengan menambahkan residual connection. Residual connection ini diusulkan dan menjadi dasar dari model yang cukup populer yakni ResNet. Idenya dengan “menghubungkan” output suatu layer dengan output dari beberapa layer sebelumnya. Proses “menghubungkan” ini biasanya dilakukan hanya dengan menggunakan penjumlahan kedua tensor.

Tujuan dari residual connection adalah untuk memudahkan ketika proses update model / backpropagatoin. Gradient yang dihitung saat backpropagation akan bisa melewati atau menskip beberapa layer. Sehingga bisa terhindar dari vanishing atau exploding gradient.

Penambahan

penambahan terdapat pada arsitektur model sehingga tertulis seperti ini:

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1)
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1)
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) 
        self.conv2_bn = nn.BatchNorm2d(256) 
        self.conv3_bn = nn.BatchNorm2d(256) 
        
        self.fc1 = nn.Linear(4096, 1024) 
        self.fco = nn.Linear(1024, 10)  
    
    def forward(self, x):
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) 
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x))))
        x = self.pool(x + torch.relu(self.conv3_bn(self.conv3(x)))) # residual connection
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x)))
        x = self.fco(x)
        return x

residual connection hanya bisa dilakukan (setidaknya dengan mudah) pada layer yang memiliki output ukluran yang sama. Sehingga kita hanya gunakan pada satu layer, yakni pada proses konvolusi pada layer conv3 dengan menambahkan input sebelum proses konvolusi sebagai residual.

Hasil = 83.38%

Hmm, kok turun sedikit? bisa jadi memang tidak ngefek? tapi kalau kita cek akurasi pada data train, akurasi data train menurut agak banyak jadi sekitar 97% (sebelumnya 99%), kalau ini berarti model kita jadi “sedikit” tidak overfitting sepertinya ini pertanda bagus, kita lanjutkan dulu.

4. Data Augmentation

Data augmentation adalah trik yang digunakan dengan cara membuat data latih yang lebih variatif. Kita akan memodifikasi data latih CIFAR10 dan harapannya bisa membuat model lebih memahami pola pada gambar. Metode ini sering digunakan khususnya ketika dataset yang kita miliki jumlahnya sedikit atau kurang variatif.

Penambahan

penambahan terdapat pada proses transormasi data sehingga tertulis seperti ini:

train_transform = transforms.Compose(
    [transforms.RandomCrop(32, padding=4), # data augmentation
     transforms.RandomHorizontalFlip(),    # data augmentation
     transforms.ToTensor(),
     transforms.Normalize((0.4914, 0.4822, 0.4465), (0.247, 0.243, 0.261))]) # normalization

Kita hanya menambahkan augmentasi pada saat train, jadi yang kita ubah hanya train_transform. Pada kode di atas kita menambahkan dua metode augmentasi. Yang pertama, adalah random crop dengan padding, ini seperti kita tambahkan bingkai 4 pixel mengelilingi gambar lalu secara acak kita akan buat kotak berukuran 32×32 untuk dicrop. Hasilnya nanti gambar akan seakan tergeser (cek ilustrasi di bawah). Metode augmentasi yang kedua adalah secara acak beberapa gambar akan di flip horizontal.

Hasil = 83.8%

Akurasinya sudah agak naik sedikit, dan akurasi data train turun banyak jadi sekitar 82% ini berarti model kita jadi “lebih” tidak overfitting lagi. Ini pertanda bagus

5. Tambah Layer

Terakhir, kita akan coba menambah kedalaman model kita dengan menambah satu layer konvolusi. FYI, model-model besar seperti ResNet, AlexNet, dkk yang paling sederhana biasanya terdiri dari >10 layer (bahkan hingga ratusan layer). Sejauh ini, model kita cuma terdiri dari 5 layer (atau 8 jika menghitung layer pooling), jadi tidak ada salahnya kita coba.

Penambahan

Penambahan terdapat pada arsitektur model, sehingga berakhir tertulis seperti di bawah ini. Karena penambahan layer tersebut, kita bisa menambah proses residual connection juga.

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 128, kernel_size=3, stride=1, padding=1) 
        self.conv2 = nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1) 
        self.conv3 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1)
        self.conv4 = nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1) # added layer
        self.pool = nn.MaxPool2d(kernel_size=2, stride=2) 
        self.do = nn.Dropout() 

        self.conv1_bn = nn.BatchNorm2d(128) 
        self.conv2_bn = nn.BatchNorm2d(256) 
        self.conv3_bn = nn.BatchNorm2d(256) 
        self.conv4_bn = nn.BatchNorm2d(256) 
        
        self.fc1 = nn.Linear(1024, 1024)
        self.fco = nn.Linear(1024, 10) 
    
    def forward(self, x): 
        batch_size = x.shape[0]
        x = self.pool(torch.relu(self.conv1_bn(self.conv1(x)))) 
        x = self.pool(torch.relu(self.conv2_bn(self.conv2(x))))
        x = self.pool(x + torch.relu(self.conv3_bn(self.conv3(x)))) 
        x = self.pool(x + torch.relu(self.conv4_bn(self.conv4(x)))) # new residual connection
        x = x.reshape(batch_size, -1)        
        x = self.do(torch.relu(self.fc1(x))) 
        x = self.fco(x)
        return x

Hasil = 86.48%

Yeah, mission complete!

Rangkuman Hasil Akhir

Dari menggabungkan percobaan-percobaan di atas, kita berhasil memperoleh akurasi >85% dengan kurang dari 40 epoch di CIFAR10. Ini hasil yang cukup bagus dan kita jadi bisa belajar banyak beragam strategi dalam meningkatkan akurasi deep learning pada dataset CIFAR10.

By the way, menggunakan bentuk terakhir, jika kita tambahkan waktu train hingga 200 epoch, kita bisa mencapai akurasi pada CIFAR10 hingga >90% loh! Tantangan lain yang kita juga bisa coba adalah menggunakan dataset yang mirip tapi agak lebih besar, yakni CIFAR100. Selamat mencoba!

Source code tutorial ini tersedia dalam bentuk Google Colab di sini (akan terus dilengkapi komentar dan catatan pada notebook tersebut)

Bagi teman-teman yang aktif ngikutin perkembangan Machine Learning, khususnya Natural Language Processing, pasti pernah dengar HuggingFace. HuggingFace (HF) ini adalah perusahaan yang awalnya berfokus pada pengembangan aplikasi-aplikasi NLP, tapi sekarang sudah menjelma menjadi suatu “Ekosistem” machine learning yang sangat besar. Saya sebut ekosistem karena HF bukan seperti perusahaan yang hanya menyediakan jasa, atau produk komersil, tapi lebih dari itu!

HF telah berkontribusi banyak dalam perkembangan Machine Learning saat ini, tidak hanya NLP tapi Machine Learning secara umum. Dengan menyediakan Course; platform untuk saling berbagi model, dataset, atau demo; menyediakan library untuk NLP; membangun komunitas yang aktif; yang semua itu gratis!! (HF juga menulis buku tentang NLP di sini, tapi kalau ini berbayar )

Di artikel ini saya akan coba cerita sedikit gambaran umum tentang layanan-layanan HF yang teman-teman bisa gunakan.

HuggingFace Model Hub

Saya ingat beberapa tahun lalu pernah ada yang tanya, baik langsung ke saya atau via online, apakah ada layanan di mana orang-orang bisa upload model machine learning untuk digunakan orang lain, jadi orang lain tidak perlu melakukan train, test, dan sebagainya. HuggingFace Model menjawab itu! Di sini orang-orang bisa mengupload model hasil pelatihan mereka, lalu orang lain bisa tinggal download dan pakai model tersebut.

HuggingFace Model sangat terorganisir, kalian bisa sort berdasarkan task kebutuhan kalian, library yang digunakan, pembuatnya, atau bahasa (untuk NLP). Model-model tersebut nantinya bisa digunakan sebagai pre-trained model yang lalu ditrain ulang (finetuning) atau digunakan apa adanya. Beberapa waktu lalu istri saya pernah menulis tutorial membuat chatbot menggunakan salah satu model yang ada di HF ini.

Menggunakan model-model tersebut kerasa lebih mudah ketimbang harus cari-cari model di internet, karena sudah terintegrasi dengan library HF. Selain itu penjelasan pemakaian juga biasanya didokumentasikan dengan baik pada Model Card (“Readme” nya model di HF).

Oh ya, Jika tidak mau bersentuhan dengan modelnya sama sekali, kita juga bisa menggunakan HF inference API (berbayar) yang memungkinkan kita untuk memanfaatkan model-model secara langsung melalui API. Jadi kita bahkan bisa memanfaatkan model-model machine learning tanpa perlu paham Python!

HuggingFace Dataset

HF juga menyediakan repository dataset di mana semua orang bisa berkontribusi dengan mengupload dataset yang dimiliki ke sana sehingga bisa dipakai oleh orang lain. Sudah ada banyak repository dataset di luar sana, tapi HF punya beberapa keunggulan khususnya pada “terorganisirnya” dataset. Di HF, pengunggah atau pemilik dataset bisa melampirkan loader script di HF yang bisa bikin dataset jadi lebih rapi ketika akan digunakan, memiliki informasi yang lengkap, dan bisa diulik dengan mudah di web HF.

Sebagai contoh dataset IndoNLU. Di sana kita bisa lihat ada beberapa subdataset yang berbeda, kita bisa download tiap split yang berbeda dan itu semua bisa dilakukan hanya dengan script.

from datasets import load_dataset

# download IndoNLU dataset, subset emotion classification, split data train
data_train = load_dataset("indonlu", "emot", split="train")

# menampilkan data pertama pada data_train
# output berupa dictionary:
#     {'tweet': 'Ini adalah hal yang paling membahagiakan ...', 'label': 4}
print(data_train[0])

HF Dataset hub ini, akan sangat bermanfaat untuk kebutuhan benchmarking. Dengan split yang sama dan penyimpanan dataset yang rapi, kita bisa meminimalisir pembandingan model machine learning yang tidak apple-to-apple. Misalnya, membandingkan dua model yang menggunakan dataset yang sama tapi berbeda pemilihan data train dan testnya.

HuggingFace Space

Kita bisa memanfaatkan HuggingFace Space untuk “memamerkan” model machine learning yang sudah kita buat. Sesuai namanya, kita seakan diberi ruang / halaman untuk menampilkan hasil model machine learning kita. Kita bisa memanfaatkan package seperti Streamlit atau Gradio untuk pengaturan antarmuka dan controlnya, lalu menggunakan HF Space untuk wadah deployment. HF Space biasa digunakan untuk kebutuhan demo, visualisasi, portofolio, atau beberapa orang juga menggunakan HF space untuk membuat leaderboard/benchmark suatu dataset.

Kita bisa lihat-lihat Space yang orang lain bikin, salah satu space yang cukup populer akhir-akhir ini adalah Dall-E Mini. Di sana kita bisa menggenerate gambar suka-suka kita dari kalimat yang diberikan.

Masih banyak sebenarnya yang bisa dilakukan dengan HuggingFace, teman-teman bisa lanjut eksplorasi untuk mengulik lebih dalam. Bisa coba mulai dengan belajar menggunakan HF Model, lalu mencoba menggunakan public dataset dengan HF Dataset, lalu lanjut buat aplikasi sederhana dan upload di HF Space.

Semoga bermanfaat, selamat bereksplorasi menggunakan HuggingFace!

Artikel ini akan jadi pengantar, kombinasi rangkuman course pertama Hugging Face dan materi-materi RL yang selama ini saya pahami sebelum ikut course ini.

Apa itu Reinforcement Learning?

Kita mulai dari Machine Learning: Area ilmu yang mempelajari bagaimana mesin (komputer) bisa belajar dan melakukan aksi seperti manusia menggunakan sekumpulan data (learning). Area ilmu ini cukup luas, ada banyak sub-area di dalamnya dan itupun masih ada ratusan algoritma untuk tiap sub-area itu.

Sub-area yang cukup populer adalah Supervised Learning: komputer belajar dari sekumpulan data yang sudah benar (ground truth), lalu komputer akan menebak output dari data sejenis yang belum pernah dilihat. Misalnya, diberikan sekumpulan contoh foto apel dan nanas, setelah belajar, harapannya di masa depan jika dia melihat foto suatu buah, komputer bisa tahu mana yang apel dan mana yang nanas. Algoritma yang bisa digunakan di sub-area ini: KNN, SVM, Neural Network, dll. (Tutorial klasifikasi citra)

Reinforcement Learning (RL) juga sub-area di machine learning. Pada Reinforcement Learning, komputer belajar untuk mencapai tujuan tertentu dengan cara berinteraksi dengan lingkungannya. Contohnya, kita ingin membuat komputer yang mampu memenangkan game catur, maka kita akan latih komputer dengan cara membuat dia bermain (berinteraksi) dengan game catur berkali-kali hingga dia tahu cara untuk memenangkan suatu permainan. Algoritma yang bisa digunakan di sub-area ini: DQN, PPO, A2C, dll.

Kata kunci yang membedakan RL dengan area machine learning lain adalah: Interaksi dan Tujuan. Dalam permainan catur, tidak bisa kita tentukan satu contoh langkah yang benar (Ground truth) pada suatu kondisi seperti pada Supervised Learning. Semua kembali ke tujuan akhir, apapun caranya yang penting kita bisa menang.

Contoh lain RL adalah self-driving car atau mobil yang bisa mengantar kita sampai ke lokasi secara otomatis. Tujuan dari RL di sini adalah untuk menggerakkan mobil mencapai lokasi tertentu. Ketika dilatih, model RL akan mencoba berinteraksi (mencoba-coba gas, rem, setir) di simulator (bukan pakai mobil beneran karena bisa bahaya). Dan sama seperti contoh catur, tidak ada solusi “benar” dalam berkendara, apapun caranya yang penting bisa sampai di tujuan (tentunya dengan beberapa batasan seperti waktu, bahan bakar, keselamatan penumpang, dll)

Saya lupa dari mana sumbernya, definisi lain yang menarik tentang RL: Reinforcement Learning adalah “delayed” Supervised laerning. Kalau di Supervised learning, ketika model dikasih data, maka jawaban model bisa dinilai benar salah secara langsung. Tapi di mayoritas kasus RL, ketika model dikasih data maka jawaban (aksi yang diberikan) model tidak bisa langsung dinilai benar salah. Penilaian benar atau salah serangkaian aksinya baru bisa dilakukan di akhir interaksi (misal dalam catur berakhir menang atau kalah)

Elemen dalam Reinforcement Learning

Ada beberapa kata kunci ketika mempelajari RL, dua kata kunci pertama yang perlu kita tahu adalah Agent dan Environment. Agent adalah Subjek AI yang kita latih untuk bisa berinteraksi pada environment dan mencapai suatu goal/tujuan. Sedangkan environment adalah “dunia” di mana agen bisa “melihat” dan berinteraksi. Agen akan menggunakan environemtn untuk belajar dengan cara melihat apa yang terjadi ketika dia berinteraksi.

Contoh:

• RL untuk catur -> environmentnya adalah game catur
• RL untuk self driving car -> environmentnya adalah simulasi kondisi jalanan dan mobil

Dalam implementasinya, ketika kita membuat proyek RL seringnya kita juga harus membuat environmentnya. Untuk kasus umum seperti untuk game, sudah ada banyak environment yang tersedia secara umum, seperti OpenAI Gym dan PettingZoo. Dulu saya dan tim di UII pernah buat Gapoera API untuk board game Indonesia. Tapi untuk kasus yang spesifik, kita harus buat dulu environmentnya, ini yang kadang bikin kesan RL lebih rumit.

S A R S

Semua kasus pada RL bisa dimodelkan sebagai (S,A,R,S’) singkatan dari (State, Action, Reward, State’). Istilah-istilah ini bisa kita perhatikan muncul pada ilustrasi di atas. Penting untuk kita mengurai suatu kasus yang akan dikerjakan dalam bentuk (S,A,R,S’):

• State: Informasi-informasi yang tersedia di environment pada suatu waktu. Contoh: posisi bidak catur, posisi orang di jalan, kecepatan mobil saat ini, dll. Beberapa orang juga pakai istilah Observation untuk state yang dapat dilihat agent. Contoh: dalam permainan kartu, agent tidak bisa lihat kartu yang dimiliki lawan. State pada permainan kartu adalah sebaran kartu di tangan kita dan lawan, sedangkan obersvation adalah apa yang bisa dilihat agent, yakni hanya kartu di tangannya.
• Action: Apa yang bisa dilakukan agent terhadap environment. Contoh: menggerakkan pion, menginjak rem sedalam sekian, dll. Suatu Aksi bisa berupa pilihan (diskrit, misal gerakkan suatu pion) bisa juga suatu nilai (kontinyu, misal belokkan mobil 23.5^o ke kanan)
• Reward: Apa yang diperoleh agent dari environment untuk mengukur baik buruknya tindakan. Kadang setiap aksi langsung memberikan efek baik buruknya tapi bisa jadi reward hanya diperoleh di akhir. Contoh: Pada game, reward hanya diperoleh di akhir, menang atau kalah. Sedangkan pada self-driving car, reward bisa diperoleh di tengah proses, misalnya ketika agent terlalu banyak menginjak rem maka waktu perjalanan akan hilang sekian detik yang berarti agent mendapat reward yang buruk.
• State’: Informasi-informasi yang tersedia di environment setelah suatu aksi dilakukan (disebut juga next state). Ketika agent melakukan suatu aksi, agent akan mengubah beberapa informasi pada environment. Posisi bidak catur akan berubah setiap agent melakukan aksi.
• Policy: Algoritma yang menentukan aksi apa yang seharusnya dipilih dengan diketahui state saat ini. Ini yang akan menjadi fokus utama yang akan kita pelajari.

Elemen-elemen tadi tidak langsung muncul ketika kita mengurai masalah. Kadang kita perlu mendefinisikan dengan baik dan hati-hati. Sebagai contoh, dalam menentukan reward, kita harus menentukan secara hati-hati. Apakah berjalan lambat pada self-driving car itu buruk? apakah memakan pion lawan dalam catur itu baik?

Dengan mengetahui elemen-elemen tadi, maka bisa kita rumuskan:

Pada Reinforcement Learning kita diminta untuk membuat suatu Policy agar ketika agent diberikan suatu State, agent dapat mengambil Action yang mengantarkan untuk mendapat kumulatif Reward* sebesar-besarnya

*Kumulatif reward = total reward yang diperoleh dari awal hingga akhir.

Algoritma-algoritma Reinforcement Learning

Ada banyak sekali pilihan algoritma pada RL, dan karena keterbatasan panjang artikel, saya belum bisa bahas di sini. Tapi jika teman-teman mau memulai, dua algoritma yang saya sarankan untuk pelajari adalah:

• Q-Learning / Deep Q-Learning: Pada Q-Learning nanti teman-teman akan belajar bahwa pada kasus RL yang sederhana kita bisa membuat agent cerdas hanya dengan bermodal sebuah tabel. Badanya Q-Learning dengan Deep Q-Learning adalah pada Deep Q-Learning, kita akan menggunakan Neural Network untuk menggantikan tabel yang akan sangat besar.
• REINFORCE: kalau teman-teman sudah paham Q-Learning dan Deep Q-Learning, saya sarankan untuk menengok algoritma ini. Ini akan sedikit membuka pandangan ada pendekatan yang berbeda untuk membuat agent (dua pandangan ini dikenal policy based vs value based)

Bagaimana Codingnya?

Untuk memahami langkah perlangkah dengan baik, kita bisa menulis kodenya dari awal. Bagi pengguna PyTorch, pytorch punya tutorial resmi yang cukup bagus di sini. Kalau mau menggunakan library bisa coba Stable Baseline 3, walaupun ini library tapi jangan kira cuma klik-klik sedikit, karena library ini nggak se-straight forward itu (mungkin karena RL agak kompleks). InsyaAllah saya akan coba buatkan tutorial untuk menggunakan Stable Baseline ini.

Sekian dulu untuk pengantarnya reinforcement learningnya, semoga bermanfaat!. Niatnya nulis ini selesai di minggu pertama Huggingface Course, ternyata sekarang udah jalan 3 minggu tulisannya baru bisa rilis bagi yang mau belajar RL dari course Hugging Face, masih jalan di https://github.com/huggingface/deep-rl-class

Alhamdulillah akhir 2021 lalu nemu tools menarik untuk mencatat hasil eksperimen dengan rapi dan lengkap dan mudah, yakni dengan Weights and Biases.

Weights and Biases (atau kadang ditulis W&B atau kadang juga wandb) adalah suatu tools yang memudahkan pencatatan eksperimen machine learning. Yang menarik dari weights and biases, sesuai dengan taglinenya “Log (Almost) Anything”, dia mampu mencatat hampir semua hal yang terjadi pada saat eksperimen dengan mudah. Beberapa data yang saya ingat bisa dicatat saat setiap run adalah:

• Nilai loss atau akurasi atau nilai-nilai lain yang berubah-ubah saat training
• Pemakaian CPU/GPU
• Media-media yang dihasilkan selama eksperimen (audio/citra/video)
• Perubahan bobot dan bias pada model
• Spesifikasi hardware, software, serta versi package python yang terinstall
• Parameter-parameter model, seperti learning rate, batch size, dsb.

Semua data itu dicatat secara rapi di server saat setiap kali melakukan “run” eksperimen. Jadi ketika kita melakukan beberapa run kita juga bisa membandingkan grafik-grafik data-data tersebut, dan hal ini akan sangat bermanfaat untuk mengukur performa model atau debugging seiring berjalannya waktu.

Weights and Biases Tutorial

Weights and Biases sendiri sebenarnya bisa berjalan hampir di semua framework machine learning seperi Tensorflow, Pytorch, Scikit-learn, dll. Pada tutorial ini kita akan menggunakan kode yang kita gunakan untuk klasifikasi citra menggunakan CNN dan Pytorch.

Secara umum, ada lima langkah utama untuk melakukan pencatatan menggunakan weights and biases:

1. wandb.login(): Untuk menghubungkan projek kita dengan akun W&B yang kita miliki. Secara default W&B membutuhkan koneksi internet untuk menyimpan hasil eksperimen ke server.
2. wandb.init(): Digunakan untuk mendefinisikan projek apa yang sedang kita jalankan. Pada bagian ini kita juga mendefinisikan parameter apa yang akan dicatat dalam sebuah config.
3. wandb.watch(): Digunakan untuk memperhatikan (mencatat) kondisi model dari waktu ke waktu
4. wandb.log(): Digunakan untuk mencatat variabel-variabel lain yang dibutuhkan untuk di catat.
5. wandb.finish(): Menandai akhir proses pencatatan, jika kita ingin memulai proses pencatatan yang lain.

Kode lengkap berupa Notebook disertai penjelasan (Bahasa Inggris) bisa diakses di sini: Pytorch Image Classification + Weights and Biases.

Pada kode tersebut tampak lima poin di atas bisa dilakukan hanya dalam 5 baris saja (masing-masing perintah satu baris). Menggunakan notebook di atas, saya coba bereksperimen dengan mengubah-ubah nilai learning rate dan banyaknya batch saat training. Hasilnya, tampilan ringkasan pencatatan di dashboard Weights and Biases untuk tutorial di atas seperti berikut:

Nama-nama seperti “autumn-cloud-5” dan sebagainya, adalah nama yang secara otomatis diberikan W&B untuk membedakan setiap run eksperimen yang kita lakukan. Kita bisa mengubah-ubahnya semau kita jika itu dirasa memudahkan. Untuk detail setiap run bisa dilihat dengan klik setiap namanya, atau mengubah tampilan dalam bentuk tabel seperti di bawah ini:

W&B Sweeps

W&B juga menyediakan fitur untuk melakukan hyperparameter optimization. Dengan fitur ini, secara otomatis weights and biases akan mencari nilai-nilai untuk setiap parameter yang memberikan hasil terbaik untuk kasus kita. Hasil akhirnya, kita bisa melihat hubungan nilai parameter dengan loss yang diperoleh.

Komunitas Weights and Biases

Yang menarik lagi tentang W&B ini bukan hanya tools yang disediakan namun juga komunitasnya. Saya bahkan lebih dulu mengikuti kegiatan-kegiatan di komunitas W&B sebelum saya mencoba toolsnya. W&B secara aktif mengadakan mini workshop, paper dan book reading group, seminar, Q&A session, dan masih banyak lagi, di mana kita bisa belajar banyak hal seputar machine learning secara umum tidak hanya seputar W&B.

Kalian bisa cek youtube channelnya untuk melihat beberapa rekaman yang tersedia, atau follow akun twitternya untuk bisa update kegiatan-kegiatan terbarunya.

Sekian, Semoga bermanfaat!

Pada tutorial ini kita menggunakan Tensorflow versi 2, yang sedikit berbeda dengan Tensorflow versi 1. Ini salah satu alasan artikel ini tertunda cukup lama, tahun lalu ketika artikel pertama ditulis, Tensorflow versi 2 masih belum cukup stabil untuk object detection maupun untuk diconvert ke TFLite.

Overview

Secara umum ada 3 tahapan untuk membuat model tensorflow untuk mendeteksi objek dan menjadikan model tersebut siap digunakan di Android:

1. Menyiapkan dataset. Jika objek yang ingin kita bukan objek yang umum dideteksi, maka kita perlu menyiapkan dataset terlebih dahulu. Tahap ini sudah dibahas di artikel sebelumnya.
2. Melatih pre-trained model. Kita akan menggunakan pre-trained model, karena untuk merangkai dan melatih model dari awal akan memakan waktu dan membutuhkan resource yang besar. Kita cukup melakukan fine-tuning model agar model memiliki performa yang baik, untuk dataset baru, dengan waktu pelatihan yang lebih singkat.
3. Mengconvert model menjadi TFLite. Proses mengubah model yang sudah dilatih ke format yang dapat dipahami oleh mobile Android.

Source Code

Tutorial Tensorflow Object Detection ini tersedia di Google Colab berikut: https://colab.research.google.com/drive/1dNIIcDBMaKieGzSl1BVE5H6wu17n6cO7?usp=sharing. Untuk dataset dan script-script lain yang akan digunakan dapat diakses di repository github berikut: https://github.com/rianrajagede/object-detection.git. Tutorial ini merujuk pada link Google Colab dan repo github di atas.

1. Instalasi Tensorflow Object Detection

Ketika kita menginstall Tensorflow, kita belum menginstall Tensorflow Object Detection API. Hal ini juga berlaku di Google Colab, kita tetap perlu menginstall Tensorflow Object Detection API terlebih dahulu. Langkah instalasi resminya bisa diakses di sini. Saat artikel ini ditulis instalasi bisa dilakukan dengan:

1. Clone github Tensorflow Object Detection API di Google Colab. Penanda tanda seru (!) di awal baris menunjukkan baris tersebut sedang menjalankan perintah Command Prompt, bukan Python. Perintah ini akan membuat folder models yang berisi file-file dari repository tensorflow object detection.

!git clone https://github.com/tensorflow/models.git

2. Lalu install API menggunakan perintah di bawah. Penanda %%bash fungsinya mirip dengan tanda !, jika perintah %%bash ditulis di awal baris menunjukkan cell Google Colab tersebut sedang menjalankan perintah Command Prompt, bukan Python.

%%bash
cd models/research/
protoc object_detection/protos/*.proto --python_out=.
cp object_detection/packages/tf2/setup.py .
python -m pip install .

3. Jalankan test untuk memastikan instalasi berhasil dengan menjalankan perintah berikut. Jika semua tertulis “OK” berarti instalasi berhasil.

!python models/research/object_detection/builders/model_builder_tf2_test.py

2. Download Dataset

Dataset yang akan kita gunakan ada di repository github yang saya share di bagian Source Code tadi, gunakan perintah di bawah untuk mengkloning repositori ke google colab. Setelah data didownload, lakukan pemrosesan data seperti yang telah dijelaskan di artikel sebelumnya (atau cek link Google Colab di atas di bagian “Menyiapkan TFrecord file”.

!git clone https://github.com/rianrajagede/object-detection.git

Dataset ini berisikan gabungan dari dua public dataset yang terdiri dari objek Rakun dan Kanguru. Setiap citra memiliki file anotasi bertipe XML dengan nama yang sama. Berikut ini contoh citra yang ada di file.

3. Training Pre-trained Model

Pre-trained model adalah model yang siap pakai dan sudah dilatih dengan dataset yang besar. Penjelasan lebih detail tentang pre-trained model dan penggunananya ada di artikel sebelumnya tentang transfer learning.

1. Download Pre-trained model yang akan digunakan. Pre-trained model yang tersedia untuk object detection dapat dilihat daftarnya di halaman ini. Sebagai contoh, kita akan menggunakan salah satu jenis pre-trained model SSD MobileNetv2 (ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz).

Berikut perintah yang digunakan untuk mendownload dan mengekstrak pre-trained model:

!wget http://download.tensorflow.org/models/object_detection/tf2/20200710/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz
!tar -zxvf ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz

Hasil dari proses ini adalah sebuah directory dengan nama yang sesuai dan berisikan pre-trained model.

2. Atur Pipeline.config. Sebelum proses training, kita perlu mengatur beberapa hal di file pipeline.config yang tersedia di folder pre-trained model. File ini bertanggung jawab mengatur parameter-parameter pelatihan ataupun evaliasi seperti lama pelatihan, arsitektur, dsb.

File Pipeline.config bisa dibuka dengan text editor biasa, atau jika menggunakan Google Colab bisa dengan cara double klik, nanti akan muncul jendela editor kecil.

Apa saja yang perlu diatur dari file tersebut? Sebenarnya banyak yang bisa diatur, tapi pada tutorial ini kita atur beberapa hal saja.

• Nilai pada num_class disesuaikan dengan jumlah class yang akan digunakan. Pada tutorial ini num_class: 2
• Temukan bagian fine_tune_checkpoint_type lalu ubah dari classification menjadi detection
• Nilai batch_size menentukan ukuran batch. Kita gunakan batch kecil saja ubah batch_size: 32
• Untuk dataset yang sederhana ini, kita bisa gunakan jumlah iterasi yang kecil. Atur num_steps: 1000
• MobilenetV2 ini secara default dilatih menggunakan learning rate yang dinamis berdasar banyak iterasi (nilai learning rate bisa berubah-ubah). Ini tampak dari bagian di bawah. Karena kita mengubah num_steps lebih kecil, maka kita sesuaikan juga total_steps: 1000 dan warmup_steps: 100.

learning_rate {
        cosine_decay_learning_rate {
          learning_rate_base: 0.07999999821186066
          total_steps: 50000
          warmup_learning_rate: 0.026666000485420227
          warmup_steps: 1000
        }
      }

• Cari pada file pipeline tulisan PATH_TO_BE_CONFIGURED. lalu sesuaikan dengan path yang dituju.
  • Untuk fine_tune_checkpoint arahkan ke checkpoint file dari pretrained model. Berdasarkan tutorial ini, pathnya /content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8/checkpoint/ckpt-0
  • Untuk input_path pada train_input_reader arahkan ke tfrecord data train. Berdasarkan tutorial ini, pathnya /content/object-detection/train.record
  • Untuk input_path pada eval_input_reader arahkan ke tfrecord data test. Berdasarkan tutorial ini, pathnya /content/object-detection/test.record
  • Untuk label_map_path arahkan ke file label_map.pbtxt. Di tutorial ini pathnya /content/object-detection/label_map.pbtxt

3. Jalankan perintah berikut untuk mulai pelatihan. Pada parameter --model_dir kita beritahu di mana model output proses pelatihan ini akan disimpan. Sedangkan parameter --pipeline_config_path berisi path menuju file pipeline.config yang tadi sudah kita edit.

!python /content/models/research/object_detection/model_main_tf2.py \
                --alsologtostderr \
                --model_dir="/content/output/" \
                --pipeline_config_path="/content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8/pipeline.config"

Proses training akan berlangsung cukup lama meskipun telah dijalankan di Google Colab dan dengan data yang tidak terlalu banyak. Untuk 1000 steps, kira-kira proses pelatihan akan memakan waktu 10-15 menit. Setelah proses pelatihan di atas selesai, model akan tersimpan di folder /output dalam format SavedModel.

4. Convert ke TFLite

Model yang dihasilkan sudah bisa digunakan, namun untuk bisa menggunakannya di mobile android, kita perlu mengubah formatnya menjadi bentuk TFLite. Proses pengubahan dari SavedModel ke TFLite dilakukan dalam dua langkah:

1. Buat SavedModel yang “ramah” untuk TFLite. Perintah berikut ini jika dijalankan akan menghasilkan sebuah folder /tflite yang berisi SavedModel juga namun lebih siap untuk dijadikan TFLite (model sementara)

!python models/research/object_detection/export_tflite_graph_tf2.py \
    --trained_checkpoint_dir {'/content/output'} \
    --output_directory {'/content/tflite'} \
    --pipeline_config_path {'/content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8/pipeline.config'}

2. Convert SavedModel tersebut menjadi TFLite. Jalan perintah berikut untuk menghasilkan model.tflite di folder /tflite. Jika diperhatikan, kode di bawah ini merupakan perintah python, untuk menjalankan tentu perlu ada package yang diimport. Cek kode di Colab untuk lebih lengkapnya.

_TFLITE_MODEL_PATH = "/content/tflite/model.tflite"

converter = tf.lite.TFLiteConverter.from_saved_model('/content/tflite/saved_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()

with open(_TFLITE_MODEL_PATH, 'wb') as f:
  f.write(tflite_model)

Dan selesai! kalian bisa cek model.tflite di folder tersebut, lalu menggunakannya di android.

5. Inference Model TFLite

Pada bagian ini kita akan melihat aksi model tflite yang sudah kita buat. Untuk melihat performa model TFLite yang dihasilkan, kita bisa cek menggunakan script yang ada di github repo di atas, yakni TFLite_detection_image.py.

Sebelum menjalankan upgrade terlebih dahulu Open CV di Google Colab ke versi terbaru. Saat artikel ini dibuat OpenCV di Google Colab masih versi lama sehingga bisa menyebabkan error ketika inference

!pip install -U opencv-python

Lalu jalankan script tersebut dengan format sebagai berikut. Script ini akan menguji model untuk mendeteksi objek Rakun dan Kanguru dari folder /object-detection/test_img_only.

!python /content/object-detection/scripts/TFLite_detection_image.py --imagedir "/content/object-detection/test_img_only" \
    --modeldir "/content/tflite" \
    --graph "/content/tflite/model.tflite" \
    --labels "/content/object-detection/labelmap.txt" 

Pada bagian labels path kita diarahkan ke labelmap.txt bukan label_map.pbtxt. File labelmap.txt sedikit berbeda dengan label_map.pbtxt dan digunakan untuk inference di android.

Jika dijalankan, maka script akan menghasilkan gambar yang yang telah dianotasi di home folder.

Sekian, Selamat mencoba semoga bermanfaat, jika ada yang kurang jelas bisa ditanyakan di kolom komentar

^{Photo by Lisette Verwoerd on Unsplash}

Gradient Descent

Gradient descent adalah algoritma optimasi yang digunakan untuk menemukan parameter yang menghasilkan nilai minimum pada suatu fungsi. Dalam kasus neural network, Gradient Descent digunakan untuk menemukan bobot model terbaik yang menghasilkan error minimum. Detail perhitungan gradient descent contohnya ada pada partikel sebelumnya, sedangkan implementasinya dapat di baca di artikel berikut ini.

Secara umum, langkah yang dilakukan untuk mencerdaskan model neural network menggunakan gradient descent adalah sebagai berikut:

1. Sebuah input-x_i masuk ke model neural network, lalu menghasilkan output / error E_i (forward propagation)
2. Gradient descent terhadap output / error E untuk mengupdate nilai bobot model W (backward propagation)
3. Lakukan kedua langkah di atas terhadap semua data berkali-kali hingga diperolah model terbaik.

^{Untuk kemudahan penjelasan, poin no. 1 di atas akan kami sebut sebagai Langkah 1 (bold dengan warna orange) dan poin no. 2 akan kami sebut sebagai Langkah 2 (bold dengan warna ungu)}

Langkah-langkah di atas masih cukup umum, Jika ada lebih dari satu data langkahnya seperti apa? Dari sinilah akan muncul istilah-istilah di awal tadi. Misalkan kita memiliki 100 data latih, maka urutan yang dilakukan pada Gradient Descent adalah:

1. Lakukan Langkah 1 untuk setiap data (dari data latih ke 1 hingga 100), sehingga diperoleh 100 nilai eror E_i
2. Dari 100 nilai error itu, kita hitung rata-ratanya untuk memperoleh sebuah nilai error E
3. Lakukan Langkah 2 menggunakan E untuk mengupdate W (hanya 1x)

Langkah diatas terjadi dalam satu epoch. Untuk mendapatkan model yang baik kita perlu mengulangi langkah di atas lebih dari satu kali (beberapa epoch).

Definisi sebuah Epoch, adalah ketika kita telah menggunakan semua data latih pada proses pelatihan. Pada contoh di atas, kita sudah melalui sebuah epoch karena kita telah menggunakan 100 data latih yang kita miliki.

Pada contoh tersebut sebuah epoch terdiri dari 100 kali Langkah 1 dan 1 kali Langkah 2.

Stochastic Gradient Descent

Ketika data latih yang kita miliki cukup besar, proses pelatihan menggunakan Gradient Descent bisa memakan waktu yang sangat lama. Jika diperhatikan, pada satu epoch hanya terjadi satu kali proses perbaikan model (Langkah 2) dan itu pun menggunakan rata-rata error semua data. Bayangkan jika ada 1,000,000 data, maka rata-rata errornya hanya akan memberi sedikit informasi untuk perbaikan model. Sehingga butuh jumlah epoch yang sangat besar untuk bisa melatih modelnya.

Pada Stochastic Gradient Descent (SGD), rumus perhitungannya tetap sama dengan Gradient Descent, yang membedakan adalah kapan Langkah 2 atau langkah perbaikan bobot model dilakukan. Pada SGD, Langkah 2 tidak dilakukan hanya sekali tiap epoch setelah memproses semua data, melainkan dilakukan setiap satu atau sejumlah data.

Misalnya kita memiliki 100 data latih, dan untuk setiap satu data dilakukan update bobot, maka ilustrasinya seperti di bawah ini. Satu data masuk, dihitung errornya, lalu dengan error tersebut model akan langsung d-update bobotnya.

Dan berikut ini ilustrasi jika dilakukan untuk setiap lima data. Untuk setiap lima data, dihitung rata-rata errornya, lalu menggunakan rata-rata error tersebut diupdate modelnya. Diulangi lagi untuk setiap lima data hingga data terakhir.

Definisi Batch, adalah sejumlah data atau subset data yang diproses menggunakan Langkah 1 sebelum akhirnya model diupdate menggunakan Langkah 2.

Batch Size adalah banyaknya data pada sebuah batch. Pada contoh di-atas diilustrasikan SGD dengan batch size bernilai 1 dan batch size bernilai 5.

Dari ilustrasi di atas tampak jumlah Langkah 2 yang terjadi pada sebuah epoch menjadi berbeda: Pada ilustrasi SGD dengan batch size 1, Langkah 2 dilakukan setiap 1 data sehingga untuk satu epoch terjadi 100 kali Langkah 2. Sedangkan pada ilustrasi SGD dengan batch size 5, langkah 2 dilakukan setiap 5 data, sehingga untuk 100 data, Langkah 2 dilakukan sebanyak 100/5 = 20 kali.

Mini-Batch Gradient Descent adalah jenis SGD dengan batch size lebih dari 1, tetapi bukan keseluruhan data. Seperti contoh di atas, batch size bernilai 5.

Definisi Steps sebenarnya definisi step ini berasal dari framework atau library yang biasanya kita pakai. Jadi silahkan cek kembali untuk memastikan. Tapi pada umumnya, orang-orang menggunakan istilah step untuk menunjukkan berapa kali Langkah 2 dilakukan pada sebuah epoch. Misalnya pada contoh di atas, Mini-batch SGD dengan batch size 5 memiliki 20 steps.

Sebagai penutup, perbedaan jumlah update bobot / backward propagation / Langkah 2 untuk setiap epoch sangat mempengarui proses pelatihan. Analoginya seperti kita sedang tanya alamat rumah di tengah kota, lalu kita menerima jawaban seperti ini:

• Gradient Descent = “Rumahnya di Kota bagian Selatan” (jawaban terlalu umum)
• Stochastic Gradient Descent = “Belok kiri di tikungan depan” (informasi detail tapi bisa jadi terlalu sedikit)
• Mini-batch Gradient Descent = “Ke arah Timur dulu sampai ketemu masjid” (informasi pertengahan)

Penutup

Sebagai penutup, saya mau kasih pertanyaan untuk menguji pemahaman Jika saya memiliki dataset berupa 500 sample citra, lalu saya latih menggunakan batch berukuran 5, selama 100 epoch, berapa banyak step yang terjadi selama pelatihan?

Sekian, semoga bermanfaat!

^{Photo by Andrei Castanha on Unsplash}

Itu jauh lebih banyak daripada data benchmark yang biasa digunakan klasifikasi citra, Imagenet, yang hanya 1000 kelas! Selain itu, tidak mudah juga untuk mendapatkan data per kelasnya. Apakah setiap mahasiswa harus difoto ratusan kali agar dapat data latih yang representatif? lalu bagaimana jika ada mahasiswa baru? nah, di sinilah Siamese Network bisa jadi salah satu solusinya.

Siamese Network

Siamese network adalah jenis arsitektur neural network di mana menerima dua input, yang masing-masingnya masuk ke subnetwork yang sama lalu digabungkan untuk dihitung kemiripan antara dua input tersebut.

Siamese network digunakan untuk menghitung kemiripan dua data. Kemiripan antara dua data di sini tergantung pada kasusnya, misal kemiripan wajah dari orang yang sama namun memiliki dua foto yang berbeda, atau kemiripan gaya berpakaian dari dua orang yang berbeda, dll. Model dilatih dengan menerima input pasangan data, dengan output yang dihasilkan bisa berupa biner (sama atau tidak) atau sebuah real value yang merepresentasikan tingkat tingkat kemiripan.

Siamese network tidak menspesifikkan arsitektur pada bagian subnetwork, asalkan dua arsitektur yang digunakan adalah sama (bentuk dan bobotnya). Kita bisa memakai konsep ini untuk beragam jenis data. Misalnya kita ingin mengecek kemiripan pertanyaan maka kita bisa menggunakan subnetwork berupa LSTM network, jika ingin mengecek kemiripan foto kita bisa gunakan CNN sebagai subnetworknya. Output dari subnetwork ini adalah vektor, dengan ukuran bebas (sebagai hyperparameter yang kita tentukan sendiri)

Ada banyak metode yang bisa dilakukan di bagian penggabungan (Merge) hasil dari dua subnetwork. Beberapa yang pernah saya tahu:

• Hitung selisih absolut antar vektor output subnetwork lalu masukkan vektor selisihnya ke sebuah neural net,
• Concat atau gabungkan kedua output lalu masukkan vektor gabungannya ke sebuah neural net,

Contoh Kasus

Siamese network cocok digunakan jika dataset memiliki banyak sekali class, tapi sampel tiap class sangat sedikit. Misalnya jika kita akan membuat sistem verifikasi wajah untuk presensi.

Langkah pertama yang perlu kita lakukan adalah dengan membuat pasangan-pasangan dari data yang kita miliki. Sebagai ilustrasi anggap kita memiliki foto wajah 5 orang {A, B, C, D, E} dan masing-masing orang memiliki 3 foto {A1, A2, A3, B1, B2, …, E3} maka kita bisa buat pasangan seperti di bawah, dan memberi label “1” untuk yang artinya kedua foto menunjukkan orang yang sama, dan “0” untuk sebaliknya.

Setelah itu model dilatih dengan data tersebut. Inputnya adalah sepasang foto dan outputnya akan diukur menggunakan label yang ada.

Setelah model terlatih, proses verifikasi foto ketika presensi bisa dilakukan dengan mencocokkan sampel yang baru ke foto yang ada di database kita. Jika model memberi output True, maka orang tersebut berhasil teridentifikasi.

Implementasi di PyTorch

Implementasi arsitektur Siamese Network di PyTorch tidak terlalu sulit, tergantung seperti apa subnetwork yang digunakan dan cara penggabungan yang dipilih.

Di bawah ini adalah contoh implementasi Class SiameseNetwork di PyTorch yang sederhana dengan linear layer biasa. Proses merge dilakukan dengan menghitung selisih absolut, lalu memasukkan ke neural net sederhana yang memberi output biner (True / False).

class SiameseNetwork(nn.Module):
    def __init__(self, h, input_size):
        super(SiameseNetwork, self).__init__()
        self.subnet = nn.Linear(input_size, h)
        self.mergenet = nn.Linear(h, 2)
    
    def forward(self, x1, x2):
        output1 = F.relu(self.subnet(x1))
        output2 = F.relu(self.subnet(x2))
        diff = torch.abs(output1 - output2)
        output = self.mergnet(diff)
        return output

Penutup

Sederhananya konsep siamese network di atas bukan berarti model ini adalah model yang “selalu sederhana”. Dalam implementasi ada beberapa hal yang kadang perlu ditambahkan untuk memperbaiki hasil Siamese Network. Salah satunya adalah pemakaian Contrastive Loss. Selain itu, di luar sana juga banyak cara berbeda implementasi proses Merge yang bisa dicoba. Artikel ini hanyalah pengantar Siamese Network.

Selamat bereksplorasi, semoga bermanfaat!

^{Photo by Skyler Smith on Unsplash}

Artikel ini berfokus pada pengenalan singkat tentang fastai dan juga penjelasan tentang kode di atas. Tutorial lebih detail dan mendalam tentang fastai insyaAllah akan kami coba buat di artikel lain.

Berawal dari Pytorch vs Tensorflow

Sebelum kita masuk lebih dalam tentang Fastai, kita akan me-refresh singkat tentang library atau framework di deep learning. Bagi yang belum tahu, ada dua library besar yang saat ini cukup sering digunakan, yakni Pytorch dan Tensorflow. Pytorch dibuat oleh Facebook sedangkan Tensorflow oleh Google. Keduanya memiliki beragam fitur yang mendukung deep learning, salah satunya Autograd yang pernah saya bahas di artikel ini. Nah, sering kali bagi yang baru belajar deep learning akan bertanya:

Pilih pakai Pytorch atau Tensorflow?

Jawaban salah

Tensorflow itu lebih mudah dipelajari dan digunakan daripada Pytorch. Itu jawaban yang sering saya dengar. Kenapa salah? karena saya yakin kebanyakan orang yang jawab itu dia bukan sedang membandingkan Tensorflow yang murni, melainkan library tambahan yang berada di atas Tensorflow, yakni Keras. Tensorflow yang murni bisa dibilang lumayan ribet juga loh untuk dipelajari dan digunakan (apalagi pas masih versi 1.x di tahun 2019)

Jadi sekilas sejarah, dulu library deep learning itu memang susah-susah pemakaiannya (low-level). Library generasi awal, Theano, bahkan ngodingnya harus “jungkir balik” alur mikirnya. Karenanya, dibutuhkan library lagi di atasnya yang high-level (mudah dipahami dan digunakan) namun tetap terintegrasi dengan library yang low-level, lahirlah salah satunya Keras. Sekarang Keras sudah sangat terintegerasi dengan Tensorflow bahkan tidak perlu di-install terpisah. Tutorial Tensorflow-Keras pernah saya tuliskan di sini.

Jawaban benar

Saat ini bisa dibilang Pytorch dan Tensorflow (khususnya versi 2) sangat mirip. Keduanya sama-sama smoothly bisa digunakan untuk hampir kebanyakan kebutuhan riset dan sehari-hari. Jadi apapun librarynya silakan pilih saja, dan yang terpenting, kuasai dulu sebelum coba library lain.

Kembali ke Jawaban yang salah di atas, ketika kita membandingkan Keras dengan Pytorch maka bisa dibilang kurang apple-to-apple. Karena Keras pada dasarnya adalah high-level library sedangkan Pytorch adalah low-level library, jadi jelas Keras terlihat lebih mudah pemakaiannya. Nah, di artikel ini saya akan jelaskan salah satu high-level library paling populer untuk Pytorch, yakni Fastai.

Apa itu Fastai

Fast.ai sebenarnya lebih cocok jika dibilang sebagai nama organisasi riset deep learning. Saya pertama kali dengar nama Fast.ai dari course yang mereka sediakan di sini dengan motto khasnya “Making neural nets uncool again“. Btw, course deep learning yang mereka sediakan sangat bagus, detail, mendalam, namun tetap mudah diikuti jadi wajib dicoba baik untuk pemula ataupun yang sudah berpengalaman.

Nah, selain course, fast.ai juga membuat sebuah library fastai yang dibangun di atas Pytorch. Secara ringkas, library fastai memiliki tujuan yang mirip dengan Keras, yakni menyediakan high-level API untuk pembuatan deep learning di atas library / framework yang telah ada (Pytorch dan Tensorflow). Library ini yang saya gunakan di artikel ini. Seperti yang telah saya tunjukkan di atas, dengan fastai kita bisa mengimplementasikan CNN untuk klasifikasi citra hanya dalam 6 baris kode.

Penjelasan Kode

Oke, kita masuk ke kodenya:

from fastai.vision.all import *
trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224))
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True)
learn = cnn_learner(trainloader, resnet18, metrics=error_rate) 
learn.fine_tune(3) 
print(accuracy(*learn.get_preds(dl=testloader)))

Kode di atas adalah kode yang memang minimalis, menggunakan banyak parameter defaultnya, karena saya hanya menunjukkan betapa simpelnya fastai. Tetapi dengan 6 baris kode tersebut akurasi model yang dihasilkan sangatlah baik. Bisa jadi ada beberapa pengaturan atau sintaks yang mungkin perlu ditambahkan nantinya.

Oke pertama-tama kita akan import library-nya:

from fastai.vision.all import *

Di fastai, fungsi-fungsi dikelompokkan tergantung domain apa yang akan dikerjakan. Ada 4 domain utama yang disediakan fastai saat ini, yakni vision, text, tabular, dan colaborative filtering (untuk sistem rekomendasi). Karena kita ingin membuat proyek deep learning untuk citra, kita cukup import semua yang ada di vision.all. Walaupun dikelompokkan untuk pada 4 kasus di atas, fastai juga tetap punya fungsi-fungsi umum yang bisa digunakan di beragam kasus.

trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224))
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True)

Langkah selanjutnya adalah membuat objek DataLoader. Konsep data loader adalah konsep yang umum digunakan di Pytorch. Intinya sebuah objek yang menghandle hampir semua keperluan data, seperti splitting train-validasi, preprocess, pembagian mana fitur mana label, dsb.

Jika format dataset citra kita sudah “standar” dalam folder dengan struktur seperti ini:

train/
  kelas_1/
     citra_103.png
     citra_22.png
     ...
  kelas_2/
     citra_123.png
     citra_324.png
     ...
  ...

Maka kita bisa menggunakan fungsi `ImageDataLoaders.from_folder` untuk secara otomatis me-load data. Perlu dicatat, fastai bisa dibilang hampir mewajibkan untuk penggunaan data validasi, ketika tidak kita sediakan maka fastai yang akan otomatis melakukan split dataset. Pada contoh di atas ada parameter valid_pct=0.2 yang artinya 20% data akan dipilih secara random untuk validation. Sedangkan parameter item_tfms digunakan untuk proses transformasi data. Pada kode diatas, kita beri nilai Resize(224) yang artinya setiap citra akan di-resize ukurannya menjadi 224×224.

Pada baris kedua kita membuat data loader lagi kali ini untuk data test atau data pengujian. Di sini saya meng-“copy” proses yang terjadi pada trainloader tapi untuk kebutuhan test menggunakan fungsi trainloader.test_dl()dan menginfokan untuk menggunakan get_image_files() untuk me-load data citra. Kita juga menggunakan parameter with_labels=True untuk memberi tahu agar testloader menyimpan info label dari data test untuk menghitung akurasi.

Khusus untuk pengguna windows! sampai tulisan ini dibuat, ada bug yang membuat kita perlu menambahkan parameter num_workers=0 di kedua fungsi loader di atas, sehingga akan tampak seperti berikut:

trainloader = ImageDataLoaders.from_folder("train/", valid_pct=0.2, item_tfms=Resize(224), num_workers=0)
testloader = trainloader.test_dl(get_image_files("test/"), with_labels=True, num_workers=0)

Langkah selanjutnya kita akan membuat model CNN kita. Mungkin tepatnya bukan membuat, melainkan kita akan menggunakan pretrained model CNN yang sudah tersedia alias kita akan melakukan transfer learning:

learn = cnn_learner(trainloader, resnet18, metrics=error_rate) 

Pada kode di atas kita membuat objek learner yang menggunakan pretrained model ResNet18 dengan data train dari trainloader. Kita juga menginfokan pada learner untuk menampilkan error_rate di log nantinya.

Setelah itu kita cukup jalankan perintah berikut untuk memulai proses pelatihan dengan fine tuning sebanyak 3 epoch (dalam pengaturan default, tepatnya 1 epoch dalam keadaan freeze, dan 3 epoch dalam keadaan semua layer unfreeze):

learn.fine_tune(3) 

Salah satu yang saya suka dari fastai juga adalah ketika proses training berjalan, progress barnya menarik (baca: info yang ditampilkan lengkap dan cukup untuk jadi log)

Dan dilanjut dengan menampilkan akurasi ke data test menggunakan fungsi get_preds(). Fungsi tersebut akan mengoutputkan dua nilai dalam bentuk tuple, yakni prediksi dan target/label seharusnya. Sedangkan fungsi accuracy juga bawaan dari fastai untuk menampilkan akurasi diketahui nilai prediksi dan target.

print(accuracy(*model.get_preds(dl=testloader)))

Tanda * digunakan untuk “memecah” elemen-elemen tuple untuk menjadi parameter di sebuah fungsi.

Hasilnya?

Saya menggunakan data yang sama pada tutorial CNN menggunakan Pytorch. Hanya dengan 3 epoch dan 6 baris kode akurasi model dari datatest mencapai 89.17%! Padahal di artikel sebelumnya kita hanya dapat di sekitar 70%

Tutorial Lebih Lanjut

Bagi teman-teman yang tertarik dengan fastai, bisa banget untuk langsung lanjut memperdalam library ini. InsyaAllah kami berencana untuk membuat artikel lain yang membahas fastai lebih lanjut, tapi tidak tahu juga kapan akan publish jadi bisa mulai belajar mandiri dari sumber belajar berikut:

• Course fastai : saya rekomendasikan tonton 2-3 video dulu agar terbayang gambaran umumnya. Sebagai catatan, course ini tidak hanya membahas teknis tetapi juga banyak sisi teorinya, menarik!
• Official Tutorial fastai: tapi sejujurnya saya kurang merekomendasikan, dulu belajar dari sini ngerasa agak kesulitan memahami “kenapa-kenapa” nya
• Walk With Fastai: dibuat oleh Zach Mueller (bukan official fastai), berisi course-course yang cocok untuk temen-temen yang ingin fokus ke sisi praktiknya. Saya sangat terbantu dengan walk with fastai, sangat melengkapi course dan tutorial resmi dari fastai

Sekian, semoga bermanfaat! jadi mau pakai library apa untuk proyek deep learning selanjutnya?

_{Cover Photo by Arie Wubben on Unsplash}

Model Deep Learning

Sebelum masuk lebih dalam ke transfer learning, saya ingin mengingatkan sedikit tentang bagaimana konsep deep learning (secara umum machine learning) bekerja.

Suatu agen cerdas yang menggunakan deep learning bekerja menggunakan data. Kita berikan data yang banyak untuk dipelajari, kita lakukan proses training/belajar, lalu kita akan mendapat model/agen yang cerdas.

Lalu muncul pertanyaan..

Proses pencarian data itu rumit, proses training itu makan waktu, kenapa kita tidak download saja model cerdas yang ada di internet lalu kita gunakan untuk masalah kita? tidak perlu train, dan tidak perlu ada data, beres kan?

Transfer Learning

Ide utama dari transfer learning ini kira-kira seperti ini,

Kita gunakan model yang sudah dicerdaskan orang lain untuk permasalahan kita, yang bahkan bisa jadi berbeda

Sebagai contoh, kita mau membuat sistem untuk menghitung kendaraan beserta jenisnya menggunakan kamera CCTV. Jika jenis kendaraannya yang ingin dideteksi cukup umum, semisal “mobil” atau “truk”, kita bisa jadi cukup browsing-browsing, dan kita akan menemukan orang yang sudah membuat model deep learningnya. Kita tinggal download, pakai, dan selesai! Kita telah memiliki model cerdas deep learning yang mampu mendeteksi mobil atau truk. Tanpa perlu mencari data, tanpa perlu melatih model.

Tapi seringnya permasalahan yang kita miliki sedikit berbeda. Sedikit saja perbedaan, maka kita sudah tidak bisa lagi pakai model orang lain ini. Contohnya, kita tidak hanya ingin mendeteksi “mobil” dan “truk” tapi juga “becak”. Permasalahannya, “becak” itu bukan kendaraan yang di mana-mana ada. Sangat mungkin model yang kita download tadi belum bisa mendeteksi becak.

Di sinilah, kita butuh transfer learning. Kembali ke ide utama di atas, dengan transfer learning, kita bisa memanfaatkan model orang lain yang sudah dilatih, untuk permasalahan kita yang berbeda.

Jadi ada 3 poin yang kita bahas di sini:

• Model yang sudah dicerdaskan
• Cara menggunakan model tersebut
• Permasalahan yang (bisa jadi) berbeda

Oh ya, sebelum masuk lebih dalam, konsep Transfer Learning ini berlaku tidak hanya untuk arsitektur CNN saja. Tapi pada tutorial ini saya akan banyak mencontohkan menggunakan CNN karena lebih mudah dibayangkan.

1. Model yang sudah cerdas

Pada transfer learning, kita membutuhkan model yang sudah terlatih, entah itu dilatih oleh orang lain, atau kita melatihnya terlebih dahulu. Model yang sudah terlatih ini disebut dengan Pre-Trained Model. Pre-trained model biasanya sudah dilatih pada dataset yang besar dan merupakan dataset benchmark, sehingga kualitas pre-trained model harusnya sudah sangat baik.

Saat ini sudah banyak pre-trained model yang disediakan untuk beragam kebutuhan. Misalnya pada halaman ini PyTorch menunjukkan pre-trained model yang tersedia secara resmi untuk image classification yang telah dilatih menggunakan dataset ImageNet. Pada halaman ini Tensorflow juga menunjukkan model-model yang tersedia untuk object detection. Kumpulan pre-trained model ini juga biasa disebut dengan Model Zoo.

Alternatif lain selain menggunakan model resmi dari framework, kita juga bisa browsing-browsing dan pakai pre-trained model yang disediakan peneliti-peneliti lain, misalnya model SiameseFC ini. Atau kita juga bisa saja membuat pre-trained model sendiri.

2. Cara menggunakan

Secara umum ada dua cara menggunakan model pre-trained untuk transfer learning. Kedua cara ini pada ilustrasi diatas ditunjukkan dengan simbol gembok terbuka atau tertutup:

2.1. Fixed Feature Extractor

Pada metode ini kita menggunakan pre-trained model yang telah dilatih tanpa melatih ulang model tersebut, atau istilahnya kita membekukan (freeze) bobot pre-trained model ini. Cara pemakaian yang umum untuk freezed model adalah sebagai feature extractor.

Sebagai contoh, kita download pre-trained model resnet18 yang sudah dilatih ke data ImageNet. Arsitektur Resnet18 sama seperti arsitektur CNN pada umumnya memiliki bagian “konvolusi” dan memiliki bagian “klasifikasi”. Karena arsitektur Resnet ini sudah dilatih maka semua bobot-bobotnya sudah memiliki nilai yang bagus untuk klasifikasi citra di dataset ImageNet. Data imagenet terdiri dari sekitar 1000 kelas.

Jika kita buang layer klasifikasi terakhirnya (diilustrasikan warnah merah di gambar di atas), ketika kita inputkan citra, model akan mengoutputkan suatu vektor nilai dari proses konvolusi. Vektor ini bisa kita anggap sebagai fitur citra yang diekstrak menggunakan pre-trained model. Fitur vektor yang dihasilkan ini nantinya bisa dimanfaatkan untuk beragam kebutuhan. Misal karena vektor itu dianggap fitur, jadinya bisa masuk ke classifier lain (misalnya SVM), lalu classifier tersebut di train (tanpa melatih pre-trained modelnya ya, kan sedang di freeze) untuk klasifikasi.

Dengan mengganti layer terakhir pre-trained model, jumlah class pada classifier ini tidak harus sama dengan pre-trained model, misalnya di pre-trained model ada 1000 kelas dan kita hanya ingin membuat model yang mampu mengklasifikasi 2 kelas (mobil atau truk) ya cukup kita ataur di classifier ini hanya 2 kelas.

2.2. Fine Tuning

Pada metode ini kita menggunakan pre-trained model yang telah dilatih namun tidak kita freeze. Jadi meskipun model sudah dilatih, nantinya pre-trained model ini akan dilatih lagi untuk kebutuhan yang baru.

Sebagai contoh, kita ingin melatih model untuk mendeteksi jenis-jenis kendaraan di Indonesia, “motor”, “andong”, dan “becak”. Anggap kita memiliki pre-trained model yang sudah bisa membedakan “truk” dan “mobil”. Kita bisa melatih ulang model ini menggunakan data citra “motor”, “andong”, dan “becak” dengan bobot pre-trained model tadi sebagai bobot awal pelatihan. Proses melatih model dengan nilai awal bobot adalah berasal dari pre-trained model disebut dengan Fine Tuning.

Loh kok bisa model yang awalnya digunakan untuk mendeteksi “mobil” dan “truk” digunakan untuk mendeteksi “motor”, “andong”, dan “becak”? Bisa loh :D, karena pre-trained model yang mampu mendeteksi “mobil” dan “truk”, setidaknya memiliki “pengetahuan” yang bisa dimanfaatkan untuk mendeteksi objek lain. Misalnya, model tersebut sudah paham mana yang objek mana yang latar belakang; mana yang pohon mana yang bukan; dsb. Kita melakukan transfer pengetahuan tersebut untuk kebutuhan baru. Karenanya kita masih perlu melatih lagi (walau kebanyakan proses pelatihan jauh lebih cepat karena model sudah sedikit cerdas).

2.3. Metode Pertengahan

Selain dua metode di atas, ada juga yang pertengahan yang seakan mengkombinasikan keduanya. Alias, sebagian layer di-freeze, sebagian layer tidak di-freeze. Biasanya layer yang di-freeze adalah beberapa layer yang di depan (yang dekat dengan input layer dan menyimpan informasi yang low-level) sedangkan layer yang di belakang, yang menyimpan informasi yang lebih high-level, tidak di-freeze untuk di-fine tune. Ini biasanya digunakan ketika data yang digunakan untuk melatih pre-trained model dirasa sedikit berbeda dengan data yang baru. Selain itu ini juga kadang dilakukan untuk menghindari fine tuning semua layer. Karena melakukan fine tuning secara tidak hati-hati di semua layer dapat “membodohkan” model yang sudah cerdas.

Permasalahan seperti apa

Berdasarkan kondisi dataset yang akan digunakan dan pre-trained model yang kita miliki, ada sedikit “aturan” yang bisa kita ikuti, kapan dan teknik seperti apa yang bisa digunakan untuk transfer learning. Saya tidak akan menjelaskan detailnya, bisa dibaca di bagian “When and how to fine-tune?” dari https://cs231n.github.io/.

Sekian untuk artikel ini, semoga bermanfaat! InsyaAllah implementasinya menyusul

Dataset

Dataset yang akan kita gunakan adalah citra barang-barang yang ada di sebuah toko (dimodifikasi dari Freiburg Groceries Dataset) yang terdiri dari 5 kelas, yakni citra produk Susu (MILK), Air mineral (WATER), soda (SODA), jus (JUICE), dan cuka (VINEGAR). Total terdapat sekitar 900-an gambar untuk pelatihan dan 120 gambar untuk pengujian. Semua citra berukuran sama, yakni 256×256 pixel. Dataset dan code bisa di-download di repository berikut.

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.

Pre-Processing

Jika diperhatikan, format folder dataset yang telah di-download adalah seperti berikut.

dataset/
   train/
      kelas_1/
         citra_103.png
         citra_22.png
         ...
      kelas_2/
         citra_123.png
         citra_324.png
         ...
      ...
   test/
      ...

Format tersebut adalah format standar untuk image classification. Ketika format foldernya sudah seperti itu, beberapa framework seperti Tenorsflow atau PyTorch sudah menyediakan cara mudah untuk meload data. Pada Tensorflow kita bisa menggunakan perintah berikut untuk meload dataset.

from tensorflow.keras.preprocessing.image import ImageDataGenerator

datagen = ImageDataGenerator(rescale=1/255.) # pre-processor
datatrain = DirectoryIterator('train', datagen) # load trainset dari folder train/
datatest = DirectoryIterator('test', datagen) # load testset dari folder test/

Objek datagen adalah objek ImageDataGenerator() yang berfungsi untuk memproses data sebelum di load. Ada banyak fungsi di dalamnya. Pada artikel ini kita hanya menggunakan fungsi rescale. Fungsi rescale digunakan untuk mengubah skala nilai citra. Jadi ketika citra itu di load, citra direpresentasikan sebagai array 3D (atau kadang disebut Tensor) dengan nilai rentangan antara 0..255. Pada parameter rescale saya beri nilai “1/255” yang artinya nanti setiap nilai akan dikali 1/255 sehingga rentangan nilainya akan berubah diantara 0..1. Kenapa perlu diubah rentangan nilai ini? agak panjang detailnya tapi intinya untuk memudahkan neural network belajar.

Hasil dari perintah diatas akan menghasilkan object Tensorflow Dataset, sebuah object yang memudahkan proses pengolahan dataset. Sebagai contohnya kita bisa coba jalankan perintah di bawah, maka akan dihasilkan informasi-informasi dari dataset yang kita miliki.

print(datatrain.class_indices) # menampilkan kelas-kelas pada dataset
print("banyak batch:", len(datatrain)) # menampilkan banyak batch

for imgs, labels in datatrain: # datatrain bukan array, hanya bisa diakses melalui perulangan
    print("apa itu imgs", type(imgs)) # numpy array 4D
    print("dimensi imgs dengan batch:", imgs.shape)  # (n-batch, panjang, lebar, channel)
    print("dimensi gambar:", imgs[0].shape) # ukuran tiap gambar
    print("contoh gambar (hanya channel Red)") # nilai ada antara 0 sampai 1
    print(imgs[0,:,:,0])
    print("contoh label") 
    print(labels[0]) # sudah "one-hot". Bukan tertulis kelas "3" tapi [0, 0, 0, 1, 0]

    print("contoh gambar visualnya")
    plt.imshow( imgs[0] )
    break

Implementasi

Arsitektur CNN

Pada tutorial ini, kita akan menggunakan model CNN sama seperti yang kita gunakan pada artikel sebelumnya (silakan baca pada artikel tersebut untuk detail penjelasan arsitektur yang digunakan). Model dengan dua convolutional layer dan sebuah fully connected layer. Dengan detail parameter setiap layer sebagai berikut:

Pembuatan model di Tensorflow ada banyak cara, yang paling mudah adalah menggunakan Keras Sequential. Sebelum mendefinsikan model beberapa library perlu yang diimport untuk pembentukan model, yakni:

import tensorflow as tf
from tensorflow.keras import Sequential, layers

Lalu untuk membuat modelnya kita definsikan menggunakan Keras Sequential. Dengan menggunakan Keras Sequential, layer-layer arsitektur jaringan saraf tiruan didefinisikan secara urut dari depan (input layer) sampai belakang (output layer). Untuk model dengan ilustrasi di atas, kita definisikan sebagai berikut:

model = Sequential([
  layers.Conv2D(16, 3, activation='relu'),
  layers.MaxPooling2D(),
  layers.Conv2D(32, 16, activation='relu'),
  layers.MaxPooling2D(),
  layers.Flatten(),
  layers.Dense(512, activation='relu'),
  layers.Dense(5, activation='softmax')
])

Alur Pelatihan

Setelah model jadi dibuat, kita bisa compile model kita dengan algoritma optimasi apa yang akan kita gunakan untuk pelatihan model kita:

model.compile(loss='categorical_crossentropy',
     optimizer=tf.keras.optimizers.Adadelta(learning_rate=0.001),
     metrics=['accuracy'])

Lalu jalankan pelatihan dengan perintah berikut:

model.fit(datatrain, batch_size=16, epochs=20, verbose=1)

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 cukup dilakukan dengan perintah berikut:

test_loss, test_acc = model.evaluate(datatest, verbose=1)

Variabel test_loss akan menyimpan nilai error hasil data test sedangkan test_acc akan menympan nilai akurasi hasil data test.

Selesai!

Jika dibandingkan dengan proses klasifikasi citra menggunakan PyTorch, dapat dilihat kode Tensorflow seakan lebih ringkas. Fungsi .fit() dari Keras sangat meringkas proses iterasi pelatihan pada PyTorch.

Tapi kalau saya pribadi hal tersebut malah menjadi kekurangan dari Tensorflow. Menyembunyikan “bagian utama” dari proses pelatihan neural network malah membuat saya tidak nyaman untuk mengajari alur pelatihan yang terjadi, atau berekpserimen lebih dalam. Tapi ya setiap orang punya pendapat masing-masing yang penting “dicoba dulu saja..”. Semoga bermanfaat!