Loss Functions နှင့် Optimizers

နားလည်ထားရမယ့် အချက်

Loss function တစ်ခုက 'model က အခုဘယ်လောက် မှားနေသလဲ' ဆိုတာကို network တိုးတက်အောင် သုံးလို့ရမယ့် number တစ်ခုတည်းအဖြစ် ပြောင်းပေးတယ်—ဥပမာ `nn.MSELoss` က regression ပြဿနာအတွက် predicted value နဲ့ actual value ကြားက squared difference ရဲ့ average ကို တွက်ပြီး၊ error ကြီးလေလေ penalty ပိုကြီးလေလေ ပေးတယ်။ Loss value တစ်ခုတည်းကတော့ ဘယ်လောက်ဆိုးနေတယ်ဆိုတာကိုပဲ ပြောပြတယ်—ဘာကို ပြောင်းရမလဲဆိုတာတော့ မပြောပြဘူး။ ဒီနေရာမှာ optimizer (`torch.optim.SGD`, `Adam` စသည်) က ဝင်လာတယ်—autograd က `loss.backward()` နဲ့ တွက်ပြီးသား gradient တွေကို ယူပြီး parameter တစ်ခုချင်းစီကို loss လျော့ကျမယ့် direction ဘက်ကို update rule နဲ့ ရွှေ့ပေးတယ်။ Training loop တိုင်းရဲ့ နှလုံးခုန်သံဟာ call သုံးခုနဲ့ ဖွဲ့စည်းထားတယ်၊ order ကလည်း အရေးကြီးတယ်—`loss.backward()` က gradient တွေကို တွက်ပြီး parameter တစ်ခုစီရဲ့ `.grad` ထဲ ပေါင်းထည့်ပေးတယ်၊ `optimizer.step()` က ဒီ gradient တွေကို ဖတ်ပြီး parameter တွေကို update လုပ်တယ်၊ `optimizer.zero_grad()` က `.grad` ကို ပြန် zero ပြန်ချတယ်။ နောက်ဆုံး step ကို မေ့လွယ်တယ်—PyTorch က default အနေနဲ့ gradient တွေကို စုစည်းသိမ်းဆည်းထားတယ် (advanced technique တချို့မှာ အသုံးဝင်တယ်)၊ zero_grad ကျော်သွားရင် batch များစွာက gradient တွေ တိတ်တိတ်ဆိတ်ဆိတ် ရောနှောသွားတတ်တယ်။

လက်တွေ့ scenario နဲ့ ချိတ်ကြည့်မယ်

Tutorial Platform ရဲ့ relevance-ranking model train လုပ်နေတဲ့အခါ ၊ loss function က model ရဲ့ predicted ranking score ဟာ learner click data ကနေ ညွှန်ပြနေတဲ့ 'မှန်ကန်တဲ့' ranking နဲ့ ဘယ်လောက်ကွာဟနေသလဲဆိုတာ တိုင်းတာပေးပြီး၊ optimizer ကတော့ training step ထောင်ချီအတွင်း ဒီ error signal ကို weight ပိုကောင်းလာအောင် တကယ်ပြောင်းပေးတဲ့ အရာပါ။ forward -> loss -> backward -> step -> zero_grad sequence ကို order မှန်မှန်၊ step တိုင်းမှာ မှန်မှန်ကန်ကန် လုပ်နိုင်ခြင်းက model တစ်ခုကို တဖြည်းဖြည်း တိုးတက်စေတာနဲ့ လုံးဝ မတိုးတက်ဘဲ ဒါမှမဟုတ် လုံးဝ မှားယွင်းစွာ သင်ယူတာကြား ခြားနားချက်ပါပဲ။

• nn.MSELoss က prediction error ကို network train လုပ်ပြီး လျှော့ချနိုင်မယ့် number တစ်ခုတည်းအဖြစ် ပြောင်းပေးတယ်။
• loss.backward() က gradient တွက်တယ်၊ optimizer.step() က ဒါတွေကို apply လုပ်တယ်၊ optimizer.zero_grad() က နောက်တစ်ကြိမ်အတွက် clear လုပ်တယ်။
• PyTorch မှာ gradient တွေက default အနေနဲ့ စုစည်းနေတယ်—zero_grad() ကျော်သွားရင် step တွေကြား gradient တွေ တိတ်တိတ်ဆိတ်ဆိတ် ရောနှောသွားတတ်တယ်။

အတူတူ စမ်းရေးကြည့်မယ်

import torch
import torch.nn as nn

torch.manual_seed(0)

model = nn.Linear(1, 1)
loss_fn = nn.MSELoss()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

x = torch.tensor([[2.0]])
y_true = torch.tensor([[10.0]])

# One manual training step
prediction = model(x)
loss_before = loss_fn(prediction, y_true)
print("Loss before step:", loss_before.item())

loss_before.backward()   # compute gradients
optimizer.step()         # update parameters using gradients
optimizer.zero_grad()    # clear gradients for next round

prediction_after = model(x)
loss_after = loss_fn(prediction_after, y_true)
print("Loss after step:", loss_after.item())

Step မလုပ်ခင် positive loss value တစ်ခု print ထုတ်ပြီးမှ၊ step လုပ်ပြီးနောက် loss value ငယ်သွားတာကို print ထုတ်ပါတယ်—algebra အရ ဒီ single-example setup မှာ lr=0.01 နဲ့ SGD update တစ်ကြိမ်က loss ကို 0.81 နဲ့ မြှောက်လိုက်တာနဲ့ တူတူပါပဲ၊ ဒါကြောင့် print ထုတ်တဲ့ 'loss after' က 'loss before' ထက် ~19% လျော့ကျသွားပါတယ်။

PyTorch Docs — Optimization — Deep Learning