import torch
import torchvision
import torchvision.transforms as transforms

from torch.utils.data import Dataset, DataLoader, SubsetRandomSampler

class FashionMNIST(Dataset):
    def __init__(self):
        self.data = torchvision.datasets.FashionMNIST(root='./',
                                            download=True,
                                            train=True,
                                            transform=transforms.Compose([transforms.ToTensor()]))
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        image, label = self.data[idx]
        return image.reshape(-1), label

class ScrambledFashionMNIST(Dataset):
    def __init__(self):
        self.data = torchvision.datasets.FashionMNIST(root='./',
                                            download=True,
                                            train=True,
                                            transform=transforms.Compose([transforms.ToTensor()]))
        
        self.permutation = torch.randperm(len(self.data[0][0].view(-1)))

    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        image, label = self.data[idx]
        # scramble the image
        image = image.reshape(-1)
        image = image[self.permutation]
        return image, label

dataset = FashionMNIST()
scrambled_dataset = ScrambledFashionMNIST()

# visualize example images from both datasets
import matplotlib.pyplot as plt
idx = 365
image, label = dataset[idx]
scrambled_image, scrambled_label = scrambled_dataset[idx]

plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.imshow(image.reshape(28, 28).numpy(), 'gray')
plt.axis(False)
plt.title('Image of class {}'.format(label))
plt.subplot(122)
plt.imshow(scrambled_image.reshape(28, 28).numpy(), 'gray')
plt.axis(False)
plt.title('Image of class {}'.format(scrambled_label))

Text(0.5, 1.0, 'Image of class 1')

import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import numpy as np

from tqdm import tqdm

class ThreeLayerMLP(nn.Module):
    def __init__(self, input_dim, h1, h2, output_dim, activation_fn):
        super().__init__()
        self.fc1 = nn.Linear(input_dim, h1) # first fully-connected layer
        self.fc2 = nn.Linear(h1, h2) # second fully-connected layer
        self.fc3 = nn.Linear(h2, output_dim) # output layer
        self.activation = activation_fn

    def forward(self, x):
        x = self.activation(self.fc1(x)) # first layer
        x = self.activation(self.fc2(x)) # second layer
        z = self.fc3(x) # output layer
        return z

def training_loop(model, criterion, optimizer, n_epochs, train_loader, val_loader):
    loss_values, train_accuracies, val_accuracies = [], [], []
    for n in tqdm(range(n_epochs)):
        epoch_loss, epoch_acc = 0, 0
        for x_batch, y_batch in train_loader:
            # zero out gradients
            optimizer.zero_grad()
            # pass batch to model
            predictions = model(x_batch)
            # calculate loss
            loss = criterion(predictions, y_batch)
            # backpropagate and update
            loss.backward() # backprop
            optimizer.step()
            # logging to update epoch_loss (add loss value) and epoch_acc (add current batch accuracy)
            epoch_loss += loss.item()
            epoch_acc += multiclass_model_accuracy(model, x_batch, y_batch)
    
        loss_values.append(epoch_loss/len(train_loader))
        train_accuracies.append(epoch_acc/N_train)
        # validation performance
        val_acc = 0
        for x_batch, y_batch in val_loader:
            # don't compute gradients since we are only evaluating the model
            with torch.no_grad():
                # validation batch accuracy
                val_acc += multiclass_model_accuracy(model, x_batch, y_batch)
        val_accuracies.append(val_acc/N_val)
    return model, loss_values, train_accuracies, val_accuracies

def multiclass_model_accuracy(model, input_data, labels):
    predictions = model(input_data) # no need to squeeze/unsqueeze dimensions now!
    predicted_classes = torch.argmax(predictions, dim=1) # find highest scoring class along the columns
    n_correct = torch.sum(torch.eq(predicted_classes, labels))
    return n_correct

