Convolutional Neural Networks (CNNs) Basics – in Computer Vision

What You’ll Learn 📚

• Introduction to CNNs and their role in computer vision
• Core concepts and key terminology
• Simple to complex examples with runnable code
• Common questions and troubleshooting tips

Introduction to CNNs

Convolutional Neural Networks (CNNs) are a type of deep learning model specifically designed for processing structured grid data, like images. They are incredibly powerful for tasks such as image classification, object detection, and more.

Think of CNNs as a way to give computers ‘eyes’ to see and understand images just like we do!

Core Concepts

1. Convolution

The convolution operation is the heart of CNNs. It involves sliding a filter (or kernel) over the input image to produce feature maps. This helps in detecting edges, textures, and patterns.

2. Activation Function

After convolution, we apply an activation function like ReLU (Rectified Linear Unit) to introduce non-linearity. This helps the network learn complex patterns.

3. Pooling

Pooling layers reduce the spatial size of the feature maps, making the computation more efficient and reducing overfitting. Max pooling is a common technique.

4. Fully Connected Layers

These layers come at the end of the network and are used to make predictions based on the features extracted by previous layers.

Key Terminology

• Kernel/Filter: A small matrix used to apply effects like blurring, sharpening, edge detection, etc.
• Stride: The number of pixels by which the filter moves across the image.
• Padding: Adding extra pixels around the input image to control the spatial size of the output.

Simple Example: Edge Detection

import numpy as np
from scipy.signal import convolve2d

# Simple 3x3 image
image = np.array([[1, 2, 1],
                  [0, 1, 0],
                  [2, 1, 2]])

# Edge detection kernel
kernel = np.array([[-1, -1, -1],
                   [-1,  8, -1],
                   [-1, -1, -1]])

# Convolution operation
output = convolve2d(image, kernel, mode='same')
print(output)

[[ 0  4  0]
 [-3  8 -3]
 [ 0  3  0]]

Progressively Complex Examples

Example 1: Basic CNN with Keras

import tensorflow as tf
from tensorflow.keras import layers, models

# Define a simple CNN model
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

model.summary()

Example 2: Training a CNN on MNIST

from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical

# Load data
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# Preprocess data
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

# Compile and train the model
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=5, batch_size=64)

Example 3: Transfer Learning with Pre-trained Models

from tensorflow.keras.applications import VGG16

# Load VGG16 model pre-trained on ImageNet
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3))

# Freeze the base model
base_model.trainable = False

# Add custom layers on top
model = models.Sequential([
    base_model,
    layers.Flatten(),
    layers.Dense(256, activation='relu'),
    layers.Dense(10, activation='softmax')
])

model.summary()

Common Questions and Answers

1. What is the main advantage of using CNNs for image data?

   CNNs are particularly good at capturing spatial hierarchies in images, making them excellent for tasks like image classification and object detection.

2. Why do we use pooling layers?

   Pooling layers help reduce the spatial dimensions of feature maps, which decreases the number of parameters and computation in the network.

3. What is the role of the activation function?

   Activation functions introduce non-linearity into the model, allowing it to learn complex patterns.

4. How does transfer learning work?

   Transfer learning involves using a pre-trained model on a new task. This is efficient because the model has already learned useful features from a large dataset.

Troubleshooting Common Issues

If your model isn’t learning, check for issues like incorrect data preprocessing, inappropriate learning rates, or insufficient training epochs.

Common Mistakes

• Not normalizing input data
• Using too few epochs for training
• Overfitting due to a lack of regularization

# Incorrect: Forgetting to normalize data
train_images = train_images.reshape((60000, 28, 28, 1))

# Correct: Normalize data
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255

Practice Exercises

• Try changing the kernel size and observe how it affects the feature maps.
• Experiment with different activation functions like sigmoid or tanh.
• Implement a CNN for a different dataset, such as CIFAR-10.

Keep experimenting and don’t hesitate to ask questions. You’ve got this! 🚀