Transfer Learning

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

Large ပြီး accurate ဖြစ်တဲ့ network တစ်ခုကို scratch ကနေ train လုပ်ဖို့ labeled dataset ကြီးကြီးမားမား နဲ့ compute အလွန်များများ လိုအပ်တယ် — project အများစုမှာ ဒီလို resource မရှိကြဘူး။ Transfer learning ကတော့ large, general dataset တစ်ခုအပေါ် train လုပ်ပြီးသား model တစ်ခုကနေ စတင်ခြင်းအားဖြင့် ဒီပြဿနာကို ရှောင်တိမ်းပေးတယ်၊ ဒီ model ရဲ့ layer ရှေ့ဆုံးတွေက edge၊ texture၊ shape ရိုးရိုးလိုမျိုး visual task ဘယ်ခုအတွက်မဆို transfer ကောင်းကောင်း ဖြစ်နိုင်တဲ့ broadly useful low-level feature တွေကို သင်ယူပြီးသား ဖြစ်နေတယ်၊ ဒီနောက် ဒီ model ကို ရှင်းလင်းသေးငယ်တဲ့ task အသစ်တစ်ခုအတွက် ဘာမှမသိကနေ အားလုံး သင်ယူတာမျိုးမဟုတ်ဘဲ adapt လုပ်ပေးတယ်။ Strategy အဓိကနှစ်ခု ရှိပြီး pretrained model ကို ဘယ်လောက် ပြန် train လုပ်လဲဆိုတာနဲ့ ကွဲပြားတယ်။ Feature extraction ကတော့ pretrained layer တိုင်းရဲ့ weight ကို လုံးလုံး freeze လုပ်ထားတယ် — `requires_grad = False` ကို ချထားလိုက်ခြင်းအားဖြင့် gradient ဘာမှ update မလုပ်စေဘူး — အသစ်ထည့်လိုက်တဲ့ classifier layer နောက်ဆုံးတစ်ခုကိုပဲ train လုပ်တယ်၊ ဒါက မြန်ပြီး data အသစ် အနည်းငယ်ပဲ လိုအပ်ပြီး task အသစ်က model ရဲ့ original သင်ယူမှုနဲ့ တူညီရင် ကောင်းစွာ အလုပ်ဖြစ်တယ်။ Fine-tuning ကတော့ pretrained layer အချို့ ဒါမှမဟုတ် အားလုံးကို unfreeze လုပ်ပြီး ဆက်ပြီး train လုပ်တယ်၊ scratch training run တစ်ခုထက် learning rate ပိုနည်းနည်းလေးနဲ့ ပုံမှန်အားဖြင့် လုပ်ပြီး model ရဲ့ သင်ယူထားပြီးသား feature တွေကို task အသစ်အတွက် ပိုနက်ရှိုင်းစွာ adapt လုပ်နိုင်စေတယ်၊ ဒါပေမဲ့ သင်ယူထားပြီးသားကို မဖျက်ဆီးအောင် data နဲ့ compute ပိုများများ လိုအပ်တယ်။

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

Tutorial Platform ရဲ့ အတော်လေး သေးငယ်တဲ့ click-through dataset အပေါ် search-relevance ranking model ကို ဘာမှမသိကနေ train လုပ်မယ့်အစား team က large general corpus အပေါ် train လုပ်ပြီးသား text model တစ်ခုကနေ စတင်တယ်၊ ဒီ model ရဲ့ layer ရှေ့ဆုံးတွေက grammar နဲ့ word meaning ကို ကျယ်ကျယ်ပြန့်ပြန့် နားလည်ပြီးသား ဖြစ်နေတယ်။ Version ပထမဆုံးအတွက် ဒီ pretrained layer တွေကို freeze လုပ်ပြီး query-lesson relevance ကို score ပေးဖို့ layer နောက်ဆုံးအသစ်တစ်ခုကိုပဲ train လုပ်မယ်၊ click data ကန့်သတ်ထားလို့ feature extraction က data နည်းနည်းလေးအပေါ် overfitting ဖြစ်တာကို ရှောင်ပေးလို့ပါ။ Platform က လအတော်များများ real usage data ရလာတဲ့အခါ fine-tuning ဆီ ပြောင်းနိုင်ပြီး pretrained layer နောက်ပိုင်းတွေကို unfreeze လုပ်ကာ model ရဲ့ language understanding ကို learner တွေ programming question ကို ဘယ်လို ဖော်ပြလေ့ရှိလဲဆိုတာနဲ့ တိကျစွာ adapt ဖြစ်စေနိုင်တယ်။

• Transfer learning က scratch ကနေ train လုပ်မယ့်အစား large general dataset အပေါ် pretrained model တစ်ခုကနေ စတင်ပြီး သင်ယူပြီးသား low-level feature တွေကို ပြန်သုံးတယ်။
• Feature extraction က pretrained weight အားလုံးကို freeze လုပ်တယ် (`requires_grad = False`) layer နောက်ဆုံးအသစ်တစ်ခုကိုပဲ train လုပ်တယ် — မြန်ပြီး data နည်းနည်းပဲ လိုအပ်တယ်။
• Fine-tuning က pretrained layer အချို့ ဒါမှမဟုတ် အားလုံးကို unfreeze လုပ်ပြီး learning rate နည်းနည်းနဲ့ ပြန် train လုပ်တယ် — ပိုနှေးပေမဲ့ data ပိုလိုအပ်ပြီး ပိုနက်ရှိုင်းစွာ adapt ဖြစ်စေတယ်။

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

import torch
import torch.nn as nn

class TinyBackbone(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 8, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(8, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )
        # pretend this was pretrained on a 1000-class dataset
        self.classifier = nn.Linear(16 * 8 * 8, 1000)

    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        return self.classifier(x)

model = TinyBackbone()

# Freeze all pretrained feature-extraction layers
for param in model.features.parameters():
    param.requires_grad = False

# Replace the final layer for a new 5-class task (trainable by default)
model.classifier = nn.Linear(16 * 8 * 8, 5)

for name, param in model.named_parameters():
    print(name, "trainable" if param.requires_grad else "frozen")

Parameter tensor တစ်ခုချင်းစီအတွက် line တစ်ကြောင်းစီ print ထုတ်ပြီး `features.*` weight/bias အားလုံးကို `frozen` အဖြစ်လည်းကောင်း `classifier.*` weight/bias အားလုံးကို `trainable` အဖြစ်လည်းကောင်း ပြသတယ်။

PyTorch Docs — Transfer Learning Tutorial — Deep Learning