Menyimpan Check Point pada Proses Iterasi Machine Learning

By | January 7, 2024
Print Friendly, PDF & Email
723 Views

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.

See also  Menyingkap Rahasia Machine Learning untuk Mengenali Objek dengan akurasi tinggi

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.

 

Leave a Reply