Training Loop နှင့် Backpropagation

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

Backpropagation ဆိုတာ `.backward()` ကို efficient ဖြစ်စေတဲ့ algorithm အတိအကျပါ—naive alternative (parameter တစ်ခုကို အနည်းငယ် ရွှေ့ကြည့်တယ်၊ forward pass တစ်ခုလုံးကို ပြန် run တယ်၊ loss ဘယ်လောက် ပြောင်းလဲသွားလဲ ကြည့်တယ်၊ parameter တစ်ခုချင်းစီအတွက် ထပ်ခါထပ်ခါ လုပ်တယ်) အစား backpropagation က network ထဲက parameter တိုင်းနဲ့ ပတ်သက်တဲ့ loss ရဲ့ gradient ကို backward sweep တစ်ခုတည်းနဲ့ တွက်ပေးတယ်။ Chain rule ကို output ကနေ input ဆီ systematically apply လုပ်ခြင်းဖြင့် ဒါကို လုပ်ဆောင်တာဖြစ်ပြီး၊ layer တစ်ခုစီမှာ intermediate result တွေကို ပြန်တွက်နေမယ့်အစား ပြန်သုံးတာဖြစ်တယ်၊ ဒါက parameter သန်းချီပါတဲ့ network တွေကို train လုပ်ဖို့ computationally ဖြစ်နိုင်စေတဲ့ အကြောင်းရင်းပါပဲ—naive approach ဆိုရင် parameter တစ်ခုစီအတွက် forward pass တစ်ခုစီ လိုအပ်မှာဖြစ်ပြီး parameter သန်းတစ်သန်းပါတဲ့ network တစ်ခုအတွက် သန်းတစ်သန်းဆ နှေးကွေးသွားလိမ့်မယ်။ Training loop တစ်ခုက ဒါကို repetition အဖြစ် ပေါင်းစည်းပေးတယ်—epoch တိုင်းအတွက် (dataset တစ်ခုလုံး ဖြတ်သန်းမှုတစ်ကြိမ်)၊ batch တိုင်းအတွက်၊ prediction ရဖို့ forward pass လုပ်တယ်၊ loss တွက်တယ်၊ backpropagate လုပ်ဖို့ loss.backward() ခေါ်တယ်၊ parameter update လုပ်ဖို့ optimizer step လုပ်တယ်၊ ပြီးရင် gradient zero ချတယ်—loss က သိသာထင်ရှားစွာ ဆက်မလျော့တော့တဲ့အထိ ထပ်ခါထပ်ခါ လုပ်တယ်၊ ဒါကပဲ 'model က သင်ယူပြီးပြီ' ဆိုတာရဲ့ တိကျတဲ့ အဓိပ္ပါယ်ပါ။

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

ဒီ training loop အပြည့်အစုံကပဲ Tutorial Platform ပေါ်က feature အစစ်တိုင်းကို train လုပ်ပေးတာပါ—sentiment classifier က past feedback comment ထောင်ချီကနေ သင်ယူတယ်၊ ranking model က learner click pattern ကနေ သင်ယူတယ်၊ recommendation model က lesson-completion sequence ကနေ သင်ယူတယ်—ဒါတွေအားလုံး forward -> loss -> backward -> step -> zero_grad cycle အတူတူကိုပဲ dataset အသီးသီးအပေါ် loss converge ဖြစ်တဲ့အထိ run ကြခြင်းပါ။ ဒီ chapter ထဲက အရာတိုင်း (tensor, autograd, nn.Module, loss function, optimizer) တွေဟာ ဒီ loop တစ်ခုတည်းကို ဖြစ်နိုင်စေဖို့ ရှိနေတာပါ—နောက် chapter တွေထဲက architecture ပိုအဆင့်မြင့်တွေက forward pass ထဲမှာ ဖြစ်ပျက်နေတာကို ပြောင်းလဲပေမယ့် training loop ကိုယ်တိုင်ရဲ့ ပုံစံကတော့ ဒီအတိုင်းပဲ ဆက်ရှိနေမှာပါ။

