CNNS

Written By Tal Nabulsi
Convolutional Neural Networks (CNNs) Cheat Sheet

1. Convolutional Neural Networks (CNNs) Cheat Sheet

Deep Learning
Supervised Learning
Computer Vision

High-Level Overview:

Convolutional Neural Networks (CNNs) are a class of deep neural networks particularly well-suited for image-related tasks. They leverage the spatial structure of input data through convolutional layers that learn features like edges, textures, and shapes.

While primarily used for image classification, object detection, and segmentation, CNNs are also applied to other domains like audio classification or even natural language processing (using 1D convolutions). They excel at automatically learning hierarchical features—low-level features (edges) in early layers and high-level concepts (faces, objects) in later layers.

Key Concepts:

  • Convolutional Layers: Apply filters (kernels) to input images or feature maps to extract local patterns.
  • Filters/Kernels: Small matrices that “slide” over the image, detecting features. Each filter extracts a different type of feature (e.g., vertical edges).
  • Pooling Layers: Downsample feature maps (e.g., max pooling) to reduce spatial dimensions and compute requirements, summarizing regions of the image.
  • Fully Connected Layers: After convolutions and pooling, one or more fully connected layers integrate the learned features to classify or regress an output.
  • Activation Functions: Non-linearities like ReLU help the network learn complex mappings.

How CNNs Work:

  1. Convolution: Input images pass through convolutional layers. Each layer applies multiple filters that detect features like edges, corners, or textures.
  2. Pooling: Periodically, a pooling layer reduces the dimensionality, focusing on prominent features and improving efficiency.
  3. Stacking Layers: Multiple convolution and pooling layers stack up, building a hierarchy of features: early layers learn basic patterns; deeper layers learn more complex, abstract concepts.
  4. Classification/Output: After feature extraction, fully connected layers combine these features to predict class labels or other outputs.

What Kind of Datasets Are CNNs Good For?

CNNs thrive on structured grid-like data, especially images:

  • Image Classification: Given a collection of labeled images (e.g., cats vs. dogs), CNNs can learn to classify them accurately.
  • Object Detection & Segmentation: More advanced architectures (Faster R-CNN, Mask R-CNN, YOLO) extend CNNs to localize and outline objects in images.
  • Medical Imaging: Identifying tumors or lesions in MRI scans, X-rays, or CT scans.
  • Satellite Imagery Analysis: Detecting roads, buildings, or vegetation patterns in aerial images.
Although images are the typical use case, CNNs can also process 1D signals (audio waveforms) or 2D structured data like spectrograms.

Detailed Example (Image Classification):

Suppose you want to classify images of handwritten digits (0-9) from the MNIST dataset:

  • A CNN’s early layers learn edges and simple shapes from pixel data.
  • As you go deeper, the network learns increasingly complex patterns that correlate with specific digits (like loops in '8' or angles in '7').
  • Finally, the last layers use these high-level patterns to categorize the image as a specific digit with high accuracy.

Step-by-Step Summary:

  1. Prepare Data: Collect and label images or structured data. For images, often resized and normalized.
  2. Build the CNN: Stack convolutional and pooling layers, then add fully connected layers at the end.
  3. Train the Model: Use gradient-based optimization (e.g., Adam) on a loss function (e.g., cross-entropy) to adjust filter weights.
  4. Evaluate & Tune: Adjust hyperparameters (filter sizes, number of layers, learning rate) for better performance.
  5. Deploy: Use the trained model to classify new, unseen images efficiently.

ML Engineer Perspective:

  • CNNs are a go-to solution for image tasks, drastically outperforming traditional methods in most cases.
  • They require substantial computational resources, especially for large, complex models and datasets.
  • Transfer learning is common: start from a pre-trained model (like ResNet or VGG) and fine-tune on your data to save time and improve results.
  • Explainability can be challenging, but techniques like saliency maps or Grad-CAM can highlight which image regions influence decisions.

Code Example (Python with TensorFlow/Keras):


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

# Example: A simple CNN for MNIST digit classification
model = models.Sequential([
    layers.Conv2D(32, (3,3), activation='relu', input_shape=(28,28,1)),
    layers.MaxPooling2D((2,2)),
    layers.Conv2D(64, (3,3), activation='relu'),
    layers.MaxPooling2D((2,2)),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Assume X_train, y_train, X_test, y_test are loaded MNIST data
# model.fit(X_train, y_train, epochs=5, validation_split=0.1)
# test_loss, test_acc = model.evaluate(X_test, y_test)
# print("Test accuracy:", test_acc)

This code defines a basic CNN: two convolution+pooling stages followed by a fully connected part. Training it on MNIST would yield high accuracy on handwritten digits.

Key Takeaways:

  • CNNs leverage convolution and pooling to automatically learn hierarchical features from images.
  • They dominate tasks in computer vision and also apply to audio, medical imaging, and more.
  • Complex architectures (ResNet, Inception, EfficientNet) push the state of the art in visual understanding.
  • While training can be resource-intensive, CNN-based models often achieve exceptional performance with the right data and architecture.
Tal Nabulsi
Next

RNNs