Machine Learning Academy · Les

Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT

Cursisten laden een op ImageNet voorgetrainde ResNet-50, bekijken de architectuur en voeren inferentie uit op een nieuwe afbeelding om de vooraf geleerde representaties te verifiëren.

Les 1 van 412 stappen

Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT is een gratis Machine Learning Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Machine Learning Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Waarom vooraf getrainde modellen gebruiken?

Een diep neuraal netwerk vanaf nul trainen op ImageNet vereist miljoenen gelabelde afbeeldingen en weken aan GPU-berekeningen. Vooraf getrainde modellen hebben al algemene visuele kenmerken geleerd — randen, texturen, vormen en onderdelen van objecten op hoog niveau — uit deze enorme gegevensverzameling.

Door deze gewichten opnieuw te gebruiken, profiteer je van wat het model op 1,2 miljoen afbeeldingen heeft geleerd zonder de trainingskosten te betalen. Dit is het kernidee van transfer learning: kenmerken die voor één grote taak zijn geleerd, kunnen goed worden overgedragen naar verwante, kleinere taken. torchvision.models biedt tientallen vooraf getrainde architecturen die je kunt downloaden en gebruiken.

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: overzicht van de architectuur

ResNet-50 (Residual Network met 50 lagen) introduceerde skip connections die de invoer van een blok rechtstreeks bij de uitvoer optellen: output = F(x) + x. Hierdoor kunnen gradiënten rechtstreeks door de optelling stromen, zodat zeer diepe netwerken kunnen worden getraind zonder verdwijnende gradiënten.

ResNet-50 heeft ongeveer 25 miljoen parameters en bestaat uit: één initiële convolutionele laag van 7×7, max pooling, vier residuele blokken (layer1–layer4) en een globale gemiddelde-poolinglaag, gevolgd door een volledig verbonden classificatiekop met 1000 klassen voor ImageNet. De laatste fc-laag is de laag die we vervangen voor aangepaste taken.

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

Inferentie uitvoeren met ResNet-50

Voordat je inferentie uitvoert, moeten de invoergegevens overeenkomen met de voorbewerking die tijdens het trainen op ImageNet is gebruikt: pas het formaat aan tot minimaal 224×224 en normaliseer met het gemiddelde en de standaardafwijking van ImageNet. De API torchvision.transforms handelt dit af. Roep vóór inferentie altijd model.eval() aan om dropout en de trainingsmodus van batchnormalisatie uit te schakelen.

Het model produceert 1000 logits, één per ImageNet-klasse. We passen softmax toe om waarschijnlijkheden te verkrijgen en kiezen de top-k-klassen. torchvision.models bevat nu categorienamen in de metagegevens van de gewichten, zodat een afzonderlijk labelbestand niet meer nodig is.

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: samengestelde schaling

EfficientNet (2019) introduceerde samengestelde schaling: de breedte, diepte en invoerresolutie van een netwerk systematisch tegelijk schalen met één samengestelde coëfficiënt. In plaats van netwerken willekeurig breder of dieper te maken, brengt EfficientNet alle drie de dimensies in balans voor een optimale afweging tussen nauwkeurigheid en efficiëntie.

De EfficientNet-familie loopt van efficientnet_b0 (5 miljoen parameters) tot efficientnet_b7 (66 miljoen parameters). EfficientNet-B0 behaalt een vergelijkbare nauwkeurigheid als ResNet-50 met acht keer minder parameters en zes keer minder FLOP's, waardoor het ideaal is voor implementatie op mobiele apparaten en edge-apparaten. PyTorch biedt alle acht varianten.

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): aandacht zonder convoluties

Vision Transformers (ViT) (2020) passen de transformerarchitectuur rechtstreeks toe op afbeeldingen, zonder convoluties. De afbeelding wordt opgesplitst in een raster van patches met een vaste grootte (bijvoorbeeld 16×16 pixels), die elk worden afgevlakt en geprojecteerd naar een embeddingvector. Deze patch-embeddings worden behandeld als woordtokens in NLP.

Een CLS-token (classificatietoken) wordt vóór de patchsequentie geplaatst. Nadat de sequentie meerdere transformer-encoderblokken met zelfaandacht heeft doorlopen, wordt de uitvoer van het CLS-token voor classificatie gebruikt. ViT vereist grote trainingsgegevensverzamelingen om CNN's te overtreffen, maar vooraf getrainde ViT-modellen uit torchvision maken deze kracht direct beschikbaar voor je taken.

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)

ResNet, EfficientNet en ViT vergelijken

Welke van deze architecturen je kiest, hangt af van je beperkingen en taak. ResNet-50 is de betrouwbare standaardkeuze: goed begrepen, een sterke basislijn en veel handleidingen en implementaties. EfficientNet-B0/B2 is de beste keuze wanneer inferentiesnelheid en modelgrootte belangrijk zijn — bijvoorbeeld voor mobiele apps, realtime-systemen of edgehardware.

