Machine Learning Interview Questions and Answers (Freshers and Experienced)

Machine learning is a branch of AI where systems learn patterns from data instead of following hand-written rules. You give the algorithm examples, it fits a model, and the model makes predictions on new data. A spam filter learns from thousands of labelled emails rather than a list of banned words. The trade-off: ML needs good data, and a model only knows the patterns present in what it was trained on.

Supervised learning trains on labelled data, where each input has a known answer, like predicting house prices or tagging emails as spam. Unsupervised learning finds structure in unlabelled data, such as grouping customers into segments or reducing dimensions. Reinforcement learning trains an agent to take actions in an environment and learn from rewards, as in game-playing systems or robot control. Most business ML in India today is supervised, because companies already hold labelled history like past loan defaults.

Classification predicts a category, while regression predicts a continuous number. Will this customer churn (yes or no) is classification; how much will this customer spend next month is regression. The choice changes your algorithms and metrics: classification uses accuracy, precision, recall and ROC-AUC, while regression uses MAE, RMSE or R squared. Some problems can be framed either way, for example predicting a delivery delay in minutes or simply late versus on time.

Overfitting is when a model learns the training data too closely, including its noise, so it performs well on training data but poorly on new data. Underfitting is when the model is too simple to capture the real pattern, so it does badly on both. You spot overfitting when training accuracy is much higher than validation accuracy. Fixes include more data, simpler models, regularisation, early stopping and cross-validation. Underfitting needs better features or a more flexible model.

We split data so we can measure how a model performs on data it has never seen. The training set fits the model, the validation set tunes hyperparameters and compares models, and the test set gives one final, unbiased estimate. If you tune on the test set, it stops being unseen and your reported score becomes too optimistic. A common starting split is 70, 15 and 15 percent, but for time-based data you should split by date, not randomly.

A feature is an input variable the model uses to make a prediction, such as age, city or number of past orders. Feature engineering is creating better inputs from raw data: extracting the day of week from a timestamp, computing average order value, or encoding categories as numbers. Good features often improve a model more than switching algorithms. The risk is building features that use information not available at prediction time, which causes data leakage.

Linear regression predicts a number as a weighted sum of input features plus a constant, and it learns the weights by minimising the squared error between predictions and actual values. Its classic assumptions are a linear relationship, independent errors, constant error variance (homoscedasticity), normally distributed residuals for valid inference, and no strong multicollinearity between features. In practice, it is a strong, explainable baseline. If the relationship is curved, you can add polynomial or log features while keeping the model linear in its weights.

The bias-variance trade-off says that prediction error comes partly from bias (wrong, oversimplified assumptions) and partly from variance (sensitivity to the particular training sample). Simple models like linear regression tend to have high bias and low variance; deep trees have low bias and high variance. As you increase model complexity, bias usually falls and variance rises, so the goal is the sweet spot with the lowest validation error. Ensembles like random forests reduce variance by averaging many trees.

Regularisation adds a penalty for large model weights to the loss function, which discourages overly complex models and reduces overfitting. L1 (Lasso) penalises the absolute values of weights and can push some to exactly zero, so it also acts as feature selection. L2 (Ridge) penalises squared weights, shrinking them smoothly without removing features, and handles correlated features well. Elastic Net combines both. The regularisation strength is a hyperparameter you tune with cross-validation.

Cross-validation estimates how a model will perform on unseen data by training and testing it on different splits. In k-fold cross-validation, you divide data into k parts, train on k minus 1 parts and validate on the remaining one, repeat k times, then average the scores. It gives a more stable estimate than a single split, especially on small datasets. Use stratified k-fold for imbalanced classes and time-series splits for temporal data, where shuffling would leak the future into the past.

Precision is the share of predicted positives that are actually positive; recall is the share of actual positives the model catches. F1 score is the harmonic mean of the two, useful when you need a single number that balances them. For a cancer screening model, high recall matters most because missing a patient is costly. For a spam filter, high precision matters because blocking a real email annoys users. Changing the classification threshold trades one against the other.

The ROC curve plots the true positive rate against the false positive rate across all thresholds, and AUC is the area under it. An AUC of 0.5 means random ranking and 1.0 means perfect separation; you can read it as the probability that a random positive is scored above a random negative. On heavily imbalanced data, such as fraud at under 1 percent, ROC-AUC can look high while precision stays poor. The precision-recall curve is often more informative there.

Gradient descent is an optimisation method that repeatedly moves model parameters in the direction that reduces the loss, using the gradient as a guide. The learning rate controls the step size: too large and training diverges, too small and it crawls. Batch gradient descent uses all data per step, stochastic uses one example, and mini-batch uses small groups, which is the common default in deep learning. Variants such as momentum and Adam adapt the steps to train faster and more stably.

Logistic regression is a classification model that passes a weighted sum of features through a sigmoid function to output a probability between 0 and 1. It is called regression because it models the log-odds of the positive class as a linear function of the features. It is trained by minimising log loss, also called cross-entropy. You then pick a threshold, often 0.5 but tuned to business costs, to turn probabilities into classes. Its weights are easy to explain, which banks and lenders value.

