Pytorch – loss function Cross-entropy loss

By | November 27, 2022
Print Friendly, PDF & Email
887 Views

Cara menggunakan loss function Cross-entropy loss – Bisa digunakan untuk tugas klasifikasi. Loss function ini menghitung perbedaan antara dua distribusi probabilitas untuk serangkaian kejadian atau variabel acak yang disediakan.

Ini digunakan untuk menghitung skor yang merangkum perbedaan rata-rata antara nilai yang diprediksi dan nilai sebenarnya. Untuk meningkatkan akurasi model, kalian harus mencoba meminimalkan skor—skor lintas entropi antara 0 dan 1, dan nilai sempurna adalah 0.

Loss function lainnya, seperti MSE memberikan penalti prediksi yang salah. Cross-Entropy akan memberikan penalti yang banyak. Berbeda dengan Negatif Log-Likelihood Loss, yang tidak memberikan penalti  berdasarkan keyakinan prediksi, Cross-Entropy menghukum prediksi yang salah tapi yakin, serta prediksi yang benar tapi kurang percaya diri.

Fungsi Cross-Entropy memiliki variasi yang luas, jenis yang paling umum adalah Binary Cross-Entropy (BCE). BCE Loss terutama digunakan untuk model klasifikasi biner; yaitu, model hanya memiliki 2 kelas. Persamaan matematika dari cross entropy yaitu

    \[ loss(x,y) = - \sum x \cdot log(y) \]

Kapan itu bisa digunakan?

  • Tugas klasifikasi biner, yang merupakan fungsi kerugian default di Pytorch.
  • Membuat model yang percaya diri—prediksi akan akurat dan dengan probabilitas yang lebih tinggi.

Contoh kasus

Lebih jelasnya Cara menggunakan loss function Cross-entropy loss yaitu untuk klasifikasi multiclass seperti dataset MNIST yang terdiri dari 10 kelas sehingga target isinya [0,1,2,3,4,5,6,7,8,9].  Mengingat target berupa angka tersebut maka kalian wajib menggunakan fungsi aktifasi ReLU.  Langsung saja kita buat model arsitekturnya (sederhana saja hanya MLP bukan CNN sehingga tidak perlu ada Conv2D)

import os
import torch
from torch import nn
from torchvision.datasets import MNIST
from torch.utils.data import DataLoader
from torchvision import transforms

class MLP(nn.Module):
  '''
    Multilayer Perceptron.
  '''
  def __init__(self):
    super().__init__()
    self.layers = nn.Sequential(
      nn.Flatten(),
      nn.Linear(28 * 28 * 1, 64),
      nn.ReLU(),
      nn.Linear(64, 32),
      nn.ReLU(),
      nn.Linear(32, 10)
    )


  def forward(self, x):
    '''Forward pass'''
    return self.layers(x)

Perhatikan kode  nn.Linear(32, 10)  yang mengindikasikan keluaranya terdiri dari 10 kolom. Berikut kode pelatihannya

if __name__ == '__main__':
  
  # Set fixed random number seed
  torch.manual_seed(42)
  if os.path.exists('data')==False:
      os.mkdir('data')

  # Prepare MNIST dataset
  dataset = MNIST('data', download=True, transform=transforms.ToTensor())
  trainloader = torch.utils.data.DataLoader(dataset, batch_size=10, shuffle=True, num_workers=1)
  
  # Initialize the MLP
  mlp = MLP()
  
  # Define the loss function and optimizer
  loss_function = nn.CrossEntropyLoss()
  optimizer = torch.optim.Adam(mlp.parameters(), lr=1e-4)
  
  # Run the training loop
  for epoch in range(0, 5): # 5 epochs at maximum
    
    # Print epoch
    print(f'Starting epoch {epoch+1}')
    
    # Set current loss value
    current_loss = 0.0
    
    # Iterate over the DataLoader for training data
    for i, data in enumerate(trainloader, 0):
      
      # Get inputs
      inputs, targets = data
      
      # Zero the gradients
      optimizer.zero_grad()
      
      # Perform forward pass
      outputs = mlp(inputs)
      
      # Compute loss
      loss = loss_function(outputs, targets)
      
      # Perform backward pass
      loss.backward()
      
      # Perform optimization
      optimizer.step()
      
      # Print statistics
      current_loss += loss.item()
      if i % 500 == 499:
          print('Loss after mini-batch %5d: %.3f' %
                (i + 1, current_loss / 500))
          current_loss = 0.0

  # Process is complete.
  print('Training process has finished.')

Setelah selesai training sebanyak 5 epoch, kita akan uji menggunakan kode berikut, perhatikan kode  prediksi = torch.argmax(prediksi,dim=1) untuk menentukan index/lokasi value terbesar (sama seperti di Cara menggunakan loss function Negative log likelihood loss nn.NLLLoss)

a,b = next(iter(trainloader))
prediksi = mlp(a)
prediksi = torch.argmax(prediksi,dim=1)
print('target ',b)
print('prediksi ',prediksi)

hasilnya

print('target ',b)
target  tensor([3, 2, 9, 7, 1, 1, 8, 4, 9, 8])

print('prediksi ',prediksi)
prediksi  tensor([3, 2, 9, 7, 7, 1, 8, 4, 9, 8])
See also  #Video Tutorial - Belajar Python Bagian 3

Leave a Reply

Your email address will not be published.




Enter Captcha Here :