🧠 1️⃣ CNN Foundations

🌐 What is a CNN?

A Convolutional Neural Network (CNN) is a class of deep learning models tailored for grid-like data, most notably images. While traditional neural networks treat images as flat vectors, CNNs preserve spatial structure, allowing them to see patterns in local regions and build up hierarchies of features.

🧩 From Pixel Grids to Pattern Detectors

• Input image: a grid of pixels, e.g. 28×28 (grayscale) or 224×224×3 (RGB).
• CNN sees this grid locally: it applies filters (kernels) that slide over the image.
• These filters are learned during training to detect edges, textures, and shapes.
• Deeper layers detect complex objects: faces, cars, tumors, etc.

🧬 Biological Inspiration

• Hubel and Wiesel's experiments showed neurons respond to local stimuli (edges, orientations).
• These neurons are called receptive fields — similar to how convolution kernels operate in CNNs.
• A CNN mimics this: early layers are local (like the retina), deeper ones are more abstract (like the brain).

🧠 Core Idea

• Locality: A filter only sees a small patch (e.g., 3×3).
• Parameter sharing: The same filter slides across the image — fewer parameters.
• Hierarchy: First layers → low-level edges. Middle → textures. Last → object parts.

📊 Diagram (textual layout)

[Input Image] 
    ↓
[Conv Layer 1: edge filters] → [ReLU] → [Pooling]
    ↓
[Conv Layer 2: textures/shapes] → [ReLU] → [Pooling]
    ↓
[Flatten] → [Dense Layer(s)] 
    ↓
[Softmax Layer: Class probabilities]
  

🔧 PyTorch Snippet (Intro CNN)

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, padding=1)
        self.pool = nn.MaxPool2d(2, 2)
        self.fc = nn.Linear(32 * 8 * 8, num_classes)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))  # [B, 16, 16, 16]
        x = self.pool(F.relu(self.conv2(x)))  # [B, 32, 8, 8]
        x = x.view(x.size(0), -1)             # Flatten
        x = self.fc(x)                        # Dense + softmax (in loss)
        return x
  

🧪 Visual/Interactive Ideas

• Upload a cat image → show filters activating on edges.
• Slider to blend first-layer outputs into original image.
• "CNN Vision" viewer: watch what each layer learns and "sees."

🧠 Quiz Prompts

1. Why do CNNs prefer convolution over full connections for images?
2. What does a convolution kernel actually learn?
3. How do early vs deep layers differ in what they detect?

🧱 2️⃣ Convolutional Layers

🔍 Core Concepts

🧮 Mathematical Operation

\( Y(i, j) = \sum_{m} \sum_{n} X(i + m, j + n) \cdot K(m, n) \)

Where:

• X = input image or feature map
• K = kernel/filter
• Y = output feature map

🔢 Visual Example (3×3 kernel over 5×5 input)