A decision tree tries candidate splits on each feature and picks the one that makes the child nodes most pure. For classification, purity is measured with Gini impurity or entropy, where the drop in entropy is called information gain. For regression trees, it picks the split that most reduces squared error. Trees are easy to explain and handle non-linear patterns, but a fully grown tree overfits badly, so you limit depth, set minimum samples per leaf or prune it.

Random forest is a bagging method: it trains many deep trees independently on bootstrapped samples with random feature subsets, then averages their votes, which mainly reduces variance. Gradient boosting trains shallow trees one after another, where each new tree corrects the errors of the previous ones, which mainly reduces bias. Boosting libraries such as XGBoost, LightGBM and CatBoost often win on tabular data but need more careful tuning. Random forest is a forgiving default when you need a decent model quickly.

K-means groups data into k clusters by repeating two steps: assign each point to its nearest centroid, then move each centroid to the mean of its assigned points, until assignments stop changing. You choose k with the elbow method (where the drop in within-cluster error flattens), silhouette scores, and most importantly whether the clusters make business sense. K-means assumes roughly round, similar-sized clusters and is sensitive to feature scale, so standardise features first and try several random starts.

PCA (principal component analysis) is a dimensionality reduction technique that finds new, uncorrelated directions, called principal components, that capture the most variance in the data. You keep the top few components and drop the rest. Use it to compress many correlated features, speed up training, reduce noise or plot high-dimensional data in two dimensions. Standardise features before PCA, or large-scale features will dominate. The trade-off is interpretability, because each component mixes many original features.

Start by choosing the right metric, such as precision, recall, F1 or PR-AUC, because accuracy hides the minority class. Then try class weights in the loss function, resampling (undersampling the majority class or oversampling the minority, for example with SMOTE) and tuning the decision threshold to match business costs. Always resample only the training data, never the validation or test sets. In my experience, threshold tuning and class weights solve most cases before you need fancy resampling.

Data leakage is when information that would not be available at prediction time sneaks into training, making offline scores look far better than real performance. Common causes are features computed after the outcome (like a refund flag when predicting fraud), scaling or imputing on the full dataset before splitting, and random splits on time-series data. Prevent it by splitting first, fitting preprocessing inside a pipeline on training folds only, and asking for every feature: would I know this at prediction time?

For missing values, first ask why they are missing, because the reason often carries signal. Options include dropping rows or columns with heavy gaps, imputing with the median or most frequent value, model-based imputation, or adding a was-missing indicator. For categorical features, use one-hot encoding for low-cardinality columns, and target or frequency encoding for high-cardinality ones like PIN codes, fitted carefully to avoid leakage. Tree-based libraries such as LightGBM and CatBoost can handle categories natively.

A neural network is a model made of layers of connected units, where each unit computes a weighted sum of its inputs and applies a non-linear activation such as ReLU. Stacking layers lets it learn complex patterns. Backpropagation computes how much each weight contributed to the loss by applying the chain rule backwards through the network, and gradient descent then updates the weights. See what a neural network is for a visual walkthrough.

Vanishing gradients happen when gradients shrink as they flow backwards through many layers, so early layers barely learn. Sigmoid and tanh activations made this common in older deep networks and RNNs. Fixes include ReLU-style activations, careful weight initialisation such as He or Xavier, batch normalisation, residual connections and gated units like LSTMs and GRUs for sequences. Exploding gradients, the opposite problem, are often handled with gradient clipping. Residual connections are a big reason modern transformer models train well.

Package the model with the exact same preprocessing used in training, usually as a pipeline, and serve it through a batch job or an API. Then monitor three things: data drift (input distributions shifting), prediction drift and actual performance once true labels arrive. Log inputs and outputs, set alerts and plan scheduled retraining. A model trained on pre-festival shopping data, for example, may behave very differently during Diwali sales. Version models and data so you can roll back quickly.

If fraud is under 1 percent of transactions, a model that predicts not fraud for everything scores 99 percent accuracy and catches nothing. I would check the confusion matrix and switch to recall, precision and PR-AUC for the fraud class. Then I would agree the cost of a missed fraud versus a wrongly blocked payment with the business, tune the threshold to that trade-off, and add class weights. The fix starts with the metric, not the algorithm.

A gap that large signals overfitting, or a mismatch between training and test data. First, check for leakage and confirm the two sets come from the same distribution. Then simplify: limit tree depth, add regularisation, reduce features, use early stopping or get more data. Use cross-validation to confirm the fix is real and not luck. If the test data is genuinely different, for example from a new city, the problem is distribution shift, and you need representative training data.

First, confirm the production pipeline computes features exactly as training did, because training-serving skew is a common cause. Next, compare live input distributions with training data to detect drift, such as new user segments or a changed app flow. Then check whether offline validation leaked future information, which would have inflated the original score. Finally, look at label delays: early production metrics can be noisy. Each check narrows the cause before you retrain anything.

I would clarify the goal (approve or reject, or set a risk-based limit), then gather application, repayment and bureau data available at decision time only. I would start with logistic regression as an explainable baseline, then try gradient boosting and compare on a time-based validation split using recall, precision and AUC. I would also check fairness across groups, since lending decisions are regulated and must be explainable. The final choice balances accuracy with explainability for credit and compliance teams.