Machine Learning Academy · Pelajaran

Pengekstrakan Ciri: Membekukan Tulang Belakang

Pelajar akan membekukan semua lapisan kecuali kepala pengelasan akhir, melatih hanya lapisan baharu pada set data tersuai yang kecil, dan mengesahkan pengurangan masa latihan yang ketara.

Pelajaran 2 daripada 412 langkah

Pengekstrakan Ciri: Membekukan Tulang Belakang ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Pengekstrakan Ciri berbanding Pelarasan Halus

Pembelajaran pemindahan mempunyai dua strategi utama. Dalam pengekstrakan ciri, tulang belakang pralatih dibekukan sepenuhnya — pemberatnya tidak berubah semasa latihan. Hanya kepala pengelasan baharu yang anda tambahkan di atasnya belajar daripada data anda. Dalam pelarasan halus, keseluruhan rangkaian atau sekurang-kurangnya sebahagian lapisan tulang belakang turut dikemas kini.

Pengekstrakan ciri ialah pilihan yang tepat apabila set data anda kecil (kurang daripada beberapa ribu imej) atau apabila imej anda serupa dengan ImageNet (gambar semula jadi objek harian). Kaedah ini jauh lebih pantas kerana kecerunan tidak mengalir melalui tulang belakang, dan mengelakkan kemusnahan ciri yang dipelajari dengan teliti akibat kemas kini bising daripada data yang terlalu sedikit.

Membekukan Parameter dalam PyTorch

Dalam PyTorch, setiap tensor parameter mempunyai atribut requires_grad. Menetapkannya kepada False menghalang pengiraan kecerunan untuk tensor tersebut, lalu membekukannya secara berkesan. Cara paling mudah untuk membekukan semua parameter tulang belakang adalah dengan melakukan lelaran pada model.parameters() dan menetapkan requires_grad = False, kemudian menggantikan kepala pengelasan (yang bermula dengan pemberat rawak baharu, maka requires_grad=True secara lalai).

Kaedah ini cekap: autograd PyTorch melangkau parameter yang dibekukan semasa laluan undur, lalu mengurangkan penggunaan memori dan mempercepatkan latihan dengan ketara berbanding pelarasan halus seluruh rangkaian.

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

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

# Freeze ALL backbone parameters
for param in model.parameters():
    param.requires_grad = False

# Replace the classification head (creates new trainable parameters)
num_classes = 10
model.fc = nn.Linear(model.fc.in_features, num_classes)
# model.fc.parameters() have requires_grad=True by default

trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
total = sum(p.numel() for p in model.parameters())
print(f'Trainable: {trainable:,} / Total: {total:,} ({trainable/total:.1%})')

Mengapa Ciri Beku Berfungsi dengan Baik

Model pralatih ImageNet mempelajari hierarki ciri: lapisan awal mengesan tepi dan warna peringkat rendah, lapisan pertengahan mengesan tekstur dan bahagian, manakala lapisan kemudian mengesan objek abstrak. Ciri ini ialah ciri visual umum yang boleh dipindahkan secara meluas merentas domain imej.

Apabila tugasan anda melibatkan imej semula jadi — bunga, haiwan, imbasan perubatan, foto satelit — ciri yang telah dipelajari ini jauh lebih bermaklumat berbanding apa-apa yang dapat diekstrak oleh rangkaian yang dimulakan secara rawak daripada set data kecil. Pengekstrakan ciri memanfaatkan perkara ini dengan menganggap tulang belakang yang dibekukan sebagai pengubah ciri tetap dan hanya melatih pengelas linear kecil di atas ciri yang diekstrak.

import torchvision.models as models
import torch

# Pre-extract features for all images (faster than forward-passing every epoch)
model = models.resnet50(weights=models.ResNet50_Weights.IMAGENET1K_V1)
model.fc = torch.nn.Identity()  # Remove classification head
model.eval()

# Extract 2048-dim features for all training images once
all_features, all_labels = [], []
with torch.no_grad():
    for images, labels in train_loader:
        features = model(images)  # Shape: (batch, 2048)
        all_features.append(features)
        all_labels.append(labels)

X_train = torch.cat(all_features)  # (N, 2048)
y_train = torch.cat(all_labels)    # (N,)

Melatih Hanya Kepala Pengelasan

Setelah ciri dibekukan, latihan menjadi pantas. Pengoptimum hanya mengemas kini pemberat kepala baharu. Anda boleh melatih lapisan nn.Linear yang ringkas dalam PyTorch, atau menghantar vektor ciri yang telah diekstrak kepada LogisticRegression atau SVC daripada scikit-learn — kedua-dua pendekatan berfungsi dengan baik untuk pengelasan linear menggunakan ciri pralatih yang kaya.

Menggunakan satu lapisan linear adalah setara dengan melatih regresi logistik pada ciri yang diekstrak. Untuk tugasan yang lebih kompleks atau apabila kelas anda memerlukan sempadan keputusan tidak linear, anda boleh menggunakan kepala berbilang lapisan yang kecil dengan pengaktifan ReLU dan pengguguran antara rangkaian asas yang dibekukan dengan output.

import torch.nn as nn
import torch.optim as optim

# Option 1: Simple linear head (logistic regression on features)
classifier = nn.Linear(2048, num_classes)
optimizer = optim.Adam(classifier.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

# Option 2: Small MLP head for more complex tasks
mlp_head = nn.Sequential(
    nn.Linear(2048, 512),
    nn.ReLU(),
    nn.Dropout(0.3),
    nn.Linear(512, num_classes)
)

# scikit-learn option (useful for small datasets)
from sklearn.linear_model import LogisticRegression
clf = LogisticRegression(max_iter=1000, C=1.0)
clf.fit(X_train.numpy(), y_train.numpy())

Persediaan DataLoader dan Transformasi

Semasa pengekstrakan ciri, prapemprosesan imej mesti sepadan dengan transformasi yang digunakan ketika melatih model asal. Bagi model pralatih ImageNet, ini bermaksud: ubah saiz kepada 256, pangkas dari tengah kepada 224×224, tukar kepada tensor dan normalkan menggunakan min serta sisihan piawai ImageNet.

Apabila anda menggunakan weights.transforms(), PyTorch menyediakan pipeline prapemprosesan yang betul secara automatik, yang berkaitan dengan pemberat khusus tersebut. Ini menghapuskan punca biasa pepijat halus apabila anda tersilap menggunakan pemalar normalisasi yang salah, yang boleh mengurangkan ketepatan pembelajaran pindahan sebanyak beberapa mata peratusan.

from torchvision import transforms, datasets
from torch.utils.data import DataLoader
import torchvision.models as models

weights = models.ResNet50_Weights.IMAGENET1K_V1
preprocess = weights.transforms()  # Includes correct resize, crop, normalize

train_dataset = datasets.ImageFolder('data/train', transform=preprocess)
val_dataset   = datasets.ImageFolder('data/val',   transform=preprocess)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader   = DataLoader(val_dataset,   batch_size=32, shuffle=False, num_workers=4)

print('Classes:', train_dataset.classes)
print('Training samples:', len(train_dataset))

Perbandingan Kelajuan Latihan

Pengekstrakan ciri jauh lebih pantas berbanding penalaan halus penuh. Apabila semua parameter rangkaian asas mempunyai requires_grad=False, PyTorch tidak mengira kecerunan melaluinya semasa loss.backward(), sekali gus menjimatkan memori dan pengiraan yang berkadar dengan bilangan lapisan yang dibekukan.

Untuk ResNet-50 (25M parameter, 2048 ciri yang dibekukan dan hanya kira-kira 2K parameter pada kepala), satu epok latihan pada set data yang mengandungi 5000 imej selesai dalam beberapa saat pada CPU, berbanding beberapa minit untuk penalaan halus penuh. Mengekstrak ciri terlebih dahulu secara luar talian kemudian melatih kepala sahaja sebagai pengelas sklearn standard adalah lebih pantas lagi, kerana laluan hadapan rangkaian asas hanya dijalankan sekali bagi setiap imej.

import time

# Measuring training time difference
# With frozen backbone (feature extraction):
start = time.time()
for batch in train_loader:
    images, labels = batch
    with torch.no_grad():
        features = backbone(images)  # Fast: no grad tracking
    loss = criterion(classifier(features), labels)
    loss.backward()  # Gradients only through tiny classifier
    optimizer.step()
    optimizer.zero_grad()
print(f'Feature extraction epoch: {time.time()-start:.1f}s')

# Full fine-tuning trains 25M params instead of ~2K

Menyesuaikan EfficientNet untuk Pengekstrakan Ciri

Pendekatan yang sama digunakan untuk EfficientNet: bekukan semua parameter, kemudian gantikan lapisan pengelasan akhir. Bagi EfficientNet, pengelas ialah blok Sequential yang dicapai melalui model.classifier, bukannya model.fc. Sentiasa semak seni bina model untuk mencari nama atribut yang betul.

Pengelas EfficientNet-B0 menjangkakan ciri input berdimensi 1280. Apabila menulis kod yang berfungsi dengan berbilang seni bina, periksa lapisan akhir menggunakan in_features dan bukannya menetapkan dimensi secara langsung, supaya kod anda lebih boleh digunakan semula merentas pilihan rangkaian asas yang berbeza.

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

model = models.efficientnet_b0(weights=models.EfficientNet_B0_Weights.IMAGENET1K_V1)

# Freeze backbone
for param in model.parameters():
    param.requires_grad = False

# EfficientNet uses model.classifier, not model.fc
print('Old classifier:', model.classifier)
in_features = model.classifier[1].in_features  # Access Linear inside Sequential
model.classifier = nn.Linear(in_features, num_classes)

trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f'Trainable parameters: {trainable:,}')

