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)

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}

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!

Facebook Detectron 2 adalah salah satu python framework yang dapat digunakan untuk kasus object detection. Detectron dikembangkan oleh Facebook dengan menggunakan basis PyTorch sebagai deep learning frameworknya. Bagi yang belum tahu tentang PyTorch, bisa cek website resminya atau kunjungi tutorial kami sebelumnya di sini.

Framework lain untuk deteksi objek yang cukup populer adalah Tensorflow object-detection API (TFOD) yang dikembangkan oleh Google. Keduanya hampir memiliki fitur utama yang sama, salah satunya mereka menyediakan Model Zoo, di mana kita bisa mulai proses training menggunakan model yang sudah ada (pretrained model).

Artikel telah di update 16 Januari 2020 pada perubahan instalasi Detectron 2 versi 0.3

Detectron 2 Tutorial

Pada tutorial ini kita akan menggunakan Google Colab. Contoh code yang akan dibahas pada artikel ini tersedia di sini.

1. Dataset
2. Instalasi
3. Menyiapkan DatasetCatalog
4. Training Model
5. Save and Load Model

1. Dataset

Dataset yang akan kita gunakan sama dengan dataset dari tutorial sebelumnya. Kita akan mendeteksi pada suatu citra apakah ada kangguru atau rakun. Penjelasan detail format data dan bagaimana memprosesnya dapat dilihat pada artikel sebelumnya. Tapi, karena artikel sebelumnya digunakan untuk object detection dengan Tensorflow sedangkan kita di sini akan menggunakan PyTorch Detectron, maka kita tidak perlu memproses data sampai membuat file tfrecord, cukup sampai bagian membuat file csv.

Dataset latihan dapat didownload melalui github dengan menuliskan perintah berikut di google colab. Detail dataset dapat dibaca di file Readme:

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

2. Instalasi Detectron 2

Sebelum menginstall detectron kita perlu menginstall PyTorch, pyyaml, dan pycocotools dengan versi yang sesuai. Di Google Colab PyTorch sudah otomatis terinstall, kita cukup menginstall 2 package sisanya melalui Google Colab:

! pip install pyyaml==5.1 pycocotools==2.0.1

Kita juga perlu memperhatikan versi PyTorch yang tersedia dan versi Cuda. Hal ini bisa dilakukan dengan menjalankan perintah berikut di Colab:

import torch
print(torch.__version__)

Pada saat tutorial ini ditulis, output dari perintah di atas adalah 1.6.0+cu101 yang artinya terinstall PyTorch versi 1.6.0 dengan Cuda versi 10.1. Selanjutnya kita cukup install Detectron berdasarkan versi yang sesuai, petunjukknya dapat dibaca di link berikut.

! python -m pip install detectron2 -f  https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.7/index.html

3. Menyiapkan DatasetCatalog

Detectron menyimpan dataset pada sebuah object bernama DatasetCatalog. Sebelum memulai training, kita perlu mengconvert dataset kita yang awalnya berbentuk XML ke DatasetCatalog.

DatasetCatalog adalah sebuah list of dictionary dengan setiap elemennya berformat sebagai berikut:

{'annotations':
    [{'bbox': [LIST KOORDINAT BOUNDING BOX 1],
       'bbox_mode': <FORMAT BOUNDING BOX 1>,
       'category_id': LABEL INDEX OBJECT 1},
     {'bbox': [LIST KOORDINAT BOUNDING BOX 2],
       'bbox_mode': <FORMAT BOUNDING BOX 2>,
       'category_id': LABEL INDEX OBJECT 2},
       .... ],
 'file_name': 'PATH KE FILE JPG',
 'height': TINGGI GAMBAR,
 'width': LEBAR GAMBAR,
 'image_id': ID GAMBAR,
}

Code yang diperlukan untuk mengconvert dari CSV dataset kita sebagai berikut (penjelasan dalam bentuk komentar):

# Buat dictionary berisikan nama label dan indexnya
labelmap = {
    "kangaroo" : 0,
    "raccoon" : 1
}

