Artificial Intelligence and Machine Learning Expertise Questions

Articulate deep expertise in one or more artificial intelligence and machine learning domains relevant to the role. Cover areas such as neural network architecture design, deep learning systems, natural language processing and large language models, generative artificial intelligence, computer vision, reinforcement learning, and full stack machine learning systems. Describe specific projects and products, datasets and data pipelines, model selection and evaluation strategies, performance metrics, experimentation and ablation studies, chosen frameworks and tooling, productionization and deployment experience, scalability and inference optimization, monitoring and maintenance practices, and contributions to model interpretability and bias mitigation. Explain the measurable impact of your work on product outcomes or research goals, trade offs you managed, and how your specialization aligns to the hiring organization needs.

HardTechnical

71 practiced

Explain counterfactual offline policy evaluation for recommender or ranking systems: describe importance sampling / inverse propensity scoring (IPS), self-normalized IPS, doubly robust estimators, their assumptions, variance behavior, and how to estimate logging policy propensities from historical data.

Sample Answer

Counterfactual offline policy evaluation estimates expected reward of a new (target) policy using logged interaction data collected by a different (logging) policy. Core idea: reweight logged outcomes to account for action-selection bias.

Importance sampling / Inverse Propensity Scoring (IPS)- IPS estimator: E_hat = (1/n) sum_i r_i * π(a_i|x_i) / μ(a_i|x_i), where μ is logging propensity, π is target policy probability, r reward.- Assumptions: positivity (μ>0 whenever π>0) and correct propensities. Unbiased if propensities known.- Variance: can be very high when π/μ is large (rare actions under logging). Sensitive to mis-specified μ.

Self-normalized IPS (SNIPS)- SNIPS = sum r_i w_i / sum w_i with w_i = π/μ. Reduces variance and stabilizes estimates at cost of small bias; particularly helpful when importance weights have heavy tails.

Doubly Robust (DR) estimators- Combine IPS with a learned reward model q(x,a): DR = (1/n) sum [ q(x_i,π) + (π(a_i|x_i)/μ(a_i|x_i)) * (r_i - q(x_i,a_i)) ], where q(x_i,π)=sum_a π(a|x_i) q(x_i,a).- Properties: unbiased if either μ is correct or q is accurate (hence “doubly robust”). Typically lowers variance versus IPS by using model predictions to control weight magnitude.

Practical issues & variance control- Clip or smooth importance weights, use SNIPS, use regularized propensity models, or use model-based baselines in DR.- Use variance estimates via bootstrap or analytic variance formulas; construct confidence intervals accounting for heavy tails (e.g., t-bootstrap or robust CI).

Estimating logging propensities μ from historical data- If the logging policy is known (e.g., logged probabilities), use directly.- If unknown, fit a probabilistic model μ̂(a|x) via supervised learning (multiclass logistic regression or probabilistic classifier) predicting logged actions given contexts; ensure calibration (Platt scaling, isotonic) because IPS is sensitive to mis-calibration.- Validate μ̂ with held-out log-likelihood, calibration plots, and synthetic checks (simulate known policies). When estimating μ is hard, prefer DR and conservative clipping.

Key takeaway: IPS provides unbiased counterfactual estimates but high variance; SNIPS reduces variance with small bias; DR gives robustness and lower variance by combining models and reweighting. Success depends on positivity, accurate or well-regularized propensities, and careful variance estimation.

MediumTechnical

79 practiced

You discover systematic prediction differences for a protected subgroup. Outline an audit plan to measure fairness using multiple metrics (demographic parity, equal opportunity, calibration), identify proxy features causing bias, and propose remediation strategies such as reweighing, adversarial debiasing, or post-processing. How would you validate the effectiveness of your chosen approach?

Sample Answer

Audit plan — scope, data, and success criteria- Define protected subgroup(s) and outcomes (e.g., loan approval). Set fairness targets and acceptable trade-offs with stakeholders (business impact, legal).- Create evaluation dataset: holdout set stratified by protected attribute, plus uplift/time slices to check distribution shift.

Measure multiple fairness metrics- Demographic parity (P(pred=1|A=protected) vs P(pred=1|A=unprotected)).- Equal opportunity (TPR difference: TPR_protected − TPR_unprotected).- Calibration (reliability curves / Brier score per group; test: P(Y=1|score)=score).- Complement with precision/recall, FPR differences, and aggregated metrics (average odds difference, disparate impact).- Use statistical tests (bootstrap CIs) to judge significance.

Identify proxy features causing bias- Feature importance by group (SHAP segmented by A), partial dependence, and correlation matrix between features and A.- Train a probe classifier to predict A from features — high AUC indicates proxies.- Causal checks: if possible, run conditional independence tests or do domain interviews to flag features that encode socio-economic info.