Menyesuaikan ViT untuk Pengekstrakan Ciri

Bagi ViT, kepala pengelasan dicapai melalui model.heads. Dimensi ciri daripada rangkaian asas ViT-B/16 ialah 768 (dimensi pembenaman transformer). Selepas membekukan semua parameter, gantikan model.heads dengan nn.Linear(768, num_classes) yang baharu.

ViT kurang mendapat manfaat daripada pengekstrakan ciri berbanding CNN kerana lapisan perhatiannya lebih khusus kepada tugasan — lapisan ini belajar untuk memberi perhatian kepada kawasan imej yang berbeza daripada kawasan yang diperlukan oleh tugasan anda. Jika anda menggunakan rangkaian asas ViT, sekurang-kurangnya nyahbekukan beberapa blok pengekod transformer terakhir untuk mendapatkan prestasi terbaik. Walau bagaimanapun, untuk percubaan pantas, pengekstrakan ciri penuh masih merupakan titik permulaan yang sah.

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

vit = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)

# Freeze all parameters
for param in vit.parameters():
    param.requires_grad = False

# Replace the classification head
print('Old head:', vit.heads)  # Sequential with Linear(768, 1000)
vit.heads = nn.Linear(768, num_classes)

print('ViT trainable params:', sum(p.numel() for p in vit.parameters() if p.requires_grad))

Menilai Hasil Pengekstrakan Ciri

Selepas latihan dengan ciri yang dibekukan, lakukan penilaian pada set pengesahan menggunakan metrik pengelasan standard. Pengekstrak ciri yang ditala dengan baik sering mencapai ketepatan 90% atau lebih pada set data tersuai kecil (500–5000 imej bagi setiap kelas), yang biasanya akan terlebih muat sepenuhnya jika dilatih dari awal.

