01 - CNN Fundamentals: Architecture, Training, Deployment

CNN Fundamentals: Architecture, Training, Deployment

How does a computer "see" a cat in a photograph? How does it tell a traffic sign from a human face? The answer lies in Convolutional Neural Networks (CNNs), the deep learning architecture that revolutionized computer vision. From self-driving cars to medical imaging diagnostics, CNNs are the invisible engine powering millions of applications we use every day.

In this first article of the Computer Vision with Deep Learning series, we will build your understanding of CNNs from scratch: what they are, how convolutional filters work, which architectures made history, and how to implement and train a complete CNN in PyTorch. By the end you will have the skills to classify real images and deploy models to production.

1. From Pixels to Features: How a Computer Sees Images

For humans, looking at a photo is effortless. Our brain instantly recognizes shapes, colors, edges, and objects. But for a computer, an image is nothing more than a grid of numbers. Each pixel is represented by numerical values indicating light intensity.

1.1 An Image as a Matrix of Numbers

A grayscale image is a 2D matrix where each cell holds a value between 0 (black) and 255 (white). A color image consists of three channels (Red, Green, Blue), each a separate matrix. A 224x224 color image is therefore a tensor of shape 3 x 224 x 224, totaling 150,528 numerical values.

4x4 Image (grayscale, values 0-255):

+-----+-----+-----+-----+
|  10 |  20 |  30 |  40 |
+-----+-----+-----+-----+
|  50 | 120 | 180 |  60 |
+-----+-----+-----+-----+
|  70 | 200 | 220 |  80 |
+-----+-----+-----+-----+
|  90 | 100 | 110 | 130 |
+-----+-----+-----+-----+

Color image (3 RGB channels):
R channel: [[10, 20, ...], ...]  --> red intensities
G channel: [[30, 40, ...], ...]  --> green intensities
B channel: [[50, 60, ...], ...]  --> blue intensities

Final tensor: shape = (3, H, W)  --> (channels, height, width)
    

1.2 Why Fully Connected Networks Fall Short

The naive approach would be to flatten the image into a 1D vector and feed it to a fully connected (dense) neural network. For a 224x224x3 image, that means an input layer with 150,528 neurons. With a 1,000-neuron hidden layer, the first layer alone would have 150 million parameters.

CNNs solve all of these problems by exploiting three key insights: locality (visual patterns are local), weight sharing (the same filter works everywhere in the image), and translation invariance (an edge is an edge regardless of where it appears).

2. The Convolution Operation

Convolution is the mathematical operation at the heart of every CNN. A small filter (called a kernel) slides across the input image, computing at each position a weighted sum of the covered pixels. The result is a new matrix called a feature map, which highlights a specific pattern (vertical edge, horizontal edge, corner, texture).

2.1 Kernels and Sliding Window

A kernel is a small weight matrix (typically 3x3 or 5x5) that slides across the entire input image. At each position, kernel values are multiplied element-wise with the underlying pixels and summed to produce a single value in the output feature map.

Input (5x5):                  Kernel (3x3):
+---+---+---+---+---+        +----+----+----+
| 1 | 2 | 3 | 0 | 1 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 0 | 1 | 2 | 3 | 1 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 1 | 0 | 1 | 2 | 0 |       | -1 |  0 |  1 |
+---+---+---+---+---+        +----+----+----+
| 2 | 1 | 0 | 1 | 3 |       (Vertical edge detector)
+---+---+---+---+---+
| 0 | 1 | 2 | 1 | 0 |
+---+---+---+---+---+

Position (0,0): apply kernel to highlighted pixels [*]
[*1][*2][*3]  0   1
[*0][*1][*2]  3   1         Calculation:
[*1][*0][*1]  2   0         (-1x1)+(0x2)+(1x3)+(-1x0)+(0x1)+(1x2)+(-1x1)+(0x0)+(1x1)
 2   1   0   1   3         = -1 + 0 + 3 + 0 + 0 + 2 - 1 + 0 + 1 = 4
 0   1   2   1   0

Output feature map (3x3):
+---+---+---+
| 4 | . | . |    <-- The 4 we just computed
+---+---+---+
| . | . | . |    The kernel slides and computes each cell
+---+---+---+
| . | . | . |
+---+---+---+
    

