Mari mengenal Pytorch

Melatih jaringan neural menggunakan Pytorch untuk mengenal tulisan tangan

Gambar dari https://engineering.fb.com/2018/10/02/ai-research/facebook-accelerates-ai-development-with-new-partners-and-production-capabilities-for-pytorch-1-0/

Salam semua, kita bertemu lagi. Dalam siri-siri yang lepas kita sudahpun menyelam ke dalam dasar laut yang kita panggil sebagai kecerdasan buatan. Pelbagai topik sudahpun kita kupas antaranya jaringan neural (neural network), jaringan neural berturut (recurrent neural network), dan juga jaringan neural berlingkar (convolutional neural network). Kita juga mengupas bahagian-bahagian asas yang ada dalam arkitekture transformer antaranya mekanisma perhatian/perhatian kendiri (attention/self-attention), tokenisasi (tokenization), penanaman posisi (positional embedding) dan juga penanaman vektor (vector embedding).

Semua topik yang kita kupas di atas dilakukan dari asas, dari kosong, tanpa menggunakan sebarang library. Dengan memahami konsep dan teori matemtatik dalam setiap arkitektur yang kita belajar, kita cuba untuk mempraktikkan teori tersebut dalam menyelesaikan masalah. Namun begitu, disebabkan dalam siri-siri yang akan datang, kita akan cuba untuk meneroka konsep dan model AI yang lebih kompleks, maka tak patutlah kita melakukan kesemuanya dari kosong. Ada baiknya juga kita sudah bermula untuk mengaplikasikan apa yang sudah kita pelajari menggunakan library, sepertimana yang dilakukan oleh hampir kebanyakan saintis data/ penyelidik yang membuat kajian dalam bidang AI. Maka untuk itu, kali ini kita akan mempelajari tentang Pytorch dan bagaimana untuk menggunakannya

Apa itu Pytorch