Input (X):         Kernel (K):
[[1 2 0 1 3]       [[ 1  0 -1]
 [4 5 2 1 0]        [ 1  0 -1]
 [3 1 1 0 2]        [ 1  0 -1]
 [2 0 1 3 1]
 [1 1 0 2 4]]
  

After convolution, you'll get a feature map (3×3) that highlights vertical edges if K is a Sobel-like kernel.

🧪 PyTorch Demo

import torch
import torch.nn.functional as F

# Simulated grayscale image (1 channel)
img = torch.rand(1, 1, 5, 5)  # Batch, Channel, Height, Width

# Define kernel manually
sobel_kernel = torch.tensor([[1, 0, -1],
                             [1, 0, -1],
                             [1, 0, -1]], dtype=torch.float32).view(1, 1, 3, 3)

# Apply convolution
output = F.conv2d(img, sobel_kernel, stride=1, padding=0)
print(output)
  

This outputs the feature map — a numerical abstraction of edges.

🎥 First vs. Deeper Layers

• First Layer: learns edges, corners, basic textures.
• Deeper Layers: combine those into motifs, parts (e.g., wheel, eye), full objects.

Use TensorBoard, Weights & Biases, or custom hook functions to visualize activations layer-by-layer.

🎮 Interactivity Ideas

• Upload an image → Display first-layer filters and what they activate on.
• Layer visualizer: Toggle through activations at each depth.
• Stride & Padding sliders: See spatial effects live.

🧠 Quiz & Reflection

1. How does increasing stride affect feature map size and detail?
2. Why is padding critical when using small inputs or deep networks?
3. What’s the intuition behind learned filters vs manually designed ones (like Sobel)?

🔄 3️⃣ Pooling & Nonlinearities

Pooling and activation functions are like the distillation and spark of a CNN’s cognition: pooling compresses, activations energize.

🧊 Pooling Techniques

Typical window: \( 2 \times 2 \), stride 2

🔢 Example: Max Pool on 2×2 patch [[1, 3], [2, 4]] → 4

🔥 Nonlinear Activations

Why use them? Without nonlinearities, a CNN is just a linear system — incapable of learning complex boundaries.

🧪 PyTorch Pooling & Activation

import torch
import torch.nn.functional as F

x = torch.tensor([[[[1.0, -1.0], [2.0, -2.0]]]])  # shape: [1, 1, 2, 2]

relu_out = F.relu(x)
leaky_out = F.leaky_relu(x)
tanh_out = torch.tanh(x)

print("ReLU:\\n", relu_out)
print("Leaky ReLU:\\n", leaky_out)
print("Tanh:\\n", tanh_out)

# Pooling on 4x4 feature map
feature_map = torch.randn(1, 1, 4, 4)
max_pooled = F.max_pool2d(feature_map, 2)
avg_pooled = F.avg_pool2d(feature_map, 2)

print("Max Pool:\\n", max_pooled)
print("Avg Pool:\\n", avg_pooled)
  

👁️ Activation Playground (Interactive Idea)

• Sliders for input range → Watch ReLU, Leaky, Tanh curves respond.
• Graph overlays for:
  • Activation curve
  • Gradient (backprop friendliness)

💡 Analogy

• Pooling is like summarizing a paragraph into a sentence — key info retained, noise dropped.
• Activation is like applying emotion to speech — adds richness and variation.

🧠 Quiz & Discussion

1. Why do we use pooling instead of strided convolution for downsampling?
2. How can Leaky ReLU solve the “dying ReLU” issue?
3. Why are nonlinearities essential even after several convolution layers?

🏗️ 4️⃣ Deep CNN Architectures

Now entering the high-rise skyline of neural design — where simplicity meets innovation, and elegance battles efficiency. These models form the landmarks of computer vision.

🔍 Overview Table

🧠 Highlights by Model

🔹 VGGNet (e.g., VGG16)

• Uniform stack of Conv3x3 → ReLU → Conv3x3 → ReLU → MaxPool
• Uses only small filters (3×3), very deep (up to 19 layers)
• No clever tricks — just depth + simplicity

model = torchvision.models.vgg16()
  

🔹 ResNet (e.g., ResNet50)

• Introduces residual blocks: \( F(x) + x \)
• Solves vanishing gradient & degradation problems
• First to train networks >100 layers

class ResidualBlock(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(64, 64, 3, padding=1)
        self.conv2 = nn.Conv2d(64, 64, 3, padding=1)

    def forward(self, x):
        out = F.relu(self.conv1(x))
        out = self.conv2(out)
        return F.relu(out + x)  # skip connection
  

🔹 Inception (GoogLeNet)

• Parallel paths: 1×1, 3×3, 5×5 convolutions
• 1×1 convolutions used for dimension reduction
• Modular “Inception blocks” allow multi-scale analysis

🔹 MobileNet

• Depthwise separable convolution = split Conv into:
  1. Depthwise: 1 filter per input channel
  2. Pointwise: 1×1 to mix channels
• Drastic reduction in FLOPs, ideal for phones & IoT

🔹 EfficientNet

• Unified scaling: width (channels), depth (layers), resolution
• Uses neural architecture search for base model
• Family from EfficientNet-B0 to B7

📊 Live Model Explorer Ideas

• Layer Viewer: click through each layer → see shape & params
• FLOPs Estimator: show compute cost per model
• Live Metrics:
  • VGG16: ~138M params
  • ResNet50: ~25M
  • MobileNetV2: ~3.4M
  • EfficientNet-B0: ~5.3M

🧪 PyTorch Quickstart

from torchvision import models

vgg = models.vgg16()
resnet = models.resnet50()
mobilenet = models.mobilenet_v2()
efficientnet = models.efficientnet_b0()

print(resnet.layer1)
  

🎯 Analogy

• VGG is like a tall, consistent apartment block.
• ResNet is a highway with overpasses (skips).
• Inception is a Swiss Army knife of filters.
• MobileNet is a scooter — light and fast.
• EfficientNet is a Formula 1 car — balanced for peak performance.

🧠 Quiz & Design Reflection

1. Why do deeper networks without skips often degrade in accuracy?
2. How do Inception blocks handle scale better than VGG?
3. Which model would you choose for a mobile app? Why?

⚙️ 5️⃣ Training CNNs

Now we dive into the engine room — where raw architectures are forged into intelligent systems through data, error, and optimization. This is where learning truly happens.

🧮 Step-by-Step Breakdown

🔧 Code Snippet (PyTorch)

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

# Loss
criterion = nn.CrossEntropyLoss()

# Optimizer
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)

# Data Augmentation
transform_train = transforms.Compose([
    transforms.RandomHorizontalFlip(),
    transforms.RandomCrop(32, padding=4),
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
])
  

🎨 Visual Training Insights

📈 Loss Curves

• Overfitting: train ↓, val ↑
• Underfitting: both high
• Convergence: both low and stable

🎨 Filter Evolution

Visualize how first-layer filters evolve during training:

• Initially random noise
• Gradually develop edge detectors, color blobs, Gabor-like filters

Use hooks to extract intermediate tensors:

def hook_fn(module, input, output):
    print("Feature Map Shape:", output.shape)

model.conv1.register_forward_hook(hook_fn)
  

🔁 Training Loop Skeleton

for epoch in range(num_epochs):
    model.train()
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)

        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

    # Optional: validate
    model.eval()
    with torch.no_grad():
        # evaluate on val set
  

