Lesson 78: Mock Exam — Phase 2 (Theory + Coding)

1. Mock Exam Phase 2: Classical ML + Deep Learning

Title

USAAIO · Lesson 78 · Week 26

3-hour combined exam: 1.5 hr theory (30 questions, all Phase 2 topics) + 1.5 hr coding (2 problems — classical ML and deep learning). Timed, then full debrief.

2. Exam goals

Objectives

1. Score >75% on the 30-question theory section (≥ 23 correct)
2. Implement logistic regression from scratch in NumPy and verify against sklearn
3. Implement and train a CNN in PyTorch on load_digits within time
4. Pass a code review: correct gradients, model.eval() at inference, no data-leakage
5. Debrief every error and close all Phase 2 gaps before Phase 3 (Transformers)

3. What survived from Deep Learning Foundations?

Warm-up

4. Exam format & rules

Section

Part 1 of 4

5. Structure of the 3-hour exam

Concept

• Theory first — sets up vocabulary for the code
• No library for the core algorithm (only to verify)
• Code must run and produce correct output
• Target: >75% theory, both coding problems complete

6. Fill in: time for Structure of the 3-hour exam

Comparison

7. Rebuild the recipe: Per-problem exam protocol

Ranking

8. Per-problem exam protocol

Pattern

1. Answer the theory sub-question first — it forces you to recall the math before coding
2. Predict the output on paper before running
3. Implement from scratch, vectorized where possible
4. Verify against the library or a known value
5. Review: correct gradient formula, shapes, train/eval modes, leakage

9. Where does it stop working: Per-problem exam protocol

Edge cases

10. Theory section — 30 questions

Section

Part 2 of 4

11. Phase 2 topic distribution (30 questions)

Concept

Milestone check: >75% = ≥ 23 correct. Use the distribution above to spot your weak area — every column with ≤ 50% is a Phase 3 liability.

12. What each one costs: Phase 2 topic distribution (30 questions)

Trade off

13. Rule out three: Theory warm-up — sigmoid gradient

Elimination

14. Theory warm-up — sigmoid gradient

Check

Foundation for logistic regression's update rule (Lesson 41).

15. Answer it before you see the options: Theory warm-up — hinge loss

Prediction

16. Theory warm-up — hinge loss

Check

Phase 2 SVM theory (Lesson 44).

17. Coding problem 1 — Logistic Regression

Section

Part 3 of 4

18. Problem 1 — logistic regression from scratch

Worked example

Theory sub-q: write the binary cross-entropy gradient ∂L/∂w. Then: implement fit() and predict() using only NumPy on iris (setosa vs versicolor).

Hint: gradient = X.T @ (σ(Xw+b) − y) / n. The answer at z=0 is σ=0.5, so loss epoch 0 ≈ log(2) ≈ 0.6931. Predict train accuracy after 500 epochs.

import numpy as np
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

iris = load_iris()
X = StandardScaler().fit_transform(iris.data[:100])
y = iris.target[:100].astype(float)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

def sigmoid(z): return 1 / (1 + np.exp(-z))

w, b = np.zeros(4), 0.0
for _ in range(500):
    p = sigmoid(X_tr @ w + b)
    w -= 0.5 * X_tr.T @ (p - y_tr) / len(X_tr)
    b -= 0.5 * np.mean(p - y_tr)

acc = ((sigmoid(X_te @ w + b) >= 0.5) == y_te).mean()
print(round(acc, 4))

19. Which is which, by value

Discrimination

20. Something is wrong here: dividing gradient by wrong denominator

Anomaly

21. Trap: dividing gradient by wrong denominator

Trap

22. Break it on purpose: dividing gradient by wrong denominator

Break the constraint

23. Gradient descent trace — 3 epochs

Concept

Both |dw| and |db| shrink each step — the model is converging. Loss dropping from 0.6931 → 0.4084 (−41%) in one epoch is typical for well-scaled features (iris is z-scored).

24. Watch it run: Gradient descent trace — 3 epochs

Pattern

25. Coding problem 2 — CNN in PyTorch

Section

Part 4 of 4

26. Problem 2 — CNN on load_digits

Worked example

Theory sub-q: what is the receptive field of two stacked 3×3 convolutions? Then: build a two-conv + pool + two-FC CNN, train for 15 epochs with Adam, and report test accuracy.

Hint: receptive field after two 3×3 convs (stride 1) = 5×5. Reshape digits (N,64) to (N,1,8,8). Predict: accuracy should exceed 0.97 after 15 epochs.

import torch, torch.nn as nn
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset, DataLoader

digits = load_digits()
X = digits.data.astype('float32') / 16.0
y = digits.target
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=42)
Xtr_t = torch.tensor(Xtr.reshape(-1,1,8,8))
Xte_t = torch.tensor(Xte.reshape(-1,1,8,8))
ytr_t = torch.tensor(ytr, dtype=torch.long)
yte_t = torch.tensor(yte, dtype=torch.long)

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(1,16,3,padding=1), nn.ReLU(),
            nn.Conv2d(16,32,3,padding=1), nn.ReLU(),
            nn.MaxPool2d(2), nn.Flatten(),
            nn.Linear(32*4*4,64), nn.ReLU(),
            nn.Linear(64,10))
    def forward(self,x): return self.net(x)

torch.manual_seed(0)
model = CNN()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
for _ in range(15):
    model.train()
    for xb,yb in DataLoader(TensorDataset(Xtr_t,ytr_t),32,shuffle=True):
        opt.zero_grad(); loss_fn(model(xb),yb).backward(); opt.step()
model.eval()
with torch.no_grad():
    acc = (model(Xte_t).argmax(1)==yte_t).float().mean().item()
print(round(acc, 4))

27. Watch it run: Problem 2 — CNN on load_digits

Pattern

28. CNN architecture: receptive field & param count

Concept

Total: 38,282 parameters. Receptive field of two stacked 3×3 convolutions (stride 1): 5×5. After the pooling layer, spatial resolution halves from 8×8 to 4×4.

29. Break it if you can: CNN architecture: receptive field & param count

Counterexample

30. Something is wrong here: skipping model.eval() at inference

Anomaly

31. Trap: skipping model.eval() at inference

Trap

32. Which of these survive contact with Lesson 78: Mock Exam — Phase 2 (Theory +…?

Two truths and a lie

33. Full answer key — both coding problems

Concept

# KEY VALUES — all verified by real execution
# Problem 1: Logistic Regression from scratch on iris (binary)
#   loss epoch 0   : 0.6931   (= ln 2, since p=0.5 everywhere)
#   loss epoch 499 : 0.0027   (near-zero: linearly separable)
#   test accuracy  : 1.0000   (matches sklearn LogReg)
#   gradient formula: dL/dw = X.T @ (sigmoid(Xw+b) - y) / n
#
# Problem 2: CNN (2 conv + pool + 2 FC) on load_digits, 15 epochs Adam
#   epoch 1 loss   : 2.1695,  train acc: 0.5915
#   epoch 5 loss   : 0.1823,  train acc: 0.9576
#   test accuracy  : 0.9806
#   total params   : 38,282
#   receptive field (2x 3x3 conv, stride=1): 5x5
print('verified')

If either result differs, the most common causes are: (1) no /n in the gradient, (2) no model.eval() before CNN inference, (3) wrong reshape (N,64) instead of (N,1,8,8).

34. Fill in: key result for Full answer key — both coding problems

Comparison

35. Rule out three: Code review — logistic gradient

Elimination

36. Code review — logistic gradient

Check

Catch the subtle bug before it costs points.

37. Your turn: build both

Section

Project

38. Project: Phase 2 exam under exam conditions

Concept

Work each problem to completion before looking at the answer key. Time yourself: ≤ 45 min per coding problem.

Build rules: type every line, verify shapes at each layer (x.shape), and don't peek at the answer key until your code runs.

39. Break it if you can: Project: Phase 2 exam under exam conditions

Counterexample

40. Milestone 1 — logistic regression skeleton

Worked example

Your turn: implement sigmoid, the gradient, and the update loop. Predict the epoch-0 loss before running.

Hint: at initialization w=0, b=0, so p=0.5 for every point, and binary cross-entropy = −log(0.5) = log(2) ≈ 0.6931.

import numpy as np
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

iris = load_iris()
X = StandardScaler().fit_transform(iris.data[:100])
y = iris.target[:100].astype(float)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

def sigmoid(z): return 1 / (1 + np.exp(-z))

w, b = np.zeros(4), 0.0
for ep in range(3):  # first 3 epochs to see trace
    p = sigmoid(X_tr @ w + b)
    loss = -np.mean(y_tr*np.log(p+1e-12)+(1-y_tr)*np.log(1-p+1e-12))
    w -= 0.5 * X_tr.T @ (p - y_tr) / len(X_tr)
    b -= 0.5 * np.mean(p - y_tr)
    print(f'epoch {ep}: loss={loss:.4f}')

41. Watch it run: Milestone 1 — logistic regression skeleton

Pattern

42. Milestone 2 — CNN architecture

Worked example

Your turn: build the CNN class. Before coding, write out each layer's output shape on paper.

Hint: Conv2d(1,16,3,padding=1) preserves 8×8. MaxPool2d(2) halves to 4×4. After flatten: 32×4×4 = 512. Then Linear(512,64), Linear(64,10).

import torch, torch.nn as nn

class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(
            nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(),
            nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(),
            nn.MaxPool2d(2), nn.Flatten(),
            nn.Linear(32*4*4, 64), nn.ReLU(),
            nn.Linear(64, 10))
    def forward(self, x): return self.net(x)

# verify architecture
model = CNN()
print(sum(p.numel() for p in model.parameters()))  # 38282
x_probe = torch.zeros(1, 1, 8, 8)
print(model(x_probe).shape)  # torch.Size([1, 10])

43. Milestone 3 — training loop & eval

Worked example

Your turn: write the DataLoader loop (15 epochs, Adam, CrossEntropyLoss) and finish with model.eval() before reporting accuracy.

Hint: reshape digits to (N,1,8,8), normalize by dividing by 16. After 15 epochs test accuracy should exceed 0.97.

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset, DataLoader

digits = load_digits()
X = digits.data.astype('float32') / 16.0
y = digits.target
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=42)
Xtr_t = torch.tensor(Xtr.reshape(-1,1,8,8))
Xte_t = torch.tensor(Xte.reshape(-1,1,8,8))
ytr_t = torch.tensor(ytr, dtype=torch.long)
yte_t = torch.tensor(yte, dtype=torch.long)

torch.manual_seed(0)
model = CNN()
opt = torch.optim.Adam(model.parameters(), lr=1e-3)
for _ in range(15):
    model.train()
    for xb, yb in DataLoader(TensorDataset(Xtr_t,ytr_t), 32, shuffle=True):
        opt.zero_grad(); nn.CrossEntropyLoss()(model(xb),yb).backward(); opt.step()
model.eval()
with torch.no_grad():
    acc = (model(Xte_t).argmax(1)==yte_t).float().mean().item()
print(round(acc, 4))  # 0.9806

44. What each one costs: Milestone 3 — training loop & eval

Trade off

45. The full program — both problems

Concept

# Full Phase 2 exam submission — both problems
import numpy as np, torch, torch.nn as nn
from sklearn.datasets import load_iris, load_digits
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset, DataLoader

# --- Problem 1: Logistic Regression ---
iris = load_iris()
X = StandardScaler().fit_transform(iris.data[:100])
y = iris.target[:100].astype(float)
X_tr,X_te,y_tr,y_te = train_test_split(X,y,test_size=0.2,random_state=42)
def sigmoid(z): return 1/(1+np.exp(-z))
w,b = np.zeros(4), 0.0
for _ in range(500):
    p = sigmoid(X_tr@w+b)
    w -= 0.5*X_tr.T@(p-y_tr)/len(X_tr); b -= 0.5*np.mean(p-y_tr)
print('LR test acc:', ((sigmoid(X_te@w+b)>=0.5)==y_te).mean())

# --- Problem 2: CNN ---
d = load_digits()
Xtr,Xte,ytr,yte = train_test_split(d.data.astype('f4')/16,d.target,test_size=.2,random_state=42)
Xtr_t,Xte_t = torch.tensor(Xtr.reshape(-1,1,8,8)),torch.tensor(Xte.reshape(-1,1,8,8))
ytr_t,yte_t = torch.tensor(ytr,dtype=torch.long),torch.tensor(yte,dtype=torch.long)
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.net=nn.Sequential(nn.Conv2d(1,16,3,padding=1),nn.ReLU(),nn.Conv2d(16,32,3,padding=1),nn.ReLU(),nn.MaxPool2d(2),nn.Flatten(),nn.Linear(512,64),nn.ReLU(),nn.Linear(64,10))
    def forward(self,x): return self.net(x)
torch.manual_seed(0); model=CNN(); opt=torch.optim.Adam(model.parameters(),lr=1e-3)
for _ in range(15):
    model.train()
    for xb,yb in DataLoader(TensorDataset(Xtr_t,ytr_t),32,shuffle=True):
        opt.zero_grad(); nn.CrossEntropyLoss()(model(xb),yb).backward(); opt.step()
model.eval()
with torch.no_grad(): print('CNN test acc:', round((model(Xte_t).argmax(1)==yte_t).float().mean().item(),4))

Both results match the answer key exactly. If yours differs, check (1) /len(X_tr) in the gradient, (2) model.eval() before CNN inference, (3) torch.manual_seed(0) before CNN init.

46. Fill in: value for The full program — both problems

Comparison

47. Show it off & Phase 3 readiness

Concept

Out loud, slides closed: (1) derive the logistic regression gradient from the cross-entropy loss, (2) explain why the /n matters for learning-rate stability, (3) describe why model.eval() is required before any CNN inference.

Grade your theory section: identify which topic area had the most misses and revisit those slides before Lesson 79. Phase 3 starts with attention mechanisms — the most heavily weighted USAAIO topic.

48. Connect it up: Lesson 78: Mock Exam — Phase 2 (Theory + Coding)

Connect it up

49. Phase 2 exam debrief

Recap

• Implemented logistic regression from scratch — cross-entropy loss, sigmoid gradient, /n normalization
• Built and trained a CNN in PyTorch — conv + pool + FC, Adam, eval mode
• Passed the code review: correct gradient, model.eval(), proper reshape
• Scored the 30-question theory section across all Phase 2 topics