ML Interview Questions in R: 25 Solved Problems

Explanation: Training error is monotonically non-increasing in model complexity, so degree 9 "wins" on the training set every time. That is exactly why it is a useless model-selection criterion: the drop from degree 5 to degree 9 is the model memorising noise, not signal. The correct move is to judge models on data they did not see, which the next problem does.

Explanation: Test error is the honest signal. It falls sharply from degree 1 to 3 (fixing underfitting), flattens in the sweet spot, then rises past degree 8 as the extra terms chase noise. Training error never shows this turn, which is the whole reason you hold out data. A common interview mistake is quoting training accuracy as if it were performance.

Explanation: Expected test error decomposes as $\mathbb{E}[(y-\hat{f})^2] = \text{Bias}^2 + \text{Variance} + \sigma^2$. This experiment isolates the variance term: the degree-9 model's prediction swings roughly 3.5 times more than the degree-1 model's because flexible models bend to fit each sample's noise. The simple model has higher bias but lower variance, and the best model trades one against the other.

Explanation: The curve plunges from n = 5 to n = 10, then flattens at about 1.0, which is the noise standard deviation you built in. Once a model sits on that floor, more data barely helps and the answer to "more data or better model?" flips to "a model that can capture more signal." A flat, high curve signals high bias; a large train-test gap signals high variance.

Explanation: Indexing the test set with -train_idx guarantees a disjoint partition, and set.seed() makes the split reproducible so results are comparable across runs. The overlap check looks trivial but catches a real bug: sampling with replace = TRUE, or re-sampling test rows separately, can silently place the same observation in both sets and inflate your score.

Explanation: The full-data mean (10.095) differs from the training-only mean (10.444) because the test rows moved it, and any preprocessing built on that number has already peeked at the test set. In production, the scaler must be fit on training data and merely applied to new rows, since at prediction time you do not have the future data to average over. The right way is to learn mu and sd on the training fold and reuse them everywhere.

Explanation: The leaky feature lifts accuracy from 0.68 to 0.89 because it is essentially the answer key. In interviews this shows up as "we hit 99% offline but 60% live": a feature was populated after the outcome was known, or joined from a table that includes the label. The fix is to audit every feature for whether it would be available at prediction time, before the event you are predicting has happened.

Explanation: The target is random noise, so no feature carries real signal, yet the leaked cross-validation error (0.58) sits well below the null variance (0.85). Choosing the top-correlated features using all rows lets the test folds vote on their own selection, an optimistic bias sometimes called the selection winner's curse. The cure is to run feature selection inside each training fold, so the held-out fold never influences which columns survive.

Explanation: The cross-validation estimate is the average of the fold RMSEs, and the spread across folds (2.06 to 2.93) is itself informative: wide spread on a small dataset like mtcars means the estimate is noisy, which is why 5 or 10 folds beat a single split. Averaging over folds uses every row for both training and testing without ever testing on a row the model trained on.

Explanation: Feature 9 wins purely by chance, and its tune error (0.81) undershoots its true test error (1.10) because the minimum over 20 candidates rewards whichever noise pattern happened to fit the tune set. The lesson: the data used to choose a model cannot also be used to report its performance. Reserve a final test set you touch once, or use nested cross-validation so tuning happens inside an inner loop.

Explanation: The two numbers match exactly because the leverage identity is algebra, not approximation: dividing each residual by one minus its leverage recovers the leave-one-out residual from a single fit. This turns an O(n) set of refits into one fit, which matters when n is large. It only holds for ordinary least squares, so for other models you still cross-validate the slow way.

Explanation: Stratifying within each class guarantees every fold holds about 10% positives, so no fold trains or tests on a distorted distribution. With plain random folds and only 50 positives across 5 folds, an unlucky draw could hand one fold 4 positives and another 16, making per-fold metrics wobble. Stratification is standard for classification and essential when the minority class is small.

Explanation: Each row is the fitted model at one penalty strength, and the wt coefficient marches from -3.80 toward -1.37 as lambda rises. Ridge trades a little bias for a large drop in variance, which is why it helps when predictors are correlated or n is small. Note the intercept (first, unlabelled column) is not penalised, since shrinking it would just bias the overall level of the predictions.

