Classification and Regression Fundamentals Questions

Covers the core concepts and distinctions between classification and regression in supervised learning. Classification predicts discrete categories, either binary or multi class, while regression predicts continuous numerical values. Candidates should understand how to format and encode target variables for each task, common algorithms for each family, and the theoretical foundations of representative models such as linear regression and logistic regression. For regression, know least squares estimation, coefficients interpretation, residual analysis, assumptions of the linear model, R squared, and common loss and error measures including mean squared error, root mean squared error, and mean absolute error. For classification, know logistic regression with its sigmoid transformation and probability interpretation, decision trees, k nearest neighbors, and other basic classifiers; understand loss functions such as cross entropy and evaluation metrics including accuracy, precision, recall, F one score, and area under the receiver operating characteristic curve. Also be prepared to discuss model selection, regularization techniques such as L one and L two regularization, handling class imbalance, calibration and probability outputs, feature preprocessing and encoding for targets and inputs, and trade offs when choosing approaches based on problem constraints and data characteristics.

EasyTechnical

23 practiced

Define logistic regression mathematically and explain how the sigmoid function converts linear outputs into probabilities. In a one-paragraph explanation, describe why logistic regression is suitable for binary conversion-prediction problems in an e-commerce BI context.

EasyBehavioral

26 practiced

You need to explain multicollinearity to a product manager who uses a linear regression model to prioritize product features for investment. Provide a concise explanation of what multicollinearity is, why it affects coefficient interpretation, and two remediation strategies you would implement in the BI modeling workflow.

HardTechnical

22 practiced

A BI dashboard needs to display an ensemble model's predictions but stakeholders want a simple explanation of how the prediction was made. Describe two techniques to explain ensemble outputs and how feasible they are for real-time dashboard tooltips.

Sample Answer

Technique 1 — SHAP (TreeSHAP/KernelSHAP for ensembles)- What: SHAP assigns additive feature attributions consistent with game-theoretic Shapley values. For tree ensembles you can use TreeSHAP (fast, exact for tree-based models); for arbitrary ensembles KernelSHAP approximates Shapley values.- Why: Produces per-prediction, local explanations that sum to the model output, easy to present as “+/- contribution” bars in a tooltip.- Real-time feasibility: TreeSHAP is feasible for real-time if your ensemble is tree-based (XGBoost/LightGBM/RandomForest) because it runs in milliseconds per prediction. KernelSHAP is expensive (many model evaluations) and not suitable for live tooltips without approximation. Practical approach: compute SHAP values offline for common segments, cache top-k feature contributions, or use TreeSHAP server-side microservice that returns pre-warmed values.

Technique 2 — Local surrogate models (LIME) and global simplified surrogates- What: Fit an interpretable model (linear model or small decision tree) locally around a single prediction (LIME) or globally to approximate the ensemble. LIME highlights influential features for the locality; a global surrogate yields simple rules or a small decision tree you can show in the dashboard.- Why: Surrogate explanations are intuitive (coefficients/rules) and easy to show in tooltips.- Real-time feasibility: LIME requires sampling and many model calls — costly for live tooltips. Feasible tactics: precompute surrogates for typical cohorts or use a lightweight online approximation (e.g., incremental linear model updated periodically). Global surrogates can be computed offline and served quickly.

Practical implementation tips for BI dashboards- Prefer TreeSHAP when using tree ensembles; integrate results into your ETL to compute and store SHAP values per record (or for representative cohorts) and serve via the dashboard’s data source for instant tooltips.- If model calls are cheap and latency budget allows, expose a prediction+explain API; otherwise, precompute and cache top-N feature attributions.- UI design: show top 3 contributors, direction (+/-), and a short plain-language sentence (e.g., “High recency and low purchase amount increased the churn risk by 12%”).- Guardrails: include confidence/approximation notes and provide “explain more” links that fetch full explanations asynchronously.

Trade-offs summary- Accuracy vs. latency: exact local methods (TreeSHAP) can be fast for tree models; sampling-based methods (KernelSHAP, LIME) are more interpretable but costly.- Precompute + cache is the most practical BI solution for snappy tooltips; real-time exact explanations are possible only with efficient algorithms or when serving explanations from a dedicated, optimized service.

MediumTechnical

23 practiced

Explain cross-entropy loss for binary classification and why it is preferred over 0/1 loss in training probabilistic classifiers. Describe in simple terms what minimizing cross-entropy does to model probabilities and how that relates to calibration.

EasyTechnical

32 practiced

Implement a Python function using NumPy to compute Mean Squared Error (MSE) and Root Mean Squared Error (RMSE) between two arrays: y_true and y_pred. Assume both are 1D NumPy arrays of the same length. Provide the function signature and a short explanation of when RMSE is preferred over MAE in reporting business impact.

Sample Answer

To compute MSE and RMSE efficiently with NumPy, subtract vectors elementwise, square the residuals, take the mean for MSE and square root for RMSE.

python

import numpy as np

def mse_rmse(y_true: np.ndarray, y_pred: np.ndarray) -> tuple:
    """
    Compute Mean Squared Error (MSE) and Root Mean Squared Error (RMSE).
    Assumes y_true and y_pred are 1D NumPy arrays of equal length.

    Returns: (mse, rmse)
    """
    if y_true.shape != y_pred.shape:
        raise ValueError("y_true and y_pred must have the same shape")
    # ensure float type to avoid integer overflow/truncation
    y_true = y_true.astype(float)
    y_pred = y_pred.astype(float)

    resid = y_true - y_pred
    mse = np.mean(resid ** 2)
    rmse = np.sqrt(mse)
    return mse, rmse

Key points:- Vectorized NumPy operations give O(n) time and O(1) extra space (ignoring input/resid storage).- Handle edge cases: mismatched shapes, NaNs (consider using np.nanmean if you want to ignore NaNs).

When to prefer RMSE over MAE (business context):- RMSE penalizes larger errors more due to squaring, so it's preferable when big misses are particularly costly (e.g., forecasting demand where stockouts or overstocks have nonlinear cost). MAE is more interpretable and less sensitive to outliers; choose RMSE when prioritizing reducing large errors that drive business risk or cost.

Unlock Full Question Bank

Get access to hundreds of Classification and Regression Fundamentals interview questions and detailed answers.

Join thousands of developers preparing for their dream job.