Machine Learning Interview Questions

Supervised learning trains a model on labeled data, where the correct answer is already actually known for each example. Unsupervised learning finds patterns in unlabeled data, with no predefined correct answer given at all. Reinforcement learning trains an agent to make a sequence of decisions by rewarding good actions and penalizing bad ones over time.

Supervised learning uses labeled training data, where each example already comes paired with the correct actual answer, like an email already marked spam or not spam. Unsupervised learning works with genuinely unlabeled data, trying to discover a natural structure or grouping on its own, like clustering customers into segments with no predefined category given in advance.

Classification predicts a category, like whether an email is spam or not spam. Regression predicts a continuous numeric value, like a house's actual price. The choice between the two depends entirely on what kind of answer the actual problem is genuinely asking for.

The training set is the data actually used to teach the model. The test set is a genuinely separate portion of data, held out and never actually used during training, used afterward specifically to evaluate how well the model performs on genuinely new, unseen data. Evaluating a model only on data it was already trained on would give a genuinely misleading, overly optimistic picture of its real performance.

Stratified sampling ensures each split genuinely preserves the same proportion of each class as the original full dataset. Without it, a genuinely random split on an imbalanced dataset could accidentally leave the test set with too few examples of a minority class, making the evaluation on that class genuinely unreliable.

A feature is an individual, measurable input variable used to actually make a prediction, like a house's square footage, its number of bedrooms, or its actual location. A model learns the actual relationship between these input features and the specific outcome it's genuinely trying to predict.

A label is the actual, known correct answer attached to a training example, like whether a specific email genuinely was spam. Features are the inputs a model uses to make a prediction. The label is the genuine target output the model is actually trying to learn to predict from those features.

Real-world data is very often messy, containing missing values, inconsistent formatting, or an actually wildly different scale across different features. A model trained directly on messy, unprocessed data typically performs poorly, since it can't reliably learn a genuinely meaningful pattern from noisy or genuinely inconsistent input.

Common approaches include removing rows with missing values entirely, if they're genuinely rare, or filling them in with the column's actual mean, median, or a genuinely sensible default value. The right specific choice actually depends on how much data is genuinely missing and whether that missingness itself might carry some real, meaningful signal worth actually preserving.

Feature scaling brings different features onto a genuinely comparable numeric range, since a feature measured in the thousands (like income) could otherwise completely dominate a feature measured in single digits (like number of children) purely due to their differing raw scale, not their actual genuine importance. Algorithms genuinely relying on distance calculations, like k-nearest neighbors, are especially sensitive to this.

Normalization rescales values into a fixed range, typically 0 to 1. Standardization rescales values to genuinely have a mean of 0 and a standard deviation of 1, which is generally the better choice when a feature's actual distribution roughly resembles a normal, bell-shaped curve.

A pipeline chains together preprocessing steps and a model into a single object, so calling one method runs the entire sequence, scaling, encoding, then training, in one step. It reduces the real risk of data leakage, accidentally applying a transformation using statistics from the full dataset including the test set, rather than fitting that transformation on the training data alone.

One-hot encoding converts a categorical variable, like a color with values red, green, blue, into several separate binary columns, one per category, each marked 1 or 0. It's needed because most ML algorithms genuinely require numeric input, and simply assigning arbitrary numbers directly to categories, like red=1, green=2, blue=3, would incorrectly imply a genuinely false numeric ordering between them.

The validation set lets you genuinely tune a model's hyperparameters and compare different candidate models, without ever touching the actual, final test set until the genuinely very end. Using the test set itself repeatedly during that same tuning process would gradually leak information from it into your model choices, genuinely undermining its usefulness as a truly unbiased, final evaluation.

Linear regression models the actual relationship between one or more input features and a genuinely continuous numeric output, fitting a straight line (or a hyperplane, with multiple features) that best genuinely predicts that output. It's used for a regression problem, like predicting a house's actual price based on its size.

Despite its name, logistic regression is actually used for classification, predicting the genuine probability that an input belongs to a specific category, using a logistic (sigmoid) function to squeeze its output into a range between 0 and 1. The name reflects its genuine mathematical roots in linear regression, even though its actual practical, real use is for classification.

