Lesson 39: Mock Exam — Phase 1 Coding

Discussion prompt

Before we open Lesson 39: Mock Exam — Phase 1 Coding: without looking back, what was the main idea of Mock Exam — Phase 1 Theory, and what could you do by the end of it that you could not do before?

Hint: One sentence for the idea, one for the skill. If the second one is blank, that is the part to revisit.

Discussion prompt

The USAAIO coding section is timed and runs in Colab. You implement each algorithm from scratch in NumPy — the library is allowed only to verify your answer, never to do the algorithm for you.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Put in order

These are the steps of The per-problem protocol, scrambled. Put them back in order before the next slide shows you.

1. Answer the theory sub-question first — it tells you the formula the code must implement
2. Predict the output before you run (a wrong prediction catches a bug early)
3. Implement from scratch, vectorized where NumPy allows
4. Verify against a known value or the library
5. Review: shapes, edge cases (centering, ddof, fold split), readability

Why: This is the order the recipe itself gives. Recalling the sequence without the slide in front of you is the difference between recognising the method and being able to run it — most of what goes wrong in practice is a step done out of turn.

Comparison matrix

From One running dataset for the derivations: refill the x₁ column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain What PCA is asking by analogy to something with no Machine Learning in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Discussion prompt

Explain Variance lives in the covariance matrix to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Put in order

Put the moves of Build C by hand on the 4-point toy into the order they have to happen.

1. (XᵀX)₁₁ = Σ x₁² = 2² + 0² + (−2)² + 0² = 8
2. (XᵀX)₂₂ = Σ x₂² = 0² + 2² + 0² + (−2)² = 8
3. (XᵀX)₁₂ = Σ x₁x₂ = 2·0 + 0·2 + (−2)·0 + 0·(−2) = 0

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. Column 1 dotted with itself: the squared first coordinates sum to 8.

Comparison matrix

From Build C by hand on the 4-point toy: every row here is a choice with a cost. Fill the by hand column, then say which row you would actually pick and what you give up for it.

Predict first

C is a scalar multiple of the identity — 2.667·I. Every vector is an eigenvector, and every eigenvalue equals 2.667. So the variance is the same in every direction: a symmetric cross of points has no single 'most-spread' axis.

Commit before you compute: what does Eigendecompose C come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.

Correct: Eigenvalue = variance captured by that component

Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. Each eigenvalue λ is the variance of the data projected onto its eigenvector.

Discussion prompt

Work backwards. The example finished here:

Eigenvalue = variance captured by that component

What was it asked to do, and what must it have been given? Reconstruct the problem from its answer.

Hint: Every quantity in the result had to enter somewhere. Account for each one.

Discussion prompt

Run the SVD and convert. Predict first: λ = 2.667 and λ = S²/(n−1), so S² = 3·2.667 = 8, meaning S = √8 ≈ 2.828. And equal eigenvalues ⇒ equal EVR ⇒ [0.5, 0.5].

What do you need to know — or decide — before the first line can be written? List everything the problem has to hand you.

Hint: Anything you would have to invent to get started is a thing the problem must supply.

Predict first

The table runs: 1 | 2 | −2 | −2.0 · 2 | 0 | 0 | 0.0 · 3 | −2 | 2 | 2.0

In Projecting the points onto PC1, given the rows so far: what is the next one — the row where point is 4?

Correct: 4 | 0 | 0 | 0.0

Why: The relationship between the columns, not the individual numbers, is what generates the next row. The two points on the x₁-axis get scores ±2; the two on the x₂-axis project to 0.

Step through it

Step through Projecting the points onto PC1 one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: point is 1
2. Step 2: point is 2
3. Step 3: point is 3
4. Step 4: point is 4

Fill in the blanks

From PCA on digits — full pipeline — one line has had its right-hand side removed. Put it back.

import numpy as np
from sklearn.datasets import load_digits
X = load_digits().data # (1797, 64)
Xc = X - X.mean(0) # center
U, S, Vt = np.linalg.svd(Xc, full_matrices=False)
evr = S2 / np.sum(S2)
k95 = int(np.searchsorted(np.cumsum(evr), 0.95) + 1)
print("EVR top 3 =", evr[:3].round(4))
print("k for 95% =", k95, "of", X.shape[1])

