Machine Learning Academy · Pelajaran

Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT

Peserta akan memuat ResNet-50 yang telah dilatih sebelumnya pada ImageNet, memeriksa arsitekturnya, dan melakukan inferensi pada gambar baru untuk memverifikasi representasi yang telah dipelajari.

Pelajaran 1 dari 412 langkah

Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Mengapa Menggunakan Model Pralatih?

Melatih jaringan saraf dalam pada ImageNet dari awal memerlukan jutaan gambar berlabel dan komputasi GPU selama berminggu-minggu. Model pralatih telah mempelajari fitur visual umum — tepi, tekstur, bentuk, dan bagian objek tingkat tinggi — dari kumpulan data yang sangat besar ini.

Dengan menggunakan kembali bobot tersebut, Anda memperoleh manfaat dari pembelajaran yang dilakukan pada 1,2 juta gambar tanpa menanggung biaya pelatihan. Inilah gagasan utama pembelajaran transfer: fitur yang dipelajari pada satu tugas besar dapat ditransfer dengan baik ke tugas-tugas terkait yang lebih kecil. torchvision.models menyediakan puluhan arsitektur pralatih yang siap diunduh dan digunakan.

import torchvision.models as models

# List some available pre-trained models
print(dir(models))  # Shows resnet50, efficientnet_b0, vit_b_16, etc.

# Loading weights pre-trained on ImageNet-1k
resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
print('ResNet-50 loaded, parameters:', sum(p.numel() for p in resnet.parameters()))

ResNet-50: Gambaran Umum Arsitektur

ResNet-50 (Jaringan Residual dengan 50 lapisan) memperkenalkan koneksi lompatan yang menambahkan masukan suatu blok langsung ke keluarannya: output = F(x) + x. Hal ini memungkinkan gradien mengalir langsung melalui penjumlahan, sehingga jaringan yang sangat dalam dapat dilatih tanpa gradien yang menghilang.

ResNet-50 memiliki sekitar 25 juta parameter dan terdiri atas: satu lapisan konvolusi awal berukuran 7×7, penggabungan maksimum, empat blok residual (layer1–layer4), serta lapisan penggabungan rata-rata global yang diikuti kepala terhubung penuh dengan 1000 kelas untuk klasifikasi ImageNet. Lapisan fc terakhir adalah lapisan yang kita ganti untuk tugas khusus.

import torchvision.models as models
import torch

resnet = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
print(resnet)  # Prints the full architecture

# Key layers
print('Final FC layer:', resnet.fc)  # Linear(2048, 1000)
print('Layer4 output channels:', 2048)  # Feature dimension before FC

Menjalankan Inferensi dengan ResNet-50

Sebelum menjalankan inferensi, masukan harus sesuai dengan prapemrosesan yang digunakan selama pelatihan ImageNet: ubah ukurannya menjadi setidaknya 224×224, lalu normalkan menggunakan rata-rata dan simpangan baku ImageNet. API torchvision.transforms menangani hal ini. Selalu panggil model.eval() sebelum inferensi untuk menonaktifkan dropout dan mode pelatihan normalisasi batch.

Model menghasilkan 1000 logit, satu untuk setiap kelas ImageNet. Kami menerapkan softmax untuk memperoleh probabilitas dan memilih kelas-kelas top-k. torchvision.models kini menyertakan nama kategori dalam metadata bobot, sehingga tidak memerlukan berkas label terpisah.

import torch
from torchvision import transforms
from PIL import Image
import torchvision.models as models

weights = models.ResNet50_Weights.IMAGENET1K_V1
resnet = models.resnet50(weights=weights)
resnet.eval()

# Preprocessing transforms from the weights metadata
preprocess = weights.transforms()

# Load and preprocess an image
img = Image.open('cat.jpg')
tensor = preprocess(img).unsqueeze(0)  # Add batch dimension

with torch.no_grad():
    logits = resnet(tensor)
    probs = torch.softmax(logits, dim=1)
    top5 = torch.topk(probs, 5)
print('Top-5 probabilities:', top5.values)

EfficientNet: Penskalaan Gabungan

EfficientNet (2019) memperkenalkan penskalaan gabungan: melakukan penskalaan lebar, kedalaman, dan resolusi masukan jaringan secara sistematis menggunakan satu koefisien gabungan. Alih-alih memperlebar atau memperdalam jaringan secara sembarangan, EfficientNet menyeimbangkan ketiga dimensi tersebut untuk memperoleh pertukaran akurasi dan efisiensi yang optimal.

Keluarga EfficientNet berkisar dari efficientnet_b0 (5 juta parameter) hingga efficientnet_b7 (66 juta parameter). EfficientNet-B0 mencapai akurasi yang sebanding dengan ResNet-50, tetapi menggunakan 8× lebih sedikit parameter dan 6× lebih sedikit FLOP, sehingga ideal untuk penerapan pada perangkat seluler dan perangkat edge. PyTorch menyediakan kedelapan variannya.

import torchvision.models as models
import torch