The fundamental difference between CNNs and traditional image processing is that in CNNs the kernel values are not hand-crafted. The network automatically learns the optimal filters during training through backpropagation. Early layers learn to detect edges and simple textures, while deeper layers combine these features into increasingly complex patterns (eyes, wheels, faces).

3. CNN Building Blocks

A CNN is composed of several types of layers, each with a specific role. Understanding what each component does is essential for designing effective architectures.

3.1 Convolutional Layer

The convolutional layer applies multiple filters to the input, producing one feature map per filter. If you apply 32 filters of size 3x3 to an RGB image, you get 32 feature maps, each highlighting a different pattern. The key parameters are:

Output dimension formula:
  output_size = (input_size - kernel_size + 2 * padding) / stride + 1

Example: input 32x32, kernel 3x3
  Stride=1, Padding=0: (32 - 3 + 0) / 1 + 1 = 30x30  (shrinks)
  Stride=1, Padding=1: (32 - 3 + 2) / 1 + 1 = 32x32  (same padding)
  Stride=2, Padding=1: (32 - 3 + 2) / 2 + 1 = 16x16  (halves)

Stride=1, Padding=1 ("same"):
  Input:  [A B C D E]     Output: [A B C D E]  --> same dimensions
          (with zero-padding at borders)

Stride=2 (halves resolution):
  Input:  [A B C D E F]   Output: [A C E]  --> half the size
          (skips one pixel per step)
    

3.2 Activation Function (ReLU)

After each convolution, a non-linear activation function is applied. The most common is ReLU (Rectified Linear Unit): f(x) = max(0, x). ReLU zeroes out all negative values and leaves positive values unchanged. Without non-linearity, a stack of convolutions would be equivalent to a single linear transformation, making the network unable to learn complex patterns.

ReLU:      f(x) = max(0, x)        Simple, fast, standard
LeakyReLU: f(x) = x if x>0, 0.01x otherwise   Avoids "dying ReLU"
GELU:      f(x) = x * Phi(x)      Used in Transformers, smooth
Swish:     f(x) = x * sigmoid(x)  Used in EfficientNet

Input feature map:          After ReLU:
+----+-----+----+           +----+----+----+
| -3 |  5  | -1 |          |  0 |  5 |  0 |
+----+-----+----+           +----+----+----+
|  2 | -7  |  4 |          |  2 |  0 |  4 |
+----+-----+----+           +----+----+----+
| -2 |  1  | -5 |          |  0 |  1 |  0 |
+----+-----+----+           +----+----+----+
    

3.3 Pooling Layer

Pooling reduces the spatial dimensions of feature maps, decreasing the number of parameters and making the network more robust to small variations in feature positions. The two main types are Max Pooling (takes the maximum value in each window) and Average Pooling (computes the average).

Input (4x4):                    Output (2x2):
+----+----+----+----+           +----+----+
| 12 |  20|  30|  0 |          | 20 | 30 |  max(12,20,0,8)=20
+----+----+----+----+    -->   +----+----+    max(30,0,2,14)=30
|  0 |  8 |  2 | 14 |          | 15 | 16 |
+----+----+----+----+           +----+----+
| 15 |  2 |  3 | 16 |
+----+----+----+----+          Reduces 4x4 --> 2x2
|  1 |  6 |  7 |  8 |         (halves height and width)
+----+----+----+----+

Max Pooling: takes maximum    --> preserves strongest features
Avg Pooling: computes average --> smoothing effect
Global Average Pooling: average over entire feature map --> single value per channel
    

3.4 Batch Normalization

Batch Normalization (BatchNorm) normalizes the output of each layer to have zero mean and unit variance. This stabilizes training, allows higher learning rates, and acts as a mild regularizer. In practice, a BatchNorm layer is placed after each convolution, before the activation function.

4. Typical CNN Architecture

A standard CNN follows a recurring pattern: feature extraction blocks (convolution + activation + pooling) followed by fully connected layers for final classification. As depth increases, feature maps shrink in spatial dimensions but grow in channel count, capturing increasingly abstract patterns.

Input Image (3 x 32 x 32)
    |
    v