Why: Xc is what everything below it consumes, so the wrong expression here fails later and somewhere else. More than half the pixel dimensions are redundant — the 64-D images live near a 29-D subspace.

Fill in the blanks

Verify against sklearn, with the scaffolding fading: two lines are gone now — fill both.

import numpy as np
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
X = load_digits().data
# from scratch
Xc = X - X.mean(0)
S = np.linalg.svd(Xc, full_matrices=False)[1]
evr_scratch = (S2 / np.sum(S2))[:3].round(4)
# library
evr_sklearn = PCA().fit(X).explained_variance_ratio_[:3].round(4)
print("scratch:", evr_scratch)
print("sklearn:", evr_sklearn)
print("match:", np.allclose(evr_scratch, evr_sklearn))

Why: Reproducing these unaided, rather than reading them, is what tells you the method has transferred. sklearn subtracts the column means internally before its SVD.

Predict first

A student writes this, and it looks reasonable:

PCA is 'just the SVD of the data', so decompose X directly — centering is an extra line I can skip.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: On the shifted toy this returns S₁ = 28.43 and PC1 = [−0.707, −0.707].

Center first — variance is defined as spread around the mean.

Why: On the shifted toy this returns S₁ = 28.43 and PC1 = [−0.707, −0.707]. The top component points toward the data's MEAN (the origin offset), not its spread. Every EVR is wrong — an instant rubric fail.

Discussion prompt

The gradient, then the update rule — before any calculation: what is the plan? Name the moves in order, in plain English, without doing the arithmetic.

Hint: It starts with: Differentiate f(w) = (w − 5)²

Annotate

From The gradient, then the update rule — read this one piece at a time. What is each part doing?