# Buat fungsi get_dicts() untuk mengconvert XML ke DatasetCatalog.
# Parameter settype digunakan untuk membedakan file dataset,
# Karena data test dan data train diperlakukan sama, maka saya
# memilih untuk menggunakan satu fungsi untuk memproses dua 
# DatasetCatalog, yaitu untuk train dan untuk test
def get_dicts(settype):
    if settype=="test":
        csvpath = main_path+"/test_labels.csv"
    else:
        csvpath = main_path+"/train_labels.csv"

    df = pd.read_csv(csvpath).values # load dataset

    dataset_dicts = []
    done = []
    for idx in range(len(df)):
        record = {}
        filename = df[idx, 0]
        record["image_id"] = idx
        record["file_name"] =  main_path+"/"+settype+"/"+filename
        record["width"] = df[idx, 1]
        record["height"] = df[idx, 2]

        if filename in done: # untuk menghindari duplikat
            continue
        done.append(filename)

        objs = []
        for row in df[df[:,0]==filename]: # simpan semua objek
            objs.append({
                    "bbox": [ row[4], row[5], row[6], row[7]],
                    "bbox_mode": BoxMode.XYXY_ABS,
                    "category_id": labelmap[row[3]],
            })
        record["annotations"] = objs
        dataset_dicts.append(record)

    return dataset_dicts

Selanjutnya kita cukup menggunanakan perintah berikut untuk membuat DatasetCatalog dengan nama rk_train dan rk_test. Sekaligus kita juga membuat MetadataCatalog untuk menyimpan informasi objeknya.

DatasetCatalog.register("rk_train", lambda t="train":get_dicts(t))
DatasetCatalog.register("rk_test", lambda t="test":get_dicts(t))
MetadataCatalog.get("rk_train").set(thing_classes=["kangaroo", "raccoon"])
MetadataCatalog.get("rk_test").set(thing_classes=["kangaroo", "raccoon"])

4. Training Model

Dengan menggunakan pretrained model, yang perlu kita lakukan adalah mendownload model dari Model Zoo lalu melakukan sedikit config atau pengaturan. Detail penjelasan pengaturan ini dapat dilihat di dokumentasi resmi Detectron 2.

from detectron2.engine import DefaultTrainer
from detectron2.config import get_cfg

cfg = get_cfg()
pre_mod = "COCO-Detection/faster_rcnn_X_101_32x8d_FPN_3x.yaml"

# pilih dan download model
cfg.merge_from_file(model_zoo.get_config_file(pre_mod))
cfg.MODEL.WEIGHTS = model_zoo.get_checkpoint_url(pre_mod)

# atur data train dan test
cfg.DATASETS.TRAIN = ("rk_train",)
cfg.DATASETS.TEST = ()

# atur pelatihan
cfg.DATALOADER.NUM_WORKERS = 2
cfg.SOLVER.IMS_PER_BATCH = 2
cfg.SOLVER.BASE_LR = 0.005  # learning rate
cfg.SOLVER.MAX_ITER = 100  # banyak iterasi
cfg.MODEL.ROI_HEADS.BATCH_SIZE_PER_IMAGE = 48
cfg.MODEL.ROI_HEADS.NUM_CLASSES = 2

Setelah pengaturan di atas, proses training cukup menjalankan perintah berikut:

# membuat direktori output pelatihan
os.makedirs(cfg.OUTPUT_DIR, exist_ok=True)

trainer = DefaultTrainer(cfg) 
 # resume=False artinya pelatihan baru bukan melanjutkan
trainer.resume_or_load(resume=False)
trainer.train()

Hasil dari proses pelatihan ini akan muncul di folder output. Model akhir bernama model_final.pth

5. Load Model

Kita bisa gunakan model akhir tersebut untuk mendeteksi citra dengan langkah berikut. Pertama-tama kita load terlebih dahulu model dan beri sedikit pengaturan treshold.

cfg.MODEL.WEIGHTS = os.path.join("output/", "model_final.pth")
cfg.MODEL.ROI_HEADS.SCORE_THRESH_TEST = 0.8  
predictor = DefaultPredictor(cfg)

predictor adalah objek model kita. Untuk melakukan deteksi kita cukup menuliskan perintah berikut:

from detectron2.utils.visualizer import ColorMode

im = cv2.imread("/content/TestImage.png") # load image
outputs = predictor(im) # predict
v = Visualizer(im[:, :, ::-1], metadata=metadata, scale=0.8) # visualisasi
out = v.draw_instance_predictions(outputs["instances"].to("cpu"))
cv2_imshow(out.get_image()[:, :, ::-1])

