ML theory interview

Hi, I'm Alex. This is the ML fundamentals round, about thirty-five minutes. I'll ask six questions across the core topics, and dig into each one a bit, sometimes with a small scenario. If you don't know something, saying so is fine, and I'll move on. I may also cut in to keep us on time. There's no code here, just talk me through your thinking. Before we start, what are you working on at the moment?

Hi. So I'm finishing my master's at Lakeview State, in data science. My thesis is on predicting late deliveries for a regional grocery delivery company, Greenbasket, it's a partnership through the department. Mostly tabular data, gradient boosting, and, um, a lot of fighting with the data, honestly. Timestamps in three different time zones. And I'm doing a small side project fine-tuning a small language model to tag recipe ingredients, mostly to learn how that works.

Okay. How big is the delivery dataset, and how often are deliveries actually late?

About four hundred thousand deliveries over eighteen months, and around six percent are late, which is the positive class.

What counts as late, exactly? Someone had to decide that.

More than fifteen minutes after the promised window ends. The company picked that. I asked about it, and it's what triggers a refund voucher, so it's the business definition, not mine. Though if you move it to ten minutes the positive rate almost doubles, so the threshold matters a lot.

Thanks. First question. Explain the bias-variance trade-off and how you diagnose which problem your model has.

So, bias is error from the model being too simple, or having the wrong assumptions, so it misses the real pattern. Variance is error from being too sensitive to the particular training set, so if you trained on a different sample you'd get a quite different model. For squared error the expected test error splits into bias squared plus variance plus irreducible noise. To diagnose it, um, I compare training and validation error. If both are high and close to each other, that's bias. If training is low and validation is much higher, that's variance. And you need some reference for high, like a baseline or human-level error.

Okay. You said compare training and validation error. If you plot both against the training set size, what do the learning curves look like for each case?

For high bias both curves flatten out close together at a high error, and adding data doesn't help, they're already converged. For high variance there's a big gap, training error is low, and the validation curve keeps coming down as you add data, so more data helps. In my thesis I actually did this with the boosting model, the gap was still closing at the full dataset, so we argued for getting another six months of data.

Did the extra six months help? By how much?

A bit. PR AUC went from about point three eight to point four one on the same test window. Less than the curve suggested, probably because the older data was from before they changed the routing system, so it wasn't quite the same distribution.

Different model. Training error is 2%, validation is 11%, and doubling the data moved validation to 9%. What do you do next, in order?

Um, so that's variance, big gap, and data is helping. First I'd check the cheap things: is validation from the same distribution, any leakage, because two percent training error is suspiciously low. Then regularization, stronger L2 or dropout, or for trees, shallower trees and fewer leaves, and early stopping. And if getting more data is cheap, more data, since the curve is still going down. I wouldn't make the model bigger.

Where does ensembling fit in this picture?

Bagging averages models trained on different samples, so it mostly cuts variance, that's random forests. Boosting adds models that fix the previous errors, so it mostly cuts bias. So it depends which kind of ensemble.

Mm-hm. That's the classical picture. Large neural networks don't always follow it. How does deep learning's double descent complicate this picture?

Hmm, I've heard of it, but I don't know it well. I think test error, kind of, goes up and then comes down again once the model is much bigger than it needs to be to fit the training data? So, um, bigger doesn't always mean more overfitting, I guess. I couldn't explain why it happens.

That's okay. One smaller angle. If test error does go up and then down, where would you expect the peak to be?

Um, maybe around the point where the model can, sort of, just barely fit the training data exactly? Where the number of parameters is about the number of examples. That's a guess, though.

Okay. Next topic, evaluation. You are building a fraud detector where 0.1% of transactions are fraud. How do you evaluate it?

Um, first, accuracy is useless here, predicting not-fraud every time already gives ninety-nine point nine percent. So I'd use a ranking metric that doesn't depend on the threshold, like ROC AUC, and look at the confusion matrix at a few thresholds.

Is ROC AUC a good fit at 0.1%?

Hmm... the ROC curve uses the false positive rate, and with that many negatives the false positive rate stays tiny even when there are thousands of false alarms. So the curve looks great and the model can still be useless for the analysts. So, actually, precision and recall are better here: PR AUC, and precision at the recall the business needs. Which is what I use in my thesis too, at six percent positives, I should have said that first.

Okay. The model outputs a score, and someone has to decide where to cut. How would you pick the operating threshold?

