Deep learning adalah cabang dari model machine learning yang didasarkan pada neural networks. Pada model mesin lainnya, pemrosesan data untuk menemukan fitur-fitur penting sering dilakukan secara manual atau bergantung pada domain expertise; namun, deep learning dapat meniru otak manusia untuk menemukan fitur-fitur penting secara otomatis, sehingga meningkatkan kinerja model.
Ada banyak aplikasi untuk model deep learning termasuk facial recognition, fraud detection, speech-to-text, text generation, dan masih banyak lagi. Deep learning telah menjadi pendekatan standar dalam banyak aplikasi machine learning yang canggih, dan tidak ada salahnya kita mempelajarinya.
Untuk mengembangkan model deep learning ini, alih-alih bekerja dari awal, kita bisa menggunakan berbagai library framework yang tersedia. Dalam artikel ini, kita akan membahas dua library berbeda yang dapat kita gunakan untuk mengembangkan model deep learning: PyTorch dan Lightning AI. Mari kita mulai.
PyTorch
PyTorch adalah library framework open-source untuk melatih deep-learning neural networks. PyTorch dikembangkan oleh Meta (sebelumnya Facebook) pada tahun 2016 dan semakin populer. Popularitasnya meningkat berkat fitur PyTorch yang menggabungkan library backend GPU dari Torch dengan bahasa Python. Kombinasi ini membuat library ini mudah diikuti oleh pengguna tetapi tetap kuat dalam mengembangkan model deep learning.
Ada beberapa fitur unggulan PyTorch yang disediakan oleh library ini, termasuk antarmuka yang bagus, pelatihan terdistribusi, dan proses eksperimen yang cepat dan fleksibel. Karena banyak pengguna PyTorch, pengembangan dan investasi komunitas juga sangat besar. Itulah mengapa mempelajari PyTorch akan bermanfaat dalam jangka panjang.
Building block PyTorch adalah tensor, array multi-dimensi yang digunakan untuk meng-encode semua input, output, dan parameter model. Anda dapat membayangkan tensor seperti array NumPy tetapi dengan kemampuan untuk dijalankan di GPU.
Mari kita coba library PyTorch. Sebaiknya lakukan tutorial di cloud, seperti Google Colab jika Anda tidak memiliki akses ke sistem GPU (meskipun masih bisa bekerja dengan CPU). Namun, jika Anda ingin memulai di lokal, kita perlu menginstal library melalui halaman ini. Pilih sistem dan spesifikasi yang sesuai dengan milik Anda.
Misalnya, kode di bawah ini adalah untuk instalasi pip jika Anda memiliki sistem yang Mendukung CUDA.
pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118Setelah instalasi selesai, mari kita coba beberapa kemampuan PyTorch untuk mengembangkan model deep learning. Kita akan membuat model klasifikasi gambar sederhana dengan PyTorch dalam tutorial ini berdasarkan tutorial web mereka. Kita akan membahas kode dan memiliki penjelasan tentang apa yang terjadi di dalam kode tersebut.
Pertama, kita akan mengunduh dataset dengan PyTorch. Untuk contoh ini, kita akan menggunakan dataset MNIST, yang merupakan dataset klasifikasi angka tulisan tangan.
from torchvision import datasets
train = datasets.MNIST(
root="image_data",
train=True,
download=True
)
test = datasets.MNIST(
root="image_data",
train=False,
download=True,
)Kita mengunduh dataset MNIST train dan test ke folder root kita. Mari kita lihat bagaimana tampilan dataset kita.
import matplotlib.pyplot as plt
for i, (img, label) in enumerate(list(train)[:10]):
plt.subplot(2, 5, i+1)
plt.imshow(img, cmap="gray")
plt.title(f'Label: {label}')
plt.axis('off')
plt.show()
Setiap gambar adalah angka satu digit antara nol sampai sembilan, yang berarti kita memiliki sepuluh label. Selanjutnya, mari kita mengembangkan image classifier berdasarkan dataset ini.
Kita perlu mengubah dataset gambar menjadi tensor untuk mengembangkan model deep learning dengan PyTorch. Karena gambar kita adalah objek PIL, kita dapat menggunakan fungsi PyTorch ToTensor untuk melakukan transformasi. Selain itu, kita dapat secara otomatis mengubah gambar dengan fungsi datasets.
from torchvision.transforms import ToTensor
train = datasets.MNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test = datasets.MNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)Dengan melewatkan fungsi transformasi ke parameter transform, kita dapat mengontrol bagaimana data akan terlihat. Selanjutnya, kita akan membungkus data ke dalam objek DataLoader sehingga model PyTorch dapat mengakses data gambar kita.
from torch.utils.data import DataLoader
size = 64
train_dl = DataLoader(train, batch_size=size)
test_dl = DataLoader(test, batch_size=size)
for X, y in test_dl:
print(f"Shape of X [N, C, H, W]: {X.shape}")
print(f"Shape of y: {y.shape} {y.dtype}")
breakShape of X [N, C, H, W]: torch.Size([64, 1, 28, 28])
Shape of y: torch.Size([64]) torch.int64Pada kode di atas, kita membuat objek DataLoader untuk data training dan data testing. Setiap iterasi batch data akan mengembalikan 64 fitur dan label dalam objek di atas. Selain itu, bentuk gambar kita adalah 28 28 (tinggi lebar).
Selanjutnya, kita akan mengembangkan objek model Neural Network.
from torch import nn
#Change to 'cuda' if you have access to GPU
device = 'cpu'
class NNModel(nn.Module):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
self.lr_stack = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU(),
nn.Linear(128, 128),
nn.ReLU(),
nn.Linear(128, 10)
)
def forward(self, x):
x = self.flatten(x)
logits = self.lr_stack(x)
return logits
model = NNModel().to(device)
print(model)
NNModel(
(flatten): Flatten(start_dim=1, end_dim=-1)
(lr_stack): Sequential(
(0): Linear(in_features=784, out_features=128, bias=True)
(1): ReLU()
(2): Linear(in_features=128, out_features=128, bias=True)
(3): ReLU()
(4): Linear(in_features=128, out_features=10, bias=True)
)
)Pada objek di atas, kita membuat Model Neural dengan beberapa struktur layer. Untuk mengembangkan objek Model Neural, kita menggunakan metode subclassing dengan fungsi nn.module dan membuat neural network layers di dalam init.
Kita awalnya mengubah data gambar 2D menjadi nilai piksel di dalam layer dengan fungsi flatten. Kemudian, kita menggunakan fungsi sequential untuk membungkus layer kita menjadi sequence of layers. Di dalam fungsi sequential, kita memiliki layer model kita:
nn.Linear(28*28, 128),
nn.ReLU(),
nn.Linear(128, 128),
nn.ReLU(),
nn.Linear(128, 10)Secara berurutan, apa yang terjadi di atas adalah:
Pertama, input data yang merupakan fitur 28 * 28 diubah menggunakan fungsi linear di linear layer dan memiliki 128 fitur sebagai output.
ReLU adalah fungsi aktivasi non-linear yang ada antara input dan output model untuk memperkenalkan non-linearitas.
input 128 fitur ke linear layer dan memiliki 128 fitur output
Fungsi aktivasi ReLU lainnya
128 fitur sebagai input di linear layer dan 10 fitur sebagai output (label dataset kita hanya memiliki 10 label).
Terakhir, fungsi forward hadir untuk proses input aktual ke model.
Selanjutnya, model akan membutuhkan fungsi loss dan fungsi optimasi.
from torch.optim import SGD
loss_fn = nn.CrossEntropyLoss()
optimizer = SGD(model.parameters(), lr=1e-3)Untuk kode berikutnya, kita hanya menyiapkan persiapan training dan testing sebelum kita menjalankan aktivitas pemodelan.
import torch
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
model.train()
for batch, (X, y) in enumerate(dataloader):
X, y = X.to(device), y.to(device)
pred = model(X)
loss = loss_fn(pred, y)
loss.backward()
optimizer.step()
optimizer.zero_grad()
if batch % 100 == 0:
loss, current = loss.item(), (batch + 1) * len(X)
print(f"loss: {loss:>2f} [{current:>5d}/{size:>5d}]")
def test(dataloader, model, loss_fn):
size = len(dataloader.dataset)
num_batches = len(dataloader)
model.eval()
test_loss, correct = 0, 0
with torch.no_grad():
for X, y in dataloader:
X, y = X.to(device), y.to(device)
pred = model(X)
test_loss += loss_fn(pred, y).item()
correct += (pred.argmax(1) == y).type(torch.float).sum().item()
test_loss /= num_batches
correct /= size
print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>2f} \n")Sekarang kita siap untuk menjalankan training model. Kita akan memutuskan berapa banyak epoch (iterasi) yang ingin kita lakukan dengan model kita. Untuk contoh ini, anggap kita ingin menjalankannya lima kali.
epoch = 5
for i in range(epoch):
print(f"Epoch {i+1}\n-------------------------------")
train(train_dl, model, loss_fn, optimizer)
test(test_dl, model, loss_fn)
print("Done!")
Modelnya sekarang telah menyelesaikan pelatihan dan dapat digunakan untuk aktivitas prediksi gambar apa pun. Hasilnya dapat bervariasi, jadi perkirakan hasil yang berbeda dari gambar di atas.
Ini hanyalah beberapa hal yang dapat dilakukan PyTorch, tetapi Anda dapat melihat bahwa membangun model dengan PyTorch itu mudah. Jika Anda tertarik dengan model pre-trained, PyTorch memiliki hub yang dapat Anda akses.
Lighting AI
Lighting AI adalah perusahaan yang menyediakan berbagai produk untuk meminimalkan waktu melatih model deep learning PyTorch dan menyederhanakannya. Salah satu produk open-source mereka adalah PyTorch Lighting, yang merupakan library yang menawarkan framework untuk melatih dan menerapkan model PyTorch.
Lighting menawarkan beberapa fitur, termasuk fleksibilitas kode, no-boilerplate, API minimal, dan peningkatan kolaborasi tim. Lighting juga menawarkan fitur seperti pemanfaatan multi-GPU dan pelatihan cepat dengan presisi rendah. Ini menjadikan Lighting alternatif yang baik untuk mengembangkan model PyTorch kita.
Mari kita coba pengembangan model dengan Lighting. Untuk memulai, kita perlu menginstal paketnya.
pip install lightningSetelah Lighting terinstal, kita juga akan menginstal produk Lighting AI lainnya yang disebut TorchMetrics untuk menyederhanakan pemilihan metrik.
pip install torchmetricsKetika semua library telah terinstal, kita akan mencoba mengembangkan model yang sama dari contoh sebelumnya menggunakan Lighting wrapper. Di bawah ini adalah kode lengkap untuk mengembangkan model.
import torch
import torchmetrics
import pytorch_lightning as pl
from torch import nn
from torch.optim import SGD
# Change to 'cuda' if you have access to GPU
device = 'cpu'
class NNModel(pl.LightningModule):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
self.lr_stack = nn.Sequential(
nn.Linear(28 * 28, 128),
nn.ReLU(),
nn.Linear(128, 128),
nn.ReLU(),
nn.Linear(128, 10)
)
self.train_acc = torchmetrics.Accuracy(task="multiclass", num_classes=10)
self.valid_acc = torchmetrics.Accuracy(task="multiclass", num_classes=10)
def forward(self, x):
x = self.flatten(x)
logits = self.lr_stack(x)
return logits
def training_step(self, batch, batch_idx):
x, y = batch
x, y = x.to(device), y.to(device)
pred = self(x)
loss = nn.CrossEntropyLoss()(pred, y)
self.log('train_loss', loss)
# Compute training accuracy
acc = self.train_acc(pred.softmax(dim=-1), y)
self.log('train_acc', acc, on_step=True, on_epoch=True, prog_bar=True)
return loss
def configure_optimizers(self):
return SGD(self.parameters(), lr=1e-3)
def test_step(self, batch, batch_idx):
x, y = batch
x, y = x.to(device), y.to(device)
pred = self(x)
loss = nn.CrossEntropyLoss()(pred, y)
self.log('test_loss', loss)
# Compute test accuracy
acc = self.valid_acc(pred.softmax(dim=-1), y)
self.log('test_acc', acc, on_step=True, on_epoch=True, prog_bar=True)
return lossMari kita uraikan apa yang terjadi dalam kode di atas. Perbedaannya dengan model PyTorch yang kita kembangkan sebelumnya adalah kelas NNModel sekarang menggunakan subclassing dari LightingModule. Selain itu, kita menetapkan metrik akurasi untuk menilai menggunakan TorchMetrics. Kemudian, kita menambahkan langkah training dan testing dalam kelas dan mengatur fungsi optimasi.
Ketika semua model telah siap, kita akan menjalankan training model menggunakan objek DataLoader yang telah diubah untuk melatih model kita.
# Buat trainer PyTorch Lightning
trainer = pl.Trainer(max_epochs=5)
# Buat model
model = NNModel()
# Terapkan model
trainer.fit(model, train_dl)
# Tes model
trainer.test(model, test_dl)
print("Training Finish")
Dengan library Lighting, kita dapat dengan mudah mengubah struktur yang Anda butuhkan. Untuk bacaan lebih lanjut, Anda bisa membaca dokumentasi mereka.
Kesimpulan
PyTorch adalah library untuk mengembangkan model deep learning, dan menyediakan framework yang mudah bagi kita untuk mengakses banyak API canggih. Lighting AI juga mendukung library yang menyediakan framework untuk menyederhanakan pengembangan model dan meningkatkan fleksibilitas pengembangan. Artikel ini memperkenalkan kita pada fitur library dan implementasi kode sederhana.
Comments