Monitoring Kinerja Deep Learning menggunakan Tensorboard

By | August 26, 2023
Print Friendly, PDF & Email
645 Views

Monitoring Kinerja Deep Learning menggunakan Tensorboard – Deep Learning seringkali memakan waktu cukup lama apalagi menggunakan dataset dan model yang besar. Biasanya sih cara paling gampang dengan cara menyimpan setiap data pada format CSV serta memvisualisasikan data dengan matplotlib.

Namun hal tersebut kurang praktis karena kita bisa kok menggunakan tensorboard untuk melihat pergerakan nilai epoch bahkan sampai waktu yang dibutuhkan ataupun visualisai model dalam bentuk flowchart. Agar lebih mudah kita akan memanfaatkan model RNN yang telah kita bahas sebelumnya disini RNN untuk Image Recognition

Secara real akan ada banyak tunning pelatihan oleh sebab itu kita butuh nama folder yang unik untuk membedakan dengan lainnya. Misalkan saja kita beri nama folder (tidak boleh ada spasi ya) runs/latihan_MNIST

from tqdm import tqdm
import torch.nn as nn
import torch
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import Dataset
from PIL import Image
import glob
from torch.utils.data.dataloader import DataLoader
import numpy as np
from matplotlib import pyplot as plt
import torch.optim as optim
import os
from torch.autograd import Variable
# Device
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

tambahkan library berikut serta berikan nama foldernya

from torch.utils.tensorboard import SummaryWriter
writer = SummaryWriter('runs/latihan_MNIST')

kemudian kita buat modelnya

# Create RNN Model
class RNNModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, layer_dim, output_dim):
        super(RNNModel, self).__init__()
        
        # Number of hidden dimensions
        self.hidden_dim = hidden_dim
        
        # Number of hidden layers
        self.layer_dim = layer_dim
        
        # RNN
        self.rnn = nn.RNN(input_dim, hidden_dim, layer_dim, batch_first=True, nonlinearity='relu')
        
        # Readout layer
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x):
        
        # Initialize hidden state with zeros
        h0 = Variable(torch.zeros(self.layer_dim, x.size(0), self.hidden_dim))
            
        # One time step
        out, hn = self.rnn(x, h0)
        out = self.fc(out[:, -1, :]) 
        return out

Panggil dataset MNIST nya

BATCH_SIZE = 64
# list all transformations
transform = transforms.Compose(
    [transforms.ToTensor()])

# download and load training dataset
trainset = torchvision.datasets.MNIST(root='./data', train=True,download=False, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=BATCH_SIZE,shuffle=True, num_workers=2)

# download and load testing dataset
testset = torchvision.datasets.MNIST(root='./data', train=False,download=False, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=BATCH_SIZE,shuffle=False, num_workers=2)

Kita panggil modelnya

# Create RNN
input_dim = 28    # input dimension
hidden_dim = 100  # hidden layer dimension
layer_dim = 1     # number of hidden layers
output_dim = 10   # output dimension

model = RNNModel(input_dim, hidden_dim, layer_dim, output_dim)

# Cross Entropy Loss 
criterion = nn.CrossEntropyLoss()

# SGD Optimizer
learning_rate = 0.05
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)

Nah kita tambahkan kode berikut writer.add_scalar("Loss/train", loss, epoch)

loss_list = list()
N_EPHOCS  = 1000
for epoch in tqdm(range(N_EPHOCS)):
    train_running_loss = 0.0
    train_acc = 0.0
    model.train()
    # TRAINING ROUND
    for i, data in enumerate(trainloader):
         # zero the parameter gradients
        optimizer.zero_grad()
        # get the inputs
        inputs, labels = data
        inputs = inputs.view(-1, 28,28) 
        # forward + backward + optimize
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
    loss_list.append(loss.item())
    writer.add_scalar("Loss/train", loss, epoch)
    print("epoch: ",epoch," loss: ",loss.item())
write.flush()

Sambil proses training, kita buka saja di terminal dan pastikan kalian didalam directory yang sama dengan file python diatas tersebut dan ketikan pada terminal/command prompt

See also  Mencoba Kinerja Model VGG16

tensorboard --logdir=runs

bukalah browser dengan alamat localhost:6006

Kalian bisa melihat informasi detail

Visualisasi Model

Untuk melakukan visualisasi model, cukup panggil

dataiter = next(iter(trainloader))
images, labels = dataiter
writer.add_graph(model, images.view(-1,28,28))

Inilah yang saya suka dengan visualisasi tensorboard untuk modelnya yaitu disertakan informasi mengenai dimensi setiap tensor setelah proses sehingga kita dapat melihat pergerakan reduksi dimensi dari semula 28×28 sampai pada output paling akhir 1 x 10

Tampilkan Image dataset

Kita juga bisa menampilkan gambar kedalam tensorboard hanya untuk sekedar melihat seperti apa gambar yang dimasukan kedalam pelatihan

img_grid = torchvision.utils.make_grid(images)
writer.add_image('gambar_mnist', img_grid)

dan bila sudah selesai semua, kita panggil write.close()

Sebenarnya ada banyak sekali feature dari tensorboard yang bisa kalian explore lebih lanjut, untuk saat ini seperti itu dulu Pembahasan Monitoring Kinerja Deep Learning menggunakan Tensorboard

Referensi:

https://pytorch.org/tutorials/intermediate/tensorboard_tutorial.html

https://towardsdatascience.com/a-complete-guide-to-using-tensorboard-with-pytorch-53cb2301e8c3

https://pytorch.org/tutorials/recipes/recipes/tensorboard_with_pytorch.html

https://kuanhoong.medium.com/how-to-use-tensorboard-with-pytorch-e2b84aa55e67

 

 

 

 

Leave a Reply