Machine Learning Academy · บทเรียน

การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ

บทเรียน 3 จาก 412 ขั้นตอน

การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ เป็นบทเรียน Machine Learning Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Machine Learning Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน

เหตุใดจึงต้องปรับจูนหลังการดึงคุณลักษณะ

การดึงคุณลักษณะจะปรับเฉพาะส่วนหัวการจำแนก โดยปล่อยให้แกนหลักแช่แข็งอยู่ การปรับจูนดำเนินการต่อไปด้วยการอัปเดตชั้นบางส่วนหรือทั้งหมดของแกนหลัก ทำให้โมเดลสามารถปรับการแทนข้อมูลให้เข้ากับการกระจายข้อมูลเฉพาะของคุณได้

การปรับจูนมีประโยชน์มากที่สุดเมื่อโดเมนของคุณแตกต่างจาก ImageNet — เช่น ภาพถ่ายดาวเทียม ภาพสแกนทางการแพทย์ หรือภาพตำหนิในอุตสาหกรรม คุณลักษณะจาก ImageNet สามารถถ่ายโอนได้บางส่วน แต่การปรับคุณลักษณะเหล่านั้นจะเพิ่มความแม่นยำอย่างเห็นได้ชัด ความเสี่ยงคือการลืมอย่างรุนแรง: หากปรับจูนด้วยอัตราการเรียนรู้สูง ข้อมูลใหม่จะเขียนทับคุณลักษณะที่เรียนรู้ไว้อย่างรอบคอบ ทำให้ประสิทธิภาพลดลงอย่างรวดเร็ว

กลยุทธ์การปรับจูนสองระยะ

แนวทางการปรับจูนมาตรฐานมีสองระยะ ระยะที่ 1: แช่แข็งแกนหลักทั้งหมดและฝึกเฉพาะส่วนหัวการจำแนกใหม่เป็นเวลาหลายยุค จนกว่าจะลู่เข้า วิธีนี้ช่วยให้ส่วนหัวเริ่มจากสถานะที่เหมาะสมก่อนที่ความชันจากแกนหลักจะเข้ามาร่วม

ระยะที่ 2: ยกเลิกการแช่แข็งชั้นของแกนหลักทั้งหมดหรือบางส่วน แล้วฝึกต่อด้วยอัตราการเรียนรู้ที่ต่ำมาก (โดยทั่วไปต่ำกว่าระยะที่ 1 10–100 เท่า) วิธีนี้จะค่อย ๆ ปรับคุณลักษณะที่เรียนรู้ไว้ล่วงหน้าเข้าหาโดเมนของคุณโดยไม่ทำลายคุณลักษณะเหล่านั้น การข้ามระยะที่ 1 แล้วเริ่มปรับจูนทันทีด้วย LR สูง เป็นข้อผิดพลาดที่พบบ่อยที่สุดและทำให้ผลลัพธ์ไม่ดี

import torchvision.models as models
import torch.nn as nn
import torch.optim as optim

model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)

# --- Phase 1: Freeze backbone, train head ---
for param in model.parameters():
    param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)
optimizer = optim.Adam(model.fc.parameters(), lr=1e-3)
# Train for 5-10 epochs...

# --- Phase 2: Unfreeze and fine-tune with low LR ---
for param in model.parameters():
    param.requires_grad = True
optimizer = optim.Adam(model.parameters(), lr=1e-5)  # 100x lower

การยกเลิกการแช่แข็งแบบเลือกชั้นต่อชั้น

แทนที่จะยกเลิกการแช่แข็งแกนหลักทั้งหมดในครั้งเดียว คุณสามารถยกเลิกการแช่แข็งทีละชั้นโดยเริ่มจากด้านบน (ใกล้กับผลลัพธ์มากที่สุด) เนื่องจากชั้นหลัง ๆ มีคุณลักษณะที่เฉพาะกับงานมากที่สุด ขณะที่ชั้นต้น ๆ เรียนรู้คุณลักษณะสากล (ขอบและพื้นผิว) ซึ่งแทบไม่จำเป็นต้องอัปเดต