🧠 Key Concepts

CrossEntropyLoss:

\[ \text{Loss} = -\sum y_i \log(\hat{y}_i) \]

for class probabilities \( \hat{y} \) and one-hot target \( y \)

Dropout: randomly zeroes neurons during training (e.g., nn.Dropout(p=0.5))

L2 Regularization: encourages smaller weights:

\[ L = \text{Loss} + \lambda \|w\|^2 \]

💡 Tips

• Adam is usually a solid default optimizer
• Early Stopping can save from overfitting
• Use learning rate schedulers for better convergence
• Combine batch normalization + dropout wisely (dropout after BN is often less useful)

🧠 Quiz & Reflection

1. What’s the difference between CrossEntropyLoss and NLLLoss?
2. Why might Adam converge faster than SGD?
3. What happens if you apply too much dropout?

👁️ 6️⃣ Visualization & Interpretability

Welcome to the realm where CNNs go from black-box to glass-box. Here, we peer into their "mind's eye" and witness the emergence of understanding.

Understanding what a CNN has learned is crucial for:

• Debugging models
• Gaining trust (e.g., in medical AI)
• Improving robustness

🔍 Visualizing Filters & Activations

🧪 Filter Visualization

• Especially useful for first convolutional layer
• Reveals what kind of edge or texture each filter responds to

# Visualize conv1 weights
import matplotlib.pyplot as plt

weights = model.conv1.weight.data.clone().cpu()
for i in range(6):
    plt.subplot(1, 6, i+1)
    plt.imshow(weights[i][0], cmap='gray')
  

🔋 Activation Maps

• Extract feature maps from intermediate layers using hooks
• Show which spatial regions are activated by input features

def hook_fn(module, input, output):
    activation_map = output[0].detach().cpu()
    plt.imshow(activation_map[0], cmap='viridis')
  

🔥 Grad-CAM (Gradient-weighted Class Activation Mapping)

Shows which parts of an image contribute most to a specific class prediction.

Steps:

1. Get gradients of target class w.r.t. feature maps
2. Weight each channel by its average gradient
3. Overlay on input image