# EfficientNet-B0: lightweight but accurate
eff_b0 = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)
print('EfficientNet-B0 params:', sum(p.numel() for p in eff_b0.parameters()))
print('EfficientNet-B0 classifier:', eff_b0.classifier)

# Compare with ResNet-50
resnet50 = models.resnet50(weights=None)  # No weights to count params only
print('ResNet-50 params:', sum(p.numel() for p in resnet50.parameters()))

Vision Transformer (ViT): Perhatian Tanpa Konvolusi

Vision Transformers (ViT) (2020) menerapkan arsitektur transformer langsung pada gambar, tanpa konvolusi apa pun. Gambar dibagi menjadi kisi patch berukuran tetap (misalnya, 16×16 piksel), lalu setiap patch diratakan dan diproyeksikan menjadi vektor embedding. Embedding patch ini diperlakukan seperti token kata dalam NLP.

Sebuah token CLS (klasifikasi) ditambahkan di awal urutan patch. Setelah melewati beberapa blok pembuat enkode transformer dengan perhatian mandiri, keluaran token CLS digunakan untuk klasifikasi. ViT memerlukan kumpulan data pelatihan yang besar agar dapat mengungguli CNN, tetapi model ViT pralatih dari torchvision segera menghadirkan kemampuan ini untuk tugas Anda.

import torchvision.models as models
import torch

