ML Fundamentals: Supervised Learning Algorithms Questions

Deep understanding of linear regression, logistic regression, decision trees, random forests, SVMs, and ensemble methods. Be able to explain: how each algorithm works, advantages/disadvantages, when to use each, regularization techniques (L1/L2), hyperparameter tuning, and how to handle overfitting.

HardSystem Design

54 practiced

Design a production ML system to train, validate, deploy, and monitor supervised models (linear/logistic regression, decision trees, ensembles). Include requirements: batch and real-time inference, retraining on detected drift, model registry and versioning, reproducible experiments, feature store, and resource allocation (GPU/CPU). Describe rollback and A/B testing strategy.

Sample Answer

Requirements (functional & non-functional):- Support training and validating supervised models (linear/logistic, trees, ensembles).- Batch + real-time inference; low latency (<100ms) for real-time, high throughput for batch.- Automatic detection of data/model drift → trigger retraining.- Model registry with versioning, metadata, artifacts, reproducible experiments.- Feature store (online + offline) with consistent feature transformation.- Resource allocation across GPU/CPU; cost-aware scheduling.- A/B testing and safe rollback.

High-level architecture:- Ingestion layer: streaming (Kafka) + batch (S3/Glue).- Feature pipeline: ETL jobs (Spark/Flink) -> Offline feature store (Parquet on S3 + catalog) and Online feature store (Redis/Cassandra) with feature keys.- Experimentation & training: Kubeflow/MLFlow orchestrating jobs (K8s); trainers pick CPU/GPU node pools; use DAGs for preprocessing, training, evaluation.- Model registry: MLflow or custom service storing model artifacts, metrics, signatures, lineage, schema, and CI/CD hooks.- Serving: Two serving paths: - Batch: Spark jobs reading offline features + model artifact from registry. - Real-time: Model server (KFServing/TorchServe/Seldon) using online feature store; autoscaled via K8s HPA/Knative; GPU nodes for heavy ensembles if needed.- Monitoring & drift detection: Metrics pipeline (Prometheus + Grafana) + ML-specific monitors (Evidently/WhyLogs) capturing feature distributions, prediction distributions, label arrival; compute PSI, KL-divergence, performance degradation.- Retraining loop: If drift or performance drop crosses thresholds, create retrain job via orchestrator using last-n data, run automated validation (backtests, holdout), register candidate model to registry with tests.

Data flow:1. Data → ingestion → feature engineering → store in offline/online stores.2. Trainer pulls offline features, runs reproducible experiment (Docker image + seed + hash of code + data snapshot), stores artifact+metadata in registry.3. CI validation (smoke tests, unit, integration, fairness, explainability) → promotion to staging.4. Deployment via canary/A-B to serving infra, routing controlled by Feature Flags/Traffic Router.

Reproducibility & lineage:- All experiments logged: code hash (git), environment (Conda/Docker), data snapshot IDs, feature transforms, hyperparams.- Use immutable feature definitions and transform libraries stored in repo; register feature schemas.

Resource allocation:- K8s node pools: CPU pool (for linear models, light work) and GPU pool (for heavy ensembles). Jobs labeled to request specific pools. Scheduler (K8s + Volcano) for priority and spot instances for cost savings.- Autoscaling based on queue length, latency SLOs, and throughput.

Model registry & versioning:- Each model version stores: artifact, signature (input schema), metrics, validation results, training data snapshot, lineage, deployed endpoints.- Promotion stages: Staging → Canary → Production. Only promoted via gated approvals or automated policies.

A/B testing & rollback:- Canary rollout: deploy new model to small % of traffic; collect online metrics and compare to control (prod) using predefined significance tests for key metrics (latency, error rate, business KPIs).- Multi-armed A/B: use randomized traffic splitter, log treatment assignment, and use offline statistical tests or sequential testing with false discovery control.- Automatic rollback policy: If new model underperforms on core metrics or increases error beyond threshold, orchestrator routes all traffic back to last stable version and marks the candidate as failed in registry.- Manual rollback: one-click in UI to promote previous version.