With the business costs. A missed fraud costs roughly the transaction amount, a false alarm costs a manual review, say five dollars of analyst time, plus some customer annoyance if the card gets blocked. I'd pick the threshold that minimizes expected cost on a validation set. Or, if the review team has fixed capacity, like two hundred alerts a day, the threshold is just whatever gives the top two hundred, and I'd report precision at that cutoff. And the scores should be calibrated if anyone reads them as probabilities.

Okay. Before any metric, how do you split the data for this evaluation?

By time. Train on older months, validate and test on later months. A random split would let the model see future fraud patterns, and the same card or the same fraud ring could be on both sides. Maybe also group by card so one card isn't in both.

Your model flags a thousand transactions a day. Fifty of them are fraud, and there are eighty frauds a day in total. What are precision and recall?

Precision is fraud among the flagged, so fifty out of a thousand, five percent. Recall is the frauds we caught out of all frauds, fifty out of eighty, um, sixty-two and a half percent. So we catch most of it, but ninety-five percent of the reviews are wasted. Whether that's fine depends on what a review costs compared to the average fraud.

How would you deal with the imbalance when training?

Class weights first, it's the simplest. Or undersample the negatives. But only in the training set, never in validation or test, otherwise the precision numbers are made up. And if I resample, the predicted probabilities are off, so I'd recalibrate them afterwards, like with isotonic or Platt scaling on a validation set with the real ratio.

How would you check the calibration?

A reliability plot, bin the predictions and compare the average prediction with the actual fraud rate in each bin. With point one percent positives most bins are almost empty of fraud, so I'd use bins by quantile, not fixed widths. I've only done that on my thesis data, not on something this rare.

A colleague reports a ROC AUC of 0.97 for this fraud model and wants to ship it. What do you ask them before anything else?

What's the precision at the threshold we'd actually use, and at what review volume. And how they split the data, by time or randomly. A point nine seven with a random split on fraud I'd be suspicious of, it could be the same cards on both sides.

Fraudsters adapt, so a pattern that worked last quarter stops working. Fraud patterns change. How does that affect evaluation?

Um, so the test window has to be after the training window, that's the time split. And labels come late, chargebacks can take like sixty days, so the most recent weeks look cleaner than they are. I'd evaluate on a window that's old enough for labels to settle. And I'd retrain regularly and watch precision at the cutoff over time. I'm less sure how you'd, kind of, detect a new pattern before the labels arrive.

Okay. Moving on. This one sounds basic, so I'll push on it a bit. What is overfitting and what are the main ways to prevent it?

It's when the model learns the noise or the quirks of the training set, so it's great there and worse on new data. To prevent it: more data, or data augmentation for images and text. Regularization, L1, L2, dropout, weight decay. Early stopping on a validation set. A simpler model, fewer features, shallower trees. And cross-validation to estimate it honestly.

You listed dropout. What does it do during training, and what changes at inference?

During training it zeroes each unit with some probability, so the network can't rely on any single unit, a bit like training many thinned networks. At inference nothing is dropped, and the scale is corrected, in the usual implementation the activations are scaled up during training so inference needs no change.

Okay. You ship a model. Your validation score is great and production is terrible. What do you check first?

Hmm. I'd check whether the production data looks different from the training data, like the distributions of the features. And whether the features are computed the same way in production. Oh, and, actually, first I'd check for leakage. If validation is suspiciously great, maybe a feature has information from the future. In my thesis we had a feature, minutes since the driver's last status update, and it turned out the last status update could be the delivered event itself. So validation PR AUC was like point seven and it was fake.

A leak like that is easy to miss. How did you find it?

Feature importance. That one feature was way above everything else, and it made no sense that it would be that predictive. I checked the timestamps of a few rows by hand. After I removed it the score dropped to around point three eight, which was the real number.

And beyond leakage, the features themselves can be computed differently in production. How would you set things up so this is caught before launch?

Um, compute the features from one shared code path for training and serving, if possible. Log the production inputs and compare their distributions with training. And maybe run in shadow mode for a while before it acts on anything. I haven't done the shadow part myself.

You mentioned cross-validation. Your thesis data is deliveries over eighteen months. Anything to watch for with cross-validation on data like that?

Yes, a normal k-fold shuffles time, so the model trains on the future and tests on the past. I used expanding windows, train on the first months, test on the next one, then move forward. Also the same driver appears many times, so I think there's some leakage through the driver even with time splits. I didn't fully solve that one.

How do you pick the regularization strength?

Search over it on the validation folds, usually on a log scale, like ten to the minus four up to ten. Pick the best mean score, or the simplest model within one standard error of the best.

You listed data augmentation earlier. When can augmentation hurt instead of help?