Jika ketepatan lebih rendah daripada jangkaan, pertimbangkan untuk: (1) menambah pengayaan data semasa latihan, (2) menggunakan lapisan pengguguran sebelum kepala linear, (3) menggunakan kepala yang lebih berkeupayaan sedikit (dua lapisan linear dengan ReLU), atau (4) beralih kepada penalaan halus separa dengan menyahbekukan blok baki terakhir. Pantau ketepatan latihan dan pengesahan untuk membezakan terlebih muat daripada terkurang muat.

from sklearn.metrics import classification_report
import torch

def evaluate(model, loader, device):
    model.eval()
    all_preds, all_labels = [], []
    with torch.no_grad():
        for images, labels in loader:
            images = images.to(device)
            logits = model(images)
            preds = logits.argmax(dim=1).cpu()
            all_preds.extend(preds.numpy())
            all_labels.extend(labels.numpy())
    print(classification_report(all_labels, all_preds,
                                target_names=class_names))

evaluate(model, val_loader, device)

Apabila Pengekstrakan Ciri Tidak Mencukupi

Pengekstrakan ciri berfungsi paling baik apabila domain sumber (ImageNet: gambar foto semula jadi) dan domain sasaran adalah serupa. Apabila data anda sangat berbeza — imej sinar-X, imejan satelit, mikroskopi, imej terma inframerah — ciri aras rendah masih boleh dipindahkan (pengesan tepi bersifat sejagat), tetapi ciri ImageNet aras tinggi mungkin kurang berguna.

Tanda-tanda bahawa pengekstrakan ciri berprestasi rendah: ketepatan pengesahan mendatar jauh di bawah jangkaan, atau ketepatan latihan jauh lebih tinggi daripada pengesahan (menunjukkan kepala terlebih muat kepada terlalu sedikit ciri). Dalam keadaan ini, beralih kepada penalaan halus: nyahbekukan beberapa lapisan rangkaian asas dan latih dengan kadar pembelajaran yang jauh lebih rendah untuk menyesuaikan ciri yang telah dipelajari secara beransur-ansur dengan domain anda.

Semakan Pantas

Uji pemahaman anda tentang pengekstrakan ciri dengan rangkaian asas yang dibekukan daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Imbas Kembali Pelajaran

Dalam pelajaran ini, anda telah mempelajari bahawa: pengekstrakan ciri membekukan semua parameter rangkaian asas dan hanya melatih kepala pengelasan baharu, lalu memberikan latihan pantas serta hasil yang kukuh apabila data anda menyerupai ImageNet; pembekuan dilakukan dengan menetapkan requires_grad=False pada parameter rangkaian asas sebelum menggantikan lapisan akhir; dan mengekstrak ciri terlebih dahulu secara luar talian adalah lebih pantas lagi dengan menjalankan rangkaian asas sekali dan menyimpan vektor ciri dalam cache. Seterusnya, kita akan mempelajari penalaan halus — cara menyahbekukan lapisan rangkaian asas dengan teliti menggunakan kadar pembelajaran yang rendah untuk mendapatkan ketepatan yang lebih baik.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pengekstrakan Ciri: Membekukan Tulang Belakang” percuma?

Ya — teks penuh “Pengekstrakan Ciri: Membekukan Tulang Belakang” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pengekstrakan Ciri: Membekukan Tulang Belakang”?

Pelajar akan membekukan semua lapisan kecuali kepala pengelasan akhir, melatih hanya lapisan baharu pada set data tersuai yang kecil, dan mengesahkan pengurangan masa latihan yang ketara. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Pengekstrakan Ciri: Membekukan Tulang Belakang” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?

Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Model Terlatih Awal dalam torchvision: ResNet, EfficientNet dan ViT
Pengekstrakan Ciri: Membekukan Tulang Belakang
Penalaan Halus: Menyahbeku dan Kadar Pembelajaran Rendah
Penyesuaian Domain: Pengimejan Perubatan dengan Label Terhad

← Kembali ke Machine Learning Academy