A decision tree makes a prediction by repeatedly splitting the data based on a specific feature's actual value, following a genuinely learned sequence of if-then style questions down through the tree until it reaches a final leaf node, which holds the actual predicted answer.

Entropy measures how genuinely mixed or impure a set of labels currently is, with a perfectly pure, single-class group having zero entropy. A decision tree evaluates a genuine potential split by how much it would actually reduce entropy, choosing the split that produces the greatest reduction, called information gain, at each individual step down the tree.

KNN predicts a new data point's actual label by looking at the k genuinely closest existing data points in the training set and taking a genuine majority vote (for classification) or an average (for regression) among them. It requires genuinely no actual training phase in the traditional sense, since it simply compares directly against the stored, existing data at actual prediction time.

A parametric algorithm, like linear regression, learns a genuinely fixed number of parameters regardless of how much training data it actually sees. A non-parametric algorithm, like KNN, doesn't assume a genuinely fixed form and can effectively grow in complexity as more actual data becomes genuinely available.

Naive Bayes is a classification algorithm based on Bayes' theorem, calculating the genuine probability of each class given the actual input features. It's called naive because it genuinely assumes every feature is completely independent of every other feature, an assumption that's rarely genuinely, perfectly true in real data, yet the algorithm still often performs surprisingly well in practice regardless.

A generative model, like Naive Bayes, learns the actual joint probability of the features and the label together, effectively modeling how the data itself was genuinely generated. A discriminative model, like logistic regression, learns only the decision boundary directly, the actual probability of a label given the features, without modeling how the features themselves came to exist in the first place.

Accuracy is the percentage of predictions a model genuinely got correct out of the total. Its genuine limitation shows up on an imbalanced dataset, where a model that simply predicts the majority class every single time can still score a genuinely high accuracy while actually being completely useless in practice.

A confusion matrix breaks a classification model's predictions down into true positives, true negatives, false positives, and false negatives, showing exactly where a model is genuinely making mistakes, beyond just an aggregate overall accuracy number that hides those genuine specific details.

Precision measures, of everything the model actually predicted positive, how many were genuinely, actually positive. Recall measures, of everything that was genuinely, actually positive, how many the model actually managed to correctly find. There's typically a genuine trade-off between the two, improving one often genuinely comes at some real cost to the other.

The F1 score is the harmonic mean of precision and recall, combining both into a genuinely single number. It's used when you genuinely need to balance both concerns together, rather than optimizing purely for one of them alone while completely ignoring the other.

A p-value estimates how likely an observed improvement would be if there were truly no real difference between the two models at all. A very small p-value suggests the improvement is genuinely unlikely to be pure chance, though a statistically significant result still needs to be checked against whether the actual size of that improvement is meaningful in a real, practical business sense.

Overfitting happens when a model learns the training data too closely, including its genuine noise and specific quirks, rather than the actual, genuinely underlying pattern, so it performs very well on training data but noticeably worse on genuinely new, unseen data.

Underfitting happens when a model is genuinely too simple to actually capture the real underlying pattern in the data at all, performing poorly on both the training data and genuinely new data alike. Overfitting instead performs well on training data specifically but poorly on new data, the exact opposite genuine failure pattern.

A baseline model is a genuinely simple, quick-to-build model, sometimes just predicting the most common class or the average value, used as a real point of comparison for anything more sophisticated you build afterward. It's built first because a genuinely complex model that only marginally beats a simple baseline may not actually justify its added complexity at all.

Bias measures how far off a model's own assumptions genuinely are from the real, actual underlying pattern, high bias leads to underfitting. Variance measures how much a model's predictions genuinely change based on small fluctuations in the specific training data used, high variance leads to overfitting. Reducing one often genuinely increases the other, which is exactly the real, underlying trade-off.

Compare the model's actual performance on the training set against its actual performance on a genuinely separate validation set. A large gap, where training performance is genuinely much higher than validation performance, is the classic, telltale sign of overfitting.

Gathering more genuine training data, simplifying the model itself, applying regularization to actually penalize excessive complexity, and using cross-validation to more reliably evaluate performance rather than relying on a single, potentially unrepresentative train-test split.

Regularization adds a genuine penalty to a model's own loss function specifically for having overly large or overly complex parameters, discouraging it from fitting the training data's own genuine noise too closely and thereby helping it generalize better to genuinely new, unseen data.