# set up data
N = 1000
N_train = 600
N_val = 300
N_test = 100
dataset = FashionMNIST()
scrambled_dataset = ScrambledFashionMNIST()
indices = np.random.choice(np.arange(len(dataset)), size=N, replace=False)
np.random.shuffle(indices)
train_indices = indices[:N_train]
val_indices = indices[N_train:N_train+N_val]
test_indices = indices[N_train+N_val:N_train+N_val+N_test]

# create separate dataloaders for regular and scrambled datasets, but they still use the same images!
batch_size = 8
train_loader = DataLoader(dataset, batch_size=batch_size, sampler=SubsetRandomSampler(train_indices))
val_loader = DataLoader(dataset, batch_size=batch_size, sampler=SubsetRandomSampler(val_indices))
test_loader = DataLoader(dataset, batch_size=N_test, sampler=SubsetRandomSampler(test_indices))
scrambled_train_loader = DataLoader(scrambled_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(train_indices))
scrambled_val_loader = DataLoader(scrambled_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(val_indices))
scrambled_test_loader = DataLoader(scrambled_dataset, batch_size=N_test, sampler=SubsetRandomSampler(test_indices))

# initialize model for each dataset
input_dim = 784 # dimension of images after being vectorized
h1 = 128
h2 = 64
output_dim = 10 # number of classes
activation_fn = nn.ReLU()
model = ThreeLayerMLP(input_dim, h1, h2, output_dim, activation_fn)
scrambled_model = ThreeLayerMLP(input_dim, h1, h2, output_dim, activation_fn)

# initialize loss function and optimizers for each dataset
criterion = nn.CrossEntropyLoss()
lr = 1e-3
optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.99, weight_decay=1e-4)
scrambled_optimizer = torch.optim.SGD(scrambled_model.parameters(), lr=lr, momentum=0.99, weight_decay=1e-4)

# train each model on their respective datasets
n_epochs = 300
model, losses, train_accs, val_accs = training_loop(model, criterion, optimizer, n_epochs, train_loader, val_loader)
scrambled_model, s_losses, s_train_accs, s_val_accs = training_loop(scrambled_model, criterion, scrambled_optimizer,
                                                                    n_epochs, scrambled_train_loader, scrambled_val_loader)

# original dataset results
plt.figure(figsize=(12,6))
plt.subplot(131)
plt.semilogy(losses)
plt.grid(True)
plt.title('Loss values (Original)')
plt.xlabel('Epoch')
plt.subplot(132)
plt.plot(train_accs)
plt.grid(True)
plt.title('Training Accuracy (Original)')
plt.xlabel('Epoch')
plt.subplot(133)
plt.plot(val_accs)
plt.grid(True)
plt.title('Validation Accuracy (Original)')
plt.xlabel('Epoch')

# scrambled dataset results
plt.figure(figsize=(12,6))
plt.subplot(131)
plt.semilogy(s_losses)
plt.grid(True)
plt.title('Loss values (Scrambled)')
plt.xlabel('Epoch')
plt.subplot(132)
plt.plot(s_train_accs)
plt.grid(True)
plt.title('Training Accuracy (Scrambled)')
plt.xlabel('Epoch')
plt.subplot(133)
plt.plot(s_val_accs)
plt.grid(True)
plt.title('Validation Accuracy (Scrambled)')
plt.xlabel('Epoch')

  0%|                                                                                                                                                                             | 0/300 [00:00<?, ?it/s]

  0%|▌                                                                                                                                                                    | 1/300 [00:00<02:06,  2.37it/s]

  1%|█                                                                                                                                                                    | 2/300 [00:00<01:56,  2.56it/s]

  1%|█▋                                                                                                                                                                   | 3/300 [00:01<01:50,  2.68it/s]

  1%|██▏                                                                                                                                                                  | 4/300 [00:01<01:55,  2.56it/s]

  2%|██▊                                                                                                                                                                  | 5/300 [00:01<01:50,  2.66it/s]

  2%|███▎                                                                                                                                                                 | 6/300 [00:02<01:59,  2.45it/s]

  2%|███▊                                                                                                                                                                 | 7/300 [00:02<01:59,  2.46it/s]

  3%|████▍                                                                                                                                                                | 8/300 [00:03<01:59,  2.45it/s]

  3%|████▉                                                                                                                                                                | 9/300 [00:03<01:55,  2.52it/s]

for x,y in test_loader:
    print(y)

normal_FashionMNIST_test_inputs, normal_FashionMNIST_test_labels     = next(iter(test_loader))
shuffled_FashionMNIST_test_inputs, shuffled_FashionMNIST_test_labels = next(iter(scrambled_test_loader))

print("Model trained on standard dataset evaluating the standard dataset: " + str(multiclass_model_accuracy(model,   normal_FashionMNIST_test_inputs,   normal_FashionMNIST_test_labels).data.item()) + "%")
print("Model trained on shuffled dataset evaluating the shuffled dataset: " + str(multiclass_model_accuracy(scrambled_model, shuffled_FashionMNIST_test_inputs, shuffled_FashionMNIST_test_labels).data.item()) + "%")
print("Model trained on standard dataset evaluating the shuffled dataset: " + str(multiclass_model_accuracy(model,   shuffled_FashionMNIST_test_inputs,   shuffled_FashionMNIST_test_labels).data.item()) + "%")
print("Model trained on shuffled dataset evaluating the standard dataset: " + str(multiclass_model_accuracy(scrambled_model, normal_FashionMNIST_test_inputs, normal_FashionMNIST_test_labels).data.item()) + "%")

tensor([7, 5, 1, 5, 4, 9, 0, 2, 5, 5, 9, 1, 0, 4, 3, 8, 8, 5, 4, 5, 5, 5, 8, 9,
        4, 1, 2, 1, 3, 1, 0, 6, 1, 0, 7, 3, 5, 3, 4, 2, 9, 2, 3, 5, 9, 5, 3, 0,
        3, 9, 3, 5, 1, 2, 4, 0, 7, 5, 4, 8, 8, 0, 6, 8, 9, 8, 2, 0, 8, 4, 9, 8,
        6, 6, 8, 9, 1, 2, 3, 2, 0, 5, 5, 2, 2, 5, 8, 9, 7, 8, 3, 8, 3, 1, 0, 0,
        2, 5, 0, 9])
Model trained on standard dataset evaluating the standard dataset: 78%
Model trained on shuffled dataset evaluating the shuffled dataset: 75%
Model trained on standard dataset evaluating the shuffled dataset: 11%
Model trained on shuffled dataset evaluating the standard dataset: 13%

class ShiftedFashionMNIST(Dataset):
    def __init__(self, n=0, m=0):
        self.n = n  # Shift right
        self.m = m  # Shift down
        self.data = torchvision.datasets.FashionMNIST(
            root='./',
            download=True,
            train=True,
            transform=transforms.ToTensor()
        )
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx): #Doing a zero-padded shift
        image, label = self.data[idx]  # image: [1, 28, 28]
        _, H, W = image.shape

        # Create a zero image
        shifted_image = torch.zeros_like(image)

        # Compute new ranges based on shift
        y_start = self.m
        x_start = self.n
        y_end = H
        x_end = W

        # Fill the new image with shifted values from the original image
        shifted_image[:, y_start:y_end, x_start:x_end] = image[:, 0:H - self.m, 0:W - self.n]

        return shifted_image.reshape(-1), label

shifted_dataset = ShiftedFashionMNIST(2, 0)
    
shifted_train_loader = DataLoader(shifted_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(train_indices))
shifted_val_loader = DataLoader(shifted_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(val_indices))
shifted_test_loader = DataLoader(shifted_dataset, batch_size=N_test, sampler=SubsetRandomSampler(test_indices))

# visualize example images from original and shifted datasets
import matplotlib.pyplot as plt
idx = 365
image, label = dataset[idx]
shifted_image, shifted_label = shifted_dataset[idx]

plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.imshow(image.reshape(28, 28).numpy(), 'gray')
plt.axis(False)
plt.title('Image of class {}'.format(label))
plt.subplot(122)
plt.imshow(shifted_image.reshape(28, 28).numpy(), 'gray')
plt.axis(False)
plt.title('Image of class {}'.format(shifted_label))

Text(0.5, 1.0, 'Image of class 1')

shifted_FashionMNIST_test_inputs, shifted_FashionMNIST_test_labels = next(iter(shifted_test_loader))
print("Model trained on standard dataset evaluating the shifted dataset: " + str(multiclass_model_accuracy(model,   shifted_FashionMNIST_test_inputs,   shifted_FashionMNIST_test_labels).data.item()) + "%")

Model trained on standard dataset evaluating the shifted dataset: 57%

import cv2
import numpy as np
import matplotlib.pyplot as plt

# Step 1: Load image
image = cv2.imread('img/dog.jpeg')
if image is None:
    raise FileNotFoundError("Image not found. Please check the path.")

# Step 2: Convert to grayscale
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# Step 3: Define a convolutional kernel
# # Example: #3d "raised effect"  
# kernel = np.array([[-2, -1, 0], 
#                    [-1,  1, 1],
#                    [ 0,  1, 2]])
# Example: Outline/laplacian 
kernel = np.array([[1,  1, 1],
                   [1, -8, 1],
                   [1,  1, 1]])
# Step 4: Apply convolution using cv2.filter2D
convolved = cv2.filter2D(gray, -1, kernel)

# Normalize to 0–255 for display
norm_convolved = cv2.normalize(convolved, None, 0, 255, cv2.NORM_MINMAX)

# Convert to uint8 (for proper display)
norm_convolved = np.uint8(norm_convolved)

# Step 5: Show original and convolved images side by side
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.title("Original Grayscale")
plt.imshow(gray, cmap='gray')
plt.axis('off')

plt.subplot(1, 2, 2)
plt.title("After Convolution")
plt.imshow(convolved, cmap='gray_r')
plt.axis('off')

plt.tight_layout()
plt.show()

import torch
import torch.nn as nn

class FiveLayerCNN(nn.Module):
    def __init__(self, in_channels, n_classes):
        super().__init__()
        self.conv1 = nn.Conv2d(in_channels=in_channels, out_channels=16, kernel_size=3, padding=1, stride=1, bias=False)
        self.conv2 = nn.Conv2d(in_channels=16, out_channels=16, kernel_size=3, padding=1, stride=1, bias=False)
        self.conv3 = nn.Conv2d(in_channels=16, out_channels=32, kernel_size=5, padding=2, stride=1, bias=False)
        self.conv4 = nn.Conv2d(in_channels=32, out_channels=32, kernel_size=5, padding=2, stride=1, bias=False)
        self.conv5 = nn.Conv2d(in_channels=32, out_channels=64, kernel_size=3, padding=1, stride=1, bias=False)
        self.pooling = nn.MaxPool2d(kernel_size=2, stride=2) # max pooling layer
        self.global_pooling = nn.AdaptiveAvgPool2d(output_size=(1, 1)) # global pooling layer
        self.activation_fn = nn.ReLU()
        self.fc = nn.Linear(64, n_classes, bias=True)

    def forward(self, x):
        print('Input is shape: {}'.format(x.shape))
        B = x.size(0) # B is the batch size or number of examples passed to the model
        x = self.activation_fn(self.conv1(x))
        x = self.activation_fn(self.conv2(x))
        z1 = self.pooling(x)
        z1 = self.activation_fn(self.conv3(z1))
        z1 = self.activation_fn(self.conv4(z1)) 
        z2 = self.pooling(z1)
        z2 = self.activation_fn(self.conv5(z2))
        z3 = self.global_pooling(z2).view(B, -1) # make sure feature maps for each input image are vectorized
        z4 = self.fc(z3)
        print('Result after max pooling stage 1 is shape: {}'.format(z1.shape))
        print('Result after max pooling stage 2 is shape: {}'.format(z2.shape))
        print('Result after global average pooling is shape: {}'.format(z3.shape))
        print('Result after global average pooling is shape: {}'.format(z4.shape))
        return z4

in_channels = 3
n_classes = 5
model = FiveLayerCNN(in_channels, n_classes)
print(model)

B = 2 # batch size
H, W = 28, 28
input_data = torch.rand(B, in_channels, H, W)
with torch.no_grad():
    class_scores = model(input_data)

print('Conv 1 Parameters: {}'.format(torch.numel(model.conv1.weight)))
print('Conv 2 Parameters: {}'.format(torch.numel(model.conv2.weight)))
print('Conv 3 Parameters: {}'.format(torch.numel(model.conv3.weight)))
print('Conv 4 Parameters: {}'.format(torch.numel(model.conv4.weight)))
print('Conv 5 Parameters: {}'.format(torch.numel(model.conv5.weight)))
print('Fully Connected Parameters: {}'.format(torch.numel(model.fc.weight)+torch.numel(model.fc.bias)))

FiveLayerCNN(
  (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (conv2): Conv2d(16, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (conv3): Conv2d(16, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), bias=False)
  (conv4): Conv2d(32, 32, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2), bias=False)
  (conv5): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)
  (pooling): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (global_pooling): AdaptiveAvgPool2d(output_size=(1, 1))
  (activation_fn): ReLU()
  (fc): Linear(in_features=64, out_features=5, bias=True)
)
Input is shape: torch.Size([2, 3, 28, 28])
Result after max pooling stage 1 is shape: torch.Size([2, 32, 14, 14])
Result after max pooling stage 2 is shape: torch.Size([2, 64, 7, 7])
Result after global average pooling is shape: torch.Size([2, 64])
Result after global average pooling is shape: torch.Size([2, 5])
Conv 1 Parameters: 432
Conv 2 Parameters: 2304
Conv 3 Parameters: 12800
Conv 4 Parameters: 25600
Conv 5 Parameters: 18432
Fully Connected Parameters: 325

# fill this in!
class MyCNNModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1, bias=False)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1, bias=False)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=1, padding=1, bias=False)
        self.pooling = nn.MaxPool2d(stride=2, kernel_size=2)
        self.gap = nn.AdaptiveAvgPool2d((1, 1))
        self.activation = nn.ReLU()
        self.fc = nn.Linear(128, 10)
    
    def forward(self, x):
        B = x.size(0)
        x = self.activation(self.conv1(x))
        x = self.pooling(x)
        x = self.activation(self.conv2(x))
        x = self.pooling(x)
        x = self.activation(self.conv3(x))
        x = self.gap(x).view(B, -1)
        z = self.fc(x)
        return z

# 2D version of Fashion MNIST datasets
class FashionMNIST2D(Dataset):
    def __init__(self):
        self.data = torchvision.datasets.FashionMNIST(root='./',
                                            download=True,
                                            train=True,
                                            transform=transforms.Compose([transforms.ToTensor()]))
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        image, label = self.data[idx]
        return image, label

import numpy as np

# set up data
N = 1000
N_train = 600
N_val = 300
N_test = 100
dataset = FashionMNIST2D()
indices = np.random.choice(np.arange(len(dataset)), size=N, replace=False)
np.random.shuffle(indices)
train_indices = indices[:N_train]
val_indices = indices[N_train:N_train+N_val]
test_indices = indices[N_train+N_val:N_train+N_val+N_test]

# create separate dataloaders for regular and scrambled datasets, but they still use the same images!
batch_size = 8
train_loader = DataLoader(dataset, batch_size=batch_size, sampler=SubsetRandomSampler(train_indices))
val_loader = DataLoader(dataset, batch_size=batch_size, sampler=SubsetRandomSampler(val_indices))

# initialize model for each dataset
model = MyCNNModel()

# initialize loss function and optimizers for each dataset
criterion = nn.CrossEntropyLoss()
lr = 3e-3
optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=0.99, weight_decay=1e-4)

# train each model on their respective datasets
n_epochs = 300
model, losses, train_accs, val_accs = training_loop(model, criterion, optimizer, n_epochs, train_loader, val_loader)

# original dataset results
plt.figure(figsize=(12,6))
plt.subplot(131)
plt.semilogy(losses)
plt.grid(True)
plt.title('Loss values (Original)')
plt.xlabel('Epoch')
plt.subplot(132)
plt.plot(train_accs)
plt.grid(True)
plt.title('Training Accuracy (Original)')
plt.xlabel('Epoch')
plt.subplot(133)
plt.plot(val_accs)
plt.grid(True)
plt.title('Validation Accuracy (Original)')
plt.xlabel('Epoch')

  0%|                                                                                                                                                                             | 0/300 [00:00<?, ?it/s]

  0%|▌                                                                                                                                                                    | 1/300 [00:02<11:57,  2.40s/it]

  1%|█                                                                                                                                                                    | 2/300 [00:04<11:46,  2.37s/it]

  1%|█▋                                                                                                                                                                   | 3/300 [00:07<12:24,  2.51s/it]

  1%|██▏                                                                                                                                                                  | 4/300 [00:09<12:12,  2.47s/it]

  2%|██▊                                                                                                                                                                  | 5/300 [00:12<12:28,  2.54s/it]

  2%|███▎                                                                                                                                                                 | 6/300 [00:15<12:35,  2.57s/it]

  2%|███▊                                                                                                                                                                 | 7/300 [00:17<12:36,  2.58s/it]

  3%|████▍                                                                                                                                                                | 8/300 [00:20<13:03,  2.68s/it]

  3%|████▉                                                                                                                                                                | 9/300 [00:23<13:23,  2.76s/it]

class ShiftedFashionMNIST2D(Dataset):
    def __init__(self, n=0, m=0):
        self.n = n  # Shift right
        self.m = m  # Shift down
        self.data = torchvision.datasets.FashionMNIST(
            root='./',
            download=True,
            train=True,
            transform=transforms.ToTensor()
        )
        
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx): #Doing a zero-padded shift
        image, label = self.data[idx]  # image: [1, 28, 28]
        _, H, W = image.shape

        # Create a zero image
        shifted_image = torch.zeros_like(image)

        # Compute new ranges based on shift
        y_start = self.m
        x_start = self.n
        y_end = H
        x_end = W

        # Fill the new image with shifted values from the original image
        shifted_image[:, y_start:y_end, x_start:x_end] = image[:, 0:H - self.m, 0:W - self.n]

        return shifted_image, label

shifted2D_dataset = ShiftedFashionMNIST2D(2, 0)
    
shifted2D_train_loader = DataLoader(shifted2D_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(train_indices))
shifted2D_val_loader = DataLoader(shifted2D_dataset, batch_size=batch_size, sampler=SubsetRandomSampler(val_indices))
shifted2D_test_loader = DataLoader(shifted2D_dataset, batch_size=N_test, sampler=SubsetRandomSampler(test_indices))

shifted_FashionMNIST2D_test_inputs, shifted_FashionMNIST2D_test_labels = next(iter(shifted2D_test_loader))
print("CNN model trained on standard dataset evaluating the shifted dataset: " + str(multiclass_model_accuracy(model,   shifted_FashionMNIST2D_test_inputs,   shifted_FashionMNIST2D_test_labels).data.item()) + "%")

CNN model trained on standard dataset evaluating the shifted dataset: 70%

Lecture 15 - Convolutional neural networks¶

ECE364 - Programming Methods for Machine Learning¶

Nickvash Kani¶

Slides based off prior lectures by Alex Schwing, Aigou Han, Farzad Kamalabadi, Corey Snyder. All mistakes are my own!¶

Recap of multi-layer perceptrons (MLPs)¶

Problems with Straight MLPs¶

Convolutional Layers¶

Fully connected layers:¶

Locally connected layers:¶

Convolutional layers:¶

What is convolution?¶

You've seen convolution before:¶

Convolutional neural networks¶

Visual example¶

Example of what convolutional does¶

Pooling Layers¶

Classification Heads¶

Summary of Common CNN Structure for Classification¶

Examining a Small CNN¶

Revisiting Fashion MNIST¶

That's it for today¶

References¶