# ViT-B/16: Base model with 16x16 patches
vit = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)
print('ViT-B/16 params:', sum(p.numel() for p in vit.parameters()))
print('ViT patch size: 16x16 pixels')
print('ViT sequence length for 224x224 image:', (224 // 16) ** 2 + 1, '(196 patches + 1 CLS token)')
print('ViT head:', vit.heads)  # Linear(768, 1000)

Membandingkan ResNet, EfficientNet, dan ViT

Pemilihan di antara arsitektur-arsitektur ini bergantung pada batasan dan tugas Anda. ResNet-50 adalah pilihan bawaan yang andal: dipahami dengan baik, menjadi tolok ukur yang kuat, serta memiliki banyak tutorial dan implementasi. EfficientNet-B0/B2 unggul ketika kecepatan inferensi dan ukuran model menjadi hal penting — misalnya pada aplikasi seluler, sistem waktu nyata, atau perangkat edge.

ViT unggul pada tugas berskala besar dan mendapat manfaat dari prapelatihan mandiri (DINO, CLIP). Model ini memerlukan komputasi dan memori yang lebih besar daripada CNN dengan akurasi serupa. Untuk sebagian besar tugas klasifikasi gambar khusus dengan kumpulan data berukuran sedang, mulailah dengan EfficientNet-B2 atau ResNet-50, lalu coba ViT jika Anda memiliki sumber daya untuk menyetel ulangnya.

# Rough comparison on ImageNet top-1 accuracy
comparison = {
    'ResNet-50':       {'params': '25M', 'top1': '76.1%', 'year': 2015},
    'EfficientNet-B0': {'params': '5M',  'top1': '77.7%', 'year': 2019},
    'EfficientNet-B4': {'params': '19M', 'top1': '83.4%', 'year': 2019},
    'ViT-B/16':        {'params': '86M', 'top1': '81.1%', 'year': 2020},
    'ViT-L/16':        {'params': '307M','top1': '85.1%', 'year': 2020},
}
for name, info in comparison.items():
    print(f'{name}: {info["params"]} params, {info["top1"]} top-1')

Memeriksa Internal Model

Sebelum memodifikasi model pralatih untuk tugas Anda, periksa arsitekturnya untuk memahami lapisan mana yang harus diganti. Gunakan print(model) untuk melihat pohon lapisan, dan named_modules() atau named_children() untuk melakukan iterasi secara terprogram.

Wawasan utamanya: setiap model torchvision diakhiri dengan kepala klasifikasi yang berukuran untuk 1000 kelas ImageNet. Untuk menyesuaikan model dengan tugas Anda menggunakan num_classes yang berbeda dari 1000, Anda mengganti lapisan terakhir ini. Ekstraktor fitur (segala sesuatu sebelum kepala) mempertahankan fitur yang dipelajari dari ImageNet.

import torchvision.models as models

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

# Find the names of top-level children
for name, module in resnet.named_children():
    print(name, '->', type(module).__name__)

# Output:
# conv1 -> Conv2d
# bn1 -> BatchNorm2d
# relu -> ReLU
# maxpool -> MaxPool2d
# layer1 -> Sequential  (Residual blocks)
# layer2 -> Sequential
# layer3 -> Sequential
# layer4 -> Sequential
# avgpool -> AdaptiveAvgPool2d
# fc -> Linear  <-- This is what we replace

Ukuran Vektor Fitur untuk Setiap Arsitektur

Saat mengganti kepala klasifikasi, Anda perlu mengetahui dimensi fitur yang dihasilkan oleh tulang punggung (segala sesuatu kecuali lapisan terakhir). Dimensi ini merupakan ukuran masukan kepala klasifikasi baru Anda.

Dimensi keluaran tulang punggung yang umum: ResNet-50 menghasilkan 2048, EfficientNet-B0 menghasilkan 1280, dan ViT-B/16 menghasilkan 768. Vektor fitur ini dihitung melalui penggabungan rata-rata global pada peta fitur spasial, sehingga menghasilkan satu vektor untuk setiap gambar. Kepala pengganti Anda menerima vektor ini sebagai masukan.

import torch
import torchvision.models as models

# Feature dimensions before the classification head
feature_dims = {
    'resnet50':        2048,
    'efficientnet_b0': 1280,
    'efficientnet_b2': 1408,
    'efficientnet_b4': 1792,
    'vit_b_16':        768,
    'vit_l_16':        1024,
}

# Verify for ResNet-50 by running a dummy forward pass without the head
resnet = models.resnet50(weights=None)
resnet.fc = torch.nn.Identity()  # Remove FC layer
x = torch.randn(1, 3, 224, 224)
features = resnet(x)
print('ResNet-50 feature size:', features.shape)  # (1, 2048)

Memeriksa Kualitas Bobot Pralatih

Anda dapat dengan cepat memverifikasi bahwa bobot model pralatih sudah benar dengan menjalankannya pada gambar uji yang dikenal luas dan memeriksa apakah prediksi teratas sesuai dengan label yang diharapkan. Pemeriksaan kewajaran ini memastikan bobot dimuat dengan benar dan alur prapemrosesan sudah tepat.

Selain pengujian ini, sebaiknya Anda selalu memeriksa format masukan yang diharapkan dari metadata bobot: ukuran masukan (224×224 untuk sebagian besar model), urutan kanal (RGB, bukan BGR), serta konstanta normalisasi (rata-rata dan simpangan baku ImageNet). Penggunaan normalisasi yang salah merupakan kesalahan umum yang menyebabkan hasil pembelajaran transfer buruk.

import torchvision.models as models

weights = models.ResNet50_Weights.IMAGENET1K_V1
print('Expected input size:', weights.meta['min_size'])  # (1, 1)
print('Transforms:', weights.transforms())
# Includes Resize(232), CenterCrop(224), Normalize(mean, std)

# ImageNet normalisation constants
IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD  = [0.229, 0.224, 0.225]
# Always use these EXACT values with ImageNet pre-trained models

Mempersiapkan Penyetelan Halus untuk Tugas Anda

Alur kerja umum untuk menggunakan model pralatih pada tugas khusus adalah: (1) muat model pralatih dengan weights=...IMAGENET1K..., (2) ganti kepala klasifikasi terakhir dengan nn.Linear baru yang ukurannya sesuai dengan jumlah kelas Anda, (3) jika diperlukan, bekukan bobot tulang punggung pada tahap awal, dan (4) lakukan pelatihan menggunakan laju pembelajaran yang lebih rendah daripada yang digunakan saat memulai dari awal.

Kepala klasifikasi baru dimulai dengan bobot acak dan perlu belajar dari data Anda. Tulang punggung dimulai dengan fitur yang sangat baik dan hanya memerlukan sedikit penyesuaian. Inilah sebabnya laju pembelajaran diferensial — laju yang sangat rendah untuk tulang punggung dan lebih tinggi untuk kepala — sering meningkatkan kecepatan konvergensi dan akurasi akhir.

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

# Example: Adapt ResNet-50 for 5-class flower classification
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)

# Replace the final FC layer
num_classes = 5
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Differential learning rates
optimizer = torch.optim.Adam([
    {'params': model.fc.parameters(), 'lr': 1e-3},      # High LR for new head
    {'params': [p for n, p in model.named_parameters() if 'fc' not in n], 'lr': 1e-5}  # Low LR for backbone
])

Pemeriksaan Singkat

Uji pemahaman Anda tentang model torchvision pralatih dari pelajaran ini.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, Anda mempelajari bahwa: ResNet-50 menggunakan koneksi lompatan untuk melatih jaringan yang sangat dalam dan menghasilkan fitur berdimensi 2048, EfficientNet mencapai pertukaran akurasi dan efisiensi yang lebih baik melalui penskalaan gabungan lebar, kedalaman, dan resolusi, serta ViT menerapkan perhatian mandiri transformer pada patch gambar tanpa konvolusi. Selanjutnya, kita akan mempelajari ekstraksi fitur — membekukan tulang punggung pralatih dan hanya melatih kepala klasifikasi baru pada kumpulan data khusus Anda.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT” gratis?

Ya — teks lengkap “Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT”?

Peserta akan memuat ResNet-50 yang telah dilatih sebelumnya pada ImageNet, memeriksa arsitekturnya, dan melakukan inferensi pada gambar baru untuk memverifikasi representasi yang telah dipelajari. Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?

Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Model Pralatih dalam torchvision: ResNet, EfficientNet, dan ViT
Ekstraksi Fitur: Membekukan Backbone
Fine-Tuning: Membuka Pembekuan dan Laju Pembelajaran Rendah
Adaptasi Domain: Pencitraan Medis dengan Label Terbatas

← Kembali ke Machine Learning Academy