สำหรับ ResNet-50 ลำดับการยกเลิกการแช่แข็งแบบเลือกชั้นโดยทั่วไปคือ: (1) fc (ฝึกได้อยู่แล้ว) (2) layer4 (3) layer3 และสุดท้าย (4) layer1 กับ layer2 หากจำเป็น แต่ละขั้นต้องประเมินว่าการยกเลิกการแช่แข็งเพิ่มเติมช่วยเพิ่มความแม่นยำของชุดตรวจสอบหรือไม่ เนื่องจากพารามิเตอร์ที่ฝึกได้มากขึ้นเพิ่มความเสี่ยงต่อการฟิตเกินบนชุดข้อมูลขนาดเล็ก

import torchvision.models as models
import torch.nn as nn

model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
# Freeze everything first
for param in model.parameters():
    param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, num_classes)

# After phase 1 training, selectively unfreeze layer4
for param in model.layer4.parameters():
    param.requires_grad = True

trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'Trainable (fc + layer4): {trainable:,}')
# Much fewer parameters to fine-tune than the full 25M

อัตราการเรียนรู้ที่แตกต่างกัน

อัตราการเรียนรู้ที่แตกต่างกันจะกำหนดอัตราการเรียนรู้ที่แตกต่างกันให้กับส่วนต่าง ๆ ของเครือข่าย ส่วนหัวใหม่ฝึกด้วยอัตราสูงสุด (1e-3) ชั้นของแกนหลักที่เพิ่งยกเลิกการแช่แข็งฝึกด้วยอัตราปานกลาง (1e-4) และชั้นต้น ๆ ของแกนหลักฝึกด้วยอัตราต่ำสุด (1e-5) หรือแช่แข็งไว้ทั้งหมด

ตัวเพิ่มประสิทธิภาพของ PyTorch ยอมรับรายการกลุ่มพารามิเตอร์ซึ่งแต่ละกลุ่มมี lr ของตัวเอง เทคนิคนี้เป็นมาตรฐานในงานวิจัยด้านการเรียนรู้แบบถ่ายโอน และใช้ในอัตราการเรียนรู้แบบจำแนกของ fast.ai แนวคิดคือ ส่วนของเครือข่ายที่มีคุณลักษณะทั่วไปมากกว่าต้องการการปรับน้อยกว่าชั้นที่เฉพาะกับงาน

import torch.optim as optim
import torchvision.models as models

model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Unfreeze everything
for p in model.parameters():
    p.requires_grad = True

# Differential learning rates per layer group
optimizer = optim.Adam([
    {'params': model.fc.parameters(),     'lr': 1e-3},   # Head: highest LR
    {'params': model.layer4.parameters(), 'lr': 1e-4},   # Top block
    {'params': model.layer3.parameters(), 'lr': 5e-5},   # Middle
    {'params': list(model.layer1.parameters()) +
               list(model.layer2.parameters()), 'lr': 1e-5}  # Early layers
])

การติดตามการลืมอย่างรุนแรง

การลืมอย่างรุนแรงเกิดขึ้นเมื่อการปรับจูนด้วยอัตราการเรียนรู้สูงเขียนทับคุณลักษณะที่เรียนรู้ไว้ล่วงหน้า ทำให้ความแม่นยำของชุดตรวจสอบลดลงต่ำกว่าค่าพื้นฐานจากการดึงคุณลักษณะเสียอีก คุณจะเห็นได้จากการพุ่งขึ้นอย่างรวดเร็วของความสูญเสียในการฝึกช่วงต้นของระยะที่ 2 ตามด้วยการฟื้นตัวอย่างช้า ๆ

เพื่อป้องกันปัญหานี้: (1) เริ่มระยะที่ 2 ด้วยอัตราการเรียนรู้ที่ต่ำมากเสมอ (2) ติดตามความแม่นยำของชุดตรวจสอบทุกยุค และหยุดทันทีหากลดลงต่ำกว่าค่าที่ดีที่สุดของระยะที่ 1 (3) ใช้ตัวจัดตารางอัตราการเรียนรู้ที่ค่อย ๆ เพิ่ม LR ของแกนหลัก และ (4) บันทึกจุดตรวจสอบของโมเดลที่ดีที่สุดระหว่างระยะที่ 1 เพื่อให้สามารถกู้คืนได้หากระยะที่ 2 ล้มเหลว

import torch

best_val_acc = 0.0
best_state = None

