I’ve been thinking about convolutional neural networks lately because they’re the backbone of modern computer vision. Whether you’re building a medical imaging system or a self-driving car, understanding how to construct these networks from the ground up gives you the power to solve real problems. Let me show you how to build and train your own CNNs using PyTorch.

Why do we use convolutional layers instead of dense layers for images? The answer lies in how they process spatial information. Convolutional layers scan small windows across an image, learning local patterns that combine to form complex features. This approach preserves spatial relationships while dramatically reducing parameters.

Here’s how you define a basic convolutional layer:

import torch.nn as nn

conv_layer = nn.Conv2d(
    in_channels=3,      # Input channels (RGB)
    out_channels=32,    # Number of filters
    kernel_size=3,      # 3x3 filter size
    stride=1,           # Step size
    padding=1           # Maintain spatial dimensions
)

Have you ever wondered what happens to your image dimensions after each convolution? The output size depends on your kernel size, stride, and padding. You can calculate it using: (W - K + 2P)/S + 1, where W is input size, K is kernel size, P is padding, and S is stride.

Let’s build a complete CNN architecture. I prefer starting with a simple structure and gradually adding complexity:

class CustomCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(CustomCNN, self).__init__()
        
        self.features = nn.Sequential(
            nn.Conv2d(3, 32, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
            
            nn.Conv2d(32, 64, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2),
            
            nn.Conv2d(64, 128, 3, padding=1),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2)
        )
        
        self.classifier = nn.Sequential(
            nn.Linear(128 * 4 * 4, 512),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),
            nn.Linear(512, num_classes)
        )
    
    def forward(self, x):
        x = self.features(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

Data preparation is often more important than model architecture. How much time do you spend on data preprocessing? I’ve found that proper data augmentation can sometimes double model performance. Here’s my standard augmentation pipeline:

from torchvision import transforms

train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomRotation(degrees=15),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                        std=[0.229, 0.224, 0.225])
])

Training a CNN requires careful monitoring. I always use learning rate scheduling and early stopping. Here’s my training loop structure:

def train_model(model, dataloaders, criterion, optimizer, num_epochs=25):
    best_acc = 0.0
    for epoch in range(num_epochs):
        for phase in ['train', 'val']:
            if phase == 'train':
                model.train()
            else:
                model.eval()
            
            running_loss = 0.0
            running_corrects = 0
            
            for inputs, labels in dataloaders[phase]:
                inputs, labels = inputs.to(device), labels.to(device)
                
                optimizer.zero_grad()
                
                with torch.set_grad_enabled(phase == 'train'):
                    outputs = model(inputs)
                    loss = criterion(outputs, labels)
                    
                    if phase == 'train':
                        loss.backward()
                        optimizer.step()
                
                running_loss += loss.item() * inputs.size(0)
                _, preds = torch.max(outputs, 1)
                running_corrects += torch.sum(preds == labels.data)
            
            epoch_loss = running_loss / len(dataloaders[phase].dataset)
            epoch_acc = running_corrects.double() / len(dataloaders[phase].dataset)
            
            if phase == 'val' and epoch_acc > best_acc:
                best_acc = epoch_acc
                best_model_wts = copy.deepcopy(model.state_dict())
    
    model.load_state_dict(best_model_wts)
    return model

What metrics do you track during training? I monitor loss, accuracy, and learning rate, but also keep an eye on gradient norms to detect vanishing or exploding gradients.

When your custom CNN isn’t performing well, where should you look first? Check your data pipeline, then your model capacity, and finally your training configuration. Sometimes the solution is as simple as adjusting your learning rate or adding more data augmentation.

Remember that building CNNs is both science and art. You need theoretical understanding but also practical intuition. Don’t be afraid to experiment with different architectures and hyperparameters.

I hope this guide helps you build better computer vision models. If you found this useful, please share it with others who might benefit. I’d love to hear about your experiences in the comments – what challenges have you faced when building custom CNNs?