Variabel outputs yang dihasilkan menyimpan data-data seperti koordinat bounding box, score, dan class object pada gambar sehingga mudah diolah. Untuk visualisasi kita bisa memanfaatkan fungsi Visualizer bawaan Detectron yang dapat langsung menampilkan gambar disertai bounding boxnya seperti di bawah ini:

Sekian tutorialnya, semoga bermanfaat! kode yang kami bahas di artikel ini tersedia di sini.

Membuat model object detection bukanlah suatu yang mudah, dan menjadikannya bisa dijalankan di Handphone adalah masalah yang lain lagi. Pada artikel ini saya akan coba jelaskan bagaimana membuat sebuah model object detection menggunakan custom dataset buatan sendiri yang nantinya dapat diaplikasikan ke mobile (Android/IOS). Artikel ini fokus ke tahap pertama, yakni penyiapan data.

Tensorflow Object Detection API

Kami menggunakan framework Tensorflow untuk menyelesaikan permasalahan ini. Ada beberapa pertimbangan kenapa framework ini cukup cocok untuk melakukan object detection melalui handphone:

1. Salah satu keunggulan Tensorflow adalah kemudahannya dalam mengimplementasi model ke Handphone Android, misalnya dengan mengkonversi model menjadi TFLite model. (Tensorflow dan Android sama-sama dipegang Google)
2. Selain itu Tensorflow juga menyediakan beberapa API yang memudahkan kita dalam proses pembuatan model object detection dengan custom dataset (dataset buatan kita sendiri).

Pada artikel ini Kami akan menggunakan Tensorflow versi 2. Tensorflow dan Tensorflow object detection diinstall secara terpisah. Detailnya bisa dilihat sesuai dokumentasi resminya (bisa update setiap waktu) atau di artikel selanjutnya.

Dataset untuk Object Detection

Format dataset untuk Object Detection berbeda dengan dataset yang digunakan pada klasifikasi citra biasa. Data yang digunakan untuk kasus deteksi objek biasa memiliki label berupa file terpisah yang mencatat nama objek dan lokasi objek tersebut pada suatu citra. File label ini seringnya disebut file anotasi.

Terdapat dua style penulisan file anotasi yang cukup populer, yakni style COCO dataset dan PASCAL-VOC. Pada tutorial ini Kami menggunakan format PASCAL-VOC XML dengan contoh tampilan seperti berikut:

<annotation>
	<folder>My Drive</folder>
	<filename>Image1.jpg</filename>
	<path>C:\My Drive\Image1.jpg</path>
	<source>
		<database>Unknown</database>
	</source>
	<size>
		<width>1280</width>
		<height>720</height>
		<depth>3</depth>
	</size>
	<segmented>0</segmented>
	<object>
		<name>Object 1</name>
		<pose>Unspecified</pose>
		<truncated>0</truncated>
		<difficult>0</difficult>
		<bndbox>
			<xmin>925</xmin>
			<ymin>343</ymin>
			<xmax>1097</xmax>
			<ymax>464</ymax>
		</bndbox>
	</object>
</annotation>

Jadi pada contoh di atas saya punya file citra “Image1.jpg” dan file XML “Image1.xml”. Isi dari file XML nya adalah data di atas. Berisikan koordinat objek yang ingin dideteksi. Pembuatan file XML ini tidak perlu dibuat manual (diketik satu persatu), kita bisa menggunakan software anotasi. Anotasi citra diatas dibuat menggunakan software labelimg.

Penyiapan Dataset

Dataset dengan format di atas belum bisa langsung diproses oleh Tensorflow. Ada beberapa penyesuaian data yang perlu dilakukan sebelum masuk ke proses model training, kira-kira alur pemrosesan datanya akan seperti ini:

1. Jadi setelah punya gambar beserta anotasi XML untuk setiap gambar, langkah pertama adalah kita perlu convert dulu ke CSV. File CSV ini hanya terdiri dari 1 file yang “merangkum” semua file xml yang kita punya
2. Dari file CSV tersebut lalu kita convert ke TFRecord file, suatu objek yang dapat dibaca oleh tensorflow dengan mudah.
3. File TFRecord ini yang nantinya akan digunakan untuk proses pelatihan.