Use a genuinely more complex model capable of actually capturing more real nuance, add more genuinely relevant features, or reduce any regularization that might currently be overly constraining the model's own actual ability to properly fit the real, underlying data.

As the number of features grows, the data needed to genuinely cover that feature space adequately grows exponentially, which means the same amount of training data becomes genuinely sparser and less representative as dimensionality increases. This can hurt a model's ability to actually learn a reliable pattern, especially for a distance-based algorithm like KNN.

Feature selection identifies and keeps only the genuinely most relevant, useful features, discarding ones that add genuinely little real predictive value. Fewer, genuinely more relevant features can reduce overfitting, speed up genuine training, and make the resulting model easier to actually interpret and explain.

Target encoding, replacing each category with a genuinely relevant statistic like the average target value for that category, or grouping genuinely rare categories together into a single other bucket, both help avoid the excessive dimensionality that plain one-hot encoding would otherwise genuinely create.

Dimensionality reduction reduces the number of features while genuinely preserving as much of the original, meaningful information as reasonably possible. PCA (Principal Component Analysis) is a genuinely common technique, transforming the original features into a genuinely smaller set of new, uncorrelated components that still capture most of the actual original variance.

Techniques include oversampling the minority class, undersampling the majority class, or using a genuinely different evaluation metric like precision, recall, or F1 rather than accuracy alone, since accuracy is genuinely misleading on an imbalanced dataset. Some algorithms also support class weighting directly, penalizing a mistake on the minority class more heavily during actual training.

A random forest trains many genuinely separate decision trees, each on a genuinely random subset of the data and a genuinely random subset of features, then combines their individual predictions together, typically through a genuine majority vote. This reduces overfitting compared to a single tree, since individual trees' own genuine errors tend to cancel each other out somewhat.

An SVM finds the genuinely best boundary (a hyperplane) separating two classes, specifically maximizing the actual margin, the distance between that boundary and the genuinely closest data points from each class. A wider genuine margin generally leads to better generalization on genuinely new, unseen data.

The kernel trick lets an SVM genuinely find a non-linear decision boundary by implicitly mapping data into a higher-dimensional space, without actually ever needing to explicitly compute that potentially expensive, higher-dimensional transformation directly. It solves the genuine problem of separating data that genuinely isn't linearly separable in its own original feature space.

k-means groups data into k genuinely separate clusters by iteratively assigning each point to its genuinely nearest cluster center, then recalculating each center as the actual average of the points currently assigned to it, repeating that same process until the clusters genuinely stop meaningfully changing.

The elbow method plots the model's actual error against different genuine values of k, looking for the point where increasing k further genuinely stops meaningfully reducing that error, the elbow of the resulting curve. Domain knowledge about how many genuinely distinct groups you'd actually expect also helps guide that same choice.

Hierarchical clustering builds a genuine tree of nested clusters, either merging smaller clusters together (agglomerative) or splitting a larger one apart (divisive), without needing to specify the number of clusters upfront the way k-means genuinely requires. The resulting tree, or dendrogram, can then be cut at genuinely any level to actually produce a chosen number of clusters afterward.

Cross-validation splits the data into several folds, trains and evaluates the model multiple times using genuinely different folds for training and testing each time, then averages the results. This gives a genuinely more reliable estimate of how the model will actually generalize than a single train-test split, which can give a misleadingly good or bad result depending purely on which specific rows happened to land in the test set.

An ROC curve plots a classifier's true positive rate against its false positive rate across genuinely different classification thresholds. AUC summarizes that entire curve into a genuinely single number, representing how well the model genuinely separates the two classes overall, with 1.0 being genuinely perfect separation and 0.5 being genuinely no better than random guessing.

Hyperparameters are settings you genuinely choose before training, like a decision tree's maximum depth, as opposed to parameters the model genuinely learns from data itself. Grid search or random search systematically try genuinely different combinations of hyperparameters, using cross-validation to evaluate each one, returning the combination that genuinely performed best.

Data leakage happens when information from outside the genuinely legitimate training data accidentally influences the model, like accidentally including a feature that genuinely wouldn't actually be available at real, actual prediction time. A model with suspiciously, genuinely perfect performance is a classic warning sign genuinely worth investigating for exactly this kind of leakage.

