Introduction
Building a VGG16 model from scratch with PyTorch and training it on the CIFAR-100 dataset is a powerful way to explore deep learning. VGG16, a deep convolutional neural network (CNN), has been a key player in image recognition tasks due to its simplicity and effectiveness. In this guide, we will walk through the process of designing the VGG16 architecture, loading and preprocessing the CIFAR-100 dataset, and optimizing the model’s performance. Whether you’re a beginner or looking to sharpen your skills, this article will give you hands-on experience in building, training, and testing a deep learning model using PyTorch.
What is ?
VGG
Imagine this: you’re at your desk, working on a problem in computer vision. You’ve seen how AlexNet made a huge impact by introducing deeper networks. But now, you’re thinking, “What if we could take it even further?” Well, that’s exactly where VGG comes in. It takes the idea of deeper networks and cranks it up a notch, stacking layer after layer of convolutional layers, making the model even more powerful.
VGG, created by Simonyan and Zisserman, brought a fresh idea to the world of Convolutional Neural Networks (CNNs)—depth. AlexNet was already a big step forward, but VGG took it further, saying, “Let’s push this even more.” It usually uses 16 convolutional layers, which is why the version of the model built from this design is called VGG-16 . But that’s not all. If you’re feeling adventurous and want to go even deeper, you can add even more layers and go up to 19, creating what’s known as VGG-19 .
The basic structure of both VGG-16 and VGG-19 is the same—the only difference is the number of layers stacked on top of each other.
So, why does the number of layers matter so much? Well, every convolutional layer in VGG uses 3×3 filters. Sounds simple, right? But this is a smart design choice that keeps the network deep yet computationally efficient. Using these small 3×3 filters throughout each layer means the model can go deeper, learning more complex features as it moves through the layers. The beauty of this design is that it lets you add more layers without overloading the system with too many parameters, making it easier to manage. Think of it like trying to add more shelves to a bookshelf without making it too heavy to carry.
What’s also great about VGG is how it strikes a balance between depth and computational cost. It’s like knowing exactly when to push your system harder and when to back off so that everything runs smoothly. This balance is what makes VGG a great example of how to build a network that’s both smarter and more complex, without using up all your resources.
If you’re curious and want to dive deeper into how VGG works, how it became such a game-changer, and the breakthroughs it brought to image recognition, check out the official research paper, Very Deep Convolutional Networks for Large-Scale Image Recognition. Inside, you’ll find a detailed breakdown of the architecture, the design decisions made, and how VGG models delivered amazing results in the world of computer vision.
Data Loading
Imagine you’re about to jump into deep learning, and the first thing you need to do is gather your treasure—the dataset. It’s kind of like preparing for an adventure: you need to get your gear in order before setting off. The dataset you’re using is CIFAR-100, a solid collection of images that will be the foundation of your project. CIFAR-100 is like an upgrade from CIFAR-10—it has 100 different classes, not just 10. Each class holds 600 images, giving you plenty of material to work with. What’s really cool about CIFAR-100 is that each class has 500 training images and 100 testing images, so your model has a lot of data to learn from. To add a twist, the dataset is organized into 20 superclasses, each containing multiple classes.
Here’s the fun part: each image in CIFAR-100 comes with two labels. One is a “fine” label, which tells you the exact class of the image (like “dog” or “airplane”), and the other is a “coarse” label, which represents the broader superclass (like “animal” or “vehicle”). For this project, we’ll be using the “fine” labels to classify the images into their specific classes.
Now, let’s talk about how we load and process this treasure chest of data. We’ll use a few trusty Python libraries for this job: torch for building and training the model, torchvision for handling and processing the dataset, and numpy for all the number-crunching tasks. And of course, you’ll want to make sure you’re ready to tap into your computer’s full power. That’s where the device variable comes in, ensuring your program uses GPU acceleration if available.
import numpy as np
import torch
import torch.nn as nn
from torchvision import datasets
from torchvision import transforms
from torch.utils.data.sampler import SubsetRandomSampler
Next up, let’s set the device. You want your program to automatically pick the best available option—GPU if it’s there, and if not, it’ll fall back on the CPU:
device = torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’)
Now, we’re ready to load the data. The torchvision library is like your trusty guide, making it easy to load and pre-process the CIFAR-100 dataset. It will help us get the images into a format that the model can learn from. To start, we’ll normalize the dataset. This step is important because it makes sure the images are on a consistent scale for the color channels (red, green, and blue). We use the mean and standard deviation of each channel for this, and don’t worry—torchvision has these values ready to go:
normalize = transforms.Normalize(
mean=[0.4914, 0.4822, 0.4465],
std=[0.2023, 0.1994, 0.2010],
)
Once that’s done, we define the transformation process. This resizes the images to a standard size, converts them into tensors (which the model can work with), and applies the normalization:
transform = transforms.Compose([
transforms.Resize((227, 227)),
transforms.ToTensor(),
normalize,
])
Now, we get to the exciting part—loading the dataset! We’ll set up a data_loader function that can handle both training and testing data. If you’re testing, it loads the test data; otherwise, it loads the training data and splits it into training and validation sets. Here’s how we do that:
def data_loader(data_dir, batch_size, random_seed=42, valid_size=0.1, shuffle=True, test=False):
if test:
dataset = datasets.CIFAR100(
root=data_dir, train=False,
download=True, transform=transform,
)
data_loader = torch.utils.data.DataLoader(
dataset, batch_size=batch_size, shuffle=shuffle
)
return data_loader</p>
<p> # Load the train and validation datasets
train_dataset = datasets.CIFAR100(
root=data_dir, train=True,
download=True, transform=transform,
)
valid_dataset = datasets.CIFAR100(
root=data_dir, train=True,
download=True, transform=transform,
)</p>
<p> num_train = len(train_dataset)
indices = list(range(num_train))
split = int(np.floor(valid_size * num_train))</p>
<p> if shuffle:
np.random.seed(random_seed)
np.random.shuffle(indices)</p>
<p> train_idx, valid_idx = indices[split:], indices[:split]
train_sampler = SubsetRandomSampler(train_idx)
valid_sampler = SubsetRandomSampler(valid_idx)</p>
<p> train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=batch_size, sampler=train_sampler
)
valid_loader = torch.utils.data.DataLoader(
valid_dataset, batch_size=batch_size, sampler=valid_sampler
)</p>
<p> return (train_loader, valid_loader)
This function is key to loading the data, and it’s smart enough to load the right set based on whether you’re training, validating, or testing. Plus, it lets you shuffle the data to make sure the model doesn’t just memorize the order of the images.
Finally, let’s load the CIFAR-100 dataset for training, validation, and testing using our data_loader function. Here’s how we set everything into motion:
train_loader, valid_loader = data_loader(data_dir=’./data’, batch_size=64)
test_loader = data_loader(data_dir=’./data’, batch_size=64, test=True)
Now the dataset is loaded into memory in manageable batches, ready for the deep learning model to start working. Using data loaders like this is super helpful because it only loads the data as it’s needed, rather than trying to shove everything into memory at once. This keeps the process smooth and avoids performance bottlenecks, especially with large datasets like CIFAR-100.
In short, getting the data loaded right is a big first step in training a deep learning model. Once everything’s prepped, your model is ready to start learning and making predictions. Ready to train?
VGG16 from Scratch
Imagine you’re standing on the edge of a vast landscape, filled with endless possibilities for building a model that can understand and classify images. Right in front of you is a challenge: creating a Convolutional Neural Network (CNN) from scratch. But not just any CNN, you’re tasked with building VGG16—the deep architecture that’s revolutionized the way computers see images. So, where do you begin?
First things first: you need to understand how to define a model in PyTorch, which is the framework that will bring your VGG16 to life. Every custom model in PyTorch has to inherit from the nn.Module class. This class isn’t just a technical requirement—it provides all the necessary tools to make training the model as smooth as possible. But what’s next?
Once you’ve got your custom model class set up, you’ll have two main tasks ahead of you:
- Define the layers: This is where the magic happens, as you start creating the building blocks of the network.
- Specify the forward pass: This step shows the model exactly how the input should flow through each of the layers you’ve defined.
Now, let’s break down the layers that make up the VGG16 architecture. Each layer has a specific role in transforming raw data into something useful:
- nn.Conv2d : These are the convolutional layers, the heart of the network. They take the input and apply filters to extract important features. Think of them like magnifying glasses, zooming in on the fine details of the images. Each convolutional layer uses a kernel size (or filter size) that can be adjusted based on what you need.
- nn.BatchNorm2d : After the convolutional layers, we apply batch normalization. This step helps stabilize the network and speeds up training by ensuring the data passing through each layer stays on the same scale.
- ReLU : This is the activation function we use. ReLU (Rectified Linear Unit) introduces non-linearity to the model, allowing it to learn more complex patterns. You can think of ReLU as a gatekeeper, letting only values greater than zero pass through.
- nn.MaxPool2d : Max pooling comes next. It reduces the spatial size of the feature maps, making the model more efficient and focusing only on the most important features.
- Dropout : Dropout helps prevent overfitting by randomly turning off some neurons during training. This forces the model to learn more generalized features and not become too reliant on any one neuron.
- nn.Linear : These are the fully connected layers. Each neuron in one layer is connected to every neuron in the next layer, helping the model make its final decisions.
- Sequential : This is a container that lets you stack layers one after another in a neat, organized way.
Now that we know what each layer does, it’s time to build the VGG16 architecture. We’ll use all the layers mentioned above to create the model, ensuring that the data flows through them in the right order. Here’s how it looks in code:
class VGG16(nn.Module):
def __init__(self, num_classes=10):
super(VGG16, self).__init__()
self.layer1 = nn.Sequential(
nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(64),
nn.ReLU()
)
self.layer2 = nn.Sequential(
nn.Conv2d(64, 64, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.layer3 = nn.Sequential(
nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(128),
nn.ReLU()
)
self.layer4 = nn.Sequential(
nn.Conv2d(128, 128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.layer5 = nn.Sequential(
nn.Conv2d(128, 256, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(256),
nn.ReLU()
)
self.layer6 = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(256),
nn.ReLU()
)
self.layer7 = nn.Sequential(
nn.Conv2d(256, 256, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(256),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.layer8 = nn.Sequential(
nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU()
)
self.layer9 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU()
)
self.layer10 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.layer11 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU()
)
self.layer12 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU()
)
self.layer13 = nn.Sequential(
nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(512),
nn.ReLU(),
nn.MaxPool2d(kernel_size=2, stride=2)
)
self.fc = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU()
)
self.fc1 = nn.Sequential(
nn.Dropout(0.5),
nn.Linear(4096, 4096),
nn.ReLU()
)
self.fc2 = nn.Sequential(
nn.Linear(4096, num_classes)
)</p>
<p> def forward(self, x):
out = self.layer1(x)
out = self.layer2(out)
out = self.layer3(out)
out = self.layer4(out)
out = self.layer5(out)
out = self.layer6(out)
out = self.layer7(out)
out = self.layer8(out)
out = self.layer9(out)
out = self.layer10(out)
out = self.layer11(out)
out = self.layer12(out)
out = self.layer13(out)
out = out.reshape(out.size(0), -1) # Flatten the output to feed into the fully connected layers
out = self.fc(out)
out = self.fc1(out)
out = self.fc2(out)
return out
The model is designed to first pass the image through a series of convolutional layers, each one pulling out features from the image. These layers are followed by max-pooling, which helps shrink the feature maps and focus on the most important details. Once all the convolutional and pooling layers have done their job, the output is flattened, and then it moves through the fully connected layers. These layers make the final decision, classifying the image into one of the categories.
To sum it up, the VGG16 architecture is a carefully planned combination of convolutional layers, batch normalization, ReLU activations, max-pooling, and fully connected layers. By stacking them strategically, VGG16 becomes a powerhouse model, capable of learning complex patterns from large-scale image data. The addition of batch normalization and dropout makes the model more stable during training, reducing the risk of overfitting and improving generalization. This model is very flexible and can be easily adapted to different image classification tasks by simply adjusting the number of classes in the last layer.
VGG16 Architecture Paper (2014)
Hyperparameters
Alright, let’s get into the core of setting up the model: the hyperparameters. These little settings are the unsung heroes behind any machine learning or deep learning project. You see, adjusting these parameters can make all the difference between a model that learns quickly and one that struggles. While it’s common to try different values to see what works best, today we’re setting them upfront and letting the model do its thing. These hyperparameters will guide our VGG16 model as it learns to recognize images from the CIFAR-100 dataset. Let’s break them down:
- num_classes = 100: This one’s easy. Our model will classify images into 100 different categories, because that’s how many distinct classes are in the CIFAR-100 dataset. This is no small dataset—there are 100 categories, ranging from animals to vehicles.
- num_epochs = 20: The number of epochs decides how many times the entire dataset is passed through the model during training. Here, we set it to 20, which means our model will have 20 chances to learn from the same set of images. It’s like going over your notes multiple times to make sure everything sticks—20 times, to be exact.
- batch_size = 16: The batch size is how many images the model will process at once before it updates its weights. In this case, we’re training on 16 images at a time. Think of it like a group of 16 people solving a problem together—each group learns from the experience and then makes adjustments before moving on.
- learning_rate = 0.005: This setting controls how much the model adjusts its weights after each training step. If the learning rate is too high, the model might jump over the optimal solution. If it’s too low, it could take forever to learn. We’ve set it to 0.005—a moderate value that ensures steady progress without rushing things.
With these hyperparameters in place, we’re ready to get our VGG16 model up and running. Here’s how we initialize it:
$model = VGG16(num_classes).to(device)
This line of code creates an instance of the VGG16 model and moves it to the right device, whether that’s the GPU (if you’re lucky enough to have one) or the CPU. The model is now ready to learn, and we’re one step closer to putting it through its paces.
But before we start training, we need to set up the loss function and optimizer. These are like the coach and referee for our training session.
Loss Function (criterion): The loss function tells us how well the model’s predictions match the real-world labels. For classification tasks like this one, we use
nn.CrossEntropyLoss()
criterion = nn.CrossEntropyLoss()
Optimizer: The optimizer is in charge of adjusting the model’s weights after each training step, based on the gradients calculated during backpropagation. We’re using Stochastic Gradient Descent (SGD), a well-established algorithm that delivers solid results. The learning rate is set to 0.005, with a weight decay of 0.005 to reduce overfitting, and momentum set to 0.9 to help the model converge faster.
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, weight_decay=0.005, momentum=0.9)
Now that everything’s ready, our model is all set to begin its training journey. But wait—before we start, we need to track its progress. To do that, we calculate the total number of steps in one training epoch by checking the length of the training data loader:
total_step = len(train_loader)
This tells us how many mini-batches we’ll process during each epoch. It’s like counting how many pages you have to read in a textbook before you reach the end of a chapter.
With all of that in place, our model is ready to start training. The hyperparameters are set, the optimizer is in place, and the loss function is ready to guide the model through its learning process. It’s time to dive into the world of CIFAR-100 images and start training.
Training
Alright, now the real fun begins. We’re ready to train our VGG16 model, and this is where all the magic happens. But before we dive in, let’s walk through how PyTorch will help us train this model and what each part of the process looks like.
Each time we start a new epoch, the model begins its journey through the training data. We feed it images and labels from the train_loader —the data’s already prepped and ready to go. If we’ve got a GPU, PyTorch will automatically send the images and labels to it, ensuring faster processing. It’s like having a high-speed lane for the data to zoom through.
The model then does what it’s best at: it generates predictions by running those images through the network. Think of it like throwing a ball through a hoop, but the hoop gets adjusted slightly with every throw based on how well the ball lands. This is done using
model(images)But here’s the kicker: once we get the predictions, we need to figure out how close we were to the truth. So, we calculate the loss by comparing the model’s predictions to the true labels using a loss function, which in this case is
criterion(outputs, labels)Once we have the loss, the next step is backpropagation, a process where PyTorch calculates how much each weight in the network contributed to the error. This is done with
loss.backward()optimizer.step()However, before each optimizer update, we need to reset the gradients. This is where
optimizer.zero_grad()And then, after each epoch, we take a breather and evaluate how the model is doing on the validation set. During this phase, no gradients are needed, so we use
torch.no_grad()Here’s the complete code for training and evaluating the model:
total_step = len(train_loader)
for epoch in range(num_epochs):
for i, (images, labels) in enumerate(train_loader):
# Move tensors to the configured device (GPU or CPU)
images = images.to(device)
labels = labels.to(device)
# Forward pass: Get model predictions
outputs = model(images)
loss = criterion(outputs, labels)
# Backward pass and optimize: Update the model weights
optimizer.zero_grad() # Reset gradients
loss.backward() # Backpropagate the loss
optimizer.step() # Update weights
# Print loss for each step within the epoch
print(f’Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{total_step}], Loss: {loss.item():.4f}’)
# Validation phase: Evaluate model accuracy on validation set
with torch.no_grad():
correct = 0
total = 0
for images, labels in valid_loader:
images = images.to(device)
labels = labels.to(device)
# Get model predictions
outputs = model(images)
_, predicted = torch.max(outputs.data, 1) # Get the predicted class
# Count correct predictions
total += labels.size(0)
correct += (predicted == labels).sum().item()
# Free up memory after processing each batch
del images, labels, outputs
# Print accuracy for the validation set after each epoch
print(f’Accuracy of the network on the {5000} validation images: {100 * correct / total:.2f} %’)
Breakdown of the Code:
- Training Loop: Every epoch, we loop over the training data ( train_loader ). For each batch of images, we make predictions, calculate the loss, and update the model’s weights.
- Forward Pass: During the forward pass, the model takes the images, processes them through the network, and generates predictions. We then compute the loss by comparing these predictions with the true labels using the loss function.
- Backward Pass and Optimization: After computing the loss, we use backpropagation (
) to calculate the gradients. The optimizer then updates the weights using these gradients to minimize the loss.
loss.backward() - Validation: After each epoch, we evaluate the model’s performance on the validation set. Since we don’t need to compute gradients during validation, we use
to speed up the process. The accuracy is calculated by comparing the predicted labels with the actual labels, helping us see how well the model generalizes.
torch.no_grad()
This iterative process allows the model to adjust its weights and get better at making predictions over time. As training progresses, you’ll see the loss decrease, and the validation accuracy will give you a sense of how well the model is learning.
PyTorch Neural Network Tutorial
Testing
Alright, the moment of truth has arrived. After all the training and fine-tuning, it’s time to see how well our VGG16 model performs on unseen data. This is where we switch from the training phase to testing, and while the process is similar to validation, there’s a key difference: we don’t need to compute gradients when testing. That’s right, no backpropagation needed, which means we can speed things up and use less memory.
So, how does this work? Well, we start by using the test_loader instead of the valid_loader . This simple change means that we’re now looking at fresh, unseen images that the model hasn’t encountered during training or validation. It’s like giving the model a pop quiz—it’s on its own now, and there’s no more training to influence the answers.
To make this happen, we’ll use torch.no_grad() . This is like telling PyTorch, “Hey, we’re done with backpropagation for now—just focus on making predictions.” It helps improve memory efficiency and speeds up the process because we don’t need to track gradients anymore.
Here’s how it’s done in code:
with torch.no_grad():
correct = 0
total = 0
for images, labels in test_loader:
# Move tensors to the configured device (GPU or CPU)
images = images.to(device)
labels = labels.to(device)
# Forward pass: Get model predictions
outputs = model(images)
# Get the predicted class
_, predicted = torch.max(outputs.data, 1)
# Count the correct predictions
total += labels.size(0)
correct += (predicted == labels).sum().item()
# Free up memory after processing each batch
del images, labels, outputs
# Print the accuracy on the test set
print(‘Accuracy of the network on the {} test images: {} %’.format(10000, 100 * correct / total))
Breakdown of the Code:
- torch.no_grad(): This context manager is our hero here. It disables gradient tracking, which we don’t need during testing. It’s like telling the model, “Focus on making predictions and don’t worry about updating weights.” This helps save memory and speeds up the process.
- Forward Pass: During the forward pass, we get the predictions by passing the images through the network with model(images) . The model then makes its best guess on each image.
- Predictions: To find out which class the model thinks the image belongs to, we use torch.max(outputs.data, 1) . This tells us the index of the class with the highest probability. In simple terms, it’s like picking the winner from a lineup of possibilities.
- Accuracy Calculation: Once we have the predictions, we compare them with the true labels to see how many were correct. The total number of correct predictions is counted, and the accuracy is calculated by dividing that by the total number of test images. The result gives us a percentage, showing how well the model did.
- Memory Management: After processing each batch of images, we free up memory by deleting the images, labels, and outputs objects. This ensures that we don’t run out of memory when working with large datasets.
Once we ran the model through 20 epochs of training, we tested it on the CIFAR-100 test set, and guess what? It achieved an accuracy of 75%! Not too shabby, right? It shows that the model has learned to generalize pretty well to unseen data, but of course, there’s always room for improvement. We could experiment with different hyperparameters or try using data augmentation techniques to give the model even more diverse examples to learn from.
In the end, the testing phase is where you truly see how your model stacks up against the real world. It’s like taking your model out for its first test drive—sometimes it does well, sometimes it needs a little more tuning, but that’s all part of the fun!
PyTorch Documentation on torch.no_grad()
Conclusion
In conclusion, building the VGG16 model from scratch with PyTorch and training it on the CIFAR-100 dataset is a great way to explore the power of deep learning. By defining the VGG16 architecture, optimizing hyperparameters, and properly preparing your dataset, you can achieve significant results—like the 75% accuracy on the test set we saw here. This process not only sharpens your understanding of convolutional neural networks (CNNs) but also sets the stage for experimenting with advanced models like VGG-19 or incorporating new datasets. As deep learning continues to evolve, the ability to fine-tune and adapt architectures such as VGG16 will play a key role in achieving even higher accuracy in real-world applications.Future advancements may include improved architectures and the integration of transfer learning to boost performance on smaller datasets. With PyTorch’s flexibility and the growing availability of datasets like CIFAR-100, the possibilities for developing sophisticated models are limitless.This conclusion sums up key points in a concise way and provides a glimpse into future developments in deep learning, reinforcing SEO-friendly keywords naturally.
Master PyTorch Deep Learning Techniques for Advanced Model Control (2025)
