CtrlK
VGGNet is a family of convolutional neural network architectures developed in 2014 by Karen Simonyan and Andrew Zisserman of the Visual Geometry Group at the University of Oxford. The family is described in the paper Very Deep Convolutional Networks for Large-Scale Image Recognition, first posted on arXiv in September 2014 and presented at the International Conference on Learning Representations (ICLR) in May 2015. VGGNet pushed the depth of standard image classification networks from the 8 weight layers of AlexNet to 16 and 19 weight layers, while restricting almost every convolution in the network to a 3x3 receptive field. The networks finished first in the localization task and second in the classification task at the ImageNet Large Scale Visual Recognition Challenge (ILSVRC) 2014, behind GoogLeNet on classification.
The family is often referred to by individual variants such as VGG-11, VGG-13, VGG-16, and VGG-19, where the number indicates the count of weight-bearing layers. VGG-16 and VGG-19 became the most widely used members and remained standard reference architectures across computer vision research and industry well into the late 2010s. VGGNet is significant as a milestone in the history of deep learning for two reasons. It demonstrated that uniform stacks of small filters could match or beat the more elaborate hand-tuned architectures that preceded it, and the released pre-trained weights became one of the most-used backbones for transfer learning during the period from 2015 to 2017.
VGGNet originated in the Visual Geometry Group at the Department of Engineering Science, University of Oxford. The two named authors are Karen Simonyan, then a postdoctoral researcher at VGG who later joined Google DeepMind, and Andrew Zisserman, the group's founding director. The networks are usually named after the group rather than the authors, and the abbreviation VGG itself refers to the laboratory.
The paper was first uploaded to arXiv as preprint 1409.1556 on 4 September 2014. A revised version corresponding to the ICLR 2015 conference camera-ready was posted in April 2015. The original training code was implemented in Caffe, the C++ deep learning framework that was dominant in research before TensorFlow and PyTorch became standard.
The period from 2012 through 2015 was a turbulent few years for image classification. AlexNet had won ILSVRC 2012 with a top-5 error of about 16.4 percent, dramatically beating the previous year's classical computer vision pipelines. AlexNet relied on 5 convolutional layers with relatively large filters (11x11 in the first layer and 5x5 in the second), 3 fully connected layers, and dropout regularization. In ILSVRC 2013, the ZFNet variant by Matthew Zeiler and Rob Fergus narrowed the receptive field of the first layer to 7x7 and improved the result to roughly 11.7 percent top-5 error.
By 2014, the question facing the deep learning community was no longer whether convolutional neural networks could win ImageNet but how to make them work better. Two answers emerged in parallel. Christian Szegedy and colleagues at Google designed GoogLeNet, which used the Inception module to combine several filter sizes inside a single layer and reduced the parameter count drastically through 1x1 bottlenecks. Simonyan and Zisserman took the opposite path. They asked what would happen if you held the receptive field constant at the smallest useful size, 3x3, and stacked many such layers on top of one another. VGGNet is the answer to that question.
Both approaches turned out to work. GoogLeNet won the ILSVRC 2014 classification task with a top-5 error of about 6.7 percent. VGGNet finished as the runner-up at 7.3 percent and won the localization track outright. The fact that two completely different design philosophies could reach near-equal accuracy was itself a useful result, and it helped clarify the conditions under which depth and uniform structure pay off.
VGGNet is a feed-forward neural network consisting of a stack of convolutional blocks followed by three fully connected layers and a softmax classifier. Every convolution in the network uses a 3x3 receptive field with stride 1 and padding 1, which means the spatial resolution of the feature map is preserved across each convolution. Down-sampling happens only at the max-pooling layers, which use a 2x2 window with stride 2 and reduce both spatial dimensions by a factor of two. Each convolution is followed by a rectified linear unit (ReLU) nonlinearity, and dropout with rate 0.5 is applied to the first two fully connected layers during training.
The input to the network is a 224x224 RGB image, with the per-channel mean of the training set subtracted as the only preprocessing step. The convolutional trunk is divided into five blocks separated by max-pooling layers. The number of channels doubles after each pooling layer, starting at 64 in the first block and capping at 512 in the final two blocks. The fully connected head consists of two layers of 4,096 neurons followed by a 1,000-way softmax for the ImageNet classification problem.
The most discussed design decision in the VGG paper is the exclusive use of 3x3 convolutions. Simonyan and Zisserman justified the choice with two arguments. First, two stacked 3x3 convolutions have an effective receptive field of 5x5, and three stacked 3x3 convolutions have an effective receptive field of 7x7. So a deep stack of small filters can model the same spatial extent as a shallow stack of large filters. Second, the deep stack is strictly more expressive because it interleaves additional ReLU nonlinearities between the layers, which means the network can model a more discriminative function rather than a single linear projection over the receptive field. Third, the deep stack uses fewer parameters. A single 7x7 convolution with C input and C output channels has 49C^2 weights, while a stack of three 3x3 convolutions has 27C^2 weights, an 81 percent reduction. These three arguments together motivated the uniform small-filter design, and they have been quoted in nearly every textbook and survey on convolutional architectures published since.
Configuration C of the original paper, which corresponds to a 16-layer variant, also includes a few 1x1 convolutions in addition to the 3x3 ones. The 1x1 convolution acts as a per-pixel linear projection followed by ReLU, increasing the nonlinearity of the decision function without changing the receptive field. Configuration C is rarely used in practice. The two configurations that survived into common use are configuration D (VGG-16, 13 convolutional layers) and configuration E (VGG-19, 16 convolutional layers), both of which use exclusively 3x3 convolutions.
Max pooling with a 2x2 window and stride 2 is applied at the end of each convolutional block, for a total of five pooling operations across the network. The downsampling is purely spatial, and the channel dimension is left untouched at the pooling step. Every convolutional and fully connected layer is followed by a ReLU. Notably, the original VGGNet does not use batch normalization, which had not yet been published when the paper was written. Modern reimplementations such as those provided by torchvision include both vanilla and BN variants of each VGG configuration. The BN variants generally train faster and reach slightly higher accuracy, although the parameter counts are essentially unchanged.
The original paper enumerates six configurations of the network, labeled A, A-LRN, B, C, D, and E. They share the same overall structure (five convolutional blocks separated by max-pooling, three fully connected layers, softmax output) and differ only in the number of convolutional layers in each block. Variant A-LRN inserts local response normalization after the first convolutional layer of variant A, but the authors found this had no measurable benefit and removed it from later configurations.
| Configuration | Common name | Convolutional layers | Fully connected layers | Total weight layers | Parameters | Notes |
|---|---|---|---|---|---|---|
| A | VGG-11 | 8 | 3 | 11 | 132.9 million | Shallowest variant, used for warm-starting deeper nets |
| A-LRN | VGG-11 with LRN | 8 | 3 | 11 | 132.9 million | Adds local response normalization, no measurable gain |
| B | VGG-13 | 10 | 3 | 13 | 133.1 million | Adds a second 3x3 conv to the first two blocks |
| C | VGG-16 (1x1 variant) | 13 | 3 | 16 | 134.3 million | Three of the convs are 1x1 instead of 3x3 |
| D | VGG-16 | 13 | 3 | 16 | 138.4 million | Most common 16-layer variant, all 3x3 convs |
| E | VGG-19 | 16 | 3 | 19 | 143.7 million | Deepest variant, three additional 3x3 convs |
The parameter count is dominated by the fully connected layers. The first fully connected layer alone, which maps a 7x7x512 spatial feature map to 4,096 neurons, accounts for roughly 102 million of the 138 million parameters in VGG-16. This concentration in the head is one of the reasons later architectures such as ResNet replaced the fully connected stack with a single global average pooling layer.
The channel and spatial dimensions evolve through the network in a regular pattern. The input is 224x224x3. After each block, the spatial size halves and the channel count doubles until it reaches 512 and stops growing. By the time the feature map reaches the fully connected head, it is 7x7x512.
| Stage | Spatial size | Channels | Operations |
|---|---|---|---|
| Input | 224x224 | 3 | RGB image with mean subtracted |
| Block 1 | 224x224 | 64 | 2 to 3 conv 3x3 + max pool |
| Block 2 | 112x112 | 128 | 2 conv 3x3 + max pool |
| Block 3 | 56x56 | 256 | 2 to 4 conv 3x3 + max pool |
| Block 4 | 28x28 | 512 | 2 to 4 conv 3x3 + max pool |
| Block 5 | 14x14 | 512 | 2 to 4 conv 3x3 + max pool |
| FC1 | 1x1 | 4096 | Fully connected + ReLU + dropout |
| FC2 | 1x1 | 4096 | Fully connected + ReLU + dropout |
| FC3 | 1x1 | 1000 | Fully connected |
| Output | 1x1 | 1000 | Softmax over ImageNet classes |
The original VGGNet was trained on the ILSVRC 2012 ImageNet classification dataset, which contains roughly 1.3 million training images, 50,000 validation images, and 100,000 test images across 1,000 object categories. Training used mini-batch stochastic gradient descent with momentum, with hyperparameters chosen close to those of AlexNet.
The batch size was 256 examples, the momentum coefficient was 0.9, and the L2 weight decay coefficient was 5x10^-4. Dropout with rate 0.5 was applied to the outputs of the first two fully connected layers. The initial learning rate was 10^-2, and it was divided by 10 each time the validation set accuracy stopped improving. In the published runs the learning rate was decreased three times, and training stopped after about 74 epochs.
| Hyperparameter | Value |
|---|---|
| Optimizer | SGD with momentum |
| Batch size | 256 |
| Initial learning rate | 0.01 |
| Learning rate schedule | Divide by 10 on validation plateau |
| Momentum | 0.9 |
| Weight decay (L2) | 5 x 10^-4 |
| Dropout (FC1, FC2) | 0.5 |
| Total epochs | 74 |
| Hardware | 4 NVIDIA Titan Black GPUs |
| Training time | 2 to 3 weeks |
A practical question with very deep networks is how to initialize the weights so that gradients propagate cleanly in the early epochs. Simonyan and Zisserman addressed this with a staged training scheme. They first trained the shallowest variant, configuration A (VGG-11), with weights drawn from a Gaussian distribution with zero mean and standard deviation 0.01. They then used the trained weights of A to initialize the first four convolutional layers and the three fully connected layers of the deeper configurations, leaving the additional middle layers randomly initialized. This trick made the deeper variants converge faster than they would have from a fully random start. Within a year, the publication of Xavier and He initialization made this kind of staged warm-starting unnecessary for most architectures, but at the time it was a meaningful contribution.
The input pipeline applied two forms of augmentation. First, each training image was rescaled so that its smaller side had length S, where S was either fixed (256 or 384) or sampled uniformly from the range [256, 512] across training examples. This is sometimes called scale jittering. The authors found that the multi-scale variant gave clearly better results than either fixed scale alone. Second, a 224x224 crop was taken at a random location and was then horizontally flipped with probability 0.5. The crop also received random RGB color shifts, following AlexNet's PCA color augmentation.
At test time, two strategies were compared. The first was multi-crop evaluation, where the test image was rescaled to several sizes and a fixed grid of crops was taken at each scale (50 crops per scale, three scales, for 150 crops in total per image). The class scores were then averaged over the crops. The second was dense evaluation, in which the fully connected layers were converted to 1x1 convolutions and the network was applied as a single fully convolutional sweep over the rescaled image. Dense evaluation produces a class score map whose spatial cells are averaged to produce the final scores. Multi-crop and dense evaluation gave slightly different results, and the best published numbers came from averaging the predictions of both methods.
VGGNet achieved 7.3 percent top-5 error on the ILSVRC 2014 classification test set with a single model, and 6.8 percent with an ensemble of two models. With the seven-model ensemble used in the original ILSVRC 2014 submission, the test error was 7.3 percent. After the competition, a careful retraining and a tighter dense and multi-crop fusion with a smaller two-model ensemble brought the test error down to 6.8 percent, which is the number quoted in the ICLR 2015 paper.
The table below summarizes the top entries on the ILSVRC 2014 classification task and shows where VGGNet stood relative to the other major submissions of the year.
| Rank | Team | Architecture | Top-5 error |
|---|---|---|---|
| 1 | GoogLeNet (Google) | 22-layer Inception | 6.7% |
| 2 | VGG (Oxford) | 19-layer ConvNet | 7.3% |
| 3 | MSRA (Microsoft) | SPP-net | 8.1% |
| 4 | Andrew Howard | AlexNet variant | 8.1% |
| 5 | DeeperVision | Deep CNN | 9.5% |
On the ILSVRC 2014 localization task, where the network must predict both the class and a bounding box, VGGNet finished first with a localization error of 25.3 percent.
The table below puts VGG-16 and VGG-19 in the context of the other widely cited convolutional neural network backbones of the 2012 to 2015 era. The error figures are top-5 errors on the ILSVRC validation set, single-model except where noted.
| Architecture | Year | Weight layers | Parameters | Top-5 error | FLOPs (per image) |
|---|---|---|---|---|---|
| AlexNet | 2012 | 8 | 60 million | 16.4% | 0.7 billion |
| ZFNet | 2013 | 8 | 60 million | 11.7% | 0.7 billion |
| GoogLeNet (Inception v1) | 2014 | 22 | 6.8 million | 6.7% | 1.5 billion |
| VGG-16 | 2014 | 16 | 138 million | 7.3% | 15.3 billion |
| VGG-19 | 2014 | 19 | 144 million | 7.3% | 19.6 billion |
| ResNet-152 | 2015 | 152 | 60 million | 4.5% | 11.3 billion |
VGGNet sits in an interesting position on this table. It is much larger than GoogLeNet in both parameters and FLOPs, but it reaches roughly the same accuracy. It is similarly large compared to ResNet-152 in parameters, while having fewer layers and worse accuracy. The trade-off VGGNet made was to keep the architecture simple at the cost of computational efficiency. That trade-off paid off in adoption, because the simplicity made VGGNet trivial to reimplement, fine-tune, and modify.
VGGNet's two main limitations are its parameter count and its compute cost. With 138 million parameters in VGG-16 and 144 million in VGG-19, the model files weigh in at over 500 megabytes in single-precision floating point, which made deployment to mobile and embedded devices effectively impossible at the time. Each forward pass takes 15 to 20 billion floating-point operations, which means even modest batch inference is slow without a powerful GPU. By contrast, GoogLeNet ran the same problem with one twentieth the parameters and one tenth the FLOPs.
A second limitation is that VGGNet is essentially the deepest a plain feed-forward stack can usefully go. Attempts to extend the same design to 25 or 30 layers ran into the degradation problem identified the following year by Kaiming He and colleagues. Without skip connections or some other mechanism to keep gradients flowing, very deep plain networks become harder to optimize, not easier, and their training accuracy can actually decrease as depth grows. This observation directly motivated the residual connections of ResNet, which made networks of 50, 101, and 152 layers practical and pushed top-5 ImageNet error below 5 percent. So while VGGNet established that depth helps, it also marked the upper limit of what plain stacked depth could achieve.
A third limitation, less often discussed, is the rigid input size. The fully connected head requires a 7x7x512 input, which means the network expects exactly 224x224 RGB input images. Adapting it to other resolutions requires either resizing the input or surgically replacing the fully connected layers, both of which complicate downstream applications.
The most important downstream effect of VGGNet was on transfer learning. The Oxford group released the trained weights of VGG-16 and VGG-19 alongside the paper, and these checkpoints became the de facto pre-trained backbones for computer vision tasks during the 2015 to 2017 period. A common workflow was to take the convolutional trunk of VGG-16, discard the fully connected head, attach a small task-specific head, and either fine-tune the whole network or train only the new head. This pattern was used for object detection (Fast R-CNN and earlier versions of Faster R-CNN both used VGG-16 backbones), semantic segmentation (FCN-VGG and DeepLab v1), neural style transfer, image retrieval, and dozens of medical imaging tasks. The features learned by VGG-16 on ImageNet generalized so well that for several years it was unusual for a paper proposing a new vision task to not at least compare against a VGG-based baseline.
The same checkpoints were also widely used as feature extractors without any fine-tuning. The activations at intermediate layers of VGG-16 captured a useful hierarchy of visual concepts, with low layers responding to edges and textures, middle layers to parts and patterns, and high layers to whole objects and scenes. This made them attractive for content-based image retrieval, perceptual similarity, and various forms of image generation.
A particularly visible application is in neural style transfer. Leon Gatys, Alexander Ecker, and Matthias Bethge introduced the original style transfer algorithm in 2015, using a pre-trained VGG-19 to extract content features from one image and style features (in the form of Gram matrices) from another, and optimizing a third image to match both. The choice of VGG-19 was deliberate. Its hierarchical activations turned out to separate content and style cleanly, and the smooth transitions between layers made the optimization tractable. Justin Johnson, Alexandre Alahi, and Li Fei-Fei extended the idea in 2016 with perceptual losses, where a pre-trained VGG-16 served as a fixed feature extractor for training fast feed-forward style transfer networks. The use of VGG features as a perceptual loss survived into super-resolution (SRGAN), image-to-image translation, and many generative adversarial networks. Even after VGG was no longer the strongest classifier, its features continued to be used as a perceptual yardstick because they correlated well with human similarity judgments.
VGGNet established several conventions that subsequent architectures built on. The use of 3x3 convolutions as the dominant filter size became standard in nearly every CNN that followed, including ResNet, Inception v3 and later, DenseNet, MobileNet, and EfficientNet. The five-block structure with channel doubling and spatial halving at each pooling stage is also a direct inheritance from VGG, with only minor variations. ResNet's basic block, which consists of two 3x3 convolutions with a residual connection, is essentially a VGG block with a shortcut added.
VGGNet also reinforced the broader lesson that depth matters. The paper presented a clean ablation showing that going from 11 to 19 layers progressively improved accuracy on the ILSVRC validation set, with no other change in the architecture. This was one of the first systematic demonstrations that depth was an axis worth exploring for its own sake, independently of receptive field size, filter shape, or other design knobs. It set the stage for the sequence of even deeper networks that followed in 2015 and 2016.
ResNet, introduced by Kaiming He and colleagues at Microsoft Research in late 2015, can be read as a direct response to VGGNet. He et al. wanted to know what would happen if you tried to make plain CNNs even deeper than VGG-19. They found that beyond about 20 layers, training error started to increase, not decrease, as depth grew. Their solution was to add residual or skip connections that let signal bypass each block, which made it easy for the network to learn an identity mapping if depth was not helping. ResNet-152 reached 4.5 percent top-5 error on ImageNet, compared to VGG-19's 7.3 percent, and ResNet variants quickly displaced VGG as the default backbone. The ResNet paper opens with a comparison to VGG-19 and uses it as the parameter and FLOP reference point against which the residual networks are measured.
Reference implementations of VGGNet are available in every major deep learning framework. The original Caffe model files are still distributed by the Visual Geometry Group. The torchvision library in PyTorch includes vgg11, vgg13, vgg16, and vgg19 along with their batch-normalized variants. Keras provides VGG16 and VGG19 in its applications module, with weights pre-trained on either ImageNet or VGGFace. TensorFlow Hub hosts converted versions of the original Caffe weights. The batch-normalized variants converge faster and reach slightly higher accuracy than the original ReLU-only variants, which is why most modern projects that use VGG at all use the BN versions.
More than a decade after publication, VGGNet remains a textbook example of how a simple architectural rule applied with discipline can produce a strong result. In contemporary research, VGG has been almost entirely displaced by ResNet, EfficientNet, vision transformers, and other newer architectures, both because those models reach higher accuracy and because they are much more computationally efficient. But VGG retains a niche role as a perceptual feature extractor for generative tasks, where the smoothness of its activations still matter, and as a teaching example for introducing students to deep convolutional design.