Explanation: OLS splits the true effect of 2 into a huge positive and huge negative pair (11.1 and -9.1) because the two predictors are almost interchangeable, so their difference is barely constrained. Ridge shares the effect evenly (about 0.99 each, summing near 2) and stays stable across resamples. This is the interview answer to "why does multicollinearity matter and how does regularization help?"

Explanation: The norm falls from 0.71 to 0.25 as lambda climbs, which is the geometric picture of ridge: it constrains the coefficient vector inside an ever-smaller ball. Standardising first matters, because the penalty acts on raw coefficient size, so features on larger scales would otherwise be penalised less. This is also why you should scale before any penalised model, ridge or lasso.

Explanation: All 50 setosa are perfect while the six errors fall between versicolor and virginica, whose petals overlap, exactly where you would expect a tree to struggle. Reading this on the training data measures fit, not generalisation, so treat 6 errors as a floor: on unseen data a tree this size usually does slightly worse. The off-diagonal cells tell you which classes the model confuses, which no single accuracy number reveals.

Explanation: As cp drops from 0.30 to 0.01 the tree grows from 2 to 8 leaves, because cp is the minimum fractional improvement in fit a split must deliver to be kept. High cp gives a stubby, high-bias tree; low cp gives a deep, high-variance one. Tuning cp is therefore the same bias-variance choice as picking a polynomial degree, just wearing tree clothing. Setting xval = 0 here turns off the internal cross-validation so the counts are exactly reproducible.

Explanation: Relative error slides monotonically from 1.00 down to 0.02 as splits pile up, so on training error the fullest tree always looks best, the same trap as polynomial degree. The honest choice uses the cross-validated error column (xerror) and the one-standard-error rule: pick the smallest tree whose cross-validated error is within one standard error of the minimum. Pruning to that cp with prune() gives a tree that generalises rather than memorises.

Explanation: The top four variables (cyl, disp, hp, wt) score close together because they are all correlated proxies for engine size and mass, so importance is shared among them rather than assigned cleanly to one. That is a caution worth stating in an interview: tree importance is not a causal ranking, and correlated features can trade places across resamples. Permutation importance on held-out data is a more robust alternative.

Explanation: Sepal features separate the two species only weakly, so the matrix has real errors: 7 false positives and 4 false negatives out of 30 test cases. The diagonal (9 and 10) is correct, the off-diagonal is wrong, and the layout matters because interviewers expect you to define which cell is a false positive. Every downstream metric, precision, recall, F1, is a ratio of these four counts.

Explanation: F1 is the harmonic mean $2PR/(P+R)$, which sits below the arithmetic mean and so punishes any large gap between precision and recall. Here precision (0.889) beats recall (0.800) because the classifier misses 10 spam messages, and F1 (0.842) reflects that imbalance. Reporting F1 instead of accuracy is the standard move when one class matters more or the classes are uneven.

Explanation: As the threshold rises from 0.3 to 0.7, precision nearly doubles (0.26 to 0.51) while recall drops from 0.99 to 0.64, which is the precision-recall trade-off you tune per problem. A cancer screen wants high recall and tolerates false alarms; a spam filter wants high precision so it rarely bins a real email. Quoting a single accuracy hides this dial entirely, and the choice of threshold is a business decision, not a modelling default.

Explanation: Both methods return 0.7606 because AUC equals the Mann-Whitney U statistic normalised by the number of pairs, so the rank shortcut and the all-pairs count are the same quantity. The reading is concrete: pick one positive and one negative at random, and 76% of the time the model scores the positive higher. Because AUC ignores the threshold entirely, it measures ranking quality, which is why it survives class imbalance better than accuracy.

Explanation: The do-nothing model scores 96.3% accuracy while catching zero of the 37 positives, the textbook accuracy paradox. On rare-event problems (fraud, disease, churn) accuracy rewards ignoring the class you actually care about. The honest metrics are recall, precision, F1, or AUC on the minority class, and the fix on the modelling side is the next problem: rebalancing so the model has a reason to predict positive.

Explanation: Downsampling lifts recall from 0.19 to 0.77 because the balanced model no longer treats "positive" as a near-impossible event, so its probabilities cross 0.5 far more often. The trade-off is precision: you catch more positives but also raise false alarms, and downsampling throws away majority data. Equivalent tools are upweighting the minority (weights in glm) or simply lowering the decision threshold, which reaches the same place without discarding rows.