Klasifikasi Image dengan PyTorch

Pada tutorial kali ini kita akan melakukan klasifikasi image dengan menggunakan PyTorch. PyTorch sendiri merupakan salah satu library python untuk computer vision. Untuk lebih lengkapnya kalian baca pengertian Apache PyTorch dibawah ini.

Pengertian Apache PyTorch

Apache PyTorch adalah library tensor yang dioptimalkan terutama digunakan untuk pengaplikasin Deep Learning menggunakan GPU (Graphics Processing Unit) dan CPU (Central Processing Unit). Apache Pytorch merupakan library pembelajaran open source untuk Phyton yang dikembangkan oleh tim Riset AI Facebook. PyTorch merupakan library machine learning yang banyak digunakan seperti TensorFlow dan Keras. Seperti yang diketahui bahwa PyTorch merupakan library untuk memproses tensor, tensor merupakan unit fundamental atau dasar pada data. Data yang diproses bisa berupa angka, vector, matriks, atau n-dimensional array yang mirip dengan array numpy.

Untuk tutorial klasifikasi image dengan pytorch kali ini, kita akan menggunakan dataset CIFAR10. Dataset ini memiliki kelas antara lain pesawat, mobil, burung, kucing, rusa, anjing, katak, kuda, kapal, dan truk. Gambar di dalam dataset ini berukuran 3x32x32 yaitu gambar berwarna 3-kanal berukuran 32×32 pixel.

Pertama, kita buat file notebook baru di google colab. Bisa melalui link berikut https://colab.research.google.com/#create=true

Selanjutnya kita import libraries yang akan kita gunakan dalam klasifikasi image dengan pytorch.

import matplotlib.pyplot as plt
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms

Selanjutnya, kita akan memuat dan menormalkan dataset CIFAR10 dengan menggunakan torchvision. Disini kita memisahkan dataset ke dalam data training dan data testing. Selain itu, kita juga menentukan class/label pada dataset.

transform = transforms.Compose(
    [transforms.ToTensor(),
     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

batch_size = 4

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,
                                          shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,
                                         shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

Kemudian, disini kita akan membuat fungsi untuk memuncul gambar dari dataset CIFAR10.

def imshow(img):
  img = img / 4 + 0.5
  npimg = img.numpy()
  plt.imshow(np.transpose(npimg, (1, 2, 0)))
  plt.show()

Sebelum masuk ke dalam tahap training, kita perlu melakukan pengacakan pada dataset untuk mendapatkan akurasi yang lebih tinggi.

dataiter = iter(trainloader)
images, labels = next(dataiter)

Selanjutnya, kita akan tampilkan beberapa gambar beserta label yang terdapat dalam dataset CIFAR10.

imshow(torchvision.utils.make_grid(images))
print(' ' .  join(f'{classes[labels[j]]:5s}' for j in range(batch_size)))

Disini kita akan membuat arsitektur Convolutional Neural Network. Terdapat library yang diperlukan dalam pembentukan model yaitu torch.nn dan torch.nn.functional. Pada fungsi __init__ dilakukan proses mendefinisikan layer yang akan digunakan. Sedangkan, pada fungsi forward bertujuan untuk mendefinisikan struktur dan alur forward propagation neural network dengan menjalankan input data.

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

class Net(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = torch.flatten(x, 1) # flatten all dimensions except batch
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = Net()

Selanjutnya kita akan membuat fungsi loss dan pengoptimalan model dengan menggunakan CrossEntropyLoss dan SGD.

import torch.optim as optim

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Langkah selanjutnya yaitu training network. Pada tahap ini terdapat beberapa prose yaitu forward propagation, menghitung error, membersihkan gradient, backpropagation error, dan update bobot. Pada tahapan ini juga terdapat 2 iterasi yaitu untuk banyak epoch dan menunjukkan berapa kali terjadinya backpropagation yang dilakukan setiap mini-batch dari data training.

for epoch in range(2):  
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()

        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if i % 2000 == 1999:
            print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')
            running_loss = 0.0

print('Finished Training')

Setelah training data selesai, kita akan menyimpan model klasifikasi yang telah dibuat dengan menggunakan torch.save(). Kemudian, kita akan melakukan tahap pengujian model yang telah dibuat dengan menggunakan data testing.

PATH = './cifar_net.pth'
torch.save(net.state_dict(), PATH)

Sebelum itu, kita perlu melakukan pengacakan pada data testing. Disini kita juga akan menampilkan 4 gambar beserta label yang berada pada data testing.

dataiter = iter(testloader)
images, labels = next(dataiter)

# print images
imshow(torchvision.utils.make_grid(images))
print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))

Selanjutnya, kita akan memuat model klasifikasi yang telah kita simpan sebelumnya agar bisa kita gunakan dalam melakukan klasifikasi pada data testing.

net = Net()
net.load_state_dict(torch.load(PATH))

Pada code dibawah ini, kita lakukan tahap prediksi pada data testing dan kita juga akan menampilkan 4 hasil prediksi pada data testing.

outputs = net(images)

_, predicted = torch.max(outputs, 1)

print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'
                              for j in range(4)))

Dengan data testing yang berjumlah 10000 gambar ditemukan akurasi skor pada model sebesar 54%.

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')

Terakhir, kita juga akan menampilkan akurasi untuk setiap kelas yang diprediksi benar.

correct_pred = {classname: 0 for classname in classes}
total_pred = {classname: 0 for classname in classes}

with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predictions = torch.max(outputs, 1)
        for label, prediction in zip(labels, predictions):
            if label == prediction:
                correct_pred[classes[label]] += 1
            total_pred[classes[label]] += 1


for classname, correct_count in correct_pred.items():
    accuracy = 100 * float(correct_count) / total_pred[classname]
    print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')