Perlu diperhatikan, untuk memudahkan semisal perlu ada pembagian data train, data validation, dan data test, proses pemisahan ini dilakukan sebelum konvert ke CSV ya, jadi ilustrasi di atas hanya untuk salah satu set, data train misalnya.

1. Struktur Folder Penyimpanan

Sebelum mulai, kita samakan dulu struktur folder penyimpanannya. Berikut struktur folder yang biasa saya gunakan:

• DATASET
  • train
    • image1.jpg
    • image1.xml
    • image2.jpg
    • image2.xml
    • …
  • test
    • image102.jpg
    • image102.xml
    • …
  • validation
    • …

Jadi kita punya folder “DATASET” lalu di dalamnya ada 3 buah subfolder, train, test, dan validation. Masing-masing folder tersebut berisikan image dan file xml nya. Di sini file image bisa jadi terdiri dari beberapa kelas (seperti contoh gambar di atas artikel ini). Image dengan nama yang berbeda harus merujuk ke citra yang memang berbeda.

Source Code

Pada artikel ini saya menggunakan script-script yang saya modifikasi dari internet. Script-script tersebut dapat diakses di https://github.com/rianrajagede/object-detection. Ada 2 cara penggunaan script tersebut:

1. Kita run di komputer kita dengan menjalankan perintah python namascript.py di folder yang sesuai
2. Atay jika ingin menggunakan script-script tersebut di Google Colab, silakan upload script tersebut di drive lalu jalankan perintah-perintah di bawah nanti dengan tambahan tanda seru: !python path/ke/file.py ... di notebook Google Colab.

2. Membuat file CSV

Setelah folder telah siap, proses selanjutnya adalah membuat sebuah file csv untuk setiap subfolder. Sebenarnya proses ini tidak wajib, tapi mengulik data dalam format xml yang terpisah-pisah menurut saya jauh lebih sulit.

Silakan gunakan script yang telah saya sedikit modifikasi dari internet, xml_to_csv.py. Copy script tersebut ke dalam folder DATASET. Setelah itu jalankan script tersebut 3x dengan perintah berikut:

python xml_to_csv.py --type train
python xml_to_csv.py --type test
python xml_to_csv.py --type validation

Setelah program tersebut dijalankan nanti akan didapat 3 buah file: train_labels.csv, test_labels.csv, dan validation_labels.csv. Masing-masing file menyimpan “ringkasan” data untuk masing-masing subfolder.

2.5 Membuat file Label Map

Sebelum membuat file TFrecord kita perlu membuat dulu file labelmap. File labelmap berisi daftar keseluruhan label yang ada pada dataset. Untuk data dengan jumlah label yang sedikit, membuat labelmap tidak lah sulit secara manual, formatnya kira-kira seperti ini:

item{
    id: 1
    name: 'KUDA'
}
item{
    id: 2
    name: 'MOBIL'
}
...

Tapi karena di beberapa proyek, label objek pada dataset cukup banyak, maka saya sudah buatkan script yang meng-generate secara otomatis, generate_labelmap.py. Copy script tersebut ke dalam folder DATASET, lalu jalankan generate_labelmap.py dengan perintah di bawah. Perlu diperhatikan, ketika perintah ini dijalankan pastikan sudah tersedia train_labels.csv dan pastikan juga semua label ada di data train.

python generate_labelmap.py

Setelah dijalankan maka akan diperoleh label_map.pbtxt yang berisikan daftar semua label yang ada di data train.

Membuat file tfrecord

Langkah terakhir yang perlu dilakukan adalah membuat file tfrecord. File ini adalah objek penyimpanan data yang didesain oleh tensorflow untuk kemudahan pengaksesan data di tensorflow. Jalankan file generate_tfrecord_v2.py dengan perintah di bawah (maksud dari v2 adalah script ini untuk tensorflow versi 2):

python generate_tfrecord_v2.py --csv_input train_labels.csv --image_dir train --labelmap_dir label_map.pbtxt --output_path train.record

Perintah di atas akan mengkombinasikan train_labels.csv, label_map.pbtxt dan image pada folder train menjadi sebuah file train.record yang sudah dapat digunakan untuk proses pelaithan dengan tensorflow. Untuk data yang besar, proses ini bisa memakan waktu paling lama komputasinya.

