Hugging Face AI & ML Engineer interview questions

Fine-tuning a 65B model once demanded a node of A100s. QLoRA compresses it onto one card with three specific tricks. The signal is knowing what gets quantized, what stays trainable, and why quality barely shifts. Here is the answer.

Fuse several fine-tunes into one model by doing arithmetic on their weights, with no retraining and no data. The signal is knowing why it works and which method to pick when merges interfere.

When a drug name or a Hindi word splits into nine subword tokens, you pay in cost, context, and accuracy. Adding tokens is easy and adding them well is not. Here is the tradeoff.

A few thousand carefully chosen examples can beat a million scraped ones. The signal is knowing which filters matter, how you gauge example quality, and why diversity beats raw volume.

DPO is simple and stable, but it can drive down the probability of chosen responses, overfit the preference margin, and magnify length bias. The signal is naming these and the variants that fix each.

Distillation is not a single method. The signal is knowing when to match logits versus train on generated text, why on-policy distillation beats off-policy, and how reasoning models are distilled.

The proportions of web, code, books, and math in pretraining quietly set downstream skills. The signal is knowing how mixtures get chosen, why upsampling helps, and how methods like DoReMi automate it.

When a benchmark leaks into pretraining, the score measures memorization rather than ability. The signal is the detection methods (n-gram overlap, canaries, perturbation tests) and why fresh held-out evals matter.

The same model can land ten points apart on MMLU depending on prompt format and scoring method. The signal is knowing the knobs (log-prob vs generation, few-shot, normalization) that make evals reproducible.

Both compress an LLM to 4-bit weights, yet they choose what to protect in very different ways. What matters is GPTQ's error-correcting solve versus AWQ's activation-aware scaling, and the calibration each demands.

GGUF powers most local LLM runs, and its quant names look cryptic. What matters is decoding what Q4_K_M means and why mixed-precision k-quants outperform naive uniform quantization.

Grammar-constrained decoding seems like a solved problem until tokenization stops lining up with the grammar. The signal is the token-vs-character boundary mismatch and how prefix automata and token healing address it.

Modern embedding models expect a task instruction prepended to the text, and a wrong prefix quietly wrecks retrieval. The signal is why instructions help and the asymmetric query/passage convention.

Everyone can name learning rate and epochs. The signal is knowing that LoRA wants a learning rate roughly 10x higher than full fine-tuning, why alpha/r is the only scaling that matters, and which curve tells you your rank is too big.

A paraphrased prompt comes back with a training answer, verbatim. This is small-dataset SFT overfitting, not the pretraining memorization problem people confuse it with, and the fix has a strict order of operations.

Both work, so the decision is made by four numbers: how many examples you have, how far the capability has to move, how many variants you must serve, and how many GPUs you own. The serving axis is the one candidates never mention.

The follow-up every interviewer holds in reserve after you say you fine-tuned something. A task-metric win proves almost nothing on its own. Here is the five-part protocol that separates a shipped model from a demo.

Merging one adapter is a single matrix add. Merging four is where careers get interesting: the low-rank updates were each trained as if the others did not exist, and they collide. Here is what actually works and when to route instead.

A VLM is three parts and the interview is entirely about which ones you train. The staged recipe, why the vision encoder almost always stays frozen, and the silent failure where your model learns to answer from the text prior and never looks at the image.

A model that leads MTEB can still stumble on your jargon-heavy corpus, and most teams reach straight for the costly fix. There is a ladder, and the cheap rungs are the ones people skip. Here is the order to climb it.

Tool calling costs one LLM round trip per action. Code costs one round trip for a loop over 500 records. The signal is knowing exactly what you trade away when you let the model write the program instead of the call.

Comparing all pairs across a million documents is a trillion comparisons. MinHash estimates Jaccard similarity from a tiny signature, and LSH converts dedup into a near-linear scan. Here is the implementation.

Every chat model's 'temperature' and 'top_p' knobs come down to a few lines of logit surgery. Implementing them proves you understand decoding rather than just calling it. Here is the from-scratch version.

Nearly every modern training run relies on warmup-then-cosine, and getting it wrong destabilizes early training or squanders the tail. It's a closed-form function of the step. Here is the implementation and the why.

A build-it-yourself check on subword tokenization. What matters is greedy longest-match encoding against a fixed vocabulary, the continuation-prefix convention, and how WordPiece diverges from BPE. The code follows.

Asking a model which answer is better is one line of code. Getting a number you would let block a deploy takes position-bias control, a confidence interval, and a human-labeled set the judge is measured against. Here is the harness.

A small labeled set is the normal place to start, not an excuse. The strong answer is a ladder of techniques that pull signal from unlabeled data, pretrained models, and the labeling budget. Here it is.

Naive 4-bit quantization can wreck quality, and the reflex to give up and serve fp16 leaves a large speedup unclaimed. The accuracy is usually recoverable. Here is the ladder of fixes.

Three batching strategies, three very different latency profiles. Choosing wrong leaves throughput or tail latency on the floor. Here is what each one costs and when to use it.

Most models do not fill a GPU, so one model per GPU wastes money. The three sharing mechanisms (MIG, MPS, swapping) differ widely in isolation and overhead. Here is how to pick.

Most answers optimize the training run. For any model that gets used, inference dominates lifetime energy, and the biggest carbon lever is the serving stack. Measure first, then cut the thing that is actually large.

The technique works and everybody knows it works. The interview is not testing whether you can generate the training set; it is testing whether you know what you are agreeing to when you do.