Remediation strategies (implementation notes)- Pre-processing: Reweighing — compute instance weights to equalize P(Y|A) then retrain standard model. Simple, model-agnostic.- In-processing: Adversarial debiasing — joint objective: task loss + λ * adversary_loss(where adversary predicts A from model embeddings). Use gradient reversal or separate adversary network.- Post-processing: Threshold adjustment or equalized odds post-processing (learn separate decision thresholds per group to satisfy constraints).- Choose based on constraints: use pre-processing if data causes bias, in-processing if model complexity allows, post-processing if you cannot retrain model or need fast fixes.

Validation of effectiveness- Compare pre/post on holdout stratified set across all metrics (accuracy, TPR/FPR, calibration). Use k-fold CV and bootstrapped CIs for robustness.- Run counterfactual tests: perturb proxy features and measure prediction shifts.- A/B test (shadow or limited production rollout) to measure real-world impact and unintended consequences (false positives harms).- Monitor drift and fairness in production with alerts on threshold exceedances; log protected-attribute-adjacent signals if legal.- Document trade-offs and choose solution that meets fairness constraints with minimal business utility loss; iterate if proxy removal causes performance collapse.

EasyTechnical

67 practiced

Describe transfer learning and how you would apply it in two settings: (1) computer vision with limited labeled images, and (2) task-specific NLP using a large pretrained transformer. Explain when to freeze layers vs fine-tune and how to avoid catastrophic forgetting.

Sample Answer

Transfer learning reuses knowledge from a model pretrained on a large dataset to speed up and improve learning on a related task with less data. You transfer learned features (early layers = general) and adapt later layers to the new task.

1) Computer vision — limited labeled imagesApproach:- Start from a pretrained convnet (ResNet/VGG/MobileNet) from torchvision.- Replace the classifier head with a task-specific head.- Freeze early convolutional layers (they capture edges/textures) and train the new head first.- If validation plateaus, progressively unfreeze later layers (“gradual unfreezing”) and fine‑tune with a low learning rate and weight decay.Practical tips:- Use strong augmentation, class-balanced sampling, and mixup/cutmix.- Use discriminative learning rates: lower LR for pretrained layers, higher for new head (e.g., 1e-5 for backbone, 1e-3 for head).

Example (PyTorch):

python

import torchvision.models as models
import torch.nn as nn

m = models.resnet50(pretrained=True)
for p in m.conv1.parameters(): p.requires_grad = False  # example freeze
m.fc = nn.Linear(m.fc.in_features, num_classes)
# optimizer: pass different LRs for backbone and head

2) Task-specific NLP — large pretrained transformerApproach:- Start from a pretrained transformer (BERT/DeBERTa) via Hugging Face.- For small labeled data, try adapters or head-only fine-tuning first (add a classification/regression head).- If more capacity needed, fine-tune the whole model with very small LR (e.g., 2e-5) and gradual unfreezing.- Use techniques: layer-wise LR decay, FP16 mixed precision, early stopping.

Example (Hugging Face):

python

from transformers import AutoModelForSequenceClassification, AutoTokenizer
model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
# Trainer with small lr and weight decay

When to freeze vs fine-tune- Freeze early when data is scarce or task is similar to pretraining; reduces overfitting and compute.- Fine-tune more layers when task differs substantially or you have moderate labeled data.- Progressive strategies: head-only → unfreeze top encoder layers → full fine-tune.

Avoiding catastrophic forgetting- Use low learning rates and small batch sizes; use weight decay.- Regularization: dropout, L2, and techniques like Elastic Weight Consolidation (EWC) or L2-SP.- Replay: maintain a small buffer of original-task examples or synthetic augmentations.- Constrain updates: layer-wise LR decay or freezing critical layers.- Use adapters or prompt-tuning for NLP to keep base weights mostly unchanged while adding task-specific parameters.

Evaluation & deployment- Validate on held-out data and monitor calibration/robustness.- Save checkpoint of pretrained + adapter/head to allow quick rollback.- For production, prefer lightweight adapters or distilled models for latency-sensitive services.

This approach balances leveraging general representations while carefully adapting to task specifics to avoid overfitting and forgetting.

MediumTechnical

80 practiced

Implement in PyTorch a training loop skeleton that supports: gradient accumulation over N steps for effective large-batch training and mixed precision training using torch.cuda.amp. Describe where to update the optimizer, how to scale the loss, and how to handle the final incomplete accumulation batch.

Sample Answer

To implement gradient accumulation with mixed precision in PyTorch, use torch.cuda.amp.autocast for forward pass and torch.cuda.amp.GradScaler for safe scaling/unscaling of gradients. Divide the loss by accumulation_steps so gradients represent the effective large batch. Perform optimizer.step() and scaler.update() only after accumulation_steps mini-batches (or after the final partial accumulation). Zero grads before accumulation block or after stepping.

Example skeleton:

python

import torch