Um, when the augmentation changes the label. Like flipping a digit image, a six becomes a nine. Or cropping out the object you're classifying. And if the augmented data doesn't look like the real data, the model learns the augmentation artifacts. For tabular data I've never really used it, I'm not sure it, sort of, makes sense there beyond things like SMOTE.

Okay. Regularization in more detail. Compare L1 and L2 regularization. Why does L1 produce sparse solutions?

L1 adds the sum of absolute values of the weights to the loss, L2 adds the sum of squares. L2 shrinks all the weights smoothly toward zero but they almost never hit exactly zero. L1 sets many of them exactly to zero, so it does feature selection. Why... um, it's because of the, the gradient of the absolute value is constant?

Think about the shape of the constraint region.

Right, okay. If you write it as a constrained problem, L2 is a circle, or a ball, and L1 is a diamond. The loss contours are ellipses, and you expand them until they touch the region. With a diamond, the first touch is very likely at a corner, and corners are on the axes, so some weights are exactly zero. With the circle there are no corners, so it touches anywhere. And my gradient point is the same idea from the other side: L1 keeps pushing with the same force even when the weight is small, L2's push goes to zero.

Okay. Practical case: two features that are almost copies of each other, highly correlated. What happens under each?

L1 tends to pick one of them, kind of arbitrarily, and zero the other. L2 splits the weight between them. Elastic net is the mix, which keeps groups of correlated features together.

Is there a probabilistic way to see the difference?

Yes, as MAP estimation. L2 is a Gaussian prior on the weights, L1 is a Laplace prior. The Laplace prior has a sharp peak at zero, so it puts a lot of belief on exactly zero, which matches the sparsity. The Gaussian is smooth at zero.

When would you not want a sparse model?

When many features each carry a little signal, like text with lots of words, or when features are correlated groups and dropping some makes the model unstable between retrains. Sparse is nice for interpretability and cheap serving, but it can cost accuracy.

Okay. Same idea in deep learning, where most people train with Adam. What does weight decay do in neural networks and how does it differ from L2 in Adam?

Um. Weight decay shrinks the weights by a small factor each step. With plain SGD that's, kind of, the same as L2 regularization. With Adam it's different, I know AdamW exists because of this. I think with L2 inside Adam, the penalty gradient gets, sort of, divided by the adaptive scaling, so weights with large gradients get regularized less? And AdamW applies the decay directly to the weights, outside the adaptive part. I'm not fully sure I have the direction right.

Next, classical models, since you work with tabular data. Compare random forests and gradient boosting. When would you pick each?

Both are tree ensembles. A random forest trains many deep trees independently, each on a bootstrap sample with a random subset of features at each split, and averages them. That mostly reduces variance, because the trees are decorrelated. Gradient boosting trains shallow trees one after the other, each one fitting the residual errors, or the gradient of the loss, of the ensemble so far. That mostly reduces bias. I'd pick boosting when I want the best accuracy on tabular data and have time to tune it, learning rate, depth, number of trees with early stopping. Random forest when I want something robust with almost no tuning, or the labels are noisy, since boosting can chase noise.

Mm-hm. Which did you use in your thesis, and why that one over the other?

LightGBM. I started with a random forest as a baseline, PR AUC about point three three, and boosting got to point three eight after tuning. Also it handles the categorical features and missing values natively, which mattered because a lot of the driver features are missing for new drivers.

You mentioned missing values. Your thesis uses LightGBM, but the idea is similar. How does XGBoost handle missing values and regularization?

For missing values, at each split it learns a default direction, it tries sending the missing rows left and right and keeps whichever reduces the loss more. For regularization, there's an L2 penalty on the leaf weights, lambda, and I think also L1, alpha. And gamma, which is a minimum loss reduction to make a split. Plus the usual things like shrinkage and subsampling, I guess. I'm not sure I could write the exact objective.

Your boosting model's validation loss starts rising after about three hundred trees at a learning rate of 0.1. What do you change?

That's overfitting as trees are added. Early stopping would just stop at three hundred. If I have time, lower the learning rate, like point oh three, and let it use more trees, that usually ends a bit better. And look at the depth, or min child weight, and row and column subsampling.

Feature importances from a random forest. How far do you trust them?

Not very far. The default impurity importance is biased toward features with many split points, continuous or high-cardinality ones, and with correlated features it splits the credit randomly. Permutation importance on a validation set is better, or SHAP values. That's how I found the leaky feature, actually, but even then it only tells you what the model uses, not what causes lateness.

Okay. A quick one. In your pipeline you probably scaled features for some models and not others. Why do tree models not need feature scaling?