Libraries: pytorch-grad-cam, torchcam

pip install grad-cam
  

from pytorch_grad_cam import GradCAM
cam = GradCAM(model=model, target_layers=[model.layer4[-1]])
heatmap = cam(input_tensor=image)
  

🌊 Saliency Maps

• Compute gradient of class score w.r.t. input pixels
• Highlights sensitive pixels for decision

image.requires_grad_()
output = model(image)
output[0, target_class].backward()
saliency = image.grad.data.abs().max(dim=1)[0]
  

🧪 Occlusion Tests

Systematically mask parts of input image → watch prediction confidence drop.

# Slide a gray patch over image and record drop in prediction score
  

🎮 Visual Playground Ideas

• Upload image → click to see:
  • Activation maps
  • Grad-CAM heatmaps
  • Saliency overlays
• Compare layers: early layers = local patterns, deeper = semantic parts

🧠 Real-World Utility

🧠 Quiz & Insight

1. How does Grad-CAM differ from saliency maps?
2. What can we infer if only the edges activate in a Grad-CAM?
3. When would occlusion testing be more informative than gradients?

🔁 7️⃣ Transfer Learning & Fine-Tuning

Great — you're now entering one of the most powerful paradigms in deep learning. This section is about starting smart by leveraging pre-trained CNNs trained on massive datasets like ImageNet.

Transfer learning lets you recycle knowledge from a large task (e.g., ImageNet) to a smaller, domain-specific one (e.g., plant disease, medical images, fashion).

🎯 Methods & Benefits

📦 PyTorch Quickstart

from torchvision import models
import torch.nn as nn

# Load pretrained ResNet50
model = models.resnet50(pretrained=True)

# Freeze all layers
for param in model.parameters():
    param.requires_grad = False

# Replace classifier (ResNet: 2048 → num_classes)
num_classes = 5
model.fc = nn.Linear(2048, num_classes)
  

➡️ For fine-tuning, unfreeze deeper layers selectively:

for name, param in model.named_parameters():
    if "layer4" in name:
        param.requires_grad = True
  

⚙️ Training Strategy

1. Start with feature extraction — avoid overfitting.
2. Add early stopping, dropout, and weight decay.
3. If validation plateaus, unfreeze last conv block and reduce learning rate.
4. Use learning rate schedulers: ReduceLROnPlateau, CosineAnnealingLR

🧪 Domain-Specific Tip

📘 Pros & Caveats

• ✅ Huge reduction in data + training time
• ✅ Strong regularization effect
• ❌ If domain shift is large, pretrained features might misalign
• ❌ Overfreezing may limit learning capacity

🎮 Interactive Ideas

• Upload a dataset → auto-suggest best pretrained model
• Visualize before/after fine-tuning feature maps
• Classifier head editor: swap fully connected layers interactively

🧠 Quiz & Reflection

1. Why is it helpful to freeze early CNN layers during transfer learning?
2. What risks come with unfreezing all layers on a small dataset?
3. How would you modify transfer learning for non-image data (e.g., audio or 1D signals)?

🧪 8️⃣ Specialized CNNs

You're now venturing into Specialized CNNs, where convolutional power extends beyond standard 2D vision. These variants adapt CNNs to non-image modalities, temporal structures, and dense prediction tasks.

Each of these CNN types is tailored for a unique data geometry or prediction goal.

📦 1D CNN — For Sequences and Signals

1D Kernel slides across time or sequence axis only.

nn.Conv1d(in_channels=16, out_channels=32, kernel_size=3)
  

🧬 3D CNN — For Volume Data

3D Kernels slide across height, width, and depth.

nn.Conv3d(in_channels=1, out_channels=8, kernel_size=(3, 3, 3))
  

🧠 They extract spatiotemporal or volumetric features, crucial for anomaly detection, motion recognition, and brain scan analysis.

🔄 Temporal CNN (TCN)

Key features:

• Causal convolution: future inputs not used
• Dilated convolution: increases receptive field efficiently

Frameworks: torch.nn.Conv1d, TCNBlock, or libraries like PyTorchForecasting