for epoch in range(20):
    train_one_epoch(model, train_loader, optimizer, criterion, device)
    val_acc = evaluate(model, val_loader, device)
    
    if val_acc > best_val_acc:
        best_val_acc = val_acc
        best_state = {k: v.clone() for k, v in model.state_dict().items()}
    
    # Stop if validation drops more than 2% below best
    if val_acc < best_val_acc - 0.02:
        print('Early stop: possible catastrophic forgetting')
        model.load_state_dict(best_state)  # Restore best
        break

ตัวจัดตารางอัตราการเรียนรู้สำหรับการปรับจูน

อัตราการเรียนรู้คงที่แทบไม่ใช่ค่าที่เหมาะสมตลอดการปรับจูน ตัวจัดตารางอัตราการเรียนรู้จะปรับ LR ระหว่างการฝึกเพื่อช่วยให้การลู่เข้าดีขึ้น สำหรับการปรับจูน ตัวจัดตารางสองแบบทำงานได้ดีเป็นพิเศษ: CosineAnnealingLR จะลด LR จากค่าเริ่มต้นลงอย่างราบรื่นจนเกือบเป็นศูนย์ตามเส้นโค้งโคไซน์ และ ReduceLROnPlateau จะลด LR เมื่อเมตริกของชุดตรวจสอบหยุดพัฒนา

ReduceLROnPlateau ที่ใช้ patience=2 เป็นค่าเริ่มต้นที่ปลอดภัย: หากความสูญเสียของชุดตรวจสอบไม่ดีขึ้นเป็นเวลา 2 ยุคติดต่อกัน LR จะถูกคูณด้วย factor=0.1 วิธีนี้มักช่วยให้การพัฒนาดำเนินต่อได้เมื่อการฝึกหยุดชะงัก

import torch.optim as optim
from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR

optimizer = optim.Adam(model.parameters(), lr=1e-4)

# Option 1: Reduce on plateau
scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.1,
                               patience=2, verbose=True)
# Call after each validation: scheduler.step(val_acc)

# Option 2: Cosine annealing over T_max epochs
scheduler = CosineAnnealingLR(optimizer, T_max=20, eta_min=1e-7)
# Call after each epoch: scheduler.step()

print('Initial LR:', optimizer.param_groups[0]['lr'])

ขนาดแบตช์และการทำให้เป็นปกติระหว่างการปรับจูน

การปรับจูนด้วยขนาดแบตช์ที่ใหญ่ขึ้นช่วยลดสัญญาณรบกวนของความชัน ซึ่งเป็นประโยชน์เมื่อต้องปรับคุณลักษณะที่เรียนรู้ไว้ล่วงหน้าเพียงเล็กน้อย อย่างไรก็ตาม แบตช์ที่ใหญ่มากอาจลดความสามารถในการใช้กับข้อมูลใหม่ของการปรับจูนได้ (ปัญหา 'จุดต่ำสุดที่แหลมคม') ขนาดแบตช์ 32–64 เป็นจุดเริ่มต้นที่ดี

เพิ่มการลดน้ำหนัก (การทำให้เป็นปกติแบบ L2) ให้กับตัวเพิ่มประสิทธิภาพ: optim.Adam(model.parameters(), lr=1e-4, weight_decay=1e-4) การลดน้ำหนักช่วยป้องกันไม่ให้น้ำหนักใดน้ำหนักหนึ่งมีขนาดใหญ่เกินไป ซึ่งสำคัญเป็นพิเศษสำหรับการปรับจูน เนื่องจากน้ำหนักที่ฝึกไว้ล่วงหน้ามีขนาดที่เหมาะสมอยู่แล้ว และเราไม่ต้องการรบกวนน้ำหนักเหล่านั้นมากเกินไป

import torch.optim as optim

# Fine-tuning optimiser with weight decay
optimizer = optim.AdamW(
    model.parameters(),
    lr=1e-4,
    weight_decay=1e-4   # L2 regularisation
)

# AdamW separates weight decay from gradient adaptation
# (standard Adam incorrectly applies decay to adaptive gradient scaling)
# AdamW is preferred for fine-tuning transformer models especially

print('Optimizer:', optimizer)

การเพิ่มความหลากหลายของข้อมูลระหว่างการปรับจูน

