Understanding CNN Evolution: From LeNet to MobileNet

Computers today can recognize faces, identify objects, and assist doctors in diagnosing diseases. The core technology behind this ability is Convolutional Neural Networks (CNNs). Over the years, CNNs have evolved from simple networks capable of reading handwritten digits to highly optimized architectures that can run on mobile devices in real time.

Neural Network process | Source: 3Blue1Brown

LeNet: The Foundation of CNNs

LeNet, developed in the 1990s, was designed to recognize handwritten digits. It introduced the main building blocks of CNNs:

• Convolution layers detect edges and simple patterns
• Pooling layers reduce feature map sizes
• Fully connected layers classify the extracted features

class LeNet(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 6, 5)
        self.pool = nn.AvgPool2d(2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16*5*5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, num_classes)

    def forward(self, x):
        x = self.pool(F.tanh(self.conv1(x)))
        x = self.pool(F.tanh(self.conv2(x)))
        x = torch.flatten(x, 1)
        x = F.tanh(self.fc1(x))
        x = F.tanh(self.fc2(x))
        return self.fc3(x)

Practical use: A beginner-friendly model that demonstrates convolution and pooling.

AlexNet: Handling Large-Scale Images

AlexNet scaled CNNs to handle millions of images in ImageNet. Innovations include:

• ReLU activation for faster training
• Dropout layers to prevent overfitting
• GPU-based training for deeper networks

from torchvision import models
alexnet = models.alexnet(pretrained=True)

Use case: Real-world image recognition and large-scale datasets. AlexNet showed CNNs could handle complexity beyond digits.

VGG: Deep Networks Made Simple

VGG increased depth using repeated 3×3 convolution layers.

vgg16 = models.vgg16(pretrained=True)

• Works well for feature extraction and transfer learning
• Large parameter count makes it computationally heavy

Practical insight: Simplicity combined with depth improves feature representation, useful for tasks like style transfer or medical image analysis.

GoogLeNet (Inception): Multi-Scale Feature Capture

GoogLeNet introduced Inception modules, using multiple filter sizes in parallel to capture features at different scales.

googlenet = models.googlenet(pretrained=True)

Use case: Detects both small and large objects efficiently, making it useful for surveillance or industrial inspection.

ResNet: Training Very Deep Networks

Deep networks often struggle with vanishing gradients. ResNet uses skip connections, allowing layers to refine features instead of relearning from scratch.

resnet50 = models.resnet50(pretrained=True)

Practical use: Deep networks for autonomous vehicles, medical imaging, and any task requiring reliable training of very deep architectures.

DenseNet: Feature Reuse for Efficiency

DenseNet connects each layer to all subsequent layers for feature reuse and strong gradient flow.

densenet121 = models.densenet121(pretrained=True)

Use case: Works efficiently with limited data, common in medical and scientific imaging scenarios.

MobileNet Series: Optimized for Edge Devices

MobileNets are designed for speed and efficiency, making CNNs deployable on mobile and edge devices:

• V1: Depthwise separable convolutions reduce computation
• V2: Inverted residuals with bottlenecks maintain efficiency
• V3: Neural architecture search, channel attention, hard-swish activation improve speed and accuracy

mobilenet_v2 = models.mobilenet_v2(pretrained=True)
mobilenet_v3 = models.mobilenet_v3_large(pretrained=True)

Practical insight: Enables real-time AI applications on smartphones, drones, and IoT devices.

Comparing the Evolution

• LeNet: Small, simple, ideal for learning basics
• AlexNet: Handles large datasets, introduces GPU training
• VGG: Deep networks improve feature extraction
• GoogLeNet: Multi-scale feature detection
• ResNet: Skip connections make very deep networks trainable
• DenseNet: Efficient feature reuse, performs well with limited data
• MobileNet: Optimized for speed, memory, and edge deployment

Each model addressed a real-world problem: dataset size, network depth, gradient flow, multi-scale detection, or deployment efficiency.

Other CNN types / variants

• SqueezeNet: Very small network for efficiency
• ShuffleNet / EfficientNet: Mobile/edge optimized
• Capsule Networks (CapsNet): Spatial relationships and pose-aware features
• Wide ResNet: Wider layers for faster learning with less depth
• ResNeXt: ResNet variant with grouped convolutions
• DenseNet variants: With growth-rate modifications
• Attention-based CNNs / CBAM: Channel and spatial attention

Why This Matters

Understanding CNN evolution helps:

• Beginners grasp core concepts
• Practitioners choose the right model for their problem
• Everyone see real-world relevance from simple digit recognition to mobile AI