Menyimpan Check Point pada Proses Iterasi Machine Learning – Model yang rumit tentu membutuhkan proses komputasi yang sangat lama bahkan saking lamanya untuk menyelesaikan 1 epoch saja butuh waktu bermenit-menit / bahkan berjam-jam. Dataset dan batch yang besar juga menambahkan kesabaran kita dalam nungguin proses iterasinya.
Sedikit sekali kita yang mempunyai GPU Cuda kualitas bagus dengan harga 20 jutaan tentu tidak semua orang punya malahan paling banter menggunakan google colab gratisan atau pun yang berbayar Mencoba Google Colab Pro itupun penggunanya juga mikir-mikir karena dihitung berdasarkan unit komputasi.
Tapi tenang saja, biasanya sih kita bisa menyimpan state model sesuka kita mau berapa kali per epoch kita simpan pun bisa kita setting sehingga kita bisa melanjutkan pelatihan tanpa mengulangi dari awal lagi.
Agar lebih mudah cara kerja Menyimpan Check Point pada Proses Iterasi Machine Learning, kita akan menggunakan model yang simple yaitu Belajar RNN untuk kasus Sederhana dengan kode lengkapnya sebagai berikut
import torch
from torch import nn
import numpy as np
import matplotlib.pyplot as plt
from torch.utils.data import DataLoader, Dataset
class RNN(nn.Module):
def __init__(self, input_size, output_size, hidden_dim, n_layers):
super(RNN, self).__init__()
self.hidden_dim = hidden_dim
self.rnn = nn.RNN(input_size, hidden_dim, n_layers, batch_first=True)
self.fc = nn.Linear(hidden_dim, output_size)
def forward(self, x, hidden):
r_out, hidden = self.rnn(x, hidden)
r_out = r_out.view(-1, self.hidden_dim)
output = self.fc(r_out)
return output, hidden
class CustomDataset(Dataset):
def __init__(self,x,y):
self.x = x
self.y = torch.tensor(y).long()
def __getitem__(self, index):
x = self.x[index,:].reshape([1,2])
x = torch.tensor(x).float()
return (x, self.y[index])
def __len__(self):
return len(self.x)
x = np.array([[1,1],
[1,0],
[0,1],
[0,0]])
y = np.array([1,0,0,1])
dataset = CustomDataset(x,y)
train_loader = DataLoader(dataset, batch_size=1, shuffle=True)
for batch in train_loader:
inputs,targets = batch
print('input: ',inputs,'target: ',targets)
input_size= x.shape[1] #jumlah fitur atau jumlah kolom
output_size = 2 #target hanya 2 kolom saja mencoba untuk multi class
hidden_dim = 7
n_layers = 5
rnn = RNN(input_size, output_size, hidden_dim, n_layers)
#criterion = nn.MSELoss()
criterion = nn.CrossEntropyLoss() #dianggap mutliclass saja
optimizer = torch.optim.Adam(rnn.parameters(), lr=0.01)
rnn.train()
hidden = None
loss_list = list()
for epoch in range(1,1000):
loss_total = 0
for batch in train_loader:
inputs,targets = batch
prediction, hidden = rnn(inputs,hidden)
hidden = hidden.data
# calculate the loss
loss = criterion(prediction, targets)
# zero gradients
optimizer.zero_grad()
# perform backprop and update weights
loss.backward()
optimizer.step()
#print(inputs,targets,loss.item())
loss_total = loss_total + loss.item()
loss_total = loss_total/len(train_loader)
print('epoch: ',epoch,' loss: ',loss_total)
loss_list.append(loss_total)
Kita cukup memberikan perintah seperti berikut
import os
folder = 'latihan checkpoint'
if(os.path.exists(folder)==False):
os.mkdir(folder)
epoch_current = 1
loss_list = list()
if True:
if os.path.exists(folder+'/model.pt'):
print("menggunakan sesi pelatihan")
checkpoint = torch.load(folder+'/model.pt')
rnn.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch_current = checkpoint['epoch']
loss = checkpoint['loss']
#baca histori loss sebelumnya
loss_list = np.loadtxt(folder+'/loss.csv')
loss_list = loss_list.tolist()
epoch_current = epoch_current+1
print("epoch_current ",epoch_current)
else:
print("tidak ada model.pt")
rnn.train()
hidden = None
for epoch in range(epoch_current,1000+1):
loss_total = 0
for batch in train_loader:
inputs,targets = batch
prediction, hidden = rnn(inputs,hidden)
hidden = hidden.data
# calculate the loss
loss = criterion(prediction, targets)
# zero gradients
optimizer.zero_grad()
# perform backprop and update weights
loss.backward()
optimizer.step()
#print(inputs,targets,loss.item())
loss_total = loss_total + loss.item()
loss_total = loss_total/len(train_loader)
print('epoch: ',epoch,' loss: ',loss_total)
loss_list.append(loss_total)
if(epoch%10)==0: #akan simpan checkpoint setiap 10 epoch
if(os.path.exists(folder)==False):
os.mkdir(folder)
torch.save({
'epoch': epoch,
'model_state_dict': rnn.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss_total,
},folder+'/model.pt')
#simpan juga lost
np.savetxt(folder+'/loss.csv',np.array(loss_list), delimiter=',')
nanti per setiap 10 epoch akan menyimpan model tersebut kedalam sebuah file. Bila dirasa kurang setelah mencapai epoch 1000 kalian bisa tambahkan menjadi 5000, maka model hasil pelatihan yang sudah mencapai 1000 akan menjadi entry point sehingga tidak dimulai dari 0 lagi tapi 1001 sampai ke 5000.
Jadi tidak perlu kuatir jikalau mau melanjutkan sesi pelatihan pada waktu / hari berikutnya, biasanya hal ini saya terapkan ketika menggunakan google colab yang gratisan karena per 8 jam bila tidak aktivitas di peramban yang kita gunakan, maka secara otomatis akan non active dan mengulang lagi proses pelatihan dari awal.
Menyimpan Check Point pada Proses Iterasi Machine Learning bahkan kalian bisa menggunakan model hasil yang telah disimpan sambil untuk menguji dataset testing tentunya.