Introduction

A Machine Learning interview does not test only whether a candidate can name algorithms. Strong candidates must explain how algorithms work, identify their assumptions, select suitable evaluation metrics, write reliable code, investigate data problems, compare trade-offs, and design complete ML systems.

Interviewers may also examine how clearly candidates communicate. A technically correct answer can still appear weak if it lacks structure, ignores business requirements, overlooks data leakage, or fails to explain why one approach is preferable to another.

Effective preparation should therefore connect theory, coding, experimentation, system design, and professional communication.

Learning Objectives

Prerequisites

python -m pip install \
  numpy \
  pandas \
  scikit-learn \
  matplotlib \
  jupyter \
  pytest

Common ML Interview Formats

Understand the Target Role

Skill-Gap Matrix

Core ML Theory Checklist

Supervised vs Unsupervised Learning

Bias-Variance Trade-Off

Bias describes systematic error caused by assumptions that are too restrictive. Variance describes sensitivity to changes in the training data.

Classification Metrics

Regression Metrics

Data Leakage

Data leakage occurs when training or feature construction uses information that would not be legitimately available when a prediction is made.

Cross-Validation

Algorithm Comparison

Coding Interview Strategy

Common Coding Patterns

Coding Example: Binary Classification Metrics

def calculate_binary_metrics(
    true_labels,
    predicted_labels
):
    if len(
        true_labels
    ) != len(
        predicted_labels
    ):
        raise ValueError(
            "Label collections must "
            "have equal length."
        )

    if not true_labels:

        raise ValueError(
            "At least one prediction "
            "is required."
        )

    allowed_values = {
        0,
        1
    }

    if (
        not set(
            true_labels
        ).issubset(
            allowed_values
        )
        or not set(
            predicted_labels
        ).issubset(
            allowed_values
        )
    ):
        raise ValueError(
            "Labels must be zero or one."
        )

    true_positive = 0
    true_negative = 0
    false_positive = 0
    false_negative = 0

    for true_value, predicted_value in zip(
        true_labels,
        predicted_labels
    ):
        if (
            true_value == 1
            and predicted_value == 1
        ):
            true_positive += 1

        elif (
            true_value == 0
            and predicted_value == 0
        ):
            true_negative += 1

        elif (
            true_value == 0
            and predicted_value == 1
        ):
            false_positive += 1

        else:
            false_negative += 1

    precision_denominator = (
        true_positive
        +
        false_positive
    )

    recall_denominator = (
        true_positive
        +
        false_negative
    )

    precision = (
        true_positive
        /
        precision_denominator
        if precision_denominator
        else 0.0
    )

    recall = (
        true_positive
        /
        recall_denominator
        if recall_denominator
        else 0.0
    )

    f1_score = (
        2
        *
        precision
        *
        recall
        /
        (
            precision
            +
            recall
        )
        if (
            precision
            +
            recall
        )
        else 0.0
    )

    accuracy = (
        true_positive
        +
        true_negative
    ) / len(
        true_labels
    )

    return {
        "accuracy": accuracy,
        "precision": precision,
        "recall": recall,
        "f1": f1_score,
        "true_positive": true_positive,
        "true_negative": true_negative,
        "false_positive": false_positive,
        "false_negative": false_negative
    }

Coding Example: Top-k Frequent Values

from collections import Counter
import heapq


def top_k_frequent(
    values,
    k
):
    if k <= 0:

        raise ValueError(
            "k must be positive."
        )

    if not values:

        return []

    frequency_by_value = Counter(
        values
    )

    result_count = min(
        k,
        len(
            frequency_by_value
        )
    )

    top_items = heapq.nlargest(
        result_count,
        frequency_by_value.items(),
        key=lambda item: item[
            1
        ]
    )

    return [
        value
        for value, frequency
        in top_items
    ]

NumPy Interview Topics

import numpy as np


def standardize_columns(
    feature_matrix
):
    feature_matrix = np.asarray(
        feature_matrix,
        dtype=np.float64
    )

    if feature_matrix.ndim != 2:

        raise ValueError(
            "Expected a two-dimensional matrix."
        )

    column_means = np.mean(
        feature_matrix,
        axis=0
    )

    column_standard_deviations = np.std(
        feature_matrix,
        axis=0
    )

    if np.any(
        column_standard_deviations == 0
    ):
        raise ValueError(
            "A constant column cannot "
            "be standardized safely."
        )

    return (
        feature_matrix
        -
        column_means
    ) / column_standard_deviations

pandas Interview Topics

import pandas as pd


def summarize_customer_activity(
    transactions
):
    required_columns = {
        "customer_id",
        "transaction_id",
        "amount"
    }

    missing_columns = (
        required_columns
        -
        set(
            transactions.columns
        )
    )

    if missing_columns:

        raise ValueError(
            "Missing columns: "
            +
            ", ".join(
                sorted(
                    missing_columns
                )
            )
        )

    summary = (
        transactions
        .groupby(
            "customer_id",
            as_index=False
        )
        .agg(
            transaction_count=(
                "transaction_id",
                "nunique"
            ),
            total_amount=(
                "amount",
                "sum"
            ),
            average_amount=(
                "amount",
                "mean"
            )
        )
    )

    return summary.sort_values(
        "total_amount",
        ascending=False
    )

SQL Interview Topics

WITH customer_totals AS
(
    SELECT
        customer_id,
        COUNT(DISTINCT transaction_id) AS transaction_count,
        SUM(amount) AS total_amount,
        AVG(amount) AS average_amount
    FROM transactions
    WHERE transaction_date < :prediction_time
    GROUP BY customer_id
)
SELECT
    customer_id,
    transaction_count,
    total_amount,
    average_amount,
    DENSE_RANK() OVER
    (
        ORDER BY total_amount DESC
    ) AS amount_rank