Because a split only looks at the order of values: is x less than some threshold. Any monotonic transformation, scaling, log, keeps the order, so the same splits exist. Distance and gradient based models care about scale, trees don't.

Last topic, deep learning. Explain how a transformer works and why it replaced RNNs for most sequence tasks.

Okay, so, um, before transformers, the standard was RNNs and LSTMs, and, uh, they had attention added on top for translation, the Bahdanau paper, and then, you know, people realized you could drop the recurrence entirely, and, there were also convolutional approaches like ByteNet, and

Let me stop you there. I'm less interested in the history. How does the transformer itself work, one layer, step by step?

Sorry, yes. Each token is embedded and gets positional information added, since attention itself has no order. Then each layer has self-attention: every token makes a query, a key and a value, the attention weights are a softmax of the query dot the keys, and the output is the weighted sum of values. Multi-head means you do that several times in parallel with smaller dimensions. After attention there's a feed-forward network applied to each position, and residual connections and layer norm around both. Decoder-only models like GPT add a causal mask so a token only sees the past.

Okay. And why did it replace RNNs for most sequence tasks? The main reasons.

Two main reasons. Training parallelizes over the sequence, an RNN has to go step by step. And any token can attend directly to any other, so long-range dependencies are one step away instead of being squeezed through a hidden state over hundreds of steps. The cost is that attention is quadratic in sequence length, in compute and memory.

What does multi-head attention buy you over one big head with the same total dimension?

Um, each head can, kind of, attend to different things, like one follows syntax and one follows nearby tokens, and one softmax can only produce one distribution over positions. With one big head you'd get one weighted average. The compute is about the same. I'm not sure how much the heads really specialize in practice, I've seen papers saying you can prune a lot of them.

And positional information, what are the options?

The original paper used fixed sinusoids added to the embeddings. Then learned position embeddings, like BERT. And newer models use relative positions, rotary embeddings, RoPE, that rotate the queries and keys, so the dot product depends on the distance. I couldn't derive RoPE, but that's the idea.

Your ingredient-tagging side project. Encoder-only or decoder-only model, and why?

Hmm. Tagging spans is a classic encoder task, like BERT with a token classification head, it sees both sides of each word and it's small and fast. I actually used a small decoder model with instructions, because that's what the tutorial did and it outputs a list. If I did it again I'd try the encoder first, it's probably cheaper and easier to evaluate per token.

One detail in the attention formula. Why do we scale dot products by the square root of the dimension?

If the query and key components have variance around one, the dot product of d of them has variance around d. So for big d the scores are large, the softmax becomes almost one-hot, and the gradients get tiny. Dividing by the square root of d brings the variance back to about one.

Now inference. When a decoder model generates text, servers keep something called a KV cache. What is a KV cache and why does inference need it?

When you generate token by token, each new token needs attention over all the previous tokens. The keys and values of the previous tokens don't change, because of the causal mask, so you store them instead of recomputing the whole prefix every step. It turns each step from reprocessing the prefix into just the new token. The cost is memory, it grows with sequence length, layers and heads, which is, um, I think why people use grouped query attention, fewer key value heads. I've read about that more than I've used it.

Roughly how big is the KV cache for one sequence?

Um, let me think. For each layer and each token you store a key and a value, each of size number of heads times head dimension, so two times layers times the model dimension, times the sequence length, times bytes per number. For, say, thirty-two layers, model dimension four thousand, four thousand tokens in fp16, that's two times thirty-two times four thousand times four thousand times two bytes, um, about two gigabytes? That seems like a lot, but I think it's the right order.

Before we finish, one thing from the start. You mentioned fine-tuning a small model to tag ingredients. How do you know it works?

Honestly, not very rigorously yet. I hand-labelled about two hundred recipes as a test set, and it gets the ingredient spans right maybe eighty-five percent of the time, but I wrote the labels myself and I've looked at those examples a lot while prompting, so it's probably optimistic. I should have a test set I don't look at.

We have a few minutes left. Any questions for me?

Yes. How much of the ML work on a team like this is modeling versus building data pipelines and monitoring?

It varies by team. On many teams the data, evaluation and monitoring work takes more time than the modeling itself, especially once a model is in production and has to be retrained and watched. Some research-leaning teams are the other way around. The hiring team can tell you how it splits for a specific role. Anything else?

Sorry, can I add one thing to the double descent question? I remembered something.

Go ahead, briefly.

I think the explanation is that past the interpolation point there are many models that fit the data exactly, and gradient descent tends to find a smooth one, a kind of implicit regularization. But I'm not confident, that's from a blog post.

Okay. That's time. Thanks. Your report will be ready in a few minutes.