[Conv2d 3->32, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 32 x 16 x 16
    v
[Conv2d 32->64, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 64 x 8 x 8
    v
[Conv2d 64->128, 3x3, pad=1] --> [BatchNorm] --> [ReLU] --> [MaxPool 2x2]
    |  Feature maps: 128 x 4 x 4
    v
[Flatten]  -->  Vector of 128 * 4 * 4 = 2048 values
    |
    v
[Linear 2048 -> 256] --> [ReLU] --> [Dropout 0.5]
    |
    v
[Linear 256 -> 10]  --> Output: 10 classes (e.g., CIFAR-10)
    |
    v
[Softmax]  --> Probabilities per class: [0.02, 0.01, 0.85, ...]

Dimension flow:
  (3, 32, 32) -> (32, 16, 16) -> (64, 8, 8) -> (128, 4, 4) -> (2048) -> (256) -> (10)
  [image]       [edges,texture]  [parts]       [objects]       [decision]   [class]
    

5. Evolution of CNN Architectures

The history of CNNs is marked by groundbreaking architectures, each introducing ideas that reshaped the field. Understanding this evolution is essential for making informed architectural decisions today.

5.1 LeNet-5 (1998) - The Pioneer

Designed by Yann LeCun for handwritten digit recognition (MNIST), LeNet-5 was the first CNN to achieve practical success. With just 5 layers and 60,000 parameters, it proved that convolutions could learn discriminative features from images. It was used to automatically read bank checks.

5.2 AlexNet (2012) - The Revolution

AlexNet won the ImageNet 2012 competition by a massive margin, reducing the error rate from 26% to 16%. The key innovations: GPU training (two NVIDIA GTX 580s), ReLU activation instead of sigmoid, Dropout for regularization, and data augmentation. This result convinced both academia and industry that deep learning worked.

5.3 VGGNet (2014) - Depth Matters

VGG demonstrated that deeper networks yield better results. Its key insight is radical in its simplicity: use only stacked 3x3 filters. Two consecutive 3x3 layers have the same receptive field as a single 5x5 layer, but with fewer parameters and more non-linearity. VGG-16 has 16 layers and 138 million parameters.

5.4 EfficientNet (2019) - Smart Scaling

EfficientNet introduced compound scaling: instead of increasing only depth (like VGG) or width, it uniformly scales all three dimensions (depth, width, input resolution) with balanced coefficients. EfficientNet-B0 achieves 77.1% accuracy on ImageNet with just 5.3 million parameters, an unprecedented accuracy-to-parameter ratio.

5.5 ConvNeXt (2022) - The Modernized CNN

ConvNeXt demonstrates that CNNs, modernized with techniques inspired by Vision Transformers, can compete with (and outperform) transformer architectures. Key innovations include 7x7 depthwise separable kernels, LayerNorm replacing BatchNorm, GELU activation, and an isomorphic design with stages of increasing dimensions. ConvNeXt V2, in its E-ConvNeXt-Tiny variant, achieves 80.6% Top-1 accuracy at just 2.0 GFLOPs, making it excellent for efficient deployment scenarios.

6. ResNet and Skip Connections

ResNet (Residual Networks), proposed by He et al. in 2015, solved one of the fundamental problems in deep learning: the degradation problem. Before ResNet, adding layers to a deep network worsened results rather than improving them, even on the training set. The solution is as elegant as it is simple.

6.1 The Vanishing Gradient Problem

During backpropagation, gradients are multiplied repeatedly through the network layers. If these multiplications yield values less than 1, the gradients "vanish" exponentially as they propagate toward the initial layers. With 50 or more layers, gradients become so small that early layers stop learning altogether. Recent studies confirm that without skip connections, gradient L2 norms drop sharply in early layers, while with skip connections they remain uniform throughout the network.

Deep network WITHOUT skip connections (50 layers):

  Layer 50   Layer 49   Layer 48  ...  Layer 2    Layer 1
  grad=1.0 * 0.8      * 0.8     ...  * 0.8      * 0.8

  Gradient at layer 1: 0.8^49 = 0.00001  --> nearly zero!
  Early layers DO NOT learn.

Deep network WITH skip connections (ResNet):

  Gradients have a "direct path" through skip connections.
  They are not repeatedly multiplied by small values.
  Gradient at layer 1: ~0.5  --> layers learn normally!
    

6.2 The Solution: Residual Learning

The genius of ResNet is simple: instead of having a block learn the complete transformation H(x), have it learn only the difference (residual) from the input: F(x) = H(x) - x. The block output becomes y = F(x) + x, where x "skips" the block via a skip connection (or shortcut connection).

Standard Block:                     Residual Block:

    x                                   x ------+
    |                                   |        |
    v                                   v        | (skip connection)
  [Conv 3x3]                         [Conv 3x3] |
    |                                   |        |
  [BatchNorm]                        [BatchNorm] |
    |                                   |        |
  [ReLU]                             [ReLU]      |
    |                                   |        |
  [Conv 3x3]                         [Conv 3x3] |
    |                                   |        |
  [BatchNorm]                        [BatchNorm] |
    |                                   |        |
    v                                   v        |
  H(x) = output                     F(x) + x <--+
                                        |
                                      [ReLU]
                                        |
                                        v
                                      output

If F(x) = 0, the output is simply x (identity).
The network can "skip" a block if it is not needed.
This makes training of deep networks stable.
    

7. Training a CNN

Training a CNN means finding the optimal values for all kernels (filters) and fully connected layer weights. This happens through an iterative process of forward pass, loss computation, and gradient backpropagation.

7.1 Loss Function

For image classification, the standard loss function is Cross-Entropy Loss. It measures how much the predicted probabilities deviate from the true labels. A perfect prediction yields loss = 0; a completely wrong prediction yields loss approaching infinity.

True label (one-hot): [0, 0, 1, 0, 0, 0, 0, 0, 0, 0]  (class "cat" = index 2)

Good prediction:      [0.02, 0.03, 0.85, 0.02, 0.01, 0.02, 0.01, 0.02, 0.01, 0.01]
  Loss = -log(0.85) = 0.16    --> Low loss, correct prediction

Bad prediction:       [0.30, 0.25, 0.05, 0.10, 0.05, 0.05, 0.05, 0.05, 0.05, 0.05]
  Loss = -log(0.05) = 3.00    --> High loss, wrong prediction
    

7.2 Optimizers

The optimizer updates network weights in the direction that reduces the loss. The most commonly used optimizers are:

7.3 Data Augmentation

Data augmentation is a fundamental technique for preventing overfitting and improving network generalization. It consists of applying random transformations to training images (rotations, flips, crops, brightness changes) to create synthetic variations without collecting new data.

Original Image:         Transforms:

  +-------+             [Horizontal flip]     --> Mirrored image
  |  Cat  |             [Rotation +-15 deg]   --> Slight rotation
  | --o-- |             [Random Crop]         --> Random crop
  |  /|\  |             [Color Jitter]        --> Color variation
  +-------+             [Gaussian Noise]      --> Added noise
                        [Cutout/Erasing]      --> Random rectangular mask
                        [MixUp]               --> Weighted average of 2 images
                        [CutMix]              --> Patch from one image overlaid

Effect: from 50,000 training images, each epoch sees different
variations, as if you had millions of unique images.
    

8. Complete PyTorch Implementation

Let us move from theory to practice. We will implement a complete CNN to classify images from the CIFAR-10 dataset (60,000 images at 32x32 in 10 classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, truck).

8.1 Setup and Dataset

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# Training transforms with data augmentation
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomCrop(32, padding=4),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],   # CIFAR-10 mean
        std=[0.2470, 0.2435, 0.2616]     # CIFAR-10 std
    ),
])