A Type I error is a false positive, incorrectly predicting the positive class when the genuine, actual answer was negative. A Type II error is a false negative, incorrectly predicting the negative class when the genuine, actual answer was positive. Which error type actually matters more genuinely depends heavily on the specific real-world problem, a missed cancer diagnosis (Type II) is typically far more costly than a false alarm (Type I).

Ensemble learning combines predictions from several genuinely separate models to produce a final result, often more accurate and more genuinely stable than any single individual model. It works because different models tend to make genuinely different kinds of errors, and combining them together tends to genuinely cancel some of those individual errors out.

Bagging (Bootstrap Aggregating) trains multiple genuinely separate models, each on a genuinely different random sample of the training data, then combines their predictions, typically averaging or voting. A random forest is genuinely a bagging-based ensemble specifically built from decision trees.

Boosting trains models sequentially, with each genuinely new model specifically focusing on correcting the actual mistakes the previous models genuinely made, rather than bagging's approach of training every model independently and genuinely in parallel. Gradient Boosting and AdaBoost are both genuinely common boosting algorithms.

XGBoost is an optimized, genuinely efficient implementation of gradient boosting, adding regularization and genuinely careful handling of missing values directly built in. It's popular because it consistently performs genuinely well on tabular data across a wide, genuinely broad range of different real-world problems, often outperforming simpler algorithms with genuinely relatively little tuning required.

A neural network is a model made up of genuinely layered nodes (neurons), each connection carrying a genuinely learned weight, that together learn to transform an input into a genuine desired output by adjusting those weights during actual training. It's genuinely loosely inspired by how biological neurons connect, though the actual mathematical mechanism is quite genuinely different in practice.

An activation function introduces genuine non-linearity into a neural network, letting it actually learn genuinely complex, non-linear patterns rather than being limited to only ever learning something equivalent to a plain linear model. ReLU and sigmoid are both genuinely common activation function choices.

A shallow network has genuinely just one or a very small number of hidden layers. A deep network has genuinely many hidden layers stacked together, letting it learn a genuinely richer hierarchy of increasingly abstract features, which is exactly where the term deep learning itself actually comes from.

Softmax converts a vector of raw scores into a genuine probability distribution, where every value is between 0 and 1 and the whole set genuinely sums to 1. It's commonly used as the final layer's activation function in a multi-class classification network, turning raw output scores into an actual probability for each possible class.

Backpropagation is the algorithm used to genuinely train a neural network, calculating how much each individual weight genuinely contributed to the model's overall error, then adjusting every weight slightly in the direction that would genuinely reduce that error, repeating this process over many genuine training iterations.

Pooling reduces a feature map's spatial dimensions, typically taking the actual maximum (max pooling) or average value within each genuinely small local region. It reduces the total number of parameters and computation genuinely required, while also making the learned features somewhat more resistant to a small shift or genuine distortion in the input image.

An RNN processes a genuine sequence of inputs one step at a time, maintaining an internal hidden state that genuinely carries information forward from earlier steps in that same sequence. It fits sequential data well, like genuine text or a time series, where the actual order of the data genuinely, meaningfully matters.

During backpropagation, a gradient can shrink dramatically as it's genuinely propagated backward through many layers (or many time steps in an RNN), eventually becoming so genuinely tiny that earlier layers essentially stop actually learning at all. LSTM and GRU architectures were genuinely specifically designed to help address this particular problem for recurrent networks.

Transfer learning takes a model already genuinely pretrained on a large, existing dataset and adapts it to a genuinely new, related task, often needing far less genuinely new training data than training an entirely new model completely from scratch would require. It's common because training a genuinely large deep learning model completely from scratch demands enormous, genuinely real amounts of data and compute that most individual real-world projects simply don't actually have available.

A Transformer uses an attention mechanism to genuinely weigh the relevance of every other token in a sequence when processing any given one, rather than processing tokens strictly one at a time in genuine order the way an RNN does. This lets it genuinely process an entire sequence in parallel and capture genuinely long-range dependencies far more effectively, which is why it's become the actual dominant architecture behind most modern large language models.

Gradient descent iteratively adjusts a model's parameters in the genuine direction that reduces its actual loss function, guided by the gradient. The learning rate controls how large a genuine step is actually taken on each iteration. Too large a rate can genuinely overshoot the actual optimal point entirely. Too small a rate makes training genuinely, painfully slow to actually converge.