การเพิ่มความหลากหลายของข้อมูลจะใช้การแปลงแบบสุ่มกับภาพฝึกในแต่ละยุค ส่งผลให้ขนาดชุดข้อมูลเพิ่มขึ้นเสมือนจริง วิธีนี้สำคัญเป็นพิเศษระหว่างการปรับจูนเมื่อคุณมีภาพต่อคลาสจำนวนน้อย การเพิ่มความหลากหลายที่ใช้กับภาพธรรมชาติโดยทั่วไป ได้แก่ การพลิกภาพในแนวนอนแบบสุ่ม การหมุนแบบสุ่ม (±15°) การครอบภาพแบบสุ่ม และการปรับสีแบบสุ่ม (ความสว่าง คอนทราสต์ และความอิ่มตัวของสี)

ใช้การเพิ่มความหลากหลายเฉพาะระหว่างการฝึกเท่านั้น ไม่ใช้ระหว่างการตรวจสอบหรือการอนุมาน ใช้การแปลงแยกต่างหากสำหรับชุดตรวจสอบ โดยใช้เฉพาะการเตรียมข้อมูลเบื้องต้นแบบกำหนดแน่นอน (ปรับขนาด ครอบตรงกลาง และทำให้เป็นมาตรฐาน) transforms.Compose ของ PyTorch ช่วยให้จัดการเรื่องนี้ได้ง่าย

from torchvision import transforms

train_transform = transforms.Compose([
    transforms.RandomResizedCrop(224, scale=(0.7, 1.0)),
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
    transforms.RandomRotation(degrees=15),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

val_transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225])
])

ผลลัพธ์การปรับจูนในทางปฏิบัติ

การปรับแต่งละเอียดช่วยเพิ่มประสิทธิภาพจากการสกัดคุณลักษณะได้มากเพียงใด สำหรับชุดข้อมูลแบบกำหนดเองทั่วไปที่มีภาพประมาณ 1,000 ภาพต่อคลาส การสกัดคุณลักษณะอาจให้ความแม่นยำ 88% ขณะที่การปรับแต่งละเอียดอาจทำได้ถึง 92–95% ทั้งนี้ การเพิ่มประสิทธิภาพจะขึ้นอยู่มากว่าข้อมูลของคุณแตกต่างจาก ImageNet มากเพียงใด

ให้ติดตามตัวเลขสี่ค่านี้เพื่อทำความเข้าใจว่าเกิดอะไรขึ้น: ความแม่นยำของชุดตรวจสอบในระยะที่ 1 (ค่าพื้นฐานจากการสกัดคุณลักษณะ), ความแม่นยำของชุดตรวจสอบเริ่มต้นในระยะที่ 2 (ไม่ควรลดลงต่ำกว่าระยะที่ 1 หาก LR ถูกต้อง), ความแม่นยำสูงสุดของชุดตรวจสอบในระยะที่ 2 (ประโยชน์จากการปรับแต่งละเอียด) และ ความแม่นยำของชุดทดสอบ (ค่าผลลัพธ์สุดท้าย ซึ่งรายงานเพียงครั้งเดียวเมื่อจบกระบวนการ เพื่อหลีกเลี่ยงการรั่วไหลของชุดทดสอบ)

# Example fine-tuning progression
results = {
    'Phase 1 (frozen backbone, 10 epochs)': '88.2%',
    'Phase 2 initial (unfroze layer4, epoch 1)': '88.5%',
    'Phase 2 best (epoch 15)': '92.7%',
    'Phase 2 (unfroze layer3 too, epoch 20)': '93.1%',
    'Final test accuracy': '92.8%',  # Reported only at the end
}
for stage, acc in results.items():
    print(f'{stage}: {acc}')

# Key takeaway: fine-tuning added ~4.5% over feature extraction

การปรับแต่งละเอียดของโครงกระดูก ViT เทียบกับ CNN

การปรับแต่งละเอียดโมเดล ViT (Vision Transformer) ต้องใส่ใจเพิ่มเติมเล็กน้อยเมื่อเทียบกับ CNN โมเดล ViT ใช้ การปรับค่าปกติของเลเยอร์ แทนการปรับค่าปกติของแบตช์ ดังนั้นโหมด model.eval() / model.train() จึงส่งผลหลักต่อดรอปเอาต์มากกว่าสถิติการปรับค่าปกติ ทำให้การปรับแต่งละเอียดทำได้ง่ายขึ้นเล็กน้อย