Backpropagation က parameter တစ်ခုချင်းစီအတွက် forward pass တစ်ခုစီ လုပ်မယ့်အစား chain rule သုံးပြီး loss ရဲ့ gradient ကို backward sweep တစ်ခုတည်းနဲ့ တွက်ပေးတယ်။
Training loop က batch တိုင်း၊ epoch တိုင်းအတွက် forward pass -> loss -> backward -> optimizer step -> zero_grad ကို ထပ်ခါထပ်ခါ လုပ်ဆောင်တယ်။
'Model က သင်ယူပြီးပြီ' ဆိုတာက epoch တွေတစ်လျှောက် loss သိသာထင်ရှားစွာ ဆက်မလျော့တော့ဘူးဆိုတာကို တိကျစွာ ဆိုလိုတာပါ။

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

python

import torch
import torch.nn as nn

torch.manual_seed(0)

# Synthetic data: y = 2x + 1, plus a little noise
x = torch.linspace(-5, 5, 100).unsqueeze(1)  # shape (100, 1)
y = 2 * x + 1 + torch.randn(x.shape) * 0.5

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

for epoch in range(200):
    predictions = model(x)          # forward pass
    loss = loss_fn(predictions, y)  # compute loss
    optimizer.zero_grad()           # clear old gradients
    loss.backward()                 # backpropagation
    optimizer.step()                # update parameters

    if epoch % 40 == 0:
        print(f"Epoch {epoch}: loss = {loss.item():.4f}")

learned_w = model.weight.item()
learned_b = model.bias.item()
print(f"Learned: y = {learned_w:.2f}x + {learned_b:.2f}")

You should see

Epoch 0, 40, 80, 120, 160 တို့မှာ loss ကို print ထုတ်ပြီး၊ တဖြည်းဖြည်း လျော့ကျကာ noise ရဲ့ irreducible variance (noise standard deviation 0.5 ကနေ ~0.25 ခန့်) အနီးမှာ တည်ငြိမ်သွားပါတယ်၊ ပြီးရင် learned weight နဲ့ bias ကို print ထုတ်ပြီး synthetic data ဖန်တီးဖို့ သုံးခဲ့တဲ့ true value 2.00 နဲ့ 1.00 အနီးကပ် ရောက်သွားကြောင်း တွေ့ရပါတယ်။

၅ မိနစ် စမ်းကြည့်

Learning rate ကို 0.001 အဖြစ် ပြောင်းပြီး epoch 200 ပြန် run ကြည့်ပါ—loss က ပိုနှေးနှေးလျော့ကျတယ်၊ learned weight/bias တွေက 2.0/1.0 နဲ့ ပိုဝေးသွားတယ်ဆိုတာ သတိပြုပါ၊ ပြီးရင် 0.5 နဲ့ ထပ်ကြည့်ပြီး training က converge ဖြစ်မယ့်အစား ပျက်စီးသွားတာကို ကြည့်ပါ။

သတိလေးတစ်ချက်

optimizer.zero_grad() ကို loss.backward() ရှေ့မှာ မထားဘဲ နောက်မှာ ထားမိတာ—ဒီ lesson ရဲ့ code ထဲက order (zero_grad, ပြီးမှ backward, ပြီးမှ step) က အလုပ်ဖြစ်ပေမယ့် learner အများစုက example တွေကို မညီညွတ်ဘဲ copy လုပ်မိပြီး gradient ကို တွက်ပြီးတာနဲ့ ချက်ချင်း zero ချမိတတ်တယ်၊ ဒါက step တိုင်းကို no-op update ဖြစ်စေပြီး တိတ်တိတ်ဆိတ်ဆိတ် ဘာမှ update မလုပ်ဘဲ ဖြစ်နေတတ်တယ်။

'ပိုမြန်အောင် train ချင်လို့' learning rate ကို မြင့်လွန်းအောင် set လုပ်မိတာ—ဒီ simple linear regression အတွက် learning rate ~0.12 ထက် များများသာ တက်သွားရင် loss က minimum ကို ကပ်မယ့်အစား gradient step က overshoot ဖြစ်ပြီး oscillate ဒါမှမဟုတ် diverge ဖြစ်သွားတတ်တယ်။

Wikipedia — Backpropagation — Deep Learning