🗺️ Fully Convolutional Networks (FCNs)

No dense layers — use ConvTranspose2d or upsampling to preserve spatial output.

Architecture: Encoder (downsampling) → Decoder (upsampling)

# Decoder example
nn.ConvTranspose2d(64, 32, kernel_size=2, stride=2)
  

📘 Demo Idea: 3D Medical Classification

Upload 3D CT/MRI scan → Scroll through slices → CNN predicts region or anomaly type
Optionally: integrate a volume viewer like nibabel + PyTorch + Grad-CAM 3D

🔬 Comparison Summary

🧠 Quiz & Design Prompt

1. Why are 3D CNNs more computationally intense than 2D?
2. How do FCNs maintain spatial alignment without dense layers?
3. In what cases would a TCN outperform an LSTM?

🌍 9️⃣ CNNs in the Wild

You're entering CNNs in the Wild, where convolutional networks transcend labs and empower the real world — from diagnosing cancer to creating art and exploring galaxies.

CNNs have proven remarkably versatile and robust, achieving state-of-the-art performance in diverse domains. Here's a curated tour of where they’re making the most impact:

🏥 Healthcare

Application: X-ray, CT, MRI interpretation; pathology slide classification

• Detect diseases like pneumonia, lung cancer, retinal damage
• Models trained on datasets like NIH ChestX-ray14, LUNA16
• Notable Use: CNNs beating radiologists in sensitivity for lung cancer via CT scans (Google Health)

Tools:

• 3D CNNs for volumetric data
• Grad-CAM to explain diagnoses
• DICOM support libraries: pydicom, monai

🚗 Autonomous Vehicles

Application: Scene parsing, road segmentation, lane & sign detection

• Semantic segmentation networks (FCNs, U-Nets, DeepLab)
• Real-time inference on video streams
• High-res satellite maps + real-world driving footage

Frameworks: NVIDIA’s PilotNet, Carla Simulator

Datasets: Cityscapes, KITTI

🛰️ Space & Geospatial

Application: Satellite image classification, deforestation detection, urban mapping

• 2D CNNs + image tiling → classify scenes
• FCNs for segmenting coastlines, fields, roads
• Use with multispectral and infrared bands

Datasets: BigEarthNet, SpaceNet, Sentinel-2

🛒 Retail & E-commerce

Application: Product tagging, duplicate detection, visual search

• Classify style, brand, category using product photos
• Recommend visually similar items using embeddings from pretrained CNNs

Use: Amazon, Alibaba, Etsy AI

🎨 Art & Creativity

Application: Style transfer, generative art, neural filters

• Use VGGNet feature maps for neural style transfer
• Modify content image to "paint" in style of Monet, Van Gogh
• GAN + CNN hybrids generate surreal art and textures

Libraries: torchvision.models.vgg19, fast-style-transfer, RunwayML

📚 Case Study Highlight

"How a CNN Beat Radiologists on Lung Cancer Detection"
Google Health trained 3D CNNs on low-dose CT scans
Outperformed average radiologist sensitivity
Grad-CAM and saliency maps explained focus on nodules and tissue anomalies

🧠 Ethical & Practical Reflections

• 🔍 Interpretability is key for healthcare and legal accountability
• ⚖️ Bias in training data can propagate inequality
• 📈 Real-world deployment = inference speed + hardware constraints + reliability

💡 Design Ideas

• AI Microscope: overlay CNN predictions on pathology slides
• Street View Analyzer: real-time urban scene segmentation
• AI Curator: recommend artwork based on style similarity

🧠 Quiz & Reflection

1. How does CNN interpretability affect trust in medical AI?
2. What challenges arise when applying CNNs to satellite data?
3. How could you use a pretrained CNN in a fashion e-commerce pipeline?

🔬 🔟 Research Frontiers

Welcome to the Research Frontiers — the bleeding edge of visual intelligence, where we rethink what it means for machines to “see.”

These innovations push beyond traditional CNNs, exploring new paradigms, learning strategies, and architectural designs to solve the limits of scale, structure, and efficiency.

🧠 Capsule Networks (CapsNets)