Lakukan langkah-langkah di atas ke data test dan validation dengan mengubah beberapa parameter pentingnya (nama file, path, dsb).

Setelah mendapatkan ketiga file .record maka langkah selanjutnya adalah proses pelatihan model! InsyaAllah akan kami bahas di artikel selanjutnya. Semoga bermanfaat!

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.

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

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)

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`:

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

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

Kita bisa print informasi dari dataset kita dengan perintah berikut:

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` yang akan memudahkan proses batch ketika pelatihan nantinya.

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:

1. Class Model / Arsitektur CNN
2. Alur pelatihan
3. Alur pengujian

Arsitektur CNN (Teori)

Pada tutorial ini, kita akan menggunakan model CNN dengan dua convolutional layer dan sebuah fully connected layer. Dengan detail parameter setiap layer sebagai berikut:

Pada proses konvolusi atau pooling, parameter window size, pooling size, stride, dan padding akan menentukan perubahan ukuran data setelahnya. Ukuran data setelah proses konvolusi atau pooling dapat dihitung dengan menggunakan rumus berikut:

$$ UkuranAkhir =\frac{UkuranAwal – W + 2P}{S} + 1 $$

Rumus tersebut dihitung untuk setiap sisi citra. Sebagai contoh di atas, citra memiliki ukuran panjang x lebar (150 x 150). Pada layer Conv1 ukuran awal sisi panjang citra adalah 150. Dikarenakan nilai sisi panjang W = 3, lalu nilai P = 0, dan S = 1, diperoleh sisi panjang citra setelah proses adalah 148. Karena citra input memiliki sisi lebar yang sama, yakni 150, maka sisi lebar citra dihitung dengan cara dan diperoleh Conv1 adalah 148. Sehingga diperoleh hasil proses konvolusi berukuran 148 x 148 x 32 (dari 32 feature maps). Proses ini juga dilakukan di layer Pool1, Conv2, dan Pool2 dengan UkuranAwal adalah UkuranAkhir dari layer sebelumnya.

Arsitektur CNN (Praktik)

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

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))) # (A)
        x = self.pool(F.relu(self.conv2(x))) # (B)
        x = x.reshape(x.shape[0], -1) # (C)
        x = self.do(F.relu(self.fc1(x))) # (D)
        x = self.fc2(x) # (E)
        return x

Bisa dilihat pada class tersebut, terdapat dua komponen utama. Pada bagian `__init__` kita mendefinisikan layer-layer yang akan digunakan. Sedangkan pada bagian `forward` kita definisikan bagaimana struktur dan alur forward propagation neural networknya dengan input suatu data `x`.

Jadi keliatan, pada bagian (A) awalnya `x` masuk layer `conv1`, lalu kena fungsi aktivasi ReLU, lalu pooling. Lalu dilanjut juga pada bagian (B) juga sama. Pada bagian (C) dilakukan proses flattening atau perataan input yang berbentuk array multi dimensi menjadi satu dimentsi. Pada bagian (D) model masuk ke hidden layer dan bagian (E) adalah output layer

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

model = Net()

Alur Pelatihan

Kita mulai dengan definisikan terlebih dahulu algoritma dan parameter 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")

Mengikuti stylenya Alfredo Canziani, profesor di NYU, untuk implementasi pelatihan di PyTorch ada 5 langkah besar pada prosesnya:

1. Forward Propagation
2. Hitung error
3. Bersihkan gradient
4. Backpropagation error / Menghitung gradient
5. Update bobot

Kelima langkah tersebut diimplemetnasikan menggunakan kode di bawah. Dapat diperhatikan ada dua iterasi besar yang terjadi, iterasi pertama untuk banyak epoch sedangkan iterasi kedua menunjukkan berapa kali terjadinya 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) # LANGKAH 1: forward propagation
        loss = criterion(out, label) # LANGKAH 2: hitung error
        optimizer.zero_grad() # LANGKAH 3: bersihkan nilai gradient sisa komputasi
        loss.backward() # LANGKAH 4: backpropagation
        optimizer.step() # LANGKAH 5: 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

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("cuda")
    label = label.to("cuda")
    
    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

_{Featured image: Photo by Birmingham Museums Trust on Unsplash}