# Test transforms (no augmentation)
test_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2470, 0.2435, 0.2616]
    ),
])

# Load datasets
train_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=True, download=True, transform=train_transform
)
test_dataset = torchvision.datasets.CIFAR10(
    root='./data', train=False, download=True, transform=test_transform
)

# DataLoader with batching and shuffling
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=4)
test_loader = DataLoader(test_dataset, batch_size=128, shuffle=False, num_workers=4)

CLASSES = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck']
    

8.2 Model Definition

class ResidualBlock(nn.Module):
    """Residual block with skip connection."""

    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
        super().__init__()
        self.conv1 = nn.Conv2d(
            in_channels, out_channels, kernel_size=3,
            stride=stride, padding=1, bias=False
        )
        self.bn1 = nn.BatchNorm2d(out_channels)
        self.conv2 = nn.Conv2d(
            out_channels, out_channels, kernel_size=3,
            stride=1, padding=1, bias=False
        )
        self.bn2 = nn.BatchNorm2d(out_channels)
        self.relu = nn.ReLU(inplace=True)

        # Skip connection: if dimensions change, use 1x1 conv
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(in_channels, out_channels, kernel_size=1,
                          stride=stride, bias=False),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        identity = self.shortcut(x)

        out = self.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))
        out = out + identity   # Skip connection
        out = self.relu(out)

        return out


