Machine Learning interview questions

Showing 331–360 of 572 results

• Derive MLP shapes and explain PyTorch broadcastingMedium

  This question tests the ability to calculate matrix transformation dimensions in a Multilayer Perceptron (MLP) and explains the rules governing PyTorch broadcasting when performing operations between tensors of different shapes.

  NVIDIASoftware EngineerMachine LearningTechnical Screen
• Diagnose overfitting, DenseNet, preprocessing, CVHard

  This question evaluates a candidate's understanding of overfitting and mitigation techniques, comparative architecture knowledge between DenseNet and ResNet, leakage-free preprocessing and harmonization for medical imaging, practical CNN hyperparameter tuning, and cross-validation strategies.

  NVIDIAData ScientistMachine LearningHR Screen
• Explain Transformers and QKV matricesMedium

  This question evaluates conceptual and mathematical understanding of the Transformer self-attention mechanism, including how query, key, and value matrices are derived and used. It assesses depth of knowledge in modern deep learning architectures, commonly asked in machine learning and software engineering interviews to test reasoning about sequence modeling and attention-based design.

  NVIDIASoftware EngineerMachine LearningTechnical Screen
• Explain bias-variance, calibration, and model driftMedium

  This question tests your conceptual understanding of model performance degradation over time, the significance of calibrated outputs for decision-making, and the fundamental trade-off between bias and variance.

  NVIDIAMachine Learning EngineerMachine LearningTechnical Screen
• Explain optimization and tensor vs pipeline parallelismHard

  This question evaluates knowledge of deep learning optimization techniques (quantization, pruning, knowledge distillation, kernel/operator fusion, memory and throughput optimizations) and model parallelism strategies (tensor versus pipeline), measuring competency in performance engineering, scalability, communication patterns and system-level trade-offs for training and inference. It is commonly asked to assess an engineer's ability to reason about practical and conceptual trade-offs, collectives, bottlenecks and mitigations in distributed and resource-constrained environments, and it falls under the Machine Learning/Deep Learning domain requiring both conceptual understanding and practical application.

  NVIDIASoftware EngineerMachine LearningTechnical Screen
• When use LLMs for reporting?Medium

  This question assesses the architectural trade-offs, reliability concerns, and suitability of using LLMs for automated business reporting tasks compared to traditional deterministic methods.

  NatooraData AnalystMachine LearningTechnical Screen
• Why use LLMs for daily summaries?Medium

  This question evaluates a candidate's ability to justify tooling and architecture choices for automated daily summaries, comparing LLM-based natural language generation with rules-based or templated alternatives while accounting for data sources, consumer intent, validation, failure modes, and cost/latency trade-offs.

  NatooraData AnalystMachine LearningTechnical Screen
• Address Fraud Detection with Imbalance and Concept Drift SolutionsMedium

  Evaluates end-to-end fraud detection ML system design for online payments under drift and imbalance. Strong answers handle delayed labels, class imbalance, feature engineering, cost-sensitive validation, real-time deployment, threshold actions, monitoring, retraining, and concept drift.

  NetflixData ScientistMachine LearningOnsite
• Compare Losses and Explain LoRAMedium

  This question evaluates understanding of loss functions (mean squared error versus cross-entropy) and parameter-efficient fine-tuning via Low-Rank Adaptation (LoRA), emphasizing probabilistic interpretations, optimization behavior, and low-rank parameterization.

  NetflixMachine Learning EngineerMachine LearningTechnical Screen
• Design a robust conversion propensity modelHard

  This question evaluates a candidate's competency in end-to-end propensity modeling, covering correct labeling to avoid post-treatment leakage, time-windowed feature engineering, class-imbalance and calibration strategies, causal uplift estimation, and production concerns such as monitoring, serving consistency, and cold-start scoring.

  NetflixData ScientistMachine LearningOnsite
• Explain self-attention, LoRA, Adam vs SGD, ViTMedium

  This question evaluates understanding of modern Machine Learning/Deep Learning topics, including self-attention mechanics (queries, keys, values and scaled logits), Low-Rank Adaptation (LoRA) for parameter-efficient fine-tuning and memory savings, optimizer behavior (Adam versus SGD with momentum), and architectural trade-offs between Vision Transformers and CNNs including patch-size considerations. It is categorized under Machine Learning and is commonly asked because it probes both conceptual understanding and practical application—testing reasoning about training dynamics, model scaling, fine-tuning strategies, and resource/performance trade-offs.

  NetflixMachine Learning EngineerMachine LearningTechnical Screen
• Explain tokenization and Transformer variantsMedium

  This question evaluates understanding of tokenization techniques and Transformer architecture, covering competencies in subword and SentencePiece-style tokenizers, Transformer block internals, and comparisons of modern architectural variants and trade-offs.

  NetflixMachine Learning EngineerMachine LearningTechnical Screen
• L1 vs L2 Normalization: Definitions, Geometry and When to Use EachHard

  A machine learning fundamentals question asking how L1 normalization differs from L2 normalization of a vector. It tests precise definitions, what each normalized vector represents geometrically, when each is the right choice, and the ability to keep normalization distinct from L1 and L2 regularization.

  NetflixMachine Learning EngineerMachine LearningTechnical Screen
• ML Basics Check: Bayes' Rule, Forward-Pass Arithmetic, KNN and Transformer ConceptsEasy

  A set of basic machine learning checks: a Bayes' rule posterior with a low base rate, forward-pass and parameter-count arithmetic for small neural networks, and true-or-false concept checks on k-nearest neighbors and Transformer attention. It tests quick, accurate reasoning on core ML fundamentals.

  NetflixMachine Learning EngineerMachine LearningOnline Assessment
• Derive and implement calibration via temperature scalingMedium

  This interview question evaluates core ML concepts, assumptions, math intuition, training/evaluation trade-offs, and practical failure modes in a realistic interview setting. A strong answer for Derive and implement calibration via temperature scaling states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  NewsBreakMachine Learning EngineerMachine LearningTechnical Screen
• Design approach for class imbalanceHard

  This interview question evaluates core ML concepts, assumptions, math intuition, training/evaluation trade-offs, and practical failure modes in a realistic interview setting. A strong answer for Design approach for class imbalance states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  NewsBreakMachine Learning EngineerMachine LearningTechnical Screen
• Find Optimal Piecewise Constant Regression ParametersMedium

  This problem tests the ability to derive optimal constants for a piecewise regression model with a single split point and to implement an efficient search algorithm to minimize the sum of squared errors.

  NewsBreakSoftware EngineerMachine LearningTechnical Screen
• Build a model using only pandas/numpyMedium

  This question evaluates proficiency in applied machine learning competencies including data preprocessing, categorical encoding, feature scaling, implementing baseline models and optimization using numpy/pandas, and selecting appropriate evaluation metrics.

  NextdoorMachine Learning EngineerMachine LearningTechnical Screen
• Write Pseudocode for Embedding Creation and Vector SearchMedium

  This problem tests the ability to design a robust production pipeline for generating text embeddings and performing efficient, metadata-aware vector retrieval.

  NikeSoftware EngineerMachine LearningTechnical Screen
• Explain decision trees and tree ensemblesEasy

  This question evaluates understanding of decision trees, splitting criteria for classification versus regression, hyperparameter effects on the bias–variance trade-off, and the mechanics and rationale behind tree-based ensemble methods in the Machine Learning domain.

  OneMain FinancialData ScientistMachine LearningTechnical Screen
• Select and tune XGBoost hyperparametersHard

  This question evaluates skills in selecting and tuning XGBoost hyperparameters, managing severe class imbalance and sparse one‑hot encodings, handling missing values, and designing compute‑efficient training and grouped cross‑validation to prevent user‑level leakage.

  OneMain FinancialData ScientistMachine LearningTechnical Screen
• Build and troubleshoot image classification and backpropHard

  Build and troubleshoot image classification and backprop evaluates core ML concepts, assumptions, math intuition, training/evaluation trade-offs, and practical failure modes in a realistic interview setting. A strong answer states assumptions, handles edge cases, explains trade-offs, and shows how to validate the result clearly.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Compute Matrix Prefix Products And GradientsHard

  This question evaluates understanding of automatic differentiation for matrix operations, specifically forward and reverse-mode gradients for sequential, associative (but noncommutative) matrix products, together with algorithmic analysis of time and space complexity.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Compute entropy and implement 1-NNMedium

  This question evaluates numerical stability and streaming computation for entropy estimation from logits, along with efficient vectorized linear-algebra implementation of 1-nearest-neighbor inference and its interpretation as a neural-network forward pass under different distance metrics.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Debug MiniGPT and Backpropagate MatmulMedium

  This question evaluates proficiency in debugging PyTorch transformer implementations, reasoning about attention mechanics and causal masking, implementing key–value caching for autoregressive decoding, and constructing provably correct backward passes for matrix multiplications and custom autograd.Functions.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Debug Transformer and Add KV CacheMedium

  This problem tests your understanding of transformer architecture by requiring you to fix a broken attention mechanism and implement a Key-Value cache to optimize autoregressive inference.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Debug a Machine Learning PipelineMedium

  This question evaluates a candidate's ability to diagnose production machine learning failures, covering competencies in data quality, data and concept drift detection, model versioning and deployment checks, and operational debugging within an MLOps context.

  OpenAISoftware EngineerMachine LearningTechnical Screen
• Debug a Small PyTorch Transformer with Four Bugs, Then Add a KV CacheHard

  Debug a small PyTorch transformer language model that hides four bugs, some of which crash and some of which silently ruin training, then add a key-value cache so generation computes only the newest token each step. It tests causal masking, positional encoding, training-loop order and cached decoding.

  OpenAIMachine Learning EngineerMachine LearningOnsite
• Debug a Transformer Implementation and Implement a KV Cache for DecodingMedium

  Practice ML coding question on Transformer language models: find and fix several deliberately planted bugs in a decoder-only Transformer implementation, then implement key-value caching from scratch for autoregressive generation. Tests attention mechanics, tensor-shape reasoning, causal masking, position handling, and verification against full recomputation.

  OpenAIMachine Learning EngineerMachine LearningTechnical Screen
• Debug a broken Transformer implementationHard

  This question evaluates a candidate's ability to debug and validate a Transformer implementation, focusing on attention masking, parameter initialization, loss alignment, and other implementation-level correctness issues.

  OpenAIMachine Learning EngineerMachine LearningOnsite