• Inventor: Geoffrey Hinton
• Problem Solved: CNNs lose spatial hierarchies (e.g., misplaced parts still yield high confidence)

Key Idea: Use capsules — groups of neurons that encode pose, orientation, scale of features.

• Routing-by-agreement instead of max pooling
• Better generalization with fewer samples

Paper: “Dynamic Routing Between Capsules” (2017)

🧠 Vision Transformers (ViT)

Replaces CNNs with self-attention mechanisms from NLP.
Images are split into patches and fed as sequential tokens.

• Uses position embeddings to retain spatial info
• Directly captures global context
• Scales well with massive datasets

Frameworks: timm, vit-pytorch, transformers

Paper: “An Image is Worth 16x16 Words” (2020)

🔄 Neural Architecture Search (NAS)

Lets machines automatically design neural networks using:

• Reinforcement Learning (e.g., NASNet)
• Evolutionary Algorithms (e.g., AmoebaNet)
• Gradient-Based Search (e.g., DARTS)

Leads to architectures like EfficientNet that balance accuracy, latency, and size.

Tools: AutoKeras, NNI, Google Vizier

🔁 Hybrid CNN–RNN Architectures

Combine CNNs for spatial feature extraction with RNNs or Transformers for temporal/sequential understanding.

Alternatives: CNN + Transformer fusion, Temporal CNNs, Spatiotemporal models

📘 Paper Highlights

🧠 Emerging Concepts

• MLP-Mixers: Fully MLP-based architectures (no conv or attention)
• ConvNeXt: CNNs reimagined with Transformer-style tricks
• GNN + CNN hybrids: Combine relational graphs with local vision

🔬 Future Vision

• Bio-CNNs: architectures inspired by visual neuroscience
• Neuro-symbolic hybrids: deep learning + logic reasoning
• Energy-efficient AI: quantization, pruning, edge-aware CNNs

🧠 Quiz & Research Thinking

1. How do CapsNets address viewpoint variance better than CNNs?
2. What are the trade-offs between Vision Transformers and CNNs?
3. Which research idea is best for CNNs on real-time embedded devices?

🧰 1️⃣1️⃣️ Ecosystem & Tools

Now we arrive at Ecosystem & Tools, the practical powerhouse that makes building, training, debugging, and deploying CNNs seamless and scalable. This is your CNN toolbox — fully stocked for real-world projects.

🔧 Core Libraries

📦 Code Templates

🐣 Train CNN on CIFAR-10 (PyTorch)

import torchvision
import torchvision.transforms as transforms

# Data
transform = transforms.Compose([transforms.ToTensor()])
trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

# Model
model = torchvision.models.resnet18(num_classes=10)
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

# Training loop
for images, labels in trainloader:
    outputs = model(images)
    loss = criterion(outputs, labels)
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

🌸 Fine-Tune ResNet for Flowers

from torchvision import models

model = models.resnet50(pretrained=True)
for param in model.parameters():
    param.requires_grad = False

model.fc = nn.Linear(2048, num_classes)

# Train only final layer
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

🔥 Grad-CAM Visualization Kit

pip install grad-cam

from pytorch_grad_cam import GradCAM
target_layer = model.layer4[-1]
cam = GradCAM(model=model, target_layers=[target_layer])
heatmap = cam(input_tensor=img_tensor)

Use OpenCV to overlay:

overlay = cv2.addWeighted(original_image, 0.6, heatmap, 0.4, 0)

📈 Visualization Tools

• TensorBoard: visualize scalars, histograms, images
• wandb.init(project="cnn-training"): logs everything
• Netron: view model architectures interactively
• TorchLens: inspect layer-wise computations and outputs

🧠 Bonus Tools

🚀 From Notebook to Production

• Convert PyTorch → TorchScript or ONNX
• TensorFlow → TFLite or TF Serving
• Use Triton, TensorRT, or OpenVINO for deployment speed

🧠 Quiz & DIY Tasks

1. How does torchvision.transforms simplify preprocessing?
2. What is the benefit of freezing parameters during fine-tuning?
3. Set up a full pipeline: CIFAR-10 → ResNet18 → Grad-CAM → wandb log