The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Introduction to CNNs

Next ►
►

Convolutional Neural Networks (CNNs) are a class of deep neural networks that have proven highly effective for tasks involving image and video recognition, classification, and segmentation. In this section, we will cover the fundamental concepts of CNNs, their architecture, and how they differ from traditional neural networks.

Key Concepts

  1. Convolutional Layers

  • Convolution Operation: The core building block of a CNN. It involves a filter (or kernel) sliding over the input data to produce a feature map.
  • Filters/Kernels: Small matrices used to detect specific features such as edges, textures, or patterns in the input data.
  • Stride: The number of pixels by which the filter moves over the input matrix.
  • Padding: Adding extra pixels around the input matrix to control the spatial dimensions of the output feature map.

  1. Pooling Layers

  • Purpose: To reduce the spatial dimensions of the feature maps, thereby decreasing the computational load and controlling overfitting.
  • Types:
    • Max Pooling: Takes the maximum value from a patch of the feature map.
    • Average Pooling: Takes the average value from a patch of the feature map.

  1. Fully Connected Layers

  • Role: To combine the features extracted by convolutional and pooling layers and make final predictions.
  • Structure: Similar to traditional neural networks, where each neuron is connected to every neuron in the previous layer.

  1. Activation Functions

  • Commonly Used: ReLU (Rectified Linear Unit) is the most commonly used activation function in CNNs due to its ability to introduce non-linearity and improve training speed.

CNN Architecture

A typical CNN architecture consists of a series of convolutional and pooling layers followed by one or more fully connected layers. Here is a simple example:

  1. Input Layer: Raw image data (e.g., 32x32x3 for a color image).
  2. Convolutional Layer: Applies multiple filters to the input image to produce feature maps.
  3. Activation Layer: Applies an activation function like ReLU to introduce non-linearity.
  4. Pooling Layer: Reduces the spatial dimensions of the feature maps.
  5. Fully Connected Layer: Flattens the feature maps and connects to the output layer.
  6. Output Layer: Produces the final classification or regression output.

Practical Example

Let's implement a simple CNN using PyTorch to classify images from the CIFAR-10 dataset.

Step 1: Import Libraries

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms

Step 2: Load and Preprocess Data

# Define transformations for the training and test sets
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# Load the CIFAR-10 dataset
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=100, shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=100, shuffle=False, num_workers=2)

Step 3: Define the CNN Model

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)  # 3 input channels, 6 output channels, 5x5 kernel
        self.pool = nn.MaxPool2d(2, 2)   # 2x2 pooling
        self.conv2 = nn.Conv2d(6, 16, 5) # 6 input channels, 16 output channels, 5x5 kernel
        self.fc1 = nn.Linear(16 * 5 * 5, 120) # Fully connected layer
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)     # 10 output classes (CIFAR-10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)  # Flatten the tensor
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

net = SimpleCNN()

Step 4: Define Loss Function and Optimizer

criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

Step 5: Train the Model

for epoch in range(2):  # Loop over the dataset multiple times
    running_loss = 0.0
    for i, data in enumerate(trainloader, 0):
        inputs, labels = data

        optimizer.zero_grad()  # Zero the parameter gradients

        outputs = net(inputs)  # Forward pass
        loss = criterion(outputs, labels)  # Compute loss
        loss.backward()  # Backward pass
        optimizer.step()  # Optimize the weights

        running_loss += loss.item()
        if i % 100 == 99:  # Print every 100 mini-batches
            print(f'[Epoch {epoch + 1}, Batch {i + 1}] loss: {running_loss / 100:.3f}')
            running_loss = 0.0

print('Finished Training')

Step 6: Test the Model

correct = 0
total = 0
with torch.no_grad():
    for data in testloader:
        images, labels = data
        outputs = net(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Accuracy of the network on the 10000 test images: {100 * correct / total:.2f}%')

Summary

In this section, we introduced the fundamental concepts of Convolutional Neural Networks (CNNs), including convolutional layers, pooling layers, and fully connected layers. We also implemented a simple CNN using PyTorch to classify images from the CIFAR-10 dataset. This example provided a hands-on understanding of how CNNs work and how to build and train them using PyTorch.

In the next section, we will delve deeper into building a CNN from scratch, exploring more complex architectures and techniques to improve performance.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved