Machine Learning interview questions

Showing 361–390 of 572 results

• Debug a failing ML classifierHard

  This question evaluates a candidate's ability to diagnose a poorly generalizing ML classifier, testing practical knowledge of data leakage, feature drift, and model calibration. It assesses applied machine learning debugging skills — including cross-validation design and error analysis — commonly tested in senior engineering and ML roles.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Debug a transformer training pipelineHard

  An OpenAI ML engineer technical-screen debugging question: given a PyTorch Transformer training pipeline whose loss diverges and validation accuracy stays near chance (plus mask IndexErrors, AMP crashes, and nondeterminism), identify the distinct bugs and fix them. It tests Transformer internals - attention/causal masking, teacher-forcing label shift, positional encodings, ignore_index loss, optimizer and GradScaler order, determinism, and DDP - along with writing unit tests and a structured debugging plan.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Debug transformer and train classifierHard

  This question evaluates debugging and practical implementation skills for transformer-based text classification, covering model correctness, training loop integrity, data preprocessing, and evaluation metrics within the Machine Learning / Natural Language Processing domain.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Defend a Research Direction and Experiment DesignMedium

  This question evaluates a candidate's ability to synthesize the state of the art in Machine Learning, defend a research direction, and design rigorous experiments, measuring competencies in literature analysis, methodological justification, experimental design, and technical communication.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Derive Backpropagation for Matrix-Product LayersHard

  This question evaluates understanding of backpropagation through linear blocks, matrix calculus, and the computation of gradients with respect to individual weight matrices in a product of trainable matrices, including reasoning about tensor shapes and matrix differentials.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Derive Sharded Matrix Multiplication and BackpropagationMedium

  Derive forward and backward computation for column-sharded matrix multiplication across multiple devices. Track every local tensor shape, identify the collective needed for replicated input gradients, and propose tests for shard ordering, scaling, and numerical errors.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Design Restart Strategy for Oracle SolverMedium

  This question tests the ability to optimize restart intervals for a randomized algorithm with heavy-tailed runtime distributions, balancing the trade-off between progress and computation waste.

  OpenAISoftware EngineerMachine LearningHR Screen
• Diagnose Transformer training and inference bugsHard

  This question evaluates practical debugging skills for Transformer-based sequence models, targeting machine learning engineers who must diagnose intermittent shape/dtype errors and convergence failures simultaneously. It tests deep familiarity with the full training stack — data pipelines, attention masking, positional encoding, optimizer precision, and distributed setup — and the ability to reason about how a single root cause can manifest across multiple symptoms.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Filter Bad Human AnnotationsMedium

  Tests the ability to detect and filter low-quality human labels in large-scale dataset pipelines by modeling annotator reliability, distinguishing genuine ambiguity from noise, and evaluating downstream model performance.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Hand-Rolled Backprop: Running Product and Stable Cross-EntropyHard

  Derive and implement, without an autodiff library, the backward pass of a running (cumulative) product in linear time without division, then a numerically stable softmax cross-entropy and its gradient. Tests chain-rule fluency, prefix/suffix tricks, and gradient checking.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Hand-Written Gradients: Prefix-Product Backward Pass and Stable Cross-EntropyHard

  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.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Implement 1NN with NumPyMedium

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

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Implement Masked Cross-Entropy with Label SmoothingMedium

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

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Implement NumPy neural-network layersMedium

  This question tests your ability to implement fundamental neural network components using NumPy, focusing on matrix operations, broadcasting, and numerical stability.

  OpenAIData ScientistMachine LearningOnsite
• Implement Prefix Products and Their Backward PassMedium

  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.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Implement a 1-Nearest-Neighbor Classifier with a Manhattan-Distance Follow-UpHard

  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.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Implement a minimal reverse-mode autograd engine on PyTorch tensorsHard

  Implement the core of a PyTorch-style autograd system: a tensor wrapper that records addition, multiplication, matrix multiplication, ReLU and sum, plus a backward method that fills in gradients for every input. Tests reverse-mode differentiation, correct ordering of the backward pass, gradient accumulation for tensors used more than once, and verification against PyTorch.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Implement and Debug Backprop in NumPyMedium

  This question evaluates understanding of backpropagation and the chain rule, proficiency in vectorized NumPy implementation, numerical stability of softmax/cross-entropy, and competency in gradient checking and debugging of model gradients.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Improve Training With Noisy AnnotatorsHard

  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.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Improve classifier with noisy multi-annotator labelsHard

  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.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Repair a Broken Tiny Language Model, Then Make Decoding IncrementalHard

  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.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Train a classifier and analyze datasetHard

  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.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Vectorize One-Nearest-Neighbor and Express It as a Neural Forward PassMedium

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

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Expected Wait for a Bus That Runs Late Half the TimeMedium

  This question evaluates a candidate's understanding of probabilistic modeling and expectation calculations for stochastic arrival processes, touching on renewal-theory concepts and length-biased sampling phenomena relevant to timing and queuing problems.

  OptiverData ScientistMachine LearningTechnical Screen
• Fermi Estimation with Confidence Intervals: How Many Houses Does One Year of US Netflix Spending Buy?Easy

  This question evaluates a candidate's quantitative estimation and uncertainty-quantification skills, focusing on decomposition into estimable factors, clear articulation of assumptions, calibrated confidence intervals, and updating estimates when new aggregate data are provided.

  OptiverQuantitative ResearcherMachine LearningTechnical Screen
• How to rank statements by likelihoodHard

  This problem tests your ability to translate statistical distributions and categorical data into ranked probabilistic likelihoods, accounting for uncertainty and sample size variance.

  OptiverData ScientistMachine LearningOnline Assessment
• Market-Making Estimation Game: Optimal Confidence-Interval Strategy Over 5 RoundsHard

  This question evaluates probabilistic reasoning, decision-theoretic optimization of confidence intervals, and sequential risk–reward trade-offs by requiring interval estimation under a nonstandard scoring rule, relevant to a Data Scientist and categorized in Machine Learning/statistical decision theory.

  OptiverData ScientistMachine LearningTechnical Screen
• Quant Trading Game: Expected-Value Betting and Market Making on Coins, Dice, and CardsMedium

  This question evaluates probabilistic reasoning, expected-value calculation, risk management, and market-making intuition under time pressure within a simulated trading game.

  OptiverQuantitative TraderMachine LearningTechnical Screen
• Trading Game: Expected-Value Betting, Kelly Sizing, and Arbitrage Under Time PressureEasy

  This question evaluates quantitative probability reasoning, expected-value computation, risk-sizing (including Kelly-style sizing), arbitrage recognition, and market-making intuition within a live trading simulation.

  OptiverQuantitative ResearcherMachine LearningTechnical Screen
• Explain Medical AI Data and EvaluationMedium

  This question tests the ability to design an end-to-end evaluation and data pipeline for a clinical conversational agent, emphasizing safety, bias mitigation, and rigorous validation in a high-stakes environment.

  OracleData ScientistMachine LearningTechnical Screen