Seperti yang saya beritahu dalam siri yang lepas, PyTorch ialah sebuah library sumber terbuka (open-source) yang digunakan untuk membangunkan dan melatih model machine learning dan deep learning. PyTorch menawarkan pendekatan yang fleksibel dan intuitif dengan menggunakan graf pengiraan dinamik (dynamic computation graph), menjadikannya sangat popular dalam kalangan penyelidik dan jurutera. Ia dibangunkan oleh Facebook AI Research Lab (FAIR) (kini dikenali sebagai Meta AI pada tahun 2016.

Selain Pytorch ada lagi satu library yang orang lain gunakan untuk deep learning iaitu Tensorflow yang dibangunkan oleh Google. Tapi tensorflow lebih sesuai digunakan untuk projek-projek besar. Untuk eksperimen dan juga pembelajaran, seeloknya kita gunakan Pytorch.

Gambar dari https://datascientest.com/en/tensorflow-course-where-to-learn-how-to-use-the-framework

Kedua-dua pytorch dan tensorflow menyusun data mengikut tensor, jadi seeloknya kita fahamkan dulu apa itu tensor.

Apa itu Tensor?

Nak mudahkan pemahaman, tensor ni macam matriks lah. Matriks? Yang Keanu Reeves berlakon tu ke?

Bukan, matriks ni adalah sesuatu yang kita belajar masa kat sekolah dulu. Ingat lagi kan, kita pernah belajar pasal vektor dan matriks? Vektor kan dulu adalah satu nilai kuantiti yang kita tak boleh wakilkan dengan hanya satu nombor. Ia terdiri daripada magnitud dan juga arah. Disebabkan itulah, vektor ini kita perlu letakkan dalam satu koleksi, seperi di bawah

[1, 2, 3]

Dan vektor ini sekadar satu dimensi, maksudnya dia hanya satu baris melintang macam yang kita nampak di atas. kalau kita jadikan ia lebih dari satu dimensi, maka kita panggilnya sebagai matriks.

[[1, 2], [3, 4]]

ataupun dalam bentuk yang kita kenal dari sekolah seperti di bawah.

Gambar dari penulis

Jadi tensor tu apa pulak? Tensor adalah kedua-duanya sekali. Matriks dan juga vektor. Tensor boleh melakukan kedua-duanya malah boleh pergi jauh lagi dengan menghasilkan matriks pelbagai dimensi. Ok, nanti kita akan tengok macam mana nak gunakan tensor ini untuk menyusun data-data kita. Sebelum itu mari kita setup dulu pytorch dalam mesin ataupun komputer yang kita gunakan. Untuk memasang (ataupun install, teruk betul istilah bahasa melayu aku) pytorch dalam komputer kita, kita hanya perlu run-kan sahaja kod di bawah

!pip install torch torchvision torchaudio

Memahami Library Pytorch

Kebiasaannya, ketika kita menggunakan pytorch, kita akan memuat turun modul-modul seperti di bawah:

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

Setiap satu modul ini mempunyai fungsinya yang tersendiri yang saya perincikan lebih mendalam di bawah, contohnya

1. torch - ini modul utama yang kita perlu muat turun. Ia membolehkan kita memproses tensor dan menyediakan API untuk deep/machine learning

2. torch.nn - ini modul yang diperlukan untuk membina jaringan neural (nn = neural network). Dalam modul ni disediakan banyak kelas (class) yang diperlukan untuk membina pelbagai arkitektur jaringan neural

3. torch.optim - ini modul yang biasanya digunakan ketika proses melatih jaringan neural. Ia dipanggil sebagai optimizer kerana fungsinya yang membolehkan latihan jaringan neural dijalankan secara optimum.

4. torchvision - modul yang digunakan untuk mengendalikan deep learning yang berkaitan dengan computer vision (imej, video). Dalam kes ini kita memuat turun modul tambahan (datasets dan juga transforms) bagi membolehkan kita memuat turun data MNIST.

5. torch.utils.data - modul utiliti yang digunakan dengan pelbagai fungsi pembantu (helper function) bagi membantu proses pengurusan data. Dalam kes ini kita menggunakan DataLoader bagi membolehkan kita memuatkan data MNIST yang kita muat turun tadi ke dalam bentuk yang lebih sesuai

Demonstrasi Operasi Tensor Yang Ringkas

Ok, kita dah pun kenal sedikit sebanyak pada library pytorch dan juga modul-modul yang ada di dalamnya. Ada banyak lagi, tapi saya biar pembaca sendiri yang teroka dengan lebih mendalam. Sekarang, saya ingin tunjuk bagaimana ingin menggunakan pytorch untuk melakukan operasi tensor yang mudah. Katakanlah kita ada dua tensor, x dan y.

#kita bentuk dulu tensor x dan y menggunakan pytorch
import torch

x = torch.tensor([1,2,3,4]) #kita set x sebagai satu matriks bersaiz (4, )
y = torch.tensor([1,1,1,1]) # kita set y sebagai satu matriks bersaiz (4, )

Jadi dengan x dan y yang sudahpun dibentuk, kita boleh melakukan beberapa operasi mudah, contohnya:

#operasi tambah

tambah = x + y
tambah

#operasi tolak
tolak = x - y
tolak

Mudah kan nak faham? Ini hanyalah antara beberapa contoh operasi ringkas yang kita boleh buat menggunakan pytorch. Dan contoh yang saya tunjukkan ini sangatlah ringkas dan mudah. Untuk melihat keupayaan sebenar pytorch, ada eloknya kita gunakan ia untuk melatih jaringan neural yang sebenar.

Para pembaca masih ingat lagi tak tutorial saya yang awal dulu, mari buat jaringan neural dari kosong? Dalam tutorial tersebut, kita membentuk jaringan neural tanpa menggunakan pytorch. Kita membentuk menggunakan library asas python dengan memahami matematik dan konsep asas jaringan neural. Jadi, untuk kali ini, kita akan menggunakan pytorch untuk melatih jarigan neural untuk mengenal tulisan tangan.

Demonstrasi Pytorch untuk Melatih Jaringan Neural mengenal tulisan tangan

Saya tepekkkan pautan tutorial di lepas sebagai rujukan buat pembaca

https://medium.com/@maercaestro/siri-belajar-ai-mari-buat-jaringan-neural-dari-kosong-b525ba11171c

Dalam tutorial tersebut, kita melakukan proses latihan ini melalui beberapa langkah.

1. Memuat turun dan menyediakan data

2. Membina model

3. Mempersiapkan proses latihan

4. Melatih dan menguji model

Jadi, dengan menggunakan pytorch, kita akan melakukan langkah-langkah yang sama

Memuat turun dan menyediakan data

Dataset MNIST terdiri daripada imej grayscale 28x28 digit tulisan tangan (0–9). Kita akan memuat turun dataset ini dan menyediakan transformasi untuk menukarkan data kepada tensor dan menormalisasikannya untuk proses latihan

# Menyediakan transformasi untuk data
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))]) #sediakan fungsi untuk transform data dari imej ke nombor