class CIFAR10CNN(nn.Module):
    """CNN with residual blocks for CIFAR-10 classification."""

    def __init__(self, num_classes: int = 10):
        super().__init__()
        # First convolutional layer
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1, bias=False)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu = nn.ReLU(inplace=True)

        # Residual blocks with increasing depth
        self.layer1 = self._make_layer(32, 64, num_blocks=2, stride=1)
        self.layer2 = self._make_layer(64, 128, num_blocks=2, stride=2)
        self.layer3 = self._make_layer(128, 256, num_blocks=2, stride=2)

        # Final classifier
        self.global_avg_pool = nn.AdaptiveAvgPool2d((1, 1))
        self.dropout = nn.Dropout(0.3)
        self.fc = nn.Linear(256, num_classes)

    def _make_layer(
        self, in_ch: int, out_ch: int, num_blocks: int, stride: int
    ) -> nn.Sequential:
        layers = [ResidualBlock(in_ch, out_ch, stride)]
        for _ in range(1, num_blocks):
            layers.append(ResidualBlock(out_ch, out_ch, stride=1))
        return nn.Sequential(*layers)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.relu(self.bn1(self.conv1(x)))   # (B, 32, 32, 32)
        x = self.layer1(x)                        # (B, 64, 32, 32)
        x = self.layer2(x)                        # (B, 128, 16, 16)
        x = self.layer3(x)                        # (B, 256, 8, 8)
        x = self.global_avg_pool(x)               # (B, 256, 1, 1)
        x = x.view(x.size(0), -1)                 # (B, 256)
        x = self.dropout(x)
        x = self.fc(x)                            # (B, 10)
        return x
    

8.3 Training Loop

def train_model(
    model: nn.Module,
    train_loader: DataLoader,
    test_loader: DataLoader,
    epochs: int = 50,
    lr: float = 0.01
) -> dict:
    """Train the model and return training history."""

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model = model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = optim.SGD(
        model.parameters(), lr=lr, momentum=0.9, weight_decay=1e-4
    )
    scheduler = optim.lr_scheduler.OneCycleLR(
        optimizer, max_lr=lr, epochs=epochs,
        steps_per_epoch=len(train_loader)
    )

    history = {'train_loss': [], 'test_loss': [], 'test_acc': []}

    for epoch in range(epochs):
        # --- Training ---
        model.train()
        running_loss = 0.0

        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)

            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            scheduler.step()

            running_loss += loss.item()

        avg_train_loss = running_loss / len(train_loader)

        # --- Evaluation ---
        model.eval()
        test_loss = 0.0
        correct = 0
        total = 0

        with torch.no_grad():
            for images, labels in test_loader:
                images, labels = images.to(device), labels.to(device)
                outputs = model(images)
                loss = criterion(outputs, labels)
                test_loss += loss.item()
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()

        avg_test_loss = test_loss / len(test_loader)
        accuracy = 100.0 * correct / total

        history['train_loss'].append(avg_train_loss)
        history['test_loss'].append(avg_test_loss)
        history['test_acc'].append(accuracy)

        print(
            f"Epoch [{epoch+1}/{epochs}] "
            f"Train Loss: {avg_train_loss:.4f} | "
            f"Test Loss: {avg_test_loss:.4f} | "
            f"Accuracy: {accuracy:.2f}%"
        )

    return history


# Run training
model = CIFAR10CNN(num_classes=10)
history = train_model(model, train_loader, test_loader, epochs=50, lr=0.1)

# Expected output after 50 epochs with OneCycleLR:
# Test Accuracy: ~92-93%
    

9. Transfer Learning

