Epsilon in differential privacy and its trade-offs
WHAT IT TESTS: privacy-utility-cost balance. OUTLINE: epsilon is the privacy budget bounding how much one record can change outputs; smaller epsilon means stronger privacy but more noise and lower accuracy.
Declarative vs imperative ML platform design
WHAT IT TESTS: platform architecture tradeoffs. OUTLINE: declarative GitOps gives auditable, reproducible, reviewable desired-state config with strong governance but a steeper learning curve; imperative SDKs are flexible and fast for scientists but harder to…
Flask/Gunicorn vs Triton/TorchServe for serving
WHAT IT TESTS: choosing serving infrastructure. OUTLINE: Flask is simple and flexible but lacks dynamic batching, GPU scheduling, and multi-model management; Triton/TorchServe add those plus metrics and versioning.
Hybrid parallelism for large-model training
WHAT IT TESTS: scaling training past data-parallel limits. OUTLINE: split the model itself via tensor or pipeline parallelism so each replica is smaller, shrinking gradient all-reduce; combine with data parallelism in 2D/3D.
Why design ML pipeline steps to be idempotent?
WHAT IT TESTS: reliable, retryable pipeline design. OUTLINE: re-running a step with the same input yields the same result and no duplicate side effects; enables safe retries and backfills.
Concept drift vs data drift in production models
WHAT IT TESTS: model decay diagnosis. OUTLINE: data drift is a shift in input distribution P(X); concept drift is a shift in the relationship P(Y|X). RED FLAG: conflating them or claiming input monitoring alone detects concept drift, which needs labels.
What is a model registry and how does it enable CD?
WHAT IT TESTS: model lifecycle governance. OUTLINE: a registry versions models with metadata, lineage, and stage tags; CD watches stage transitions to trigger deploys. RED FLAG: treating it as just blob storage with no versioning, stages, or lineage.
What is shadow deployment for ML models?
WHAT IT TESTS: safe ML rollout strategy. OUTLINE: new model receives mirrored live traffic but its predictions are logged, not served; validates real-world behavior and latency without user risk.
Three ways to cut LLM inference cost
WHAT IT TESTS: LLM inference cost reduction. OUTLINE: quantization to shrink the model, continuous batching with paged attention to raise GPU utilization, and distillation or smaller routed models for easy queries.
Serving for online and batch predictions
WHAT IT TESTS: dual serving modes. OUTLINE: a low-latency online path (synchronous, autoscaled, real-time features) and a high-throughput batch path (parallel, cost-optimized, large jobs) sharing one model artifact and feature definitions.
Automated rollback for a failed model deploy
WHAT IT TESTS: safe deployment recovery. OUTLINE: detect failure via health and metric checks, automatically route traffic back to the last known-good version (blue-green or canary), keep the registry entry but unpromote, and alert.
Stages of an end-to-end ML pipeline
WHAT IT TESTS: the ML lifecycle as automation. OUTLINE: ingest, validate, preprocess and feature engineer, train, evaluate against a baseline, then register and package for deployment, with gates between stages.
Detecting data drift on a continuous feature
WHAT IT TESTS: input distribution change in production. OUTLINE: data drift is when serving feature distributions shift from training; detect with a Kolmogorov-Smirnov test comparing distributions; a small p-value signals drift to alert on.
CI/CD for microservice-based ML systems
WHAT IT TESTS: ML CI/CD at service granularity. OUTLINE: independent per-service pipelines, contract testing to protect interfaces and schemas, and incremental deploys (canary, blue-green); manage data and model contracts, not just code.
Fairness and robustness gates in CI/CD
WHAT IT TESTS: automated model quality gates. OUTLINE: sliced fairness metrics across subgroups, robustness checks via perturbation and adversarial sets, all compared to thresholds that fail the build.
Diagnosing poor distributed training scaling
WHAT IT TESTS: distributed training bottlenecks. OUTLINE: communication overhead (gradient all-reduce, interconnect), data-loading starvation, load imbalance, and small per-GPU batches; profile with the PyTorch profiler and Nsight.
Managing model-as-a-feature pipelines
WHAT IT TESTS: dependency chains between models. OUTLINE: an upstream embedding model becomes a versioned dependency, creating cascading retraining, version skew, latency stacking, and lineage complexity.
Sub-20ms online feature serving
WHAT IT TESTS: low-latency feature serving design. OUTLINE: an in-memory key-value store (Redis) as the online feature store, precomputed features, streaming updates, and offline-online consistency.
Scalable multi-modal data quality pipeline
WHAT IT TESTS: large-scale data curation. OUTLINE: staged distributed pipeline doing schema and integrity checks, modality-specific filtering, dedup, PII and toxicity removal, and metric-gated quarantine.
Versioning a 10TB dataset as code
WHAT IT TESTS: reproducible data versioning at scale. OUTLINE: treat data like code via content-addressed pointers in Git while bytes live in object storage; dedupe by hashing so versions share unchanged files. RED FLAG: copying the whole dataset per version.