Data Science & Machine Learning — Article 63
VGG-16 Network: A Comprehensive Guide
Explore detailed VGG-16 Network
Introduction
VGG-16 is the architecture that took one principle and applied it without exception: every convolution is 3 × 3 at stride 1, every pooling is 2 × 2 at stride 2, and channel count doubles whenever spatial size halves.
AlexNet’s 11 × 11 and 5 × 5 kernels are gone entirely, and what replaces them is depth. Adding it up gives 138, 357, 544 parameters, matching the commonly cited 138 million.
Two things about that number are worth stating first. A single layer, the first dense one, holds 74.27 percent of it, and the three dense layers together hold 89.36 percent while performing 0.80 percent of the compute.
And the uniformity that makes VGG easy to describe also makes it expensive: it is 2.3× AlexNet’s parameter count and 21× its FLOPs, for a model whose convolutional trunk is only 14.7 million parameters.
Table of Contents
- Introduction
- Table of Contents
- What is VGG-16
- Core Components of VGG-16
- Mathematical Foundation
- Types of VGG-16
- Evaluation Metrics
- Selecting Evaluation Metrics
- Assumptions and Practical Considerations
What is VGG-16
Definition
VGG-16 is a sixteen-weight-layer convolutional network consisting of five blocks of 3 × 3 convolutions separated by 2 × 2 max pooling, followed by three dense layers, with channel counts of 64, 128, 256, 512, 512 across the blocks.
Why it mattered
- It isolated depth as a variable. Every other choice was held fixed and uniform, so the paper’s comparison across 11, 13, 16, and 19 layers measures depth rather than a bundle of changes.
- It established that stacking small kernels beats using large ones, which Article 59 measured as 1.81× fewer parameters for the same receptive field plus two extra nonlinearities.
The structure
Thirteen convolutional layers plus three dense layers gives the 16 in the name. Pooling layers carry no parameters and are not counted.
Against AlexNet
- VGG has 6.3× AlexNet’s convolutional parameters and 21× its compute.
- The dense share fell by seven points and remains the dominant term.
Core Components of VGG-16
The 3 × 3 convolution
- The only kernel in the network.
- With padding 1 at stride 1 it preserves spatial size, so within a block the resolution is constant and only pooling changes it.
The block
- Two or three convolutions at a fixed channel count, then a pool. Blocks 1 and 2 have two; blocks 3, 4, and 5 have three.
The channel schedule
- 64 → 128 → 256 → 512 → 512. Doubling at each pool keeps per-layer FLOPs roughly constant, which Section 5.3 shows holds until block 5 breaks the pattern.
Max pooling
- 2 × 2 at stride 2, five times, taking 224 → 112 → 56 → 28 → 14 → 7.
The dense head
- 7 × 7 × 512 = 25088 flattened, then 4096 → 4096 → 1000.
What is absent
- No normalization layers, no residual connections, no 1×1 convolutions.
- VGG is the last major architecture built from convolution, pooling, ReLU, and dense layers alone.
Mathematical Foundation
Why only 3×3
VGG’s contribution was to take it seriously everywhere. At 512 channels:
The parameter saving is real and modest. The paper’s stronger argument is the second one: three stacked layers insert two extra nonlinearities into the same receptive field, making the function class strictly richer rather than merely cheaper.
So, the ratio (2L+1)² / 9L grows with L: 1.39 at L=2, 1.81 at L=3, and 2.69 at L=5. Depth is increasingly favored as the target receptive field grows.
The full accounting
One layer holds 74.27 percent of the network. fc6 maps the flattened 7×7×512 feature map to 4096 units, and at 102,764,544 parameters it is larger than all of AlexNet.
The inversion is even more extreme than AlexNet’s: the convolutional layers do 99.20 percent of the compute with 10.64 percent of the parameters.
The channel schedule, and where it breaks
Doubling channels while halving spatial size should keep FLOPs constant per layer, since parameters go up 4× and HₒᵤₜWₒᵤₜ goes down 4×. Reading the FLOP column:
The constancy follows directly. A layer with matched channel counts costs so doubling channels while halving each spatial dimension leaves the product unchanged.
Blocks 1 through 4 are exactly equal at 1849.7 MFLOPs for a layer whose input and output channel counts match.
Block 5 is a quarter of that, because the channel count stops doubling at 512 while the spatial size keeps halving.
That is a deliberate choice rather than an oversight: continuing to 1024 channels in block 5 would have added roughly 14 million parameters and 1.4 GFLOPs.
Get Arko Sengupta’s stories in your inbox
Join Medium for free to get updates from this writer.
But it means the last block is comparatively cheap, and it is the block whose features feed the classifier.
The head, and what it costs
7 × 7 × 512 × 4096 + 4096 = 102,764,544
The mechanism is the flatten. A dense layer applied after flattening an H× W× C map costs HWC · nₒᵤₜ, where global average pooling first reduces it to C:
so the ratio is exactly the spatial area HW, which is 49 here.
Replacing the head shrinks the network by 9.1× and leaves every convolutional layer untouched. GoogLeNet did exactly this in the same year and came in at roughly 6.8 million parameters.
The flatten is what makes fc6 so large. Article 59 measured the same structure in a small classifier where one dense layer held 84.55 percent, and Article 62 found LeNet’s C5 and F6 at 97.1 percent.
The pattern is that flattening a spatial map into a vector and then applying a dense layer multiplies the parameter count by the spatial area, here 49.
Receptive field
Tracking through the thirteen convolutional layers, with each pool doubling the step size:
The final convolutional layer has a receptive field of 181 pixels on a 224-pixel input. A unit in conv5_3 does not see the whole image.
This is worth being precise about. The network as a whole does see everything, because fc6 is connected to all 7×7 positions of the final feature map.
But no single convolutional unit does, which means the spatial integration is performed by the dense layer rather than by the convolutional trunk.
It is one more consequence of the head carrying so much of the network, and Article 65 shows that three additional layers push the receptive field past 224.
What VGG cost to train
The uniformity that makes VGG clear also makes it expensive.
At 15,470 MFLOPs per image it is 21× AlexNet, and the paper notes the deeper configurations were initialized from the shallower ones because training from scratch was unstable.
Types of VGG-16
Configurations A through E
- The paper defines five, differing only in depth. This is what makes the comparison clean: no other variable changes.
Configuration C
- A variant of the 16-layer network using three 1 × 1 convolutions in place of 3 × 3 in the later blocks.
- It performed slightly worse than configuration D, which is the VGG-16 in common use, and the paper reads this as evidence that spatial context matters beyond channel mixing.
VGG with batch normalization
- A later addition that makes training from scratch straightforward, removing the staged initialization the original required.
Fully convolutional VGG
- Reinterpreting fc6 as a 7 × 7 convolution and fc7, fc8 as 1 × 1 convolutions, giving identical outputs on 224 × 224 input and a dense prediction map on larger inputs.
- The parameter count is unchanged, which is worth noting: it is the same 102,764,544 weights viewed differently.
- The counts barely move across the family, because the dense head is identical in all of them and dominates.
Evaluation Metrics
Parameters and FLOPs by group
- At 10.64 percent against 99.20 percent, they are nearly complementary.
Largest single layer as a share
- 74.27 percent here. A single number that says how much of a model is one weight matrix.
FLOPs per layer against the channel schedule
- Section 5.3’s constancy at 1849.7 MFLOPs is a check that the doubling-halving convention is being followed, and its breakdown in block 5 is visible immediately.
Receptive field of the final convolutional layer
- 181 against a 224 input. If it is below the input size, spatial integration is being done by the head.
Activation memory in the early blocks
- At 224 × 224 × 64, block 1 activations dominate memory even though the layer has 1,792 parameters.
Parameters after the last convolution
Selecting Evaluation Metrics
Selection rules
- Report the largest single layer alongside the total. “138 million parameters” is mostly a statement about fc6.
- When comparing VGG configurations, compare convolutional parameters. The head is constant and swamps the difference.
- Check FLOPs per layer against the channel schedule. Constancy is the expected pattern and a departure is a design decision worth naming.
- Compute the final receptive field before adding depth. At 181 on a 224 input there is genuine headroom.
Assumptions and Practical Considerations
Convolutions use padding 1 at stride 1
- Otherwise spatial size shrinks inside a block and the 224 → 7 schedule does not hold.
The input is 224 × 224
- Five pooling's give 224/32 = 7 exactly. Any input not divisible by 32 produces a different flatten size and a different fc6.
The flatten order matters for loading weights
- 7 × 7 × 512 can be flattened channel-first or spatial-first.
- Getting it wrong loads 102 million weights into the wrong positions and produces plausible-looking garbage.
There is no normalization layer
- The original has none. A batch-normalized variant is a different model with different training behavior.
Training from scratch may need staged initialization
- The paper initialized deeper configurations from shallower ones.
- With modern initialization and batch normalization this is unnecessary, and without them it may not be.
The dense head dominates any size statement
- Pruning every convolutional layer entirely removes 10.64 percent.
FLOPs are per image at 224 × 224
- They scale with input area, so a 448×448 input quadruples them while leaving the parameter count unchanged.