In practice, you rarely train a CNN from scratch. Transfer learning allows you to reuse models pre-trained on large datasets (such as ImageNet with 1.2 million images and 1,000 classes) and adapt them to your specific problem. This drastically reduces training time, data requirements, and improves performance.

9.1 Feature Extraction vs Fine-Tuning

import torchvision.models as models

def create_transfer_model(
    num_classes: int,
    freeze_backbone: bool = True
) -> nn.Module:
    """Create a model with transfer learning from ResNet-18."""

    # Load ResNet-18 pre-trained on ImageNet
    model = models.resnet18(weights=models.ResNet18_Weights.DEFAULT)

    # Strategy 1: Feature Extraction (freeze backbone)
    if freeze_backbone:
        for param in model.parameters():
            param.requires_grad = False

    # Replace the final classifier
    num_features = model.fc.in_features  # 512 for ResNet-18
    model.fc = nn.Sequential(
        nn.Dropout(0.3),
        nn.Linear(num_features, 256),
        nn.ReLU(),
        nn.Dropout(0.2),
        nn.Linear(256, num_classes)
    )

    return model


# Feature extraction: only the classifier is trained
feature_model = create_transfer_model(num_classes=10, freeze_backbone=True)

# Fine-tuning: the entire model is retrained
finetune_model = create_transfer_model(num_classes=10, freeze_backbone=False)

# For fine-tuning, use a lower learning rate
optimizer = optim.AdamW([
    {'params': finetune_model.layer4.parameters(), 'lr': 1e-4},
    {'params': finetune_model.fc.parameters(), 'lr': 1e-3},
], weight_decay=1e-2)
    

Transfer Learning Guide:

                     Data similar to ImageNet    Data different from ImageNet
                     (objects, animals, scenes)   (medical, satellite, micro)
                  +----------------------------+----------------------------+
  Few data        | Feature Extraction          | Feature Extraction         |
  (<1,000 img)   | Freeze all, train FC        | + Increase data augment.   |
                  +----------------------------+----------------------------+
  Lots of data    | Fine-tune last layers       | Full fine-tuning           |
  (>5,000 img)    | Low LR for backbone         | or train from scratch      |
                  +----------------------------+----------------------------+
    

10. Evaluation Metrics

Accuracy alone is not enough to determine whether a CNN performs well. With imbalanced datasets (e.g., 95% class A, 5% class B), a model that always predicts "class A" achieves 95% accuracy but is completely useless. More granular metrics are needed.

Confusion Matrix (predictions vs reality):

              Predicted: plane  car   bird  cat   deer  dog   frog  horse ship  truck
  Actual:
  airplane              [92]    1     2     0     0     0     1     0     3     1
  automobile             0    [95]    0     0     0     0     0     0     1     4
  bird                   3      0   [85]    3     2     2     3     1     1     0
  cat                    0      1     2   [78]    1     12    3     2     0     1
  deer                   1      0     3     2   [88]    1     2     3     0     0

Interpretation:
- Diagonal = correct predictions (higher = better)
- Off-diagonal = errors (confusions between classes)
- cat vs dog: 12 cats classified as dogs --> "confused" classes
    

from sklearn.metrics import (
    classification_report,
    confusion_matrix
)
import numpy as np


def evaluate_model(
    model: nn.Module,
    test_loader: DataLoader,
    device: torch.device,
    class_names: list[str]
) -> dict:
    """Evaluate the model and return detailed metrics."""

    model.eval()
    all_preds = []
    all_labels = []

    with torch.no_grad():
        for images, labels in test_loader:
            images = images.to(device)
            outputs = model(images)
            _, predicted = outputs.max(1)
            all_preds.extend(predicted.cpu().numpy())
            all_labels.extend(labels.numpy())

    preds_array = np.array(all_preds)
    labels_array = np.array(all_labels)

    # Per-class detailed report
    report = classification_report(
        labels_array, preds_array,
        target_names=class_names, output_dict=True
    )

    # Confusion matrix
    cm = confusion_matrix(labels_array, preds_array)

    # Overall accuracy
    accuracy = np.mean(preds_array == labels_array) * 100

    print(f"Overall Accuracy: {accuracy:.2f}%")
    print(classification_report(
        labels_array, preds_array, target_names=class_names
    ))

    return {'accuracy': accuracy, 'report': report, 'confusion_matrix': cm}
    