Batch gradient descent uses the entire genuine training dataset to compute each individual update, which is genuinely stable but slow on a large dataset. Stochastic gradient descent uses just one genuinely single example per update, which is fast but genuinely noisy. Mini-batch gradient descent uses a genuinely small batch of examples per update, striking a practical, genuinely common middle ground between the two extremes.

L1 regularization can genuinely shrink some feature weights all the way to exactly zero, effectively performing a form of automatic feature selection. L2 regularization shrinks weights toward zero but genuinely, rarely all the way to exactly zero, instead spreading the actual penalty more genuinely evenly across every weight.

Dropout randomly disables a genuine fraction of neurons during each individual training step, forcing the network to avoid becoming overly, genuinely dependent on any one single specific neuron or a narrow, specific combination of them. This encourages the network to genuinely learn a sturdier, more redundant, and generalizable representation overall.

Batch normalization normalizes each individual layer's actual inputs during training, helping keep their genuine distribution more stable as the network's own weights keep changing throughout training. This can genuinely speed up training and, in many cases, also improve the resulting model's genuinely final performance.

Model drift happens when the statistical properties of incoming data genuinely change over time, so a model trained on older data gradually becomes less accurate on genuinely new, evolving data, even though nothing about the model itself has actually changed. Monitoring the model's live prediction accuracy against actual real outcomes, and separately monitoring the distribution of incoming feature values for a meaningful genuine shift, are both genuinely needed to catch drift, since it can happen for genuinely different underlying reasons.

MLOps applies DevOps-style discipline, version control, automated testing, continuous deployment, specifically to the Machine Learning lifecycle, but adds genuinely ML-specific concerns DevOps alone doesn't typically cover. Versioning datasets and trained models alongside code, monitoring for model drift rather than just uptime, and automating retraining pipelines are all genuinely ML-specific additions on top of standard DevOps practice.

A scheduled pipeline retrains the model on genuinely fresh data at a defined interval, evaluates the new model against the currently deployed one on a genuinely held-out validation set, and only actually promotes it to production if it genuinely performs better, rather than blindly deploying every retrained version regardless of whether it actually improved anything.

A feature store centralizes genuinely commonly-used, precomputed features so multiple models and teams can genuinely reuse the same feature logic and definitions, rather than each team independently reimplementing, and potentially subtly miscalculating, the exact same feature from scratch. It also helps ensure genuine consistency between the features used during training and the ones actually available and computed the same way at real prediction time.

Tools like DVC (Data Version Control) or MLflow track dataset and model versions alongside the actual code that produced them, so a specific model's exact training data, hyperparameters, and resulting performance metrics can genuinely always be reproduced and audited later, rather than losing track of exactly which version of the data genuinely produced which specific deployed model.

It comes down to how the prediction is actually genuinely going to be used. If a user needs an immediate answer at the moment of interaction, a fraud check during checkout, for instance, that calls for a genuinely real-time API. If predictions can be computed ahead of time and simply looked up later, a nightly batch job is genuinely simpler to build, run, and maintain.

Route a defined percentage of genuinely live traffic to each model version, log which version served each prediction alongside the eventual, actual outcome, then compare the two versions' actual real performance once enough genuine volume has accumulated to draw a statistically meaningful conclusion. This requires the serving infrastructure to genuinely support routing and logging by model version from the actual start.

A technique like SHAP values quantifies each feature's actual contribution to a genuinely specific individual prediction, translating far more naturally into plain, understandable language than trying to explain a complex model's genuine internal mechanics directly. In genuinely high-stakes or regulated contexts, this explainability requirement can sometimes actually push you toward choosing a genuinely simpler, inherently more interpretable model instead.

I'd start with a simple, interpretable baseline and only actually move to something more complex once it delivers a genuine, measurable improvement that actually matters for the real business problem at hand, since a genuinely complex model is harder to debug, explain, and maintain over time, a real cost that needs to be genuinely justified by real, actual benefit.

I'd investigate whether that subgroup is genuinely underrepresented in the training data, and consider techniques like oversampling that specific subgroup, or training a genuinely separate, specialized model for it if the underlying pattern actually genuinely differs enough to warrant that. Simply accepting a genuinely poor result for a real subgroup, especially one tied to a protected characteristic, can raise genuine fairness and real ethical concerns worth taking seriously.