On: \( w \leftarrow w - \eta\, f'(w) = w - \eta\cdot 2(w-5) \)

• Chain rule: d/dw (w−5)² = 2(w−5)·1. The gradient is zero exactly at w = 5, the vertex.
• Gradient descent moves w a small distance −η·f'(w): downhill, because the gradient points uphill. η is the learning rate.
• e.g. at w = 0, f'(0) = 2(0−5) = −10; the update w − η(−10) = w + 10η increases w, marching it toward 5. The sign logic is the heart of the method.

Step through it

Step through Trace the first six steps by hand one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: t is 0
2. Step 2: t is 1
3. Step 3: t is 2
4. Step 4: t is 3
5. Step 5: t is 4
6. Step 6: t is 5

Predict first

Sixty steps drive the 0.8ᵗ gap to essentially zero. Predict w → 5.0 before running:

Commit before you compute: what does Run it to convergence come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.

Correct: w converges to 5.0 — the analytic minimum

Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. The iteration reaches the vertex we found by calculus, confirming the code implements the math.

Fill in the blanks

From Learning-rate sweep — the stability edge — one line has had its right-hand side removed. Put it back.

import numpy as np
grad = lambda w: 2 * (w - 5)
for lr in [0.1, 0.5, 1.0, 1.1]:
w = 0.0
for _ in range(50):
w -= lr * grad(w)
tag = f"___" if abs(w) < 1e6 else f"diverged (___)"
print(f"lr=___ -> w=___")

Why: w is what everything below it consumes, so the wrong expression here fails later and somewhere else. At η = 1 the multiplier is |1 − 2η| = 1, so w bounces 0 → 10 → 0 forever and lands back at 0.

Predict first

A student writes this, and it looks reasonable:

Convergence is slow at η = 0.1, so push it way up to η = 1.1 to finish in fewer steps.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: The step multiplier |1 − 2η| = 1.2 exceeds 1, so every update grows the distance to the minimum.

Stay below the stability bound η < 2/L; tune within it for speed.

Why: The step multiplier |1 − 2η| = 1.2 exceeds 1, so every update grows the distance to the minimum. Bigger is NOT faster past the 2/L bound — it's catastrophic. The loss shoots to infinity.

Comparison matrix

From The problem: refill the the 8 data points column from what you know. The rest of the table is as it appeared.

Discussion prompt

Explain The likelihood we are maximizing to a student a year behind you. No notation, no jargon they have not met — and it still has to be true.

Hint: If your explanation needs a symbol they have never seen, you are describing the notation rather than the idea.

Put in order

Put the moves of Derive μ̂ — differentiate in μ into the order they have to happen.

1. ∂ℓ/∂μ keeps only the squared-error term
2. Set to zero and cancel σ²
3. Solve for μ̂ = the sample mean

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. The log(2πσ²) piece has no μ in it, so it drops.

Draw it

Draw what Derive μ̂ — differentiate in μ just did — the shape of it, not the line-by-line working. One picture, labels only where you need them. Then check it against the steps: anything you could not draw is a step you followed rather than understood.

Put in order

Put the moves of Derive σ̂² — differentiate in σ² into the order they have to happen.

1. ∂ℓ/∂σ² of the two σ²-terms
2. Set to zero, multiply through by 2σ⁴
3. Solve for σ̂² — divide by n

Why: These are the moves of the worked example in the order it makes them, and each one is set up by the one before it. d/dσ² of −½log(2πσ²) is −1/(2σ²); d/dσ² of −(xᵢ−μ)²/(2σ²) is +(xᵢ−μ)²/(2σ⁴).

Draw it

Translate both ways. First write the expression above as a sentence with no symbols in it at all. Then cover it, and write your sentence back as notation. If the two versions disagree, the disagreement is the thing to fix.

Annotate

From Compute the MLEs by hand — read this one piece at a time. What is each part doing?

On: \( \hat\sigma^2 = \frac{32}{8} = 4, \qquad \hat\sigma = \sqrt{4} = 2 \)

• Subtract the mean 5 from each of 2,4,4,4,5,5,7,9.
• Square each deviation and add: 9+1+1+1+0+0+4+16 = 32.

Fill in the blanks

n vs n−1 — verify against NumPy, with the scaffolding fading: two lines are gone now — fill both.

import numpy as np
d = np.array([2., 4., 4., 4., 5., 5., 7., 9.])
mu = d.mean()
var_mle = ((d - mu)2).mean()
print("var_MLE (/n) =", var_mle, "== np.var:", np.var(d))
print("var_unbiased =", ((d-mu)2).sum()/(len(d)-1),
"== np.var ddof=1:", np.var(d, ddof=1))

Why: Reproducing these unaided, rather than reading them, is what tells you the method has transferred. They are not rounding variants; they answer different questions.

Fill in the blanks

From Confirm σ̂² = 4 is really the maximum — one line has had its right-hand side removed. Put it back.

import numpy as np
d = np.array([2., 4., 4., 4., 5., 5., 7., 9.])
mu = d.mean()
def loglik(v):
return np.sum(-0.5np.log(2np.piv) - (d - mu)2 / (2v))
for v in [3.0, 4.0, 6.0]: # 4.0 is the MLE
print(f"var=___: loglik=___")

Why: mu is what everything below it consumes, so the wrong expression here fails later and somewhere else. Both neighbors (3 and 6) score lower log-likelihood than 4.

Step through it

Step through Confirm σ̂² = 4 is really the maximum one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: σ² is 3.0
2. Step 2: σ² is 4.0
3. Step 3: σ² is 6.0

Predict first

A student writes this, and it looks reasonable:

'Sample variance' always divides by n−1, so use np.var(d, ddof=1) for the MLE too.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: That is the UNBIASED estimator, a different quantity.

The Gaussian MLE divides by n — that is what maximizing the likelihood gives.

Why: That is the UNBIASED estimator, a different quantity. The prompt asked for the MLE, which the likelihood derivation pins to divisor n. Answering 4.5714 loses the point even though the number is 'a variance'.

Discussion prompt

The rule this trap just fixed:

The derivation ended in σ² = (1/n)Σ(xᵢ−μ)². Divisor n is the MLE by construction; n−1 is a separate unbiased correction. Match the estimator to the word 'MLE' in the prompt.

Now break it on purpose. Build a case that violates it and follow the consequences until something visibly fails. Where does the failure first show up — and would you have noticed it if you had not been looking?

Hint: The dangerous rules are the ones whose violation still produces an answer. If yours fails loudly, try to find one that fails quietly.

Predict first

The table runs: 0 | [0, 1] | 2,3,4,5,6,7,8,9 · 1 | [2, 3] | 0,1,4,5,6,7,8,9 · 2 | [4, 5] | 0,1,2,3,6,7,8,9 · 3 | [6, 7] | 0,1,2,3,4,5,8,9

In The fold split, made visible, given the rows so far: what is the next one — the row where round is 4?

Correct: 4 | [8, 9] | 0,1,2,3,4,5,6,7

Why: The relationship between the columns, not the individual numbers, is what generates the next row. The five folds tile the range with no overlap and no gap, so each point is held out once — the property the sub-question is testing.

Discussion prompt

Split indices, loop the held-out fold, train on the concatenated rest, score, average. Uses Ridge on diabetes — self-contained:

What do you need to know — or decide — before the first line can be written? List everything the problem has to hand you.

Hint: Anything you would have to invent to get started is a thing the problem must supply.

Step through it

Step through Implement 5-fold CV one row at a time. What is driving the change, and what would the row after the last one be?

1. Step 1: round is 0
2. Step 2: round is 1
3. Step 3: round is 2
4. Step 4: round is 3
5. Step 5: round is 4

Predict first

sklearn's KFold(shuffle=False) uses the same contiguous split, so the scores must match fold for fold. That equality is the graded check:

Commit before you compute: what does Verify against cross_val_score come out to? A rough magnitude and the right form is enough — the point is to have something concrete to be wrong about.

Correct: Fold-for-fold identical — because shuffle=False matches array_split

Why: A prediction you can defend turns the computation into a check rather than a leap of faith — and an answer that contradicts it is caught on the spot. sklearn's default KFold does NOT shuffle and splits contiguously, exactly like np.array_split.

Discussion prompt

Work backwards. The example finished here:

Fold-for-fold identical — because shuffle=False matches array_split

What was it asked to do, and what must it have been given? Reconstruct the problem from its answer.

Hint: Every quantity in the result had to enter somewhere. Account for each one.

Predict first

A student writes this, and it looks reasonable:

Compare your contiguous-split CV against cross_val_score with KFold(shuffle=True) and call it a mismatch bug.

It is wrong. Say what breaks — and say it before you turn the page.

Correct: Shuffling reorders points before splitting, so the folds hold different data — a legitimately different estimate.

Match the split protocol on both sides before comparing.

Why: Shuffling reorders points before splitting, so the folds hold different data — a legitimately different estimate. You'll 'fix' a bug that isn't there and waste exam minutes chasing a phantom.

Sort into buckets

Some of these hold up and some are the exact mistakes this lesson is built to prevent. Sort them.

Holds up

The theory sub-question for this problem: why must you center the data first? Hold that thought — the derivation answers it in two slides.; For centered data Xc (each column has mean 0), the sample covariance is C = XcᵀXc / (n−1). Entry (j,k) is the covariance of feature j with feature k.; The running sample — eight numbers chosen so every quantity is a clean integer:

Breaks

PCA is 'just the SVD of the data', so decompose X directly — centering is an extra line I can skip.; Convergence is slow at η = 0.1, so push it way up to η = 1.1 to finish in fewer steps.

sound

These are stated as this lesson states them — each one survives the edge cases Lesson 39: Mock Exam — Phase 1 Coding puts it through.

flawed

Each of these is lifted from a trap in this deck: reasonable-sounding, and wrong in a way that only shows up once you rely on it.

Put in order

These are the steps of The four gotchas, one line each, scrambled. Put them back in order before the next slide shows you.

1. PCA: center before decomposing — uncentered PC1 chases the mean, not the spread
2. Gradient descent: keep η < 2/L — bigger overshoots and diverges, it is not 'faster'
3. MLE variance: divide by n (biased MLE), not n−1 (unbiased) — match the word in the prompt
4. k-fold CV: each point is held out exactly once; match shuffle=False when verifying

Why: This is the order the recipe itself gives. Recalling the sequence without the slide in front of you is the difference between recognising the method and being able to run it — most of what goes wrong in practice is a step done out of turn.

Discussion prompt

The four gotchas, one line each works on the cases you have just seen. Push it to the edge: what is the most degenerate input it still handles — empty, zero, one item, everything equal — and what is the first case where it stops being true? Name the case, not just "it breaks".

Hint: Try the smallest legal input, then the largest, then the one where two things collide. Methods are specified at their edges; the middle takes care of itself.

Eliminate the wrong options

Your from-scratch PCA must match sklearn's explained_variance_ratio_. The most likely cause of a qualitative mismatch is:

3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.

• A. forgetting to center the data before decomposing
• B. using SVD instead of eigendecomposition of the covariance
• C. computing more components than you need
• D. using float64 instead of float32

Survives elimination: A

Why: sklearn subtracts the column means internally. A from-scratch version must center explicitly, or the top component chases the mean offset (on the shifted toy, PC1 flipped to [−0.707,−0.707] and S₁ ballooned to 28.43) and every EVR is wrong.

Check your understanding

Your from-scratch PCA must match sklearn's explained_variance_ratio_. The most likely cause of a qualitative mismatch is:

• A. forgetting to center the data before decomposing (correct)
• B. using SVD instead of eigendecomposition of the covariance
• C. computing more components than you need
• D. using float64 instead of float32

Answer: A

Why: sklearn subtracts the column means internally. A from-scratch version must center explicitly, or the top component chases the mean offset (on the shifted toy, PC1 flipped to [−0.707,−0.707] and S₁ ballooned to 28.43) and every EVR is wrong.

Why B tempts people

SVD of the centered data and eigendecomposition of the covariance give the SAME components — λ = S²/(n−1). We verified they agree to the digit. Not a source of mismatch.

Why C tempts people

Extra components don't disturb the leading ones; you just compute more of them. The top-3 EVR is unchanged.

Why D tempts people

float precision moves results by ~1e-15, not the qualitative flip that skipping centering causes.

Predict first

For the 8-point sample the sum of squared deviations from the mean is 32. What is the maximum-likelihood estimate of σ²?

Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.

Correct: 32/8 = 4.0 — divide by n

Why: Maximizing the Gaussian log-likelihood gives σ̂² = (1/n)Σ(xᵢ−μ̂)². With Σ = 32 and n = 8 that is 32/8 = 4.0. It is biased low because it reuses μ̂, but it IS the MLE.

Check your understanding

For the 8-point sample the sum of squared deviations from the mean is 32. What is the maximum-likelihood estimate of σ²?

• A. 32/8 = 4.0 — divide by n (correct)
• B. 32/7 ≈ 4.571 — divide by n−1
• C. 32/9 ≈ 3.556 — divide by n+1
• D. √(32/8) = 2.0

Answer: A

Why: Maximizing the Gaussian log-likelihood gives σ̂² = (1/n)Σ(xᵢ−μ̂)². With Σ = 32 and n = 8 that is 32/8 = 4.0. It is biased low because it reuses μ̂, but it IS the MLE.

Why B tempts people

32/7 = 4.571 is the UNBIASED sample variance (Bessel's n−1 correction), a different estimator from the MLE. np.var(d, ddof=1) returns it.

Why C tempts people

n+1 minimizes a different (mean-squared-error) criterion; it is neither the MLE nor the unbiased estimator.

Why D tempts people

2.0 is σ̂ (the standard deviation), not σ̂² (the variance). The question asked for the variance.

Predict first

Minimizing f(w) = (w−5)² (so f''= 2, L = 2) with plain gradient descent, which learning rate makes the iterates diverge?

Answer it in your own words, now, with nothing to choose from. The options are on the next slide — and picking the right one off a list is an easier skill than producing it.

Correct: η = 1.1, because 1.1 > 2/L = 1

Why: The step multiplier is |1 − 2η|. Convergence needs it below 1, i.e. η < 2/L = 1. At η = 1.1 the multiplier is 1.2 > 1, so the distance to 5 grows each step — we measured w → −45497 after 50 steps.

Check your understanding

Minimizing f(w) = (w−5)² (so f''= 2, L = 2) with plain gradient descent, which learning rate makes the iterates diverge?

• A. η = 1.1, because 1.1 > 2/L = 1 (correct)
• B. η = 0.5, because larger steps always overshoot
• C. η = 0.1, because tiny steps accumulate error
• D. none — gradient descent converges for every η > 0

Answer: A

Why: The step multiplier is |1 − 2η|. Convergence needs it below 1, i.e. η < 2/L = 1. At η = 1.1 the multiplier is 1.2 > 1, so the distance to 5 grows each step — we measured w → −45497 after 50 steps.

Why B tempts people

η = 0.5 is safely under the bound of 1 and in fact converges fastest of the rates we tried (w → 5.0). Larger-but-bounded is good, not divergent.

Why C tempts people

η = 0.1 converges (slowly) to 4.9999. Small steps are inefficient, not divergent — they don't accumulate error on a convex quadratic.

Why D tempts people

False: above η = 2/L the method diverges. η = 1 already oscillates forever without settling; η = 1.1 explodes.

Eliminate the wrong options

In standard k-fold cross-validation, how many times is each data point used for validation, and what makes your from-scratch scores match cross_val_score exactly?

3 of these 4 are wrong. Strike them one at a time, and say what rules each one out before you strike the next. The survivor is the answer.

• A. Exactly once; match sklearn's contiguous split with KFold(shuffle=False)
• B. k times; the point is validated in every fold
• C. Exactly once; but the scores can never match sklearn from scratch
• D. k−1 times; once per training fold

Survives elimination: A

Why: The folds partition the data, and each is held out in exactly one round, so every point validates once. np.array_split is contiguous, so it matches KFold(shuffle=False) fold-for-fold — both gave mean R² = 0.4102.

Check your understanding

In standard k-fold cross-validation, how many times is each data point used for validation, and what makes your from-scratch scores match cross_val_score exactly?

• A. Exactly once; match sklearn's contiguous split with KFold(shuffle=False) (correct)
• B. k times; the point is validated in every fold
• C. Exactly once; but the scores can never match sklearn from scratch
• D. k−1 times; once per training fold

Answer: A

Why: The folds partition the data, and each is held out in exactly one round, so every point validates once. np.array_split is contiguous, so it matches KFold(shuffle=False) fold-for-fold — both gave mean R² = 0.4102.

Why B tempts people

A point is held out (validated) in only ONE round; in the other k−1 rounds it is a training point. k times would mean testing on training data.

Why C tempts people

They match exactly when the split protocol is the same — we verified [0.3217,…,0.4420] identically. 'Never' is wrong.

Why D tempts people

k−1 is how many rounds a point is used for TRAINING, not validation. Validation happens exactly once.

Discussion prompt

Explain Code-review criteria by analogy to something with no Machine Learning in it at all — a queue, a recipe, a map, a bank balance, whatever fits. Then say where your analogy breaks.

Hint: An analogy that never breaks is not an analogy, it is the same idea wearing a hat. Find the seam — that is the part that is actually new.

Discussion prompt

Build rules: type every line yourself, predict the output before running, and when something errors, read the shapes in the message — don't delete the error.

That is stated as though it always holds. Do one of two things: produce a case where it fails, or say precisely what rules such a case out. "It just does" is not on the menu.

Hint: Hunt at the extremes first — zero, one, negative, empty, equal. If every extreme survives, the reason they survive is the proof.

Comparison matrix

From Milestone 3 — 5-fold CV and verify: every row here is a choice with a cost. Fill the mean R² column, then say which row you would actually pick and what you give up for it.

Comparison matrix

From The full answer key: refill the result column from what you know. The rest of the table is as it appeared.

Draw it

One page, no notation unless you need it: draw how these connect — How the coding exam works · Problem 1 — PCA · Problem 2 — Gradient descent · Problem 3 — MLE · Problem 4 — Cross-validation · Theory sub-questions. Put an arrow wherever one of them is what makes another possible, and label the arrow with why.