11. Deployment: From Trained Model to Production

Training a model is only half the work. To bring it to production you need to export it in an optimized format, create an inference API, and containerize everything for scalable deployment.

11.1 Model Export

import torch.onnx

def export_model(model: nn.Module, export_path: str) -> None:
    """Export the model to TorchScript and ONNX."""

    model.eval()
    dummy_input = torch.randn(1, 3, 32, 32)

    # --- TorchScript ---
    scripted_model = torch.jit.trace(model, dummy_input)
    scripted_model.save(f"{export_path}/model_scripted.pt")
    print("TorchScript saved.")

    # --- ONNX ---
    torch.onnx.export(
        model,
        dummy_input,
        f"{export_path}/model.onnx",
        input_names=['image'],
        output_names=['prediction'],
        dynamic_axes={
            'image': {0: 'batch_size'},
            'prediction': {0: 'batch_size'}
        },
        opset_version=17
    )
    print("ONNX saved.")


export_model(model, './exports')
    

11.2 Inference API with FastAPI

# inference_api.py
from fastapi import FastAPI, UploadFile
from PIL import Image
import torch
import torchvision.transforms as transforms
import io

app = FastAPI(title="CNN Image Classifier")

# Load TorchScript model
model = torch.jit.load("./exports/model_scripted.pt")
model.eval()

CLASSES = ['airplane', 'automobile', 'bird', 'cat', 'deer',
           'dog', 'frog', 'horse', 'ship', 'truck']

preprocess = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.4914, 0.4822, 0.4465],
        std=[0.2470, 0.2435, 0.2616]
    ),
])


@app.post("/predict")
async def predict(file: UploadFile):
    """Classify an uploaded image."""
    image_bytes = await file.read()
    image = Image.open(io.BytesIO(image_bytes)).convert("RGB")
    tensor = preprocess(image).unsqueeze(0)

    with torch.no_grad():
        outputs = model(tensor)
        probabilities = torch.softmax(outputs, dim=1)
        confidence, predicted = probabilities.max(1)

    return {
        "class": CLASSES[predicted.item()],
        "confidence": round(confidence.item() * 100, 2),
        "all_probabilities": {
            name: round(prob.item() * 100, 2)
            for name, prob in zip(CLASSES, probabilities[0])
        }
    }

# Run: uvicorn inference_api:app --host 0.0.0.0 --port 8000
    

11.3 Containerization with Docker

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY exports/ ./exports/
COPY inference_api.py .

EXPOSE 8000

CMD ["uvicorn", "inference_api:app", "--host", "0.0.0.0", "--port", "8000"]

# Build: docker build -t cnn-classifier .
# Run:   docker run -p 8000:8000 cnn-classifier
# Test:  curl -X POST -F "file=@cat.jpg" http://localhost:8000/predict
    

Pipeline: Training --> Export --> Container --> Deploy

  [Training]          [Export]           [Container]        [Deploy]
  PyTorch + GPU  -->  TorchScript/ONNX  -->  Docker     -->  Kubernetes
  50 epochs          ~10 MB file            FastAPI          Auto-scaling
  ~92% accuracy      Optimized              Health checks    Load balancer
                     No Python dependency   GPU optional     Monitoring

Serverless alternative:
  Export ONNX --> AWS Lambda + ONNX Runtime --> API Gateway
  Pro: Pay-per-use, zero infrastructure to manage
  Con: Cold start (~2s), 250MB package limit
    

Conclusions and Next Steps

In this article we built a comprehensive understanding of Convolutional Neural Networks, starting from fundamentals (how a computer sees images, the convolution operation) through practical implementation (CNN with residual blocks in PyTorch) to production deployment (TorchScript, ONNX, FastAPI, Docker).

We traced how the evolution of architectures, from LeNet-5 in 1998 to ConvNeXt in 2022, progressively improved performance through ideas like skip connections (ResNet), compound scaling (EfficientNet), and transformer-inspired design (ConvNeXt).

In the next article we will dive deep into Transfer Learning and Fine-Tuning: how to choose the right pre-trained model, progressive fine-tuning strategies, domain adaptation, and advanced techniques like knowledge distillation. In the third article we will tackle Object Detection with YOLO, the most widely used real-time object detection system in industry.