Trade-offs & considerations:- Consistency: feature store ensures training/serving parity; materialization costs vs compute-on-demand trade-off.- Latency vs model complexity: ensembles provide accuracy at cost of latency; use distillation or hybrid approach: lightweight model for real-time, heavy model for batch scoring.- Cost vs freshness: retrain frequency tuned to drift detection to avoid unnecessary compute.- Security & governance: RBAC on registry, data access controls, audit logs, and explainability hooks for compliance.

This design yields reproducible experiments, robust deployment, automatic retraining on drift, and safe rollouts with fast rollback/A-B testing while balancing latency, cost, and operational complexity.

EasyTechnical

84 practiced

In Python, implement two functions mse(y_true, y_pred) and r2_score(y_true, y_pred) using numpy arrays. Handle edge cases such as zero variance in y_true (define behavior) and ensure O(n) time and vectorized operations. Include docstrings explaining behavior.

Sample Answer

To compute MSE and R² efficiently with numpy, use fully vectorized operations and O(n) time. Behavior for zero variance in y_true: if all y_true are equal, R² will be 1.0 when y_pred exactly matches y_true, otherwise 0.0 (explicit, deterministic handling instead of NaN).

python

import numpy as np

def mse(y_true, y_pred):
    """
    Mean Squared Error (MSE).
    Parameters:
        y_true (array-like): true target values
        y_pred (array-like): predicted values
    Returns:
        float: mean squared error
    Raises:
        ValueError: if shapes don't match or inputs are empty
    """
    y_true = np.asarray(y_true, dtype=float)
    y_pred = np.asarray(y_pred, dtype=float)
    if y_true.shape != y_pred.shape:
        raise ValueError("y_true and y_pred must have the same shape")
    if y_true.size == 0:
        raise ValueError("Inputs must be non-empty")
    err = y_true - y_pred
    return float(np.mean(err * err))


def r2_score(y_true, y_pred):
    """
    Coefficient of determination (R^2).
    R^2 = 1 - SS_res / SS_tot where SS_res = sum((y_true - y_pred)^2)
    and SS_tot = sum((y_true - mean(y_true))^2).
    Edge case: if y_true has zero variance (all values equal):
      - return 1.0 if y_pred equals y_true exactly (perfect prediction)
      - else return 0.0 (no explanatory power beyond the constant)
    Parameters:
        y_true, y_pred: array-like, same shape
    Returns:
        float: R^2 score
    """
    y_true = np.asarray(y_true, dtype=float)
    y_pred = np.asarray(y_pred, dtype=float)
    if y_true.shape != y_pred.shape:
        raise ValueError("y_true and y_pred must have the same shape")
    if y_true.size == 0:
        raise ValueError("Inputs must be non-empty")

    ss_res = np.sum((y_true - y_pred) ** 2)
    mean = np.mean(y_true)
    ss_tot = np.sum((y_true - mean) ** 2)

    if ss_tot == 0.0:
        # all y_true equal
        return 1.0 if np.allclose(y_pred, y_true) else 0.0

    return float(1.0 - ss_res / ss_tot)

Key points:- Vectorized numpy ops guarantee O(n) time and O(1) extra space (besides input arrays).- Validates shapes and non-empty inputs.- Explicit, deterministic handling for zero variance in y_true.

EasyTechnical

42 practiced

Describe logistic regression for binary classification: model form (log-odds and sigmoid), loss function (binary cross-entropy / negative log-likelihood), and how to interpret coefficients as log-odds change. Compare pros and cons of logistic regression versus tree-based methods for production applications.

EasyTechnical

82 practiced

Explain the bias-variance tradeoff in supervised learning with concrete examples: how model complexity (linear models vs deep trees) affects bias and variance, how ensembling (bagging/boosting) impacts the tradeoff, and strategies to manage both in practice.

EasyTechnical

53 practiced

Explain train/validation/test splits and k-fold cross-validation for supervised learning. When should you use stratified k-fold, time-series (rolling) splits, and nested cross-validation? Explain trade-offs when data is small versus large.

Unlock Full Question Bank

Get access to hundreds of ML Fundamentals: Supervised Learning Algorithms interview questions and detailed answers.

Join thousands of developers preparing for their dream job.