The VGG network

Networks Using Blocks (VGG)

VGG: regular blocks at scale

VGG (Simonyan & Zisserman, 2014) is AlexNet taken seriously: stack more layers, but make them regular.

The contribution wasn’t a clever architecture — it was a design principle: regular blocks of 3×3 conv + ReLU, ending in a 2×2 max-pool. Whole network = a sequence of such blocks at growing channel counts.

From AlexNet’s hand-tuned layers to VGG’s repeated 3×3 blocks.

Why 3×3 convs only

• Two stacked 3×3 convs cover the same receptive field as one 5×5 — fewer parameters, one extra nonlinearity.
• All convs are stride 1 — easier to reason about, surprisingly competitive with hand-designed kernels.
• The architecture becomes a tuple of (n_convs, channels) pairs; pass a different tuple for VGG-13/16/19.

Receptive field arithmetic

Stacking small kernels grows the visible patch without paying for a large kernel in one step.

For stride 1 and no dilation:

r_L = 1 + \sum_{\ell=1}^L (k_\ell - 1).

Two 3×3 convolutions see

1 + (3 - 1) + (3 - 1) = 5

pixels across: the same 5×5 receptive field as one 5×5 conv, but with two ReLUs and fewer weights.

The VGG block

A reusable subunit: n_convs consecutive Conv-ReLU pairs at out_channels, followed by a 2×2 MaxPool:

import tensorflow as tf
from d2l import tensorflow as d2l

def vgg_block(num_convs, num_channels):
    blk = tf.keras.models.Sequential()
    for _ in range(num_convs):
        blk.add(
            tf.keras.layers.Conv2D(num_channels, kernel_size=3,
                                   padding='same', activation='relu'))
    blk.add(tf.keras.layers.MaxPool2D(pool_size=2, strides=2))
    return blk

A whole VGG-11 (the smallest variant) is just five blocks at growing channel counts (64, 128, 256, 512, 512) plus a 3-layer dense head:

class VGG(d2l.Classifier):
    def __init__(self, arch, lr=0.1, num_classes=10):
        super().__init__()
        self.save_hyperparameters()
        self.net = tf.keras.models.Sequential()
        for (num_convs, num_channels) in arch:
            self.net.add(vgg_block(num_convs, num_channels))
        self.net.add(
            tf.keras.models.Sequential([
            tf.keras.layers.Flatten(),
            tf.keras.layers.Dense(4096, activation='relu'),
            tf.keras.layers.Dropout(0.5),
            tf.keras.layers.Dense(4096, activation='relu'),
            tf.keras.layers.Dropout(0.5),
            tf.keras.layers.Dense(num_classes)]))

VGG(arch=((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))).layer_summary(
    (1, 224, 224, 1))

Sequential output shape:     (1, 112, 112, 64)
Sequential output shape:     (1, 56, 56, 128)
Sequential output shape:     (1, 28, 28, 256)
Sequential output shape:     (1, 14, 14, 512)
Sequential output shape:     (1, 7, 7, 512)
Sequential output shape:     (1, 10)

The “named architecture” is just a tuple of (n_convs, channels) pairs — passing a different tuple gives you VGG-13/16/19.

Training (a thin VGG)

Full VGG-11 is heavy for a notebook. Train a thinned version (channels 16/32/64/128/128) on Fashion-MNIST as a smoke test:

trainer = d2l.Trainer(max_epochs=10)
data = d2l.FashionMNIST(batch_size=128, resize=(224, 224))
with d2l.try_gpu():
    model = VGG(arch=((1, 16), (1, 32), (2, 64), (2, 128), (2, 128)), lr=0.01)
    trainer.fit(model, data)

Validates the block-at-scale design principle without melting your GPU.

Recap

• VGG = “stack identical, regular blocks.” A block is n × 3×3 conv + ReLU + maxpool.
• Two 3×3 convs ≈ one 5×5 receptive field, with fewer params and more nonlinearity.
• The architecture-as-a-tuple-of-blocks pattern (((1, 64), (1, 128), (2, 256), …)) is everywhere — VGG, ResNet, EfficientNet, ConvNeXt all use it.