ViT blinkt uit bij grootschalige taken en profiteert van zelfbegeleid vooraf trainen (DINO, CLIP). Het vereist meer rekenkracht en geheugen dan CNN's met een vergelijkbare nauwkeurigheid. Begin voor de meeste aangepaste afbeeldingsclassificatietaken met EfficientNet-B2 of ResNet-50 en probeer daarna ViT als je de middelen hebt om het fijn af te stemmen.

# 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')

Interne onderdelen van een model bekijken

Voordat je een vooraf getraind model voor je taak aanpast, bekijk je de architectuur om te begrijpen welke lagen je moet vervangen. Gebruik print(model) om de lagenstructuur te bekijken en named_modules() of named_children() om programmatisch te itereren.

Het belangrijkste inzicht: elk torchvision-model eindigt met een classificatiekop die is afgestemd op 1000 ImageNet-klassen. Om het model aan te passen aan je taak met een num_classes die verschilt van 1000, vervang je deze laatste laag. De kenmerkextractor (alles vóór de kop) behoudt de in ImageNet geleerde kenmerken.

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

Kenmerkvectorgrootte per architectuur

Wanneer je de classificatiekop vervangt, moet je de kenmerkdimensie kennen die door de backbone wordt geproduceerd (alles behalve de laatste laag). Deze dimensie is de invoergrootte van je nieuwe classificatiekop.

Veelvoorkomende uitvoerdimensies van backbones: ResNet-50 produceert 2048, EfficientNet-B0 produceert 1280 en ViT-B/16 produceert 768. Deze kenmerkvectoren worden berekend door globale gemiddelde-pooling over de ruimtelijke kenmerkkaarten, waardoor één vector per afbeelding ontstaat. Je vervangende kop neemt deze vector als invoer.

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)

Kwaliteit van vooraf getrainde gewichten controleren

Je kunt snel controleren of de gewichten van een vooraf getraind model correct zijn door het model op een bekende controleafbeelding uit te voeren en na te gaan of de beste voorspelling overeenkomt met het verwachte label. Deze sanitycheck bevestigt dat de gewichten correct zijn geladen en dat de voorbewerkingspijplijn juist is.

Controleer daarnaast altijd het verwachte invoerformaat in de metagegevens van de gewichten: invoergrootte (224×224 voor de meeste modellen), kanaalvolgorde (RGB, niet BGR) en normalisatieconstanten (het ImageNet-gemiddelde en de standaardafwijking). De verkeerde normalisatie gebruiken is een veelvoorkomende fout die tot slechte resultaten bij transfer learning leidt.

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

Je voorbereiden op het fijn afstellen van je eigen taak

De gebruikelijke werkwijze voor vooraf getrainde modellen op aangepaste taken is: (1) laad het vooraf getrainde model met weights=...IMAGENET1K..., (2) vervang de laatste classificatiekop door een nieuwe nn.Linear die de juiste grootte heeft voor je aantal klassen, (3) bevries aanvankelijk eventueel de gewichten van de backbone en (4) train met een lagere leersnelheid dan wanneer je vanaf nul zou trainen.

De nieuwe classificatiekop begint met willekeurige gewichten en moet leren van je gegevens. De backbone begint met uitstekende kenmerken en heeft slechts kleine aanpassingen nodig. Daarom verbeteren different 방식e leersnelheden — een zeer lage snelheid voor de backbone en een hogere voor de kop — vaak de convergentiesnelheid en de uiteindelijke nauwkeurigheid.

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
])

Korte kennistoets

Toets je begrip van vooraf getrainde torchvision-modellen uit deze les.

Samenvatting van de les

In deze les heb je geleerd dat ResNet-50 skip connections gebruikt om zeer diepe netwerken te trainen en kenmerken met 2048 dimensies produceert, dat EfficientNet een betere afweging tussen nauwkeurigheid en efficiëntie bereikt door de breedte, diepte en resolutie samengesteld te schalen, en dat ViT transformer-zelfaandacht toepast op afbeeldingspatches zonder convoluties. Hierna leren we kenmerkextractie — de vooraf getrainde backbone bevriezen en alleen een nieuwe classificatiekop trainen op je eigen gegevensverzameling.

Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
30
Lessen
120

Veelgestelde vragen

Is de les “Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT” gratis?

Ja — de volledige tekst van “Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Machine Learning Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Machine Learning Academy bevat in totaal 4 lessen.

Wat leer ik in “Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT”?

Cursisten laden een op ImageNet voorgetrainde ResNet-50, bekijken de architectuur en voeren inferentie uit op een nieuwe afbeelding om de vooraf geleerde representaties te verifiëren. Je oefent met Machine Learning Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Machine Learning Academy te beginnen?

Ervaring vooraf is niet nodig. Machine Learning Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Machine Learning Academy?

Ja. Elke les over Machine Learning Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Voorgetrainde modellen in torchvision: ResNet, EfficientNet en ViT
  2. Feature-extractie: de backbone bevriezen
  3. Fine-tuning: lagen vrijgeven en lage learning rates
  4. Domeinadaptatie: medische beeldvorming met schaarse labels
← Terug naar Machine Learning Academy