# Memuat turun dan menyediakan data latihan dan ujian
train_data = datasets.MNIST(root='./data', train=True, download=True, transform=transform) #sediakan data untuk melatih
test_data = datasets.MNIST(root='./data', train=False, download=True, transform=transform) #sediakan data untuk menguji

# Menyediakan DataLoader untuk memuat data secara batch
train_loader = DataLoader(train_data, batch_size=32, shuffle=True) #gunakan loader untuk data latihan, dengan batch saiz 32 dan shuffle
test_loader = DataLoader(test_data, batch_size=32, shuffle=False) #gunakan loader untuk data ujian dengan batch saiz 32 dan shuffle

Membina Model

Kita akan membina model rangkaian neural ringkas dengan satu lapisan tersembunyi. Model ini akan mengandungi lapisan input, satu lapisan tersembunyi, dan lapisan output untuk mengklasifikasikan digit (0–9).

# Mendefinisikan model rangkaian neural ringkas
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # Lapisan input dengan input setiap piksel
        self.fc2 = nn.Linear(128, 10)     # Lapisan output (10 kelas untuk digit 0-9)
    
    def forward(self, x):
        x = x.view(-1, 28*28)  # imej ini dijadikan satu vektor
        x = torch.relu(self.fc1(x))  # Fungsi aktivasi ReLU
        x = self.fc2(x)  # Lapisan output
        return x

# Inisialisasi model
model = SimpleNN()

Mempersiapkan Proses Latihan

Untuk melatih model, kita memerlukan fungsi kehilangan dan pengoptimum. Kita akan menggunakan CrossEntropyLossuntuk fungsi kehilangan dan SGD sebagai pengoptimum.

# Mendefinisikan fungsi kehilangan dan pengoptimum
criterion = nn.CrossEntropyLoss()  # Fungsi kehilangan untuk klasifikasi
optimizer = optim.SGD(model.parameters(), lr=0.01)  # Pengoptimum SGD dengan kadar pembelajaran 0.01

Melatih dan Menguji Model

Kita akan melatih model dengan menggunakan data latihan, dan kemudian menguji ketepatan model menggunakan data ujian. Model akan dilatih selama beberapa epoch, dan kita akan mengira kehilangan (loss) pada setiap langkah untuk memastikan model belajar dengan betul.

# Latihan model
epochs = 5
for epoch in range(epochs):
    model.train()  # Menetapkan model dalam mod latihan
    for batch_idx, (images, labels) in enumerate(train_loader):
        # Forward pass
        outputs = model(images)
        loss = criterion(outputs, labels)

        # Backward pass dan pengoptimuman
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

        if batch_idx % 100 == 0:
            print(f'Epoch [{epoch+1}/{epochs}], Langkah [{batch_idx}/{len(train_loader)}], Kehilangan: {loss.item():.4f}')

Kalau semuanya berjalan lancar, kita boleh nampak mesej seperti di bawah:

Gambar dari penulis

Dan seterusnya, kita akan menguji model tersebut

import random

# Fungsi untuk memaparkan perbandingan imej dan ramalan
model.eval()  # Menetapkan model dalam mod penilaian
with torch.no_grad():
    for i in range(4):  # Menunjukkan 4 contoh imej dan ramalan
        rand_index = random.randint(0, len(test_data) - 1)
        image, label = test_data[rand_index]
        output = model(image.unsqueeze(0))  # Tambah dimensi batch
        _, predicted = torch.max(output.data, 1)
        
        # Paparkan imej dan ramalan
        plt.imshow(image.squeeze(), cmap='gray')
        plt.title(f'Label Sebenar: {label}, Ramalan: {predicted.item()}')
        plt.show()

Bila diuji model kita, dan jika latihan berlaku dengan baik, kita boleh melihat beberapa imej perbandingan seperti di bawah:

Gambar dari penulis

Alhamdulillah, nampak mudah bukan? Berbanding dengan langkah yang kita ambil dalam siri yang lepas, menggunakan pytorch nampak lebih mudah. 

Cukup sahaja untuk kali ini. Kita akan berjumpa lagi dalam siri yang akan datang.