FROM customer_totals
ORDER BY amount_rank, customer_id;

Implement Linear Regression with Gradient Descent

import numpy as np


class LinearRegressionGradientDescent:

    def __init__(
        self,
        learning_rate=0.01,
        iterations=1000
    ):
        if learning_rate <= 0:

            raise ValueError(
                "learning_rate must be positive."
            )

        if iterations <= 0:

            raise ValueError(
                "iterations must be positive."
            )

        self.learning_rate = learning_rate
        self.iterations = iterations
        self.weights = None
        self.bias = None
        self.loss_history = []

    def fit(
        self,
        feature_matrix,
        targets
    ):
        feature_matrix = np.asarray(
            feature_matrix,
            dtype=np.float64
        )

        targets = np.asarray(
            targets,
            dtype=np.float64
        )

        if feature_matrix.ndim != 2:

            raise ValueError(
                "feature_matrix must be two-dimensional."
            )

        if targets.ndim != 1:

            raise ValueError(
                "targets must be one-dimensional."
            )

        if (
            feature_matrix.shape[
                0
            ]
            != targets.shape[
                0
            ]
        ):
            raise ValueError(
                "Feature and target counts must match."
            )

        sample_count, feature_count = (
            feature_matrix.shape
        )

        self.weights = np.zeros(
            feature_count,
            dtype=np.float64
        )

        self.bias = 0.0

        for iteration in range(
            self.iterations
        ):
            predictions = (
                feature_matrix
                @
                self.weights
                +
                self.bias
            )

            errors = (
                predictions
                -
                targets
            )

            weight_gradient = (
                2.0
                /
                sample_count
            ) * (
                feature_matrix.T
                @
                errors
            )

            bias_gradient = (
                2.0
                *
                np.mean(
                    errors
                )
            )

            self.weights -= (
                self.learning_rate
                *
                weight_gradient
            )

            self.bias -= (
                self.learning_rate
                *
                bias_gradient
            )

            mean_squared_error = np.mean(
                errors ** 2
            )

            self.loss_history.append(
                float(
                    mean_squared_error
                )
            )

        return self

    def predict(
        self,
        feature_matrix
    ):
        if self.weights is None:

            raise RuntimeError(
                "The model must be fitted "
                "before prediction."
            )

        feature_matrix = np.asarray(
            feature_matrix,
            dtype=np.float64
        )

        return (
            feature_matrix
            @
            self.weights
            +
            self.bias
        )

Implement K-Means Clustering

import numpy as np


def run_kmeans(
    feature_matrix,
    cluster_count,
    maximum_iterations=100,
    random_seed=42
):
    feature_matrix = np.asarray(
        feature_matrix,
        dtype=np.float64
    )

    if feature_matrix.ndim != 2:

        raise ValueError(
            "Expected a two-dimensional matrix."
        )

    sample_count = feature_matrix.shape[
        0
    ]

    if not (
        1
        <=
        cluster_count
        <=
        sample_count
    ):
        raise ValueError(
            "Invalid cluster_count."
        )

    random_generator = (
        np.random.default_rng(
            random_seed
        )
    )

    initial_indices = (
        random_generator.choice(
            sample_count,
            size=cluster_count,
            replace=False
        )
    )

    centroids = feature_matrix[
        initial_indices
    ].copy()

    labels = np.zeros(
        sample_count,
        dtype=np.int64
    )

    for iteration in range(
        maximum_iterations
    ):
        distances = np.linalg.norm(
            feature_matrix[
                :,
                None,
                :
            ]
            -
            centroids[
                None,
                :,
                :
            ],
            axis=2
        )

        new_labels = np.argmin(
            distances,
            axis=1
        )

        if np.array_equal(
            new_labels,
            labels
        ) and iteration > 0:

            break

        labels = new_labels

        new_centroids = []

        for cluster_id in range(
            cluster_count
        ):
            cluster_points = feature_matrix[
                labels == cluster_id
            ]

            if len(
                cluster_points
            ) == 0:
                replacement_index = (
                    random_generator.integers(
                        sample_count
                    )
                )

                new_centroids.append(
                    feature_matrix[
                        replacement_index
                    ]
                )

            else:
                new_centroids.append(
                    np.mean(
                        cluster_points,
                        axis=0
                    )
                )

        centroids = np.vstack(
            new_centroids
        )

    return {
        "centroids": centroids,
        "labels": labels,
        "iterations": iteration + 1
    }

Model Debugging Framework

ML System Design Framework

Example System Design Question

Project Deep-Dive Framework

Behavioral Interview Preparation

Behavioral answers should describe a specific situation and make your decisions and contributions clear.

Communicate Technical Answers Clearly

Theory Practice Questions

Coding Practice Questions

Test Your Coding Solution

def test_binary_metrics():

    result = calculate_binary_metrics(
        true_labels=[
            1,
            0,
            1,
            1
        ],
        predicted_labels=[
            1,
            1,
            1,
            0
        ]
    )

    assert result[
        "true_positive"
    ] == 2

    assert result[
        "false_positive"
    ] == 1

    assert result[
        "false_negative"
    ] == 1

    assert result[
        "true_negative"
    ] == 0


def test_binary_metrics_rejects_mismatched_lengths():

    try:
        calculate_binary_metrics(
            true_labels=[
                1,
                0
            ],
            predicted_labels=[
                1
            ]
        )

        assert False

    except ValueError:

        assert True

Mock Interview Framework

Interview Readiness Scorecard

Preparation Routine

Common Interview Mistakes

Recommended Interview Preparation Workflow

Hands-On Practice

Interview Readiness Checklist

Lesson Summary