def train_epoch(model, dataloader, optimizer, loss_fn, device,
                accumulation_steps=4, scaler=None):
    model.train()
    if scaler is None:
        scaler = torch.cuda.amp.GradScaler()

    optimizer.zero_grad()
    global_step = 0

    for step, (inputs, targets) in enumerate(dataloader, start=1):
        inputs = inputs.to(device)
        targets = targets.to(device)

        with torch.cuda.amp.autocast():
            outputs = model(inputs)
            loss = loss_fn(outputs, targets)
            loss = loss / accumulation_steps  # scale loss for accumulation

        # scale loss, call backward on the scaled loss
        scaler.scale(loss).backward()

        # when we've accumulated enough gradients, or it's the final batch, step
        if step % accumulation_steps == 0:
            # optional: unscale before clipping
            scaler.unscale_(optimizer)
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

            scaler.step(optimizer)   # takes the unscaled optimizer.step() safely
            scaler.update()
            optimizer.zero_grad()
            global_step += 1

    # Handle final incomplete accumulation: if last batch didn't trigger a step
    if (step % accumulation_steps) != 0:
        scaler.unscale_(optimizer)
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        scaler.step(optimizer)
        scaler.update()
        optimizer.zero_grad()

    return global_step

Key points:- Divide loss by accumulation_steps so gradient magnitudes reflect averaged large-batch gradients.- Use scaler.scale(loss).backward() and scaler.step(optimizer) / scaler.update() to handle mixed precision.- Call scaler.unscale_(optimizer) before gradient clipping to operate on true gradient magnitudes.- Zero optimizer gradients after stepping. Ensure a final optimizer step if data size isn't divisible by accumulation_steps.

MediumSystem Design

59 practiced

Design a monitoring and alerting strategy for deployed models: include which SLIs to track (latency, throughput, input distribution drift, prediction distribution drift, model confidence), how to detect concept drift vs data drift, how to build a label feedback loop, and how alerts feed into an automated or manual retraining workflow.

Sample Answer

Requirements & goals:- Detect production issues early (performance, drift), keep models within SLOs, enable safe automated or human-in-the-loop retraining.

SLIs to track (instrumented via Prometheus / OpenTelemetry; visualized in Grafana):- Latency (p50/p95/p99 inference latency per model, per route)- Throughput (requests/sec, concurrent requests)- Error rate (failed predictions, HTTP 5xx)- Input distribution metrics (feature histograms, quantiles)- Prediction distribution (class probabilities, predicted-class frequency)- Model confidence (avg/max/min predicted probability; calibration metrics)- Downstream impact metrics if available (conversion rate, CTR, revenue)

Detecting Data Drift vs Concept Drift:- Data drift (input distribution change): compare recent input feature distributions to baseline using PSI, KL-divergence, or two-sample tests (KS for continuous, chi-sq for categorical) and multivariate tests (MMD). Use rolling windows and alert on sustained drift beyond threshold.- Concept drift (P(y|x) change): requires labels. Monitor label-conditioned metrics: degradation in accuracy/F1, or changes in confusion matrix over time. Use drift detectors like ADWIN or EDDM on model error stream.- Practical distinction: if inputs shifted but performance stable → data drift; if performance drops with stable inputs → concept drift.

Label feedback loop:- Capture ground-truth labels asynchronously (user feedback, batched ETL, delayed labels). Store in versioned labeled dataset with timestamps and inference context.- Build a retraining dataset composer that samples recent labeled data + stratified historic data; run validation checks (data quality, class balance, feature stability).- Automate periodic evaluation jobs that compute production vs baseline metrics and drift tests.

Alerts → Retraining workflow:- Tiered alerting: - Informational: minor drift spikes (create ticket, notify ML owner) - Actionable: sustained drift or SLO breach (trigger automated evaluation pipeline) - Critical: large accuracy drop / business-impacting regressions (pager to on-call)- Automated path: Actionable alert triggers CI pipeline that: 1) Assembles recent labeled data 2) Trains candidate model(s) with automated validation & fairness checks 3) Runs canary A/B tests in staging; if metrics improve and validations pass, auto-deploy with gradual rollout- Manual path: If labels are insufficient or automated checks fail, create a retrain run-request for engineers/data scientists with diagnostics (feature drift reports, example inputs, counterfactuals).

Implementation notes & best practices:- Store telemetry and artifacts (featurized inputs, model versions, predictions, labels) in cheap object store and index metadata in DB.- Use Prometheus for numeric SLIs, push histograms; Grafana dashboards + alertmanager for escalation.- Version models and data; keep reproducible pipelines (CI/CD with MLflow or Kubeflow).- Protect against alert fatigue: require sustained anomalies (e.g., 3 consecutive windows) and combine signals (drift + accuracy drop) before auto-retrain.- Add canary and shadow deployments to validate candidate models before full rollout.

This strategy balances early detection, automated recovery where safe, and human oversight when needed.

Unlock Full Question Bank

Get access to hundreds of Artificial Intelligence and Machine Learning Expertise interview questions and detailed answers.

Join thousands of developers preparing for their dream job.