Module 9: Advanced Deep LearningBy Ashok Kumar Yadav4 min read

CNN Architectures: AlexNet, VGG16, ResNet & Inception

Four architectures shaped modern computer vision. This lesson explains what each one changed, how to read their layer structure, and how to load and inspect them in PyTorch.

How CNN architectures evolved

AlexNet (2012) won ImageNet with 8 layers, ReLU activations and dropout. VGG16 (2014) replaced large filters with repeated 3x3 convolutions and reached 16 weight layers. GoogLeNet/Inception (2014) used parallel branches to capture patterns at several scales. ResNet (2015) introduced residual learning and made very deep networks trainable.

Load pretrained models in PyTorch

torchvision ships all four families with ImageNet weights. Count parameters first so you understand the cost of each choice before training or fine-tuning anything.

import torch
from torchvision import models

nets = {
    "alexnet": models.alexnet(weights=models.AlexNet_Weights.DEFAULT),
    "vgg16": models.vgg16(weights=models.VGG16_Weights.DEFAULT),
    "resnet50": models.resnet50(weights=models.ResNet50_Weights.DEFAULT),
    "googlenet": models.googlenet(weights=models.GoogLeNet_Weights.DEFAULT),
}
for name, m in nets.items():
    n = sum(p.numel() for p in m.parameters())
    print(f"{name:10s} {n/1e6:6.1f}M parameters")

Why ResNet skip connections work

A residual block learns a correction F(x) and outputs F(x) + x. If the best transformation is close to identity, the block only has to push F(x) toward zero. Gradients also flow through the shortcut unchanged, which reduces the vanishing-gradient problem in deep stacks.

import torch.nn as nn

class BasicBlock(nn.Module):
    def __init__(self, c_in, c_out, stride=1):
        super().__init__()
        self.conv1 = nn.Conv2d(c_in, c_out, 3, stride, 1, bias=False)
        self.bn1 = nn.BatchNorm2d(c_out)
        self.conv2 = nn.Conv2d(c_out, c_out, 3, 1, 1, bias=False)
        self.bn2 = nn.BatchNorm2d(c_out)
        self.relu = nn.ReLU(inplace=True)
        self.short = nn.Identity()
        if stride != 1 or c_in != c_out:
            self.short = nn.Sequential(
                nn.Conv2d(c_in, c_out, 1, stride, bias=False),
                nn.BatchNorm2d(c_out))

    def forward(self, x):
        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        return self.relu(out + self.short(x))

Run inference with ResNet-50

Always use the preprocessing that ships with the weights, otherwise accuracy drops silently.

import torch
from torchvision import models
from PIL import Image

weights = models.ResNet50_Weights.DEFAULT
model = models.resnet50(weights=weights).eval()
prep = weights.transforms()

img = Image.open("photo.jpg").convert("RGB")
with torch.no_grad():
    probs = model(prep(img).unsqueeze(0)).softmax(1)[0]
top = probs.topk(3)
for p, i in zip(top.values, top.indices):
    print(weights.meta["categories"][i], round(p.item(), 3))

Which architecture should you choose?

Pick ResNet-50 as a strong default for transfer learning. Choose VGG16 only when you need simple, easy-to-visualise features, since it has about 138 million parameters. Use Inception-style models when multi-scale detail matters, and lighter networks such as MobileNet or EfficientNet when latency or memory is limited.

from torchvision.models import resnet18, vgg16
for m in [resnet18(),vgg16()]:
    print(type(m).__name__, sum(p.numel() for p in m.parameters()))

ResNet ... ~11.7M
VGG ... ~138M

import torch
x=torch.randn(1,64,56,56)
print(x.shape)

torch.Size([1, 64, 56, 56])

Frequently asked questions

Primary references

Use these official sources when exact syntax, defaults or definitions matter beyond the examples here.

• torchvision models documentation
• Deep Residual Learning for Image Recognition (He et al.)
• Very Deep Convolutional Networks (Simonyan & Zisserman)