Katkat

practice a little every day, paws crossed ♡

Machine Learning Engineer Interview Questions

Practice 9403 coding, system design and machine learning questions from 546 companies, sorted by role, topic and interview round. Every question has step-by-step hints, a code runner that supports 8 languages and an AI mentor; members also get the full solution walkthrough.

9403
Questions
546
Companies
11
Topics
8
Languages

Showing 481–510 of 782 results

  • OpenAIHardMachine Learning Engineer
    Hand-Written Gradients: Prefix-Product Backward Pass and Stable Cross-Entropy

    Write gradients by hand: the forward and backward pass of the prefix-product operation, in linear time and without division so inputs may contain zeros, and a numerically stable softmax cross-entropy loss with its gradient in NumPy. It tests the chain rule, prefix and suffix products, and gradient checking.

    Machine LearningOnsite
  • OpenAIMediumMachine Learning Engineer
    Implement 1NN with NumPy

    Tests your ability to implement a fast, vectorized 1-Nearest Neighbor (1NN) classifier using NumPy, focusing on memory-efficient distance computations and tie-breaking.

    Machine LearningTechnical Screennumpyvectorizationmachine-learning
  • OpenAIMediumMachine Learning Engineer
    Implement Masked Cross-Entropy with Label Smoothing

    Implement a numerically stable, masked cross-entropy loss function with label smoothing and temperature scaling in NumPy, returning both the loss and analytical gradients.

    Machine LearningTechnical Screenmachine-learningnumpydeep-learning
  • OpenAIMediumMachine Learning Engineer
    Implement Prefix Products and Their Backward Pass

    Work through inclusive prefix products in separate-output, in-place, reverse-gradient, and parallel variants. Explain zeros, overflow, mutation and aliasing, constant temporary workspace, synchronization, floating-point effects, and the work/depth trade-offs of each part.

    Machine LearningOnsite
  • OpenAIHardMachine Learning Engineer
    Implement a 1-Nearest-Neighbor Classifier with a Manhattan-Distance Follow-Up

    Implement a 1-nearest-neighbor classifier that labels each query point with the label of its closest training point under Euclidean distance, then extend it to Manhattan distance. Tests vectorized distance computation under memory limits, tie handling and how the choice of metric changes predictions.

    Machine LearningTechnical Screen
  • OpenAIHardMachine Learning Engineer
    Implement in-memory database insert and delete operations

    This question evaluates understanding of data structures and algorithmic complexity in the context of designing a key-value in-memory database, and it falls under the Coding & Algorithms domain for a Machine Learning Engineer role while focusing on practical implementation skills.

    Coding & AlgorithmsOnsite
  • OpenAIMediumMachine Learning Engineer
    Implement vectorized NumPy ops and explain broadcasting

    This question evaluates proficiency in vectorized numerical computing with NumPy, understanding of broadcasting semantics, and awareness of numerical stability and algorithmic time/space complexity when manipulating high-dimensional arrays.

    Data Manipulation (SQL/Python)Onsite
  • OpenAIHardMachine Learning Engineer
    Improve Training With Noisy Annotators

    This question evaluates a candidate's ability to handle label noise by estimating annotator reliability and applying data-cleaning, relabeling, or reweighting methods while measuring model performance and understanding classification metrics.

    Machine LearningOnsite
  • OpenAIHardMachine Learning Engineer
    Improve classifier with noisy multi-annotator labels

    This question evaluates a candidate's ability to analyze noisy multi-annotator labels, design label-aggregation and dataset-splitting strategies, and choose modeling and evaluation approaches for binary text classification.

    Machine LearningTechnical Screen
  • OpenAIMediumMachine Learning Engineer
    Infer Generic Return Types

    Implement a toy type-inference engine that unifies generic parameter types with concrete argument types and substitutes resolved type variables to determine the return type.

    Coding & AlgorithmsOnsiterecursiontreetype-systems
  • OpenAIMediumMachine Learning Engineer
    Maintain Entropy for a Streaming Distribution

    Maintain empirical Shannon entropy after every categorical observation without rescanning all categories. The discussion should cover arbitrary identifiers, first-item behavior, exact counts, floating-point drift, concurrency, deletions, sliding windows, and merging summaries from separate stream partitions.

    Statistics & MathOnsite
  • OpenAIMediumMachine Learning Engineer
    Model Infection, Immunity, Delayed Death, and Burn Interventions on a Grid

    Design and implement a discrete grid simulation modeling a five-stage disease progression with state countdowns, immunity, delayed mortality, and external burn interventions.

    Software Engineering FundamentalsTechnical Screensimulationmatrixstate-machine
  • OpenAIHardMachine Learning Engineer
    Repair a Broken Tiny Language Model, Then Make Decoding Incremental

    Find four planted bugs in a compact PyTorch decoder-only language model (some produce NaNs, some silently ruin learning), then add key/value caching so generation processes one new token per step.

    Machine LearningOnsitepytorchtransformersdebugging
  • OpenAIHardMachine Learning Engineer
    Schedule Incremental Labeling Tasks

    This problem tests the ability to design an incremental task scheduler that balances workload across a pool of annotators while maintaining fairness and deterministic state transitions.

    Coding & AlgorithmsOnsiteHeapsSchedulingGreedy
  • OpenAIHardMachine Learning Engineer
    Search Monster Battle Strategies

    Design a search algorithm using state-space exploration to find the minimum number of turns required to defeat a boss given transient health, scripted boss attacks, and a single-use revive.

    Coding & AlgorithmsOnsiteBreadth-First SearchState Space SearchGraph Algorithms
  • OpenAIHardMachine Learning Engineer
    Select high-quality math documents from crawls

    This question assesses the ability to design a scalable pipeline that ingests, cleans, extracts, and filters high-quality mathematical content from diverse, noisy web-crawled sources.

    ML System DesignOnsiteSystem DesignNLPData Engineering
  • OpenAIHardMachine Learning Engineer
    Simulate Infection Spread on a Grid

    Implement a discrete-time cellular automaton simulating epidemic spread on a 2D grid with multi-day infection states, immunity waning, and mortality rules.

    Coding & AlgorithmsTechnical ScreenSimulationMatrixCellular Automata
  • OpenAIMediumMachine Learning Engineer
    Simulate Infection Spread with Immunity and Recovery

    Implement a cellular automaton simulation modeling disease spread on a 2D grid with discrete cell states and timed recovery.

    Coding & AlgorithmsTechnical ScreenGrid SimulationCellular AutomataBFS
  • OpenAIHardMachine Learning Engineer
    Simulate Plant Infection With Controlled Burning

    This question evaluates a candidate's ability to implement discrete-time grid simulations with delayed state transitions, reason about simultaneous updates and neighborhood effects, and perform a limited combinatorial optimization (choosing one row or column) to minimize a global outcome.

    Coding & AlgorithmsOnsite
  • OpenAIMediumMachine Learning Engineer
    Simulate Turn-Based Monster Battles

    This problem tests your ability to design a stateful simulation engine that handles turn-based mechanics, complex status modifiers, and dynamic combat interactions.

    Coding & AlgorithmsOnsiteSimulationState ManagementGame Logic
  • OpenAIHardMachine Learning Engineer
    Streaming Entropy with Numerical Stability

    Implement an online, numerically stable algorithm to compute Shannon entropy over an unbounded stream of categorical tokens with O(1) updates.

    Coding & AlgorithmsTechnical Screenstreamingmathnumerical-computing
  • OpenAIMediumMachine Learning Engineer
    Track Expiring GPU Credits

    Design an in-memory credit ledger to track expiring GPU compute credits, support priority consumption, and manage resource debt.

    Coding & AlgorithmsOnsiteHeapDesignGreedy
  • OpenAIHardMachine Learning Engineer
    Train a classifier and analyze dataset

    This question evaluates proficiency in end-to-end supervised machine learning workflows—covering data validation, exploratory data analysis, preprocessing, model training and selection, evaluation metrics and calibration, fairness assessments, and reproducibility—and tests competencies in applied machine learning engineering, statistical reasoning, and model governance within the Machine Learning domain. It is commonly asked in technical interviews because it verifies practical implementation skills and judgment for deploying reliable classifiers, aligning metrics to business goals and diagnosing performance and fairness across slices, with emphasis on practical application informed by conceptual understanding.

    Machine LearningTechnical Screen
  • OpenAIMediumMachine Learning Engineer
    Train and analyze a classifier

    This question evaluates proficiency in end-to-end machine learning engineering, including exploratory data analysis, time-aware train/validation/test splitting, model baseline and improvement, class imbalance strategies, leakage-safe hyperparameter tuning, metric computation and calibration, error analysis, reproducible training pipelines with CLI/config/seed control, explainability (feature importance/SHAP and ablations), and documentation of risks, fairness checks and monitoring hooks. It is commonly asked to assess practical ability to manage the full ML lifecycle and data hygiene in production-like scenarios, testing applied Data Manipulation (SQL/Python) and Machine Learning competencies with an emphasis on practical application while also requiring conceptual understanding of evaluation, calibration and fairness.

    Data Manipulation (SQL/Python)Technical Screen
  • OpenAIMediumMachine Learning Engineer
    Vectorize One-Nearest-Neighbor and Express It as a Neural Forward Pass

    Tests vectorized distance computation in array libraries and the mathematical equivalence between nearest-prototype classification and an affine neural network layer.

    Machine LearningTechnical Screenvectorizationnearest-neighborslinear-algebra
  • OtherMediumMachine Learning Engineer
    Implement Linear Regression Training

    This question evaluates understanding of linear regression, mean squared error loss, gradient computation, parameter updates, and proficiency with vectorized numerical operations used in batch gradient descent.

    Coding & AlgorithmsOnsite
  • PDT PartnersMediumMachine Learning Engineer
    List All Positive Divisors of an Integer in Ascending Order, Then Beat Square-Root Time

    Given a positive integer up to one trillion, return every positive divisor in ascending order, each listed once. The task tests divisor enumeration, correct handling of perfect squares and 64-bit values, and a follow-up asking whether the running time can grow more slowly than the square root of n.

    Coding & AlgorithmsTechnical Screen
  • PDT PartnersMediumMachine Learning Engineer
    Project Deep Dive: Low-Latency LSTM Inference at Scale and the LSTM vs Transformer Choice

    A project deep dive on a small LSTM model served for large-scale, latency-sensitive inference. The candidate must explain the deployment hardware, latency requirement and use case, how inference latency was reduced, why an LSTM was chosen over a Transformer, and whether that choice still holds today.

    Machine LearningTechnical Screen
  • PayPalHardMachine Learning Engineer
    Design a traditional fraud detection system

    This question evaluates a Machine Learning Engineer's competency in end-to-end ML system design for real-time payments fraud detection, including labeling under delayed confirmations, handling extreme class imbalance and sampling, feature engineering across behavioral, graph, device and merchant signals, model selection for latency and scale, and production scoring and monitoring architecture. It is commonly asked in the ML System Design category to assess how an engineer balances low-latency decision-making with delayed sparse labels, calibration and threshold trade-offs, operational scalability and resiliency, and drift/adversarial detection, testing both conceptual understanding and practical application.

    ML System DesignOnsite
  • PayPalMediumMachine Learning Engineer
    Maximize ones with limited flips

    This question evaluates proficiency with array algorithms, particularly sliding-window and two-pointer reasoning, complexity analysis, and the ability to adapt solutions for streaming data.

    Coding & AlgorithmsOnsite