Track key performance metrics, like accuracy or false positive rate, broken down separately by each genuinely relevant group, rather than relying purely on one single, aggregated overall metric that could genuinely hide a real, meaningful disparity between groups. Alerting on a genuinely significant, growing gap between groups catches a genuine fairness issue before it actually causes real, tangible harm.

Distributed training frameworks, like Spark MLlib or a distributed variant of a deep learning framework, split the actual training work across multiple machines. For genuinely simpler cases, processing data in chunks, or using an algorithm genuinely capable of incremental, online learning, can avoid needing the full, complete dataset in memory all at once.

I'd prioritize genuinely shared infrastructure, a common feature store, standardized model deployment and monitoring tooling, that every project can genuinely reuse, rather than each individual project team independently reinventing the exact same underlying MLOps foundation separately and redundantly.

I check whether the actual problem genuinely justifies the complexity of an ML approach at all, whether the proposed evaluation metric genuinely aligns with the real business goal, and whether the team has genuinely thought through how the model will actually be monitored and maintained once it's genuinely live in production, beyond just how it performs on an offline test set.

Automate what can genuinely be automated, required model registration and monitoring setup, enforced directly as part of each team's own deployment pipeline, so standards aren't purely a matter of individual opinion. For conventions that genuinely resist full automation, I'd document the handful of decisions that actually matter most, along with the real reasoning behind each one.

I'd weigh how genuinely specific and differentiated the actual business need is against the real cost and complexity of training and maintaining a genuinely custom model. A genuinely common, well-solved problem, like general sentiment analysis, often doesn't justify custom model development, while a genuinely unique problem tied closely to a specific, actual business's own real data often does.

I'd suspect model drift first, checking whether the genuine, actual distribution of incoming production data has meaningfully shifted away from what the model was originally actually trained on. Comparing recent production data's actual feature distributions against the genuinely original training data's distributions usually reveals exactly where and how that genuine shift actually occurred.

Track prediction distribution and, where genuine ground truth eventually becomes available, actual accuracy over time, alerting on meaningful drift in either. A model that's technically up and serving predictions, but has quietly degraded in accuracy due to model drift, is a genuinely worse failure than an obvious outright crash, since nobody notices until the model's decisions start visibly causing real, tangible harm.

Treat the model's actual input and output schema as a genuine contract with every consuming system. A genuinely new model version can change its internal logic freely, but changing the expected input format or the output's own structure needs a documented, genuine transition plan, rather than a silent change that breaks a downstream consumer that was never actually told to expect it.

Roll back to the genuinely previous, known-good model version immediately to actually stop real harm, before digging into root cause. Then I'd compare the new model's actual training data and hyperparameters against the previous version's, since a genuine data quality issue or a subtle bug in the retraining pipeline itself is a far more common actual cause than the underlying algorithm itself genuinely being at fault.

Start from actual load testing the serving infrastructure at realistic prediction request volumes, and separately test the training pipeline at genuinely realistic future data volumes, since those are two genuinely distinct concerns that scale somewhat differently and can each independently become the real, actual bottleneck first.

This is a judgment question interviewers use to see how you reason under genuine uncertainty, not to test a specific textbook fact. A strong answer names the actual constraint that forced the decision, the realistic options that were genuinely on the table, why you picked one knowing it wasn't guaranteed to be right, and what you'd do differently with what you know now.

I'd pair them directly with actually deploying one of their own real models end to end, walking through model serialization, building the actual API, and setting up genuinely basic monitoring together, rather than treating production deployment as an entirely genuinely separate skill someone else always simply handles for them.

I wouldn't lead with the model's own technical accuracy metrics. I'd show it performing well specifically on a genuinely concrete, real case they personally, actually care about and already deeply understand themselves, and be genuinely transparent and upfront about exactly where and when the model is actually less confident, rather than overselling it as being universally, always genuinely correct.

I'd push for actually validating that offline improvement against real, genuine business impact through a proper, live A/B test, rather than a purely abstract, offline metric debate alone. A genuinely small, statistically significant improvement in one specific offline metric doesn't always actually translate into a genuinely meaningful real-world, real business result.