โมเดล ViT ยังได้ประโยชน์จาก อัตราการเรียนรู้สูงสุดที่ต่ำกว่า ระหว่างการปรับแต่งละเอียด (1e-5 ถึง 5e-5 เทียบกับ 1e-4 สำหรับ CNN) เนื่องจากน้ำหนักของกลไกความสนใจไวต่อการปรับค่าครั้งใหญ่ ตัวเพิ่มประสิทธิภาพ AdamW เป็นตัวเลือกที่แนะนำอย่างยิ่งสำหรับการปรับแต่งละเอียดของ ViT หากปรับแต่งอย่างระมัดระวัง ViT-B/16 อาจทำได้ดีกว่าค่าพื้นฐานของ CNN ในงานหลายประเภท

import torchvision.models as models
import torch.nn as nn
import torch.optim as optim

# Fine-tuning ViT-B/16
vit = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)
vit.heads = nn.Linear(768, num_classes)

# Very low LR for ViT fine-tuning
optimizer = optim.AdamW(
    vit.parameters(),
    lr=2e-5,
    weight_decay=0.01
)

# Warm-up scheduler (common for transformers)
from torch.optim.lr_scheduler import LinearLR, CosineAnnealingLR, SequentialLR
warmup = LinearLR(optimizer, start_factor=0.01, total_iters=5)
cosine = CosineAnnealingLR(optimizer, T_max=25)
scheduler = SequentialLR(optimizer, schedulers=[warmup, cosine], milestones=[5])

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจเกี่ยวกับกลยุทธ์การปรับแต่งละเอียดจากบทเรียนนี้

ตอบคำถามในบทเรียนแบบโต้ตอบ

ทบทวนบทเรียน

ในบทเรียนนี้ คุณได้เรียนรู้ว่า การปรับแต่งละเอียดแบบสองระยะ จะฝึกส่วนหัวก่อน (โดยตรึงโครงกระดูกไว้) จากนั้นจึงเลิกตรึงโครงกระดูกและใช้อัตราการเรียนรู้ที่ต่ำมากเพื่อหลีกเลี่ยงการลืมสิ่งที่เรียนรู้อย่างรุนแรง อัตราการเรียนรู้ที่แตกต่างกัน จะกำหนดอัตราที่สูงกว่าให้ส่วนหัว และอัตราที่ต่ำกว่าให้เลเยอร์ที่อยู่ลึกลงไปในโครงกระดูก ส่วน การเลิกตรึงแบบเลือกเฉพาะ โดยเริ่มจากเลเยอร์ด้านบนไล่ลงมา ให้สมดุลระหว่างความแม่นยำกับประสิทธิภาพดีที่สุด บทถัดไป เราจะนำเทคนิคเหล่านี้ไปใช้กับโจทย์ภาพทางการแพทย์จริงที่มีป้ายกำกับอยู่อย่างจำกัด

เริ่มต้นได้ฟรี

เรียนรู้ Python ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 30
บทเรียน: 120

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Machine Learning Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Machine Learning Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ”

ผู้เรียนจะปลดตรึงชั้นก่อนหน้า หลังฝึกส่วนหัวเบื้องต้น ใช้อัตราการเรียนรู้ที่ต่ำลงเพื่อหลีกเลี่ยงการทำลายคุณลักษณะที่ฝึกไว้ล่วงหน้า และสังเกตความแม่นยำที่เพิ่มขึ้น คุณปฏิบัติ Machine Learning Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Machine Learning Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Machine Learning Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Machine Learning Academy นี้ได้ไหม

ได้ บทเรียน Machine Learning Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

แบบจำลองที่ฝึกไว้ล่วงหน้าใน torchvision: ResNet, EfficientNet และ ViT
การสกัดคุณลักษณะ: การตรึงแกนหลัก
การปรับแต่งละเอียด: การปลดตรึงและอัตราการเรียนรู้ต่ำ
การปรับใช้ข้ามโดเมน: ภาพทางการแพทย์ที่มีป้ายกำกับจำกัด

← กลับไปที่ Machine Learning Academy