Class Schedule

What USAAIO tests, the exam format, and setting up Google Colab.

Numbers, strings, booleans, f-strings. Your first cells.

Comparison operators, if / elif / else, truthiness.

for, range, while, accumulator pattern.

def, arguments, return, local vs global.

Indexing, slicing, key/value lookup, one-line loops.

Timed drill on everything from Python I–V. No notes.

Why arrays beat lists. Creating, inspecting, reshaping.

Element-wise ops, scalar formulas, shape rules.

axis=0/1, sum/mean/max, boolean filtering.

Tables in Python. Label vs position indexing.

The split–apply–combine pattern.

Figures, axes, labels, legends. Reading a chart.

Boxplots, heatmaps, scatter-by-group.

Load → clean → explore → plot, in one notebook.

Vectors as data, length, angle, the dot product as similarity.

Matrix–vector and matrix–matrix multiplication by hand.

When can you undo a matrix? What the determinant measures.

The characteristic equation; vectors that only get scaled.

Why every ML person cares about these two.

Timed drill: decompositions, projections, least squares.

Random variables, expectation, variance, independence.

Priors, likelihoods, posteriors. The spam-filter example.

Estimating parameters from data.

Slope, rate of change, holding variables fixed.

The gradient as a compass; composing derivatives.

Features, labels, train/test split, generalization.

The hypothesis, MSE, and why we square the error.

Derive θ = (XᵀX)⁻¹Xᵀy from scratch.

Implement it in pure NumPy. No sklearn.

Learning rate, convergence, divergence.

From regression to classification.

Derive it by hand — this returns in deep learning.

NumPy implementation + decision boundary plot.

fit / predict / score, pipelines, scaling.

Underfitting vs overfitting; learning curves.

L2 vs L1, and what each does to the weights.

k-fold, hyperparameter search, data leakage.

Distance-based and rule-based models.

Random forests, boosting, margins and kernels.

Accuracy, precision/recall, F1, ROC-AUC, confusion matrix.

The algorithm, the objective, and how it can go wrong.

Implement Lloyd's algorithm in NumPy.

Directions of maximum variance; why we centre the data.

Connect it back to Module 1. Implement from scratch.

Explained variance, choosing k, a t-SNE/UMAP tour.

Timed set: clustering + PCA, by hand and in code.

From logistic regression to a neuron. ReLU, sigmoid, tanh.

Affine layers, hidden units, what depth buys you.

Push real numbers through a 2-layer net on paper.

The chain rule through a network — the core idea.

Compute every gradient on a tiny net. Exam-favourite.

Forward + backward + update, ~60 lines.

Multi-class output, log-sum-exp, numerical stability.

What each one actually does to the update rule.

Tensors, requires_grad, .backward().

The five lines every training loop has.

Dropout, weight decay, early stopping.

Why nets fail to train, and these two fixes.

Reading loss curves; diagnosing over/underfitting live.

Channels, pixels, why an MLP is the wrong tool.

The operation, and what a filter detects.

The formula. Practise until it is automatic — exam staple.

Down-sampling, receptive fields, the conv→pool→fc stack.

Train on MNIST/CIFAR-10 — CPU only, like Round 1.

Squeeze accuracy out of little data and little compute.

AlexNet, VGG, Inception, ResNet: what each contributed.

Time budget, Colab logistics, what to answer first.

Work real past problems together, out loud.

Score it, build the weak-spot list.

Target the math items missed on mock #1.

Target the coding items missed on mock #1.

Harder problems, less scaffolding.

Compare to mock #1. What improved, what didn't.

NumPy/pandas/shape questions under a stopwatch.

One page, from memory. The mental checklist.

